Feature: 19.04 part-2DMM-2

Change-Id: I0b52a6bb67c25c7955d58e29eb81a3cc9efea9e9
Signed-off-by: sharath reddy <bs.reddy@huawei.com>

4 files changed, 2287 insertions, 0 deletions

diff --git a/stacks/lwip_stack/tools/CMakeLists.txt b/stacks/lwip_stack/tools/CMakeLists.txt
new file mode 100644
index 0000000..cc8f408
--- /dev/null
+++ b/stacks/lwip_stack/tools/CMakeLists.txt
@@ -0,0 +1,95 @@
+#########################################################################
+#
+# Copyright (c) 2018 Huawei Technologies Co.,Ltd.
+# 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.
+#########################################################################
+
+if(WITH_HAL_LIB)
+else()
+endif()
+SET(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${NSTACKTOOLS_PATH})
+LINK_DIRECTORIES(${LIB_PATH_SHARED} ${LIB_PATH_STATIC})
+INCLUDE_DIRECTORIES(${PROJECT_SOURCE_DIR}/platform/SecureC/include/)
+SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O0 -g -fPIC -fPIE -pie -m64 -mssse3 -std=gnu89")
+SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Werror -Wshadow -Wfloat-equal -Wformat=2")
+SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fstack-protector -fstack-protector-all")
+SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wl,-z,relro,-z,now -Wl,--disable-new-dtags,--rpath,.")
+SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wl,-z,noexecstack -mcmodel=medium")
+
+INCLUDE_DIRECTORIES(
+	../src/include/
+	../../../thirdparty/glog/glog-0.3.5/src/
+	../../SecureC/include/
+	../../../src/include/
+	../../../src/framework/include/common/
+	../../../src/framework/include/
+	../../../src/framework/include/common/generic/
+)
+
+#ADD_EXECUTABLE(narp narp.c)
+#ADD_EXECUTABLE(nnetstat nnetstat.c)
+
+ADD_EXECUTABLE(ntcpdump ntcpdump.c)
+if(WITH_SECUREC_LIB)
+TARGET_LINK_LIBRARIES(
+    ntcpdump
+    pthread
+    rt
+    securec
+    -Wl,--whole-archive
+    libjson-c.a
+    libglog.a
+    nStackFw 
+    -Wl,--no-whole-archive,-lstdc++ -ldl
+    rte_eal
+    rte_mempool
+    rte_mbuf
+    rte_ring
+)
+else()
+TARGET_LINK_LIBRARIES(
+        ntcpdump
+        pthread
+        rt
+        -Wl,--whole-archive
+        libjson-c.a
+        libglog.a
+        nStackFw 
+        -Wl,--no-whole-archive,-lstdc++ -ldl
+        rte_eal
+        rte_mempool
+        rte_mbuf
+        rte_ring
+)
+endif()
+
+if(WITH_SECUREC_LIB)
+ADD_DEPENDENCIES(ntcpdump JSON GLOG SECUREC DPDK)
+else()
+ADD_DEPENDENCIES(ntcpdump JSON GLOG DPDK)
+endif()
+
+
+ADD_EXECUTABLE(nping nping.c)
+
+if(WITH_SECUREC_LIB)
+ADD_DEPENDENCIES(nping SECUREC DPDK)
+else()
+ADD_DEPENDENCIES(nping DPDK)
+endif()
+
+if(WITH_SECUREC_LIB)
+TARGET_LINK_LIBRARIES(nping libnStackAPI.so securec -Wl,-rpath=. -lpthread -lrt -ldl)
+else()
+TARGET_LINK_LIBRARIES(nping libnStackAPI.so -Wl,-rpath=. -lpthread -lrt -ldl)
+endif()
diff --git a/stacks/lwip_stack/tools/nping.c b/stacks/lwip_stack/tools/nping.c
new file mode 100644
index 0000000..a75de85
--- /dev/null
+++ b/stacks/lwip_stack/tools/nping.c
@@ -0,0 +1,615 @@
+/*
+*
+* Copyright (c) 2018 Huawei Technologies Co.,Ltd.
+* 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.
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <arpa/inet.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <sys/ioctl.h>
+#include <unistd.h>
+#include <netinet/in.h>
+#include <netinet/ip.h>
+#include <errno.h>
+#include <time.h>
+#include <fcntl.h>
+#include <memory.h>
+#include <strings.h>
+#include <limits.h>
+#include <getopt.h>
+#include "nstack_securec.h"
+#include "tool_common.h"
+
+/*======== for global variables =======*/
+
+NSTACK_STATIC input_info g_input_info = { 0 };
+static stat_info g_stat_info = { 0 };
+
+static char *g_nping_short_options = "c:r:I:";
+
+int g_exit = 0;
+void user_exit(int sig)
+{
+    g_exit = 1;
+}
+
+NSTACK_STATIC inline double
+get_cost_time(struct timespec *pstart, struct timespec *pend)
+{
+    double sec = (double) (pend->tv_sec - pstart->tv_sec);
+    double nsec = (double) (pend->tv_nsec - pstart->tv_nsec);
+
+    return (sec * 1000 + (nsec / 1000000));
+}
+
+NSTACK_STATIC inline double
+get_lost_rate(unsigned int lost_count, unsigned int send_count)
+{
+    if (0 == send_count)
+    {
+        return 0;
+    }
+
+    return ((double) lost_count / send_count);
+}
+
+void print_stat(stat_info * info, const char *remote_ip)
+{
+    unsigned int send_count = info->send_seq;
+    unsigned int recv_count = info->recv_ok;
+    unsigned int lost_count = send_count - recv_count;
+    double lost_rate = 100 * get_lost_rate(lost_count, send_count);
+    double cost_time = get_cost_time(&info->start_time, &info->end_time);
+
+    printf("\n------ %s ping statistics ------\n", remote_ip);
+
+    printf
+        ("%u packets transmitted, %u received, %.2f%% packet loss, time %.2fms\n",
+         send_count, recv_count, lost_rate, cost_time);
+
+    if (0 != recv_count)
+    {
+        double min_interval = info->min_interval;
+        double max_interval = info->max_interval;
+        double avg_interval = info->all_interval / recv_count;
+        printf("rtt min/avg/max = %.3f/%.3f/%.3f ms\n", min_interval,
+               avg_interval, max_interval);
+    }
+}
+
+NSTACK_STATIC inline u16 get_chksum(icmp_head * pmsg)
+{
+    int len = sizeof(icmp_head);
+    u32 sum = 0;
+    u16 *msg_stream = (u16 *) pmsg;
+    u16 check_sum = 0;
+
+    while (len > 1)
+    {
+        sum += *msg_stream;
+        len -= 2;
+        msg_stream++;
+    }
+
+    sum = (sum >> 16) + (sum & 0xFFFF);
+    sum += (sum >> 16);
+    check_sum = ~sum;
+
+    return check_sum;
+}
+
+#ifndef MAX_SHORT
+#define MAX_SHORT 0xFFFF
+#endif
+
+NSTACK_STATIC inline void
+code_icmp_req(icmp_head * pmsg, u32 send_seq, pid_t my_pid)
+{
+    struct timespec cur_time;
+
+    pmsg->icmp_type = ICMP_ECHO;
+    pmsg->icmp_code = 0;
+    pmsg->icmp_cksum = 0;
+    pmsg->icmp_seq = send_seq % (MAX_SHORT + 1);
+    pmsg->icmp_id = my_pid;
+    pmsg->timestamp = 0;
+
+    if (0 != clock_gettime(CLOCK_MONOTONIC, &cur_time))
+    {
+        printf("Failed to get time, errno = %d\n", errno);
+    }
+
+    pmsg->icmp_sec = cur_time.tv_sec;
+    pmsg->icmp_nsec = cur_time.tv_nsec;
+
+    pmsg->icmp_cksum = get_chksum(pmsg);
+    return;
+}
+
+NSTACK_STATIC int
+send_icmp_req(int socket, pid_t my_pid, stat_info * stat,
+              struct sockaddr_in *remote_addr)
+{
+    int send_ret;
+    icmp_head icmp_req;
+
+    stat->send_seq++;
+    code_icmp_req(&icmp_req, stat->send_seq, my_pid);
+
+    send_ret = sendto(socket, &icmp_req, sizeof(icmp_head), 0,
+                      (struct sockaddr *) remote_addr,
+                      sizeof(struct sockaddr_in));
+
+    if (send_ret < 0)
+    {
+        printf("send icmp request failed.\n");
+        return -1;
+    }
+
+    return send_ret;
+}
+
+NSTACK_STATIC inline double
+cal_interval(struct timespec *psend, struct timespec *precv, stat_info * stat)
+{
+    double interval = get_cost_time(psend, precv);
+
+    stat->all_interval += interval;
+
+    if (interval < stat->min_interval)
+    {
+        stat->min_interval = interval;
+    }
+
+    if (interval > stat->max_interval)
+    {
+        stat->max_interval = interval;
+    }
+
+    return interval;
+}
+
+NSTACK_STATIC inline void
+print_info_on_reply(long send_sec, long send_usec, u32 send_seq,
+                    stat_info * stat, struct sockaddr_in *dst_addr)
+{
+    struct timespec send_time;
+    struct timespec recv_time;
+    if (0 != clock_gettime(CLOCK_MONOTONIC, &recv_time))
+    {
+        printf("Failed to get time, errno = %d\n", errno);
+    }
+
+    send_time.tv_sec = send_sec;
+    send_time.tv_nsec = send_usec;
+
+    double interval = cal_interval(&send_time, &recv_time, stat);
+    const char *remote_ip = inet_ntoa(dst_addr->sin_addr);
+    printf("%lu bytes from %s: icmp_seq=%u, time=%.3f ms\n",
+           sizeof(icmp_head), remote_ip, send_seq % (MAX_SHORT + 1),
+           interval);
+}
+
+NSTACK_STATIC inline void
+print_info_on_no_reply(u32 send_seq, const char *remote_ip)
+{
+    printf("No data from %s, icmp_seq=%u, Destination Host Unreachable\n",
+           remote_ip, send_seq);
+}
+
+static inline int expect_addr(int expect, int addr)
+{
+    return (expect == addr);
+}
+
+NSTACK_STATIC inline int
+parse_icmp_reply(char *buf, unsigned int buf_len, u32 my_pid, u32 send_seq,
+                 stat_info * stat, struct sockaddr_in *dst_addr)
+{
+    unsigned int ip_head_len;
+    ip_head *recv_ip_head;
+    icmp_head *recv_icmp_head;
+
+    // parse all received ip package
+    while (buf_len > sizeof(ip_head))
+    {
+        recv_ip_head = (ip_head *) buf;
+
+        ip_head_len = recv_ip_head->ihl << 2;
+        recv_icmp_head = (icmp_head *) (buf + ip_head_len);
+        buf_len -= htons(recv_ip_head->tot_len);
+
+        if (!expect_addr(dst_addr->sin_addr.s_addr, recv_ip_head->local_ip))
+        {
+            return 0;
+        }
+
+        if ((recv_icmp_head->icmp_type == ICMP_REPLY)
+            && (recv_icmp_head->icmp_id == my_pid)
+            && (recv_icmp_head->icmp_seq == send_seq % (MAX_SHORT + 1)))
+        {
+            print_info_on_reply(recv_icmp_head->icmp_sec,
+                                recv_icmp_head->icmp_nsec, send_seq, stat,
+                                dst_addr);
+
+            return 1;
+        }
+
+        buf += ip_head_len;
+    }
+
+    return 0;
+}
+
+NSTACK_STATIC inline int
+recv_icmp_reply_ok(int socket, int my_pid, u32 send_seq, stat_info * stat,
+                   struct sockaddr_in *dst_addr)
+{
+#define MAX_RECV_BUFF_SIZE (200 * sizeof(icmp_head))
+
+    struct sockaddr_in remote_addr;
+    unsigned int addr_len = sizeof(remote_addr);
+    char recv_buf[MAX_RECV_BUFF_SIZE];
+
+    int recv_ret = recvfrom(socket, recv_buf, MAX_RECV_BUFF_SIZE, 0,
+                            (struct sockaddr *) &remote_addr, &addr_len);
+
+    if (recv_ret < 0)
+    {
+        return 0;
+    }
+
+    if (!parse_icmp_reply
+        (recv_buf, (unsigned int) recv_ret, my_pid, send_seq, stat, dst_addr))
+    {
+        return 0;
+    }
+
+    return 1;
+}
+
+// check recv msg in 2 us
+/* BEGIN: Added for PN:CODEDEX by l00351127, 2017/11/14 CID:50811*/
+NSTACK_STATIC void
+recv_icmp_reply(int socket, pid_t my_pid, input_info * input,
+                stat_info * stat, struct sockaddr_in *dst_addr)
+/* END:   Added for PN:CODEDEX by l00351127, 2017/11/14 */
+{
+#define MAX_SLEEP_TIME (2 * US_TO_NS)
+#define MAX_WAIT_TIME (1000 * MS_TO_NS)
+
+    int recv_ok = 0;
+    int retry = 0;
+    long sleep_all = 0;
+    long sleep_time = 0;
+
+    u32 expect_seq = stat->send_seq;
+
+    while (retry < input->retry_count)
+    {
+        if (recv_icmp_reply_ok(socket, my_pid, expect_seq, stat, dst_addr))
+        {
+            recv_ok = 1;
+            stat->recv_ok++;
+            break;
+        }
+
+        sleep_all += MAX_SLEEP_TIME;
+        sys_sleep_ns(0, MAX_SLEEP_TIME);
+        retry++;
+    }
+
+    if (!recv_ok)
+    {
+        print_info_on_no_reply(expect_seq, input->dst_ip);
+    }
+
+    if (sleep_all < MAX_WAIT_TIME)
+    {
+        sleep_time = MAX_WAIT_TIME - sleep_all;
+        sys_sleep_ns(0, sleep_time);
+    }
+}
+
+NSTACK_STATIC inline int is_digit_nping(char *str)
+{
+    if (NULL == str || '\0' == str[0])
+    {
+        return 0;
+    }
+
+    while (*str)
+    {
+        if (*str > '9' || *str < '0')
+        {
+            return 0;
+        }
+
+        str++;
+    }
+
+    return 1;
+}
+
+#define MIN_IP_LEN_NPING 7      //the length of string ip addr x.x.x.x is 7, 4 numbers + 3 dots = 7
+#define MAX_IP_LEN_NPING 15     //the length of string ip addr xxx.xxx.xxx.xxx is 15, 12 numbers + 3 dots = 15
+
+NSTACK_STATIC inline int is_ip_addr_nping(char *param_addr)
+{
+    int ipseg1;
+    int ipseg2;
+    int ipseg3;
+    int ipseg4;
+
+    if (NULL == param_addr)
+    {
+        return 0;
+    }
+
+    size_t len = strlen(param_addr);
+    if (len < MIN_IP_LEN_NPING || len > MAX_IP_LEN_NPING)       // valid ip MIN_IP_LEN=7, MAX_IP_LEN=15
+    {
+        printf("Input IP format error.\n");
+        return 0;
+    }
+
+    if (sscanf_s
+        (param_addr, "%d.%d.%d.%d", &ipseg1, &ipseg2, &ipseg3, &ipseg4) != 4)
+    {
+        return 0;
+    }
+
+    if ((ipseg1 & 0xffffff00)
+        || (ipseg2 & 0xffffff00)
+        || (ipseg3 & 0xffffff00) || (ipseg4 & 0xffffff00))
+    {
+        return 0;
+    }
+
+    return 1;
+}
+
+NSTACK_STATIC inline bool check_nping_input_para(input_info * input)
+{
+    if (input->send_count < 1)
+    {
+        return false;
+    }
+
+    if (input->retry_count < NPING_RETRY_COUNT
+        || input->retry_count > MAX_NPING_RETRY_COUNT)
+    {
+        return false;
+    }
+
+    if (0 == input->src_ip[0] || 0 == input->dst_ip[0])
+    {
+        return false;
+    }
+
+    return true;
+}
+
+NSTACK_STATIC inline bool
+get_nping_input_para(int argc, char **argv, input_info * input)
+{
+    int opt = 0;
+    bool arg_invalid = false;
+
+    if (argc < 2)
+    {
+        return false;
+    }
+
+    if (!is_ip_addr_nping(argv[1]))
+    {
+        return false;
+    }
+
+    /* CID 36687 (#1 of 2): Unchecked return value (CHECKED_RETURN) */
+    if (EOK != strcpy_s(input->dst_ip, sizeof(input->dst_ip), argv[1]))
+    {
+        printf("STRCPY_S failed.\n");
+        return false;
+    }
+
+    while (1)
+    {
+        opt = getopt(argc - 1, &argv[1], g_nping_short_options);
+        if (-1 == opt)
+        {
+            break;
+        }
+
+        switch (opt)
+        {
+                // for short options
+            case 'c':
+                input->send_count = atoi(optarg);
+                break;
+            case 'r':
+                input->retry_count = atoi(optarg);
+                break;
+            case 'I':
+                /* CID 36687 (#2 of 2): Unchecked return value (CHECKED_RETURN) */
+                if (!is_ip_addr_nping(optarg))
+                {
+                    return false;
+                }
+                if (EOK !=
+                    strcpy_s(input->src_ip, sizeof(input->src_ip), optarg))
+                {
+                    printf("STRCPY_S failed.\n");
+                    return false;
+                }
+                break;
+            default:
+                arg_invalid = true;
+                break;
+        }
+
+        if (arg_invalid)
+        {
+            return false;
+        }
+    }
+
+    if (!check_nping_input_para(input))
+    {
+        return false;
+    }
+
+    return true;
+}
+
+void print_help_nping()
+{
+    printf
+        ("usage:nping destination [-c send_count -I src_addr -r retry_count]\n");
+    printf("send count range:1-2147483647\n");
+    printf("retry count range:1000-20000\n");
+}
+
+NSTACK_STATIC inline void init_input_info(input_info * input)
+{
+    if (EOK != memset_s(input, sizeof(input_info), 0, sizeof(input_info)))
+    {
+        printf("MEMSET_S failed.\n");
+        return;
+    }
+
+    input->send_count = 100000;
+    input->retry_count = NPING_RETRY_COUNT;
+}
+
+NSTACK_STATIC inline void init_stat_info(stat_info * stat)
+{
+    stat->max_interval = 0;
+    stat->min_interval = 0xFFFFFFFF;
+}
+
+#ifndef NSTACK_STATIC_CHECK
+int main(int argc, char *argv[])
+#else
+int nping_main(int argc, char *argv[])
+#endif
+{
+    struct sockaddr_in local_addr;
+    struct sockaddr_in remote_addr;
+    int send_ret;
+    int ret = -1;
+    int icmp_sock;
+
+    pid_t my_pid;
+
+    if (EOK !=
+        memset_s(&local_addr, sizeof(local_addr), 0, sizeof(local_addr)))
+    {
+        printf("MEMSET_S failed.\n");
+        return 0;
+    }
+    local_addr.sin_family = AF_INET;
+
+    init_input_info(&g_input_info);
+    init_stat_info(&g_stat_info);
+
+    if (!get_nping_input_para(argc, argv, &g_input_info))
+    {
+        print_help_nping();
+        return 0;
+    }
+
+    if ((icmp_sock = socket(AF_INET, CUSTOM_SOCK_TYPE, IPPROTO_ICMP)) < 0)
+    {
+        printf("create socket failed.\n");
+        return 0;
+    }
+
+    local_addr.sin_addr.s_addr = inet_addr(g_input_info.src_ip);
+
+    if (0 !=
+        bind(icmp_sock, (struct sockaddr *) &local_addr,
+             sizeof(struct sockaddr)))
+    {
+        printf("bind failed, src ip %s\n", g_input_info.src_ip);
+        close(icmp_sock);
+        return 0;
+    }
+
+    int opt = 1;
+    ret = ioctl(icmp_sock, FIONBIO, &opt);
+    if (-1 == ret)
+    {
+        printf("fcntl O_NONBLOCK fail\n");
+        close(icmp_sock);
+        return 0;
+    }
+
+    if (EOK !=
+        memset_s(&remote_addr, sizeof(remote_addr), 0, sizeof(remote_addr)))
+    {
+        printf("MEMSET_S failed.\n");
+        close(icmp_sock);
+        return 0;
+    }
+
+    remote_addr.sin_family = AF_INET;
+    remote_addr.sin_addr.s_addr = inet_addr(g_input_info.dst_ip);
+
+    my_pid = getpid();
+    printf("nping %s %lu bytes of data, pid:%d.\n", g_input_info.dst_ip,
+           sizeof(icmp_head), my_pid);
+
+    signal(SIGINT, user_exit);
+
+    int loop_count = 0;
+    if (0 != clock_gettime(CLOCK_MONOTONIC, &g_stat_info.start_time))
+    {
+        printf("Failed to get time, errno = %d\n", errno);
+    }
+
+/* BEGIN: Added for PN:CODEDEX by l00351127, 2017/11/14  CID:50811*/
+    i32 send_count = g_input_info.send_count;
+/* END:   Added for PN:CODEDEX by l00351127, 2017/11/14 */
+
+    while (!g_exit && (loop_count < send_count))
+    {
+        send_ret =
+            send_icmp_req(icmp_sock, my_pid, &g_stat_info, &remote_addr);
+        if (send_ret < 0)
+        {
+            break;
+        }
+
+        recv_icmp_reply(icmp_sock, my_pid, &g_input_info, &g_stat_info,
+                        &remote_addr);
+
+        loop_count++;
+    }
+
+    close(icmp_sock);
+
+    if (0 != clock_gettime(CLOCK_MONOTONIC, &g_stat_info.end_time))
+    {
+        printf("Failed to get time, errno = %d\n", errno);
+    }
+
+    print_stat(&g_stat_info, g_input_info.dst_ip);
+
+    return 0;
+}
diff --git a/stacks/lwip_stack/tools/ntcpdump.c b/stacks/lwip_stack/tools/ntcpdump.c
new file mode 100644
index 0000000..b2a3436
--- /dev/null
+++ b/stacks/lwip_stack/tools/ntcpdump.c
@@ -0,0 +1,1334 @@
+/*
+*
+* Copyright (c) 2018 Huawei Technologies Co.,Ltd.
+* 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.
+*/
+
+#include <arpa/inet.h>
+#include <unistd.h>
+#include <signal.h>
+#include <time.h>
+#include <malloc.h>
+#include <stdio.h>
+#include <getopt.h>
+#include <unistd.h>
+#include "types.h"
+#include "nsfw_init_api.h"
+#include "nsfw_mem_api.h"
+#include "nsfw_fd_timer_api.h"
+#include "nsfw_maintain_api.h"
+#include "nstack_securec.h"
+
+#include "tool_common.h"
+
+NSTACK_STATIC struct option g_dump_long_options[] = {
+    {"host", 1, NULL, OPT_ARG_HOST},
+    {"lhost", 1, NULL, OPT_ARG_LOCAL_HOST},
+    {"rhost", 1, NULL, OPT_ARG_REMOTE_HOST},
+    {"port", 1, NULL, OPT_ARG_PORT},
+    {"lport", 1, NULL, OPT_ARG_LOCAL_PORT},
+    {"rport", 1, NULL, OPT_ARG_REMOTE_PORT},
+    {"mac", 1, NULL, OPT_ARG_MAC},
+    {"lmac", 1, NULL, OPT_ARG_LOCAL_MAC},
+    {"rmac", 1, NULL, OPT_ARG_REMOTE_MAC},
+    {0, 0, 0, 0}
+};
+
+static char *g_dump_short_options = "c:s:w:y:G:P:T:";
+
+NSTACK_STATIC FILE *g_dump_fp = NULL;
+static u32 g_dumped_packet = 0;
+NSTACK_STATIC u32 g_captured_packet = 0;
+static u32 g_filtered_packet = 0;
+
+NSTACK_STATIC bool g_dump_exit = 0;
+
+static dump_timer_info g_dump_hbt_timer;
+NSTACK_STATIC dump_condition g_dump_condition;
+static nsfw_mem_name g_dump_mem_ring_info =
+    { NSFW_SHMEM, NSFW_PROC_MAIN, DUMP_SHMEM_RING_NAME };
+static nsfw_mem_name g_dump_mem_pool_info =
+    { NSFW_SHMEM, NSFW_PROC_MAIN, DUMP_SHMEM_POOL_NAME };
+
+void dump_exit()
+{
+    g_dump_exit = 1;
+}
+
+void print_help_ntcpdump()
+{
+    printf("usage:ntcpdump \n\
+        -c count \n\
+        -s len \n\
+        -w file \n\
+        -y l2_protocol \n\
+        -T l3_protocol \n\
+        -G dump_seconds \n\
+        -P in/out/inout \n\
+        --host/rhost/lhost ip_addr \n\
+        --port/rport/lport port \n\
+        --mac/rmac/lmac mac_addr\n");
+}
+
+bool is_digit_ntcpdump(char *str, size_t src_len)
+{
+    size_t count = 0;
+
+    if (NULL == str || 0 == *str)
+    {
+        return FALSE;
+    }
+
+    while (*str)
+    {
+        if (*str > '9' || *str < '0')
+        {
+            return false;
+        }
+
+        str++;
+        count++;
+    }
+
+    if (count > src_len)
+    {
+        return false;
+    }
+
+    return true;
+}
+
+NSTACK_STATIC inline bool
+is_ip_addr(const char *addr, ip_addr_bits * addr_info)
+{
+    u32 ip1;
+    u32 ip2;
+    u32 ip3;
+    u32 ip4;
+
+    if (sscanf_s(addr, "%d.%d.%d.%d", &ip1, &ip2, &ip3, &ip4) != 4)
+    {
+        return false;
+    }
+
+    if ((ip1 & 0xffffff00) || (ip2 & 0xffffff00) || (ip3 & 0xffffff00)
+        || (ip4 & 0xffffff00))
+    {
+        return false;
+    }
+
+    addr_info->addr_bits1 = ip1;
+    addr_info->addr_bits2 = ip2;
+    addr_info->addr_bits3 = ip3;
+    addr_info->addr_bits4 = ip4;
+
+    return true;
+}
+
+NSTACK_STATIC inline bool get_ip_addr(const char *addr, u32 * ip_addr)
+{
+    ip_addr_bits addr_info;
+    if (!is_ip_addr(addr, &addr_info))
+    {
+        return false;
+    }
+
+    *ip_addr = ((addr_info.addr_bits1 & 0xFF)
+                | (addr_info.addr_bits2 & 0xFF) << 8
+                | (addr_info.addr_bits3 & 0xFF) << 16
+                | (addr_info.addr_bits4 & 0xFF) << 24);
+
+    return true;
+}
+
+NSTACK_STATIC inline bool get_dump_port(const char *pport, u16 * port)
+{
+    int user_port;
+
+    if (!is_digit_ntcpdump((char *) pport, MAX_PORT_STR_LEN))
+    {
+        return false;
+    }
+
+    user_port = atoi(pport);
+    if (user_port < 1024 || user_port > 65535)
+    {
+        return false;
+    }
+
+    *port = (unsigned short) user_port;
+    return true;
+}
+
+NSTACK_STATIC inline bool get_dump_len(char *plen, u32 * limit_len)
+{
+    if (!is_digit_ntcpdump(plen, MAX_INTEGER_STR_LEN))
+    {
+        return false;
+    }
+
+    *limit_len = atoi(plen);
+    return true;
+}
+
+NSTACK_STATIC inline bool get_mac_addr(const char *opt_value, char *mac_addr)
+{
+    /* avoid coredump when opt_value is NULL */
+    if (NULL == opt_value)
+    {
+        return false;
+    }
+
+    size_t org_len = strlen(opt_value);
+    if (org_len != MAC_ADDR_STR_LEN)
+    {
+        return false;
+    }
+
+    u32 tmp_mac[MAC_ADDR_LEN];
+
+    if (6 != sscanf_s(opt_value, "%x:%x:%x:%x:%x:%x",
+                      &tmp_mac[0],
+                      &tmp_mac[1],
+                      &tmp_mac[2], &tmp_mac[3], &tmp_mac[4], &tmp_mac[5]))
+    {
+        return false;
+    }
+
+    int i = 0;
+    for (; i < MAC_ADDR_LEN; i++)
+    {
+        if (tmp_mac[i] > 0xFF)
+        {
+            // 01:02:03:04:5:1FF
+            return false;
+        }
+
+        mac_addr[i] = tmp_mac[i];
+    }
+
+    return true;
+}
+
+NSTACK_STATIC inline bool check_file_name(const char *file_name)
+{
+    if (0 == access(file_name, F_OK))
+    {
+        printf("dump file exist, file name=%s.\n", file_name);
+        return false;
+    }
+    return true;
+}
+
+NSTACK_STATIC inline u16 get_para_direction(const char *para)
+{
+    if (0 == strcasecmp(para, "out"))
+    {
+        return DUMP_SEND;
+    }
+
+    if (0 == strcasecmp(para, "in"))
+    {
+        return DUMP_RECV;
+    }
+
+    if (0 == strcasecmp(para, "inout"))
+    {
+        return DUMP_SEND_RECV;
+    }
+
+    return INVALID_DIRECTION;
+}
+
+NSTACK_STATIC inline u16 get_para_l2_protocol(const char *para)
+{
+    if (0 == strcasecmp(para, "arp"))
+    {
+        return PROTOCOL_ARP;
+    }
+
+    if (0 == strcasecmp(para, "rarp"))
+    {
+        return PROTOCOL_RARP;
+    }
+
+    if (0 == strcasecmp(para, "ip"))
+    {
+        return PROTOCOL_IP;
+    }
+
+    if (0 == strcasecmp(para, "oam"))
+    {
+        return PROTOCOL_OAM_LACP;
+    }
+
+    if (0 == strcasecmp(para, "lacp"))
+    {
+        return PROTOCOL_OAM_LACP;
+    }
+
+    return INVALID_L2_PROTOCOL;
+}
+
+NSTACK_STATIC inline u16 get_para_l3_protocol(const char *para)
+{
+    if (0 == strcasecmp(para, "tcp"))
+    {
+        return PROTOCOL_TCP;
+    }
+
+    if (0 == strcasecmp(para, "udp"))
+    {
+        return PROTOCOL_UDP;
+    }
+
+    if (0 == strcasecmp(para, "icmp"))
+    {
+        return PROTOCOL_ICMP;
+    }
+
+    return INVALID_L3_PROTOCOL;
+}
+
+NSTACK_STATIC bool
+parse_long_options(int opt, const char *long_opt_arg, int optindex,
+                   dump_condition * filter_info)
+{
+    switch (opt)
+    {
+        case OPT_ARG_HOST:
+            if (!get_ip_addr(long_opt_arg, &filter_info->ip_addr))
+            {
+                printf("invalid ip addr, optindex=%d, port=%s.\n", optindex,
+                       long_opt_arg);
+                return false;
+            }
+            filter_info->ip_set_flag |= COND_OR_SET;
+            break;
+        case OPT_ARG_LOCAL_HOST:
+            if (!get_ip_addr(long_opt_arg, &filter_info->local_ip))
+            {
+                printf("invalid ip addr, optindex=%d, port=%s.\n", optindex,
+                       long_opt_arg);
+                return false;
+            }
+            filter_info->ip_set_flag |= COND_LOCAL_SET;
+            break;
+        case OPT_ARG_REMOTE_HOST:
+            if (!get_ip_addr(long_opt_arg, &filter_info->remote_ip))
+            {
+                printf("invalid ip addr, optindex=%d, port=%s.\n", optindex,
+                       long_opt_arg);
+                return false;
+            }
+            filter_info->ip_set_flag |= COND_REMOTE_SET;
+            break;
+        case OPT_ARG_PORT:
+            if (!get_dump_port(long_opt_arg, &filter_info->port))
+            {
+                printf("invalid port, optindex=%d, port=%s.\n", optindex,
+                       long_opt_arg);
+                return false;
+            }
+            filter_info->port_set_flag |= COND_OR_SET;
+            break;
+        case OPT_ARG_LOCAL_PORT:
+            if (!get_dump_port(long_opt_arg, &filter_info->local_port))
+            {
+                printf("invalid port, optindex=%d, port=%s.\n", optindex,
+                       long_opt_arg);
+                return false;
+            }
+            filter_info->port_set_flag |= COND_LOCAL_SET;
+            break;
+        case OPT_ARG_REMOTE_PORT:
+            if (!get_dump_port(long_opt_arg, &filter_info->remote_port))
+            {
+                printf("invalid port, optindex=%d, port=%s.\n", optindex,
+                       long_opt_arg);
+                return false;
+            }
+            filter_info->port_set_flag |= COND_REMOTE_SET;
+            break;
+        case OPT_ARG_MAC:
+            if (!get_mac_addr(long_opt_arg, filter_info->mac_addr))
+            {
+                printf("invalid mac addr, optindex=%d, mac=%s.\n", optindex,
+                       long_opt_arg);
+                return false;
+            }
+            filter_info->mac_set_flag |= COND_OR_SET;
+            break;
+        case OPT_ARG_LOCAL_MAC:
+            if (!get_mac_addr(long_opt_arg, filter_info->local_mac))
+            {
+                printf("invalid mac addr, optindex=%d, mac=%s.\n", optindex,
+                       long_opt_arg);
+                return false;
+            }
+            filter_info->mac_set_flag |= COND_LOCAL_SET;
+            break;
+        case OPT_ARG_REMOTE_MAC:
+            if (!get_mac_addr(long_opt_arg, filter_info->remote_mac))
+            {
+                printf("invalid mac addr, optindex=%d, mac=%s.\n", optindex,
+                       long_opt_arg);
+                return false;
+            }
+            filter_info->mac_set_flag |= COND_REMOTE_SET;
+            break;
+        default:
+            printf("unknow arg, optindex=%d, arg=%s.\n", optindex,
+                   long_opt_arg);
+            return false;
+    }
+
+    return true;
+}
+
+NSTACK_STATIC inline bool condition_valid(dump_condition * condition)
+{
+    // check direction
+    if (INVALID_DIRECTION == condition->direction)
+    {
+        printf("direction invalid.\n");
+        return false;
+    }
+
+    // check l2 protocol
+    if (INVALID_L2_PROTOCOL == condition->l2_protocol)
+    {
+        printf("L2 protocol invalid.\n");
+        return false;
+    }
+
+    // check l3 protocol
+    if (INVALID_L3_PROTOCOL == condition->l3_protocol)
+    {
+        printf("L3 protocol invalid.\n");
+        return false;
+    }
+
+    // check ip
+    if (condition->ip_set_flag > 0x4)
+    {
+        printf("IP options invalid.\n");
+        return false;
+    }
+
+    // check port
+    if (condition->port_set_flag > 0x4)
+    {
+        printf("Port options invalid.\n");
+        return false;
+    }
+
+    // check mac
+    if (condition->mac_set_flag > 0x4)
+    {
+        printf("MAC options invalid.\n");
+        return false;
+    }
+
+    if (condition->dump_time > MAX_DUMP_TIME
+        || condition->dump_time < MIN_DUMP_TIME)
+    {
+        printf("dump time invalid.\n");
+        return false;
+    }
+
+    return true;
+}
+
+NSTACK_STATIC inline bool
+get_dump_condition(int argc, char **argv, dump_condition * filter_info)
+{
+    int opt = 0;
+    int opt_index = 0;
+    bool arg_invalid = false;
+    filter_info->has_condition = 0;
+
+    if (argc < 2)
+    {
+        // dump all package
+        return true;
+    }
+
+    while (1)
+    {
+        opt =
+            getopt_long(argc, argv, g_dump_short_options, g_dump_long_options,
+                        &opt_index);
+        if (-1 == opt)
+        {
+            break;
+        }
+
+        switch (opt)
+        {
+                // for short options
+            case 'c':
+                filter_info->dump_count = atoi(optarg);
+                break;
+            case 's':
+                if (!get_dump_len(optarg, &filter_info->limit_len))
+                {
+                    printf("length invalid, optindex=%d, arg=%s.\n",
+                           opt_index, optarg);
+                    arg_invalid = true;
+                }
+                break;
+            case 'w':
+                if (!check_file_name(optarg))
+                {
+                    printf("invalid file name, optindex=%d, arg=%s.\n",
+                           opt_index, optarg);
+                    arg_invalid = true;
+                }
+                else
+                {
+                    filter_info->dump_file_name = optarg;
+                }
+                break;
+            case 'y':
+                filter_info->l2_protocol = get_para_l2_protocol(optarg);
+                break;
+            case 'G':
+                filter_info->dump_time = atoi(optarg);
+                break;
+            case 'P':
+                filter_info->direction = get_para_direction(optarg);
+                break;
+            case 'T':
+                filter_info->l3_protocol = get_para_l3_protocol(optarg);
+                break;
+            case '?':
+                arg_invalid = true;
+                break;
+                // for long options
+            default:
+                if (!parse_long_options(opt, optarg, opt_index, filter_info))
+                {
+                    arg_invalid = true;
+                }
+                break;
+        }
+
+        if (arg_invalid)
+        {
+            print_help_ntcpdump();
+            return false;
+        }
+
+        filter_info->has_condition = 1;
+    }
+
+    if (!condition_valid(filter_info))
+    {
+        filter_info->has_condition = 0;
+        return false;
+    }
+
+    return true;
+}
+
+NSTACK_STATIC inline void open_file()
+{
+    if (NULL == g_dump_condition.dump_file_name)
+    {
+        return;
+    }
+
+    g_dump_fp = fopen(g_dump_condition.dump_file_name, "w+");
+    if (NULL == g_dump_fp)
+    {
+        printf("open file %s failed\n", g_dump_condition.dump_file_name);
+    }
+}
+
+NSTACK_STATIC inline void close_file()
+{
+    if (NULL != g_dump_fp)
+    {
+        fclose(g_dump_fp);
+        g_dump_fp = NULL;
+    }
+}
+
+NSTACK_STATIC inline void write_file_head(FILE * fp)
+{
+    dump_file_head file_head;
+    file_head.magic = 0xA1B2C3D4;
+    file_head.major_ver = 2;    // 0x0200;
+    file_head.minor_ver = 4;    // 0x0400;
+    file_head.area = 0;
+    file_head.time_stamp = 0;
+    file_head.max_pack_size = 0x0000FFFF;       // 0xFFFF0000;
+    file_head.link_type = 1;    //0x01000000;
+
+    if (fwrite(&file_head, sizeof(dump_file_head), 1, fp) != 1)
+    {
+        return;
+    }
+
+    fflush(fp);
+}
+
+NSTACK_STATIC inline void write_packet(parse_msg_info * pmsg, FILE * fp)
+{
+    packet_head pack_head;
+    dump_msg_info *org_msg = (dump_msg_info *) pmsg->org_msg;
+    pack_head.sec = org_msg->dump_sec;
+    pack_head.usec = org_msg->dump_usec;
+    pack_head.save_len =
+        (u32) nstack_min(org_msg->len, g_dump_condition.limit_len);
+    pack_head.org_len = org_msg->len;
+
+    if (fwrite(&pack_head, sizeof(packet_head), 1, fp) != 1)
+    {
+        // log error
+        return;
+    }
+
+    if (fwrite(org_msg->buf, pack_head.save_len, 1, fp) != 1)
+    {
+        // log error
+        return;
+    }
+
+    fflush(fp);
+    return;
+}
+
+#define EMPTY(x) (0 == (x))
+#define EQUAL(x, y) ((x) == (y))
+
+#define STR_EMPTY(str) (0 == str[0])
+#define STR_EQUAL(str1, str2, len) (0 == memcmp(str1, str2, len))
+
+#define MATCH(cond, info, field) \
+    (EQUAL(cond->field, info->field))
+
+#define MATCH_MORE(cond, field, info, field1, field2) \
+    (EQUAL(cond->field, info->field1) || EQUAL(cond->field, info->field2))
+
+#define MATCH_STR(cond, info, field, len) \
+    (STR_EQUAL(cond->field, info->field, len))
+
+#define MATCH_STR_MORE(cond, field, info, field1, field2, len) \
+    (STR_EQUAL(cond->field, info->field1, len) || STR_EQUAL(cond->field, info->field2, len))
+
+NSTACK_STATIC inline bool
+ip_match(dump_condition * condition, parse_msg_info * msg_info)
+{
+    bool ret = false;
+    switch (condition->ip_set_flag)
+    {
+        case COND_NOT_SET:
+            ret = true;
+            break;
+        case COND_LOCAL_SET:
+            if (MATCH(condition, msg_info, local_ip))
+            {
+                ret = true;
+            }
+            break;
+        case COND_REMOTE_SET:
+            if (MATCH(condition, msg_info, remote_ip))
+            {
+                ret = true;
+            }
+            break;
+        case COND_AND_SET:
+            if (MATCH_MORE(condition, local_ip, msg_info, local_ip, remote_ip)
+                && MATCH_MORE(condition, remote_ip, msg_info, local_ip,
+                              remote_ip))
+            {
+                ret = true;
+            }
+            break;
+        case COND_OR_SET:
+            if (MATCH_MORE(condition, ip_addr, msg_info, local_ip, remote_ip))
+            {
+                ret = true;
+            }
+            break;
+        default:
+            break;
+    }
+
+    return ret;
+}
+
+NSTACK_STATIC inline bool
+port_match(dump_condition * condition, parse_msg_info * msg_info)
+{
+    bool ret = false;
+    switch (condition->port_set_flag)
+    {
+        case COND_NOT_SET:
+            ret = true;
+            break;
+        case COND_LOCAL_SET:
+            if (MATCH(condition, msg_info, local_port))
+            {
+                ret = true;
+            }
+            break;
+        case COND_REMOTE_SET:
+            if (MATCH(condition, msg_info, remote_port))
+            {
+                ret = true;
+            }
+            break;
+        case COND_AND_SET:
+            if (MATCH(condition, msg_info, local_port)
+                && MATCH(condition, msg_info, remote_port))
+            {
+                ret = true;
+            }
+            break;
+        case COND_OR_SET:
+            if (MATCH_MORE
+                (condition, port, msg_info, local_port, remote_port))
+            {
+                ret = true;
+            }
+            break;
+        default:
+            break;
+    }
+
+    return ret;
+}
+
+NSTACK_STATIC inline bool
+mac_match(dump_condition * condition, parse_msg_info * msg_info)
+{
+    bool ret = false;
+    switch (condition->mac_set_flag)
+    {
+        case COND_NOT_SET:
+            ret = true;
+            break;
+        case COND_LOCAL_SET:
+            if (MATCH_STR(condition, msg_info, local_mac, MAC_ADDR_LEN))
+            {
+                ret = true;
+            }
+            break;
+        case COND_REMOTE_SET:
+            if (MATCH_STR(condition, msg_info, remote_mac, MAC_ADDR_LEN))
+            {
+                ret = true;
+            }
+            break;
+        case COND_AND_SET:
+            if ((MATCH_STR_MORE
+                 (condition, local_mac, msg_info, local_mac, remote_mac,
+                  MAC_ADDR_LEN)
+                 && MATCH_STR_MORE(condition, remote_mac, msg_info, local_mac,
+                                   remote_mac, MAC_ADDR_LEN)))
+            {
+                ret = true;
+            }
+            break;
+        case COND_OR_SET:
+            if (MATCH_STR_MORE
+                (condition, mac_addr, msg_info, local_mac, remote_mac,
+                 MAC_ADDR_LEN))
+            {
+                ret = true;
+            }
+            break;
+        default:
+            break;
+    }
+
+    return ret;
+}
+
+NSTACK_STATIC inline bool
+filter_by_condition(dump_condition * condition, parse_msg_info * msg_info)
+{
+    dump_msg_info *org_msg = (dump_msg_info *) msg_info->org_msg;
+    if (0 == condition->has_condition)
+    {
+        return false;
+    }
+
+    // direction
+    if (!(condition->direction & org_msg->direction))
+    {
+        return true;
+    }
+
+    // l2_protocol
+    if ((0 != condition->l2_protocol)
+        && !MATCH(condition, msg_info, l2_protocol))
+    {
+        return true;
+    }
+
+    // l3_protocol
+    if ((0 != condition->l3_protocol)
+        && !MATCH(condition, msg_info, l3_protocol))
+    {
+        return true;
+    }
+
+    // ip
+    if (!ip_match(condition, msg_info))
+    {
+        return true;
+    }
+
+    // port
+    if (!port_match(condition, msg_info))
+    {
+        return true;
+    }
+
+    // mac
+    if (!mac_match(condition, msg_info))
+    {
+        return true;
+    }
+
+    return false;
+}
+
+NSTACK_STATIC inline char *get_l2_protocol_desc(u16 l2_protocol)
+{
+    switch (l2_protocol)
+    {
+        case PROTOCOL_IP:
+            return "IP";
+        case PROTOCOL_ARP:
+            return "ARP";
+        case PROTOCOL_RARP:
+            return "RARP";
+        case PROTOCOL_OAM_LACP:
+            return "OAM/LACP";
+        default:
+            return "unknown";
+    }
+}
+
+NSTACK_STATIC inline char *get_l3_protocol_desc(u16 l3_protocol)
+{
+    switch (l3_protocol)
+    {
+        case PROTOCOL_ICMP:
+            return "ICMP";
+        case PROTOCOL_TCP:
+            return "TCP";
+        case PROTOCOL_UDP:
+            return "UDP";
+        default:
+            return "unknown";
+    }
+}
+
+NSTACK_STATIC inline void get_ip_str(char *pip_addr, u32 ip_addr_len, u32 ip)
+{
+    int retVal;
+    retVal = sprintf_s(pip_addr, ip_addr_len, "%d.%d.%d.%d",
+                       ip & 0x000000FF,
+                       (ip & 0x0000FF00) >> 8,
+                       (ip & 0x00FF0000) >> 16, (ip & 0xFF000000) >> 24);
+    if (-1 == retVal)
+    {
+        printf("get_ip_str:SPRINTF_S failed %d.\n", retVal);
+    }
+}
+
+NSTACK_STATIC inline void print_packet(parse_msg_info * msg_info, u32 seq)
+{
+    char str_local_ip[IP_ADDR_LEN];
+    char str_remote_ip[IP_ADDR_LEN];
+    get_ip_str(str_local_ip, sizeof(str_local_ip), msg_info->local_ip);
+    get_ip_str(str_remote_ip, sizeof(str_remote_ip), msg_info->remote_ip);
+
+    dump_msg_info *org_msg = (dump_msg_info *) msg_info->org_msg;
+
+    printf("%-6d %-6d:%6d %-8s %-8s %-16s %-16s %-10d %-10d %-8d\n",
+           seq,
+           org_msg->dump_sec, org_msg->dump_usec,
+           get_l2_protocol_desc(msg_info->l2_protocol),
+           get_l3_protocol_desc(msg_info->l3_protocol),
+           str_local_ip,
+           str_remote_ip,
+           msg_info->local_port, msg_info->remote_port, org_msg->len);
+}
+
+void print_head()
+{
+    if (NULL != g_dump_fp)
+    {
+        write_file_head(g_dump_fp);
+    }
+    else
+    {
+        printf("ntcpdump start listening:\n");
+        printf("%-6s %-18s %-8s %-8s %-16s %-16s %-10s %-10s %-8s\n",
+               "Frame", "sec:usec", "L2", "L3", "Src IP", "Dest IP",
+               "Src Port", "Dest Port", "Length");
+    }
+}
+
+void register_dump_signal()
+{
+    signal(SIGINT, dump_exit);
+}
+
+NSTACK_STATIC inline void init_parse_msg_info(parse_msg_info * info)
+{
+    int retVal =
+        memset_s(info, sizeof(parse_msg_info), 0, sizeof(parse_msg_info));
+    if (EOK != retVal)
+    {
+        printf("MEMSET_S failed.\n");
+    }
+}
+
+NSTACK_STATIC inline void
+parse_msg(dump_msg_info * msg, parse_msg_info * info)
+{
+    init_parse_msg_info(info);
+
+    info->org_msg = msg;
+
+    char *pmsg = msg->buf;
+    u32 len = msg->len;
+    /* BEGIN: Added for PN:CODEDEX by l00351127, 2017/11/14 CID:50886 */
+    if (len < MAC_ADDR_LEN + MAC_ADDR_LEN + sizeof(u16))
+    {
+        return;
+    }
+    /* END:   Added for PN:CODEDEX by l00351127, 2017/11/14 */
+
+    // get mac addr
+    if (EOK !=
+        memcpy_s(info->remote_mac, sizeof(info->remote_mac), pmsg,
+                 MAC_ADDR_LEN))
+    {
+        return;
+    }
+
+    pmsg += MAC_ADDR_LEN;
+    len -= MAC_ADDR_LEN;
+
+    if (EOK !=
+        memcpy_s(info->local_mac, sizeof(info->local_mac), pmsg,
+                 MAC_ADDR_LEN))
+    {
+        return;
+    }
+
+    pmsg += MAC_ADDR_LEN;
+    len -= MAC_ADDR_LEN;
+
+    info->l2_protocol = htons(*(u16 *) pmsg);
+    pmsg += sizeof(u16);
+    len -= sizeof(u16);
+
+    if (PROTOCOL_IP != info->l2_protocol)
+    {
+        return;
+    }
+
+    ip_head *p_ip_head = (ip_head *) pmsg;
+    if (len < p_ip_head->ihl)
+    {
+        return;
+    }
+
+    info->local_ip = p_ip_head->local_ip;
+    info->remote_ip = p_ip_head->remote_ip;
+    info->l3_protocol = p_ip_head->protocol;
+
+    pmsg += p_ip_head->ihl * sizeof(u32);
+
+    if (PROTOCOL_TCP == info->l3_protocol)
+    {
+        tcp_head *p_tcp_head = (tcp_head *) pmsg;
+        info->local_port = htons(p_tcp_head->src_port);
+        info->remote_port = htons(p_tcp_head->dst_port);
+        return;
+    }
+
+    if (PROTOCOL_UDP == info->l3_protocol)
+    {
+        udp_head *p_udp_head = (udp_head *) pmsg;
+        info->local_port = htons(p_udp_head->src_port);
+        info->remote_port = htons(p_udp_head->dst_port);
+        return;
+    }
+
+    return;
+}
+
+NSTACK_STATIC inline bool
+time_expired(struct timespec * start_time, u32 work_sec)
+{
+#define TIME_EXPIRE_CHECK_COUNT 1000
+
+    static u32 loop_count = 0;
+    loop_count++;
+
+    if (0 != loop_count % TIME_EXPIRE_CHECK_COUNT)
+    {
+        return false;
+    }
+
+    struct timespec cur_time;
+    GET_CUR_TIME(&cur_time);
+
+    if (cur_time.tv_sec - start_time->tv_sec > work_sec)
+    {
+        return true;
+    }
+
+    return false;
+}
+
+NSTACK_STATIC void dump_packet(parse_msg_info * msg)
+{
+    g_dumped_packet++;
+    if (!g_dump_fp)
+    {
+        print_packet(msg, g_dumped_packet);
+        return;
+    }
+
+    write_packet(msg, g_dump_fp);
+}
+
+NSTACK_STATIC void
+dump_msg(mring_handle dump_ring, mring_handle dump_pool,
+         dump_condition * condition, struct timespec *start_time)
+{
+    u32 dump_count = 0;
+    open_file();
+
+    print_head();
+
+    void *msg = NULL;
+    while (!g_dump_exit
+           && (dump_count < condition->dump_count)
+           && !time_expired(start_time, condition->dump_time))
+    {
+        if (nsfw_mem_ring_dequeue(dump_ring, &msg) <= 0)
+        {
+            sys_sleep_ns(0, 10000);
+            continue;
+        }
+
+        if (NULL == msg)
+        {
+            continue;
+        }
+
+        parse_msg_info msg_info;
+        parse_msg(msg, &msg_info);
+
+        g_captured_packet++;
+        if (!condition->has_condition)
+        {
+            dump_packet(&msg_info);
+            dump_count++;
+            nsfw_mem_ring_enqueue(dump_pool, msg);
+            continue;
+        }
+
+        if (filter_by_condition(condition, &msg_info))
+        {
+            g_filtered_packet++;
+            nsfw_mem_ring_enqueue(dump_pool, msg);
+            continue;
+        }
+
+        dump_packet(&msg_info);
+        dump_count++;
+        nsfw_mem_ring_enqueue(dump_pool, msg);
+    }
+
+    close_file();
+}
+
+mring_handle dump_get_mem_ring()
+{
+    return nsfw_mem_ring_lookup(&g_dump_mem_ring_info);
+}
+
+mring_handle dump_get_mem_pool()
+{
+    return nsfw_mem_sp_lookup(&g_dump_mem_pool_info);
+}
+
+NSTACK_STATIC void dump_clear_mem(mring_handle ring, mring_handle pool)
+{
+    void *msg = NULL;
+    while (nsfw_mem_ring_dequeue(ring, &msg) > 0)
+    {
+        nsfw_mem_ring_enqueue(pool, msg);
+        sys_sleep_ns(0, 1000);
+    }
+}
+
+/* BEGIN: Added for PN:CODEDEX by l00351127, 2017/11/14 CID:50859*/
+i16 dump_send_req(u16 op_type, i16 task_id, u32 task_keep_time)
+/* END:   Added for PN:CODEDEX by l00351127, 2017/11/14 */
+{
+    nsfw_mgr_msg *req =
+        (nsfw_mgr_msg *) nsfw_mgr_msg_alloc(MGR_MSG_TOOL_TCPDUMP_REQ,
+                                            NSFW_PROC_MAIN);
+    if (NULL == req)
+    {
+        printf("all message for getting instance id failed.\n");
+        return -1;
+    }
+
+    nsfw_tool_dump_msg *req_body = GET_USER_MSG(nsfw_tool_dump_msg, req);
+    req_body->op_type = op_type;
+    req_body->task_id = task_id;
+    req_body->task_keep_time = task_keep_time;
+
+    nsfw_mgr_msg *rsp = nsfw_mgr_null_rspmsg_alloc();
+    if (NULL == rsp)
+    {
+        printf("alloc rsp message for getting memory failed.\n");
+        nsfw_mgr_msg_free(req);
+        return -1;
+    }
+
+    if (!nsfw_mgr_send_req_wait_rsp(req, rsp))
+    {
+        printf("request memory can not get response.\n");
+        nsfw_mgr_msg_free(req);
+        nsfw_mgr_msg_free(rsp);
+        return -1;
+    }
+
+    if (rsp->src_proc_type != NSFW_PROC_MAIN
+        || rsp->dst_proc_type != NSFW_PROC_TOOLS)
+    {
+        printf
+            ("dump get wrong response, src or dst proc type error,src proc type=%u, dst proc type=%u.\n",
+             rsp->src_proc_type, rsp->dst_proc_type);
+        nsfw_mgr_msg_free(req);
+        nsfw_mgr_msg_free(rsp);
+        return -1;
+    }
+
+    if (rsp->msg_type != MGR_MSG_TOOL_TCPDUMP_RSP)
+    {
+        printf("dump get wrong response, msg type error, msg type=%d.\n",
+               rsp->msg_type);
+        nsfw_mgr_msg_free(req);
+        nsfw_mgr_msg_free(rsp);
+        return -1;
+    }
+
+    nsfw_tool_dump_msg *rsp_body = GET_USER_MSG(nsfw_tool_dump_msg, rsp);
+
+/* BEGIN: Added for PN:CODEDEX by l00351127, 2017/11/14 CID:50859*/
+    i16 new_task_id = rsp_body->task_id;
+/* END:   Added for PN:CODEDEX by l00351127, 2017/11/14 */
+
+    nsfw_mgr_msg_free(req);
+    nsfw_mgr_msg_free(rsp);
+
+    return new_task_id;
+}
+
+i16 start_dump_task(u32 task_keep_time)
+{
+    return dump_send_req(START_DUMP_REQ, -1, task_keep_time);
+}
+
+i16 stop_dump_task(i16 task_id)
+{
+    return dump_send_req(STOP_DUMP_REQ, task_id, 0);
+}
+
+NSTACK_STATIC void init_dump_condition(dump_condition * condition)
+{
+    if (EOK !=
+        memset_s(condition, sizeof(dump_condition), 0,
+                 sizeof(dump_condition)))
+    {
+        printf("MEMSET_S failed.\n");
+    }
+    condition->limit_len = DUMP_MSG_SIZE;
+    condition->dump_time = DEFAULT_DUMP_TIME;
+    condition->direction = 3;
+    condition->dump_count = DEFAULT_DUMP_COUNT;
+}
+
+NSTACK_STATIC inline bool send_hbt_req(u32 seq, i16 task_id)
+{
+    nsfw_mgr_msg *req =
+        (nsfw_mgr_msg *) nsfw_mgr_msg_alloc(MGR_MSG_TOOL_HEART_BEAT,
+                                            NSFW_PROC_MAIN);
+    if (NULL == req)
+    {
+        printf("all message for getting instance id failed.\n");
+        return false;
+    }
+
+    nsfw_tool_hbt *req_body = GET_USER_MSG(nsfw_tool_hbt, req);
+    req_body->seq = seq;
+    req_body->task_id = task_id;
+
+    if (!nsfw_mgr_send_msg(req))
+    {
+        printf("request memory can not get response.\n");
+    }
+
+    nsfw_mgr_msg_free(req);
+
+    return true;
+}
+
+NSTACK_STATIC bool on_send_hbt_req(u32 timer_type, void *data)
+{
+    dump_timer_info *ptimer_info = (dump_timer_info *) data;
+    // send heartbeat
+
+    send_hbt_req(ptimer_info->seq, ptimer_info->task_id);
+    ptimer_info->seq++;
+
+    ptimer_info->ptimer =
+        nsfw_timer_reg_timer(DUMP_HBT_TIMER, ptimer_info, on_send_hbt_req,
+                             *(struct timespec *) (ptimer_info->interval));
+    return true;
+}
+
+NSTACK_STATIC bool start_dump_hbt(dump_timer_info * ptimer_info, i16 task_id)
+{
+    struct timespec *time_interval =
+        (struct timespec *) malloc(sizeof(struct timespec));
+    if (NULL == time_interval)
+    {
+        return false;
+    }
+
+    time_interval->tv_sec = DUMP_HBT_INTERVAL;
+    time_interval->tv_nsec = 0;
+
+    ptimer_info->interval = time_interval;
+    ptimer_info->seq = 1;
+    ptimer_info->task_id = task_id;
+
+    ptimer_info->ptimer =
+        nsfw_timer_reg_timer(DUMP_HBT_TIMER, ptimer_info, on_send_hbt_req,
+                             *time_interval);
+
+    return true;
+}
+
+NSTACK_STATIC bool stop_dump_hbt(dump_timer_info * ptimer_info)
+{
+    free(ptimer_info->interval);
+    /* fix "SET_NULL_AFTER_FREE" type codedex issue */
+    ptimer_info->interval = NULL;
+    nsfw_timer_rmv_timer(ptimer_info->ptimer);
+    return true;
+}
+
+#ifndef NSTACK_STATIC_CHECK
+int main(int argc, char *argv[])
+#else
+int ntcpdump_main(int argc, char *argv[])
+#endif
+{
+    register_dump_signal();
+
+    init_dump_condition(&g_dump_condition);
+    if (!get_dump_condition(argc, argv, &g_dump_condition))
+    {
+        printf("dump exit because of input invalid.\n");
+        return INPUT_INVALID;
+    }
+
+    printf("parse filter condition ok.\n");
+
+    fw_poc_type proc_type = NSFW_PROC_TOOLS;
+    nsfw_mem_para stinfo = { 0 };
+    stinfo.iargsnum = 0;
+    stinfo.pargs = NULL;
+    stinfo.enflag = proc_type;
+    nstack_framework_set_module_param(NSFW_MEM_MGR_MODULE, &stinfo);
+    nstack_framework_set_module_param(NSFW_MGR_COM_MODULE,
+                                      (void *) ((u64) proc_type));
+    nstack_framework_set_module_param(NSFW_TIMER_MODULE,
+                                      (void *) ((u64) proc_type));
+
+    if (0 != nstack_framework_init())
+    {
+        printf("dump init failed.\n");
+        return FRAMEWORK_INIT_FAILED;
+    }
+
+    mring_handle dump_mem_pool = dump_get_mem_pool();
+    if (NULL == dump_mem_pool)
+    {
+        printf("dump init mem pool failed.\n");
+        return MEMPOOL_INIT_FAILED;
+    }
+
+    mring_handle dump_mem_ring = dump_get_mem_ring();
+    if (NULL == dump_mem_ring)
+    {
+        printf("dump init mem ring failed.\n");
+        return MEMRING_INIT_FAILED;
+    }
+
+    // initialize queue first
+    dump_clear_mem(dump_mem_ring, dump_mem_pool);
+
+    i16 task_id = start_dump_task(g_dump_condition.dump_time);
+    if (task_id < 0 || task_id > MAX_DUMP_TASK)
+    {
+        printf("start dump task failed.\n");
+        return START_TASK_FAILED;
+    }
+
+    if (!start_dump_hbt(&g_dump_hbt_timer, task_id))
+    {
+        printf("start dump heart beat timer failed.\n");
+        return START_TIMER_FAILED;
+    }
+
+    struct timespec dump_start_time;
+    GET_CUR_TIME(&dump_start_time);
+    dump_msg(dump_mem_ring, dump_mem_pool, &g_dump_condition,
+             &dump_start_time);
+
+    i16 new_task_id = stop_dump_task(task_id);
+    if (new_task_id != task_id)
+    {
+        printf("stop dump task failed.\n");
+    }
+    /* modify deadcode type codedex issue */
+    (void) stop_dump_hbt(&g_dump_hbt_timer);
+
+    printf("dump complete.\n");
+    printf("captured packets=%u.\n", g_captured_packet);
+    printf("dumped packets=%u.\n", g_dumped_packet);
+    printf("filtered packets=%u.\n", g_filtered_packet);
+
+    return 0;
+}
diff --git a/stacks/lwip_stack/tools/tool_common.h b/stacks/lwip_stack/tools/tool_common.h
new file mode 100644
index 0000000..5a302d1
--- /dev/null
+++ b/stacks/lwip_stack/tools/tool_common.h
@@ -0,0 +1,243 @@
+/*
+*
+* Copyright (c) 2018 Huawei Technologies Co.,Ltd.
+* 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.
+*/
+
+#ifndef _TOOL_COMMON_H_
+#define _TOOL_COMMON_H_
+
+#include <time.h>
+#include "types.h"
+
+#ifndef NSTACK_STATIC
+#ifndef NSTACK_STATIC_CHECK
+#define NSTACK_STATIC static
+#else
+#define NSTACK_STATIC
+#endif
+#endif
+
+#ifndef IP_ADDR_LEN
+#define IP_ADDR_LEN 16
+#endif
+
+#ifndef MAC_ADDR_LEN
+#define MAC_ADDR_LEN 6
+#endif
+
+#ifndef MAC_ADDR_STR_LEN
+#define MAC_ADDR_STR_LEN 17
+#endif
+
+#define ICMP_ECHO 8
+#define ICMP_REPLY 0
+#define MS_TO_NS 1000000
+#define US_TO_NS 1000
+#define NPING_RETRY_COUNT 1000
+#define MAX_NPING_RETRY_COUNT 20000
+
+#define MAX_PORT_STR_LEN 5
+#define MAX_IP_STR_LEN 15
+#define MAX_INTEGER_STR_LEN 10
+
+#define DUMP_HBT_TIMER 1
+
+#define INVALID_DIRECTION 0xFFFF
+#define DEFAULT_DUMP_COUNT 1000
+
+#ifndef CUSTOM_SOCK_TYPE
+#define CUSTOM_SOCK_TYPE 0xF001
+#endif
+
+enum DUMP_ERR_CODE
+{
+    RET_OK = 0,
+    INPUT_INVALID = 1,
+    FRAMEWORK_INIT_FAILED = 2,
+    MEMPOOL_INIT_FAILED = 3,
+    MEMRING_INIT_FAILED = 4,
+    START_TASK_FAILED = 5,
+    START_TIMER_FAILED = 6,
+    UNKNOW_ERR
+};
+
+enum COND_LOCAL_REMOTE_SET
+{
+    COND_NOT_SET = 0,
+    COND_REMOTE_SET = 0x1,
+    COND_LOCAL_SET = 0x2,
+    COND_AND_SET = 0x3,
+    COND_OR_SET = 0x4
+};
+
+enum DUMP_OPT_ARG
+{
+    OPT_ARG_HOST = 256,
+    OPT_ARG_LOCAL_HOST,
+    OPT_ARG_REMOTE_HOST,
+    OPT_ARG_PORT,
+    OPT_ARG_LOCAL_PORT,
+    OPT_ARG_REMOTE_PORT,
+    OPT_ARG_MAC,
+    OPT_ARG_LOCAL_MAC,
+    OPT_ARG_REMOTE_MAC,
+    OPT_ARG_INVALID
+};
+
+typedef struct _ip_head
+{
+    u8 ihl:4;
+    u8 version:4;
+    u8 tos;
+    u16 tot_len;
+    u16 id;
+    u16 frag_off;
+    u8 ttl;
+    u8 protocol;
+    u16 chk_sum;
+    u32 local_ip;
+    u32 remote_ip;
+} ip_head;
+
+typedef struct _tcp_head
+{
+    u16 src_port;
+    u16 dst_port;
+    u32 seq_no;
+    u32 ack_no;
+} tcp_head;
+
+typedef struct _udp_head
+{
+    u16 src_port;
+    u16 dst_port;
+    u16 uhl;
+    u16 chk_sum;
+} udp_head;
+
+typedef struct _dump_file_head
+{
+    u32 magic;
+    u16 major_ver;
+    u16 minor_ver;
+    u32 area;
+    u32 time_stamp;
+    u32 max_pack_size;
+    u32 link_type;
+} dump_file_head;
+
+typedef struct _packet_head
+{
+    u32 sec;
+    u32 usec;
+    u32 save_len;
+    u32 org_len;
+} packet_head;
+
+typedef struct _ip_addr_bits
+{
+    u32 addr_bits1;
+    u32 addr_bits2;
+    u32 addr_bits3;
+    u32 addr_bits4;
+} ip_addr_bits;
+
+typedef struct _parse_msg_info
+{
+    u16 l2_protocol;            // ARP/IP/OAM/LACP
+    u16 l3_protocol;            // TCP/UDP/ICMP
+    u16 local_port;
+    u16 remote_port;
+    u32 local_ip;
+    u32 remote_ip;
+    char local_mac[MAC_ADDR_LEN + 1];
+    char remote_mac[MAC_ADDR_LEN + 1];
+
+    void *org_msg;
+} parse_msg_info;
+
+typedef struct _dump_condition
+{
+    bool has_condition;
+    u32 dump_count;
+    u32 dump_time;
+    u32 limit_len;
+    u16 direction;              //1:send 2:recv 3:send-recv
+    u16 l2_protocol;            // ARP/IP/OAM/LACP
+    u16 l3_protocol;            // TCP/UDP/ICMP
+    u16 port_set_flag;
+    u16 port;
+    u16 local_port;
+    u16 remote_port;
+    u16 ip_set_flag;
+    u32 ip_addr;
+    u32 local_ip;
+    u32 remote_ip;
+    u16 mac_set_flag;
+    char mac_addr[MAC_ADDR_LEN + 1];
+    char local_mac[MAC_ADDR_LEN + 1];
+    char remote_mac[MAC_ADDR_LEN + 1];
+
+    char *dump_file_name;
+} dump_condition;
+
+typedef struct _icmp_head
+{
+    u8 icmp_type;
+    u8 icmp_code;
+    u16 icmp_cksum;
+    u16 icmp_id;
+    u16 icmp_seq;
+    u32 timestamp;
+
+    long icmp_sec;
+    long icmp_nsec;
+} icmp_head;
+
+typedef struct _ning_input_info
+{
+    i32 send_count;             // total send req
+    i32 retry_count;            // retry count for 1 req
+    char src_ip[IP_ADDR_LEN];
+    char dst_ip[IP_ADDR_LEN];
+} input_info;
+
+typedef struct _nping_stat_info
+{
+    u32 send_seq;
+    u32 recv_ok;
+    double all_interval;
+    double min_interval;
+    double max_interval;
+    struct timespec start_time;
+    struct timespec end_time;
+} stat_info;
+
+#ifndef sys_sleep_ns
+#define sys_sleep_ns(_s, _ns)\
+{ \
+    if (_s >= 0 && _ns >= 0) \
+    { \
+        struct timespec delay, remain; \
+        delay.tv_sec = _s; \
+        delay.tv_nsec = _ns; \
+        while (nanosleep(&delay, &remain) < 0) \
+        { \
+            delay = remain; \
+        } \
+    } \
+}
+#endif
+
+#endif