Merge "IPA configuration manager daemon and IPA NAT library."
diff --git a/Makefile.am b/Makefile.am
new file mode 100644
index 0000000..fab2aff
--- /dev/null
+++ b/Makefile.am
@@ -0,0 +1,3 @@
+ACLOCAL_AMFLAGS = -I m4
+AUTOMAKE_OPTIONS = foreign
+SUBDIRS = ipanat/src ipacm/src/
diff --git a/configure.ac b/configure.ac
new file mode 100644
index 0000000..f826305
--- /dev/null
+++ b/configure.ac
@@ -0,0 +1,31 @@
+# -*- Autoconf -*-
+# Process this file with autoconf to produce a configure script.
+
+AC_PREREQ([2.65])
+AC_INIT(data-ipa, 1.0.0)
+AM_INIT_AUTOMAKE(data-ipa, 1.0.0)
+AC_OUTPUT(Makefile ipanat/src/Makefile ipacm/src/Makefile)
+AC_CONFIG_SRCDIR([ipanat/src/ipa_nat_drv.c])
+AC_CONFIG_HEADERS([config.h])
+AC_CONFIG_MACRO_DIR([m4])
+
+# Checks for programs.
+AC_PROG_CC
+AC_PROG_LIBTOOL
+AC_PROG_CXX
+
+
+# Checks for libraries.
+
+# Checks for header files.
+AC_CHECK_HEADERS([fcntl.h netinet/in.h sys/ioctl.h unistd.h])
+
+# Checks for typedefs, structures, and compiler characteristics.
+AC_TYPE_OFF_T
+
+# Checks for library functions.
+AC_FUNC_MALLOC
+AC_FUNC_MMAP
+AC_CHECK_FUNCS([memset munmap])
+
+AC_OUTPUT
diff --git a/ipacm/inc/IPACM_CmdQueue.h b/ipacm/inc/IPACM_CmdQueue.h
new file mode 100644
index 0000000..4eb4be7
--- /dev/null
+++ b/ipacm/inc/IPACM_CmdQueue.h
@@ -0,0 +1,108 @@
+/*
+Copyright (c) 2013, The Linux Foundation. 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 name of The Linux 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 "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+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.
+*/
+/*!
+ @file
+ IPACM_CmdQueue.h
+
+ @brief
+ This file implements the IPAM Comment Queue definitions
+
+ @Author
+
+*/
+#ifndef IPA_CONNTRACK_MESSAGE_H
+#define IPA_CONNTRACK_MESSAGE_H
+
+#include <iostream>
+#include <pthread.h>
+#include "IPACM_Defs.h"
+
+
+
+/*---------------------------------------------------------------------------
+ Event data required by IPA_CM
+---------------------------------------------------------------------------*/
+
+
+typedef struct _ipacm_cmd_q_data {
+ ipa_cm_event_id event;
+ void *evt_data;
+}ipacm_cmd_q_data;
+
+typedef struct cmd_s
+{
+ void (*callback_ptr)(ipacm_cmd_q_data *);
+ ipacm_cmd_q_data data;
+}cmd_t;
+
+class Message
+{
+private:
+ Message *m_next;
+
+public:
+ cmd_t evt;
+
+ Message()
+ {
+ m_next = NULL;
+ evt.callback_ptr = NULL;
+ }
+ ~Message() { }
+ void setnext(Message *item) { m_next = item; }
+ Message* getnext() { return m_next; }
+};
+
+class MessageQueue
+{
+
+private:
+ Message *Head;
+ Message *Tail;
+ Message* dequeue(void);
+ static MessageQueue *inst;
+
+ MessageQueue()
+ {
+ Head = NULL;
+ Tail = NULL;
+ }
+
+public:
+
+ ~MessageQueue() { }
+ void enqueue(Message *item);
+
+ static void* Process(void *);
+ static MessageQueue* getInstance();
+
+};
+
+#endif /* IPA_CONNTRACK_MESSAGE_H */
+
diff --git a/ipacm/inc/IPACM_Config.h b/ipacm/inc/IPACM_Config.h
new file mode 100644
index 0000000..f0d356f
--- /dev/null
+++ b/ipacm/inc/IPACM_Config.h
@@ -0,0 +1,93 @@
+/*
+Copyright (c) 2013, The Linux Foundation. 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 name of The Linux 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 "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+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.
+*/
+/*!
+ @file
+ IPACM_Config.h
+
+ @brief
+ This file implements the IPACM Configuration from XML file
+
+ @Author
+ Skylar Chang
+
+*/
+#ifndef IPACM_CONFIG_H
+#define IPACM_CONFIG_H
+
+#include "IPACM_Defs.h"
+#include "IPACM_Xml.h"
+
+/* iface */
+class IPACM_Config
+{
+public:
+
+ /* Store interested interface and their configuration from XML file */
+ ipa_ifi_dev_name_t *iface_table;
+
+ /* Store interested ALG port from XML file */
+ ipacm_alg *alg_table;
+
+ /* Store private subnet configuration from XML file */
+ ipa_private_subnet private_subnet_table[IPA_MAX_PRIVATE_SUBNET_ENTRIES];
+
+ /* Store the number of interface IPACM read from XML file */
+ int ipa_num_ipa_interfaces;
+
+ int ipa_num_private_subnet;
+
+ int ipa_num_alg_ports;
+
+ int ipa_nat_max_entries;
+
+ /* IPACM routing table name for v4/v6 */
+ struct ipa_ioc_get_rt_tbl rt_tbl_lan_v4, rt_tbl_wan_v4, rt_tbl_v6;
+
+ /* To return the instance */
+ static IPACM_Config* GetInstance();
+
+ inline int GetAlgPortCnt()
+ {
+ return ipa_num_alg_ports;
+ }
+
+ int GetAlgPorts(int nPorts, ipacm_alg *pAlgPorts);
+ int GetNatMaxEntries(void)
+ {
+ return ipa_nat_max_entries;
+ }
+
+private:
+ static IPACM_Config *pInstance;
+ IPACM_Config(void);
+ int Init(void);
+
+};
+
+#endif /* IPACM_CONFIG */
diff --git a/ipacm/inc/IPACM_ConntrackClient.h b/ipacm/inc/IPACM_ConntrackClient.h
new file mode 100644
index 0000000..b125c68
--- /dev/null
+++ b/ipacm/inc/IPACM_ConntrackClient.h
@@ -0,0 +1,98 @@
+/*
+Copyright (c) 2013, The Linux Foundation. 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 name of The Linux 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 "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+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 IPACM_CONNTRACK_FILTER_H
+#define IPACM_CONNTRACK_FILTER_H
+
+#include <iostream>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <errno.h>
+
+#include "IPACM_ConntrackClient.h"
+#include "IPACM_CmdQueue.h"
+#include "IPACM_Conntrack_NATApp.h"
+#include "IPACM_EvtDispatcher.h"
+#include "IPACM_Defs.h"
+
+#ifndef IPACM_DEBUG
+#define IPACM_DEBUG
+#endif
+
+extern "C"
+{
+#include <libnetfilter_conntrack/libnetfilter_conntrack.h>
+#include <libnetfilter_conntrack/libnetfilter_conntrack_tcp.h>
+}
+
+using namespace std;
+
+#define UDP_TIMEOUT_UPDATE 20
+#define BROADCAST_IPV4_ADDR 0xFFFFFFFF
+
+class IPACM_ConntrackClient
+{
+
+private:
+ static IPACM_ConntrackClient *pInstance;
+
+ struct nfct_handle *tcp_hdl;
+ struct nfct_handle *udp_hdl;
+ struct nfct_filter *tcp_filter;
+ struct nfct_filter *udp_filter;
+
+ static int IPA_Conntrack_Filters_Ignore_Local_Addrs(struct nfct_filter *filter);
+ IPACM_ConntrackClient();
+
+public:
+ static int IPAConntrackEventCB(enum nf_conntrack_msg_type type,
+ struct nf_conntrack *ct,
+ void *data);
+
+ static int IPA_Conntrack_UDP_Filter_Init(void);
+ static int IPA_Conntrack_TCP_Filter_Init(void);
+ static void* TCPRegisterWithConnTrack(void *);
+ static void* UDPRegisterWithConnTrack(void *);
+ static void* UDPConnTimeoutUpdate(void *ptr);
+
+ static void UpdateUDPFilters(void *);
+ static void UpdateTCPFilters(void *);
+
+ static IPACM_ConntrackClient* GetInstance();
+
+#ifdef IPACM_DEBUG
+ static void iptodot(const char *type, uint32_t ipAddr);
+#endif
+
+};
+
+#endif /* IPACM_CONNTRACK_FILTER_H */
diff --git a/ipacm/inc/IPACM_ConntrackListener.h b/ipacm/inc/IPACM_ConntrackListener.h
new file mode 100644
index 0000000..3cea83a
--- /dev/null
+++ b/ipacm/inc/IPACM_ConntrackListener.h
@@ -0,0 +1,68 @@
+/*
+Copyright (c) 2013, The Linux Foundation. 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 name of The Linux 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 "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+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 IPACM_CONNTRACK_LISTENER
+#define IPACM_CONNTRACK_LISTENER
+
+#include <iostream>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <errno.h>
+
+#include "IPACM_CmdQueue.h"
+#include "IPACM_Conntrack_NATApp.h"
+#include "IPACM_Listener.h"
+
+using namespace std;
+
+class IPACM_ConntrackListener : public IPACM_Listener
+{
+
+private:
+ bool isCTReg;
+ bool isWanUp;
+
+ void ProcessCTMessage(void *data);
+ void ProcessTCPorUDPMsg(struct nf_conntrack *ct, enum nf_conntrack_msg_type, u_int8_t);
+ void TriggerWANUp(void *);
+ void TriggerWANDown(uint32_t wan_addr);
+ int CreateNatThreads(void);
+
+public:
+ char wan_ifname[IPA_IFACE_NAME_LEN];
+ uint32_t wan_ipaddr;
+ IPACM_ConntrackListener();
+ void event_callback(ipa_cm_event_id, void *data);
+};
+
+#endif /* IPACM_CONNTRACK_LISTENER */
diff --git a/ipacm/inc/IPACM_Conntrack_NATApp.h b/ipacm/inc/IPACM_Conntrack_NATApp.h
new file mode 100644
index 0000000..3e1f5a6
--- /dev/null
+++ b/ipacm/inc/IPACM_Conntrack_NATApp.h
@@ -0,0 +1,118 @@
+/*
+Copyright (c) 2013, The Linux Foundation. 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 name of The Linux 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 "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+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 IPACM_CONNTRACK_NATAPP_H
+#define IPACM_CONNTRACK_NATAPP_H
+
+#include <string.h> /* for stderror */
+#include <stdlib.h>
+#include <cstdio> /* for perror */
+
+#include "IPACM_Config.h"
+#include "IPACM_Xml.h"
+
+extern "C"
+{
+#include <libnetfilter_conntrack/libnetfilter_conntrack.h>
+#include <ipa_nat_drv.h>
+}
+
+#define IPACM_DEBUG
+
+typedef struct _nat_table_entry
+{
+ uint32_t private_ip;
+ uint16_t private_port;
+
+ uint32_t target_ip;
+ uint16_t target_port;
+
+ uint16_t public_port;
+
+ u_int8_t protocol;
+ uint32_t timestamp;
+
+ bool dst_nat;
+ uint32_t rule_hdl;
+
+}nat_table_entry;
+
+#define CHK_TBL_HDL() if(0 == nat_table_hdl){\
+ int n =0; \
+ n = snprintf(log_buf, sizeof(log_buf), "%s:%d %s() %s", __FILE__, __LINE__, __FUNCTION__, "Error:");\
+ snprintf((log_buf+n), (sizeof(log_buf)-n)-1, "Invalid table handle\n");\
+ logmessage(log_buf);\
+ }
+
+class NatApp
+{
+private:
+
+ static NatApp *pInstance;
+
+ nat_table_entry *cache;
+ uint32_t pub_ip_addr;
+ uint32_t nat_table_hdl;
+
+ int curCnt, max_entries;
+
+ ipacm_alg *pALGPorts;
+ uint16_t nALGPort;
+
+ uint32_t PwrSaveIfs[IPA_MAX_NUM_WIFI_CLIENTS];
+
+ struct nf_conntrack *ct;
+ struct nfct_handle *ct_hdl;
+
+ NatApp();
+ int Init();
+
+ void UpdateCTUdpTs(nat_table_entry *, uint32_t);
+ bool ChkForDup(const nat_table_entry *);
+ bool isAlgPort(uint8_t, uint16_t);
+ void Reset();
+ bool isPwrSaveIf(uint32_t);
+
+public:
+ static NatApp* GetInstance();
+
+ int AddTable(uint32_t);
+ int DeleteTable(uint32_t);
+
+ int AddEntry(const nat_table_entry *);
+ int DeleteEntry(const nat_table_entry *);
+
+ void UpdateUDPTimeStamp();
+
+ int UpdatePwrSaveIf(uint32_t);
+ int ResetPwrSaveIf(uint32_t);
+};
+
+
+
+#endif /* IPACM_CONNTRACK_NATAPP_H */
diff --git a/ipacm/inc/IPACM_Defs.h b/ipacm/inc/IPACM_Defs.h
new file mode 100644
index 0000000..19ddbec
--- /dev/null
+++ b/ipacm/inc/IPACM_Defs.h
@@ -0,0 +1,178 @@
+/*
+Copyright (c) 2013, The Linux Foundation. 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 name of The Linux 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 "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+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.
+*/
+/*!
+ @file
+ IPACM_Defs.h
+
+ @brief
+ This file implements the common definitions amon all ifaces.
+
+ @Author
+ Skylar Chang
+
+*/
+#ifndef IPA_CM_DEFS_H
+#define IPA_CM_DEFS_H
+
+#include <linux/msm_ipa.h>
+#include "IPACM_Log.h"
+
+extern "C"
+{
+#include <libnetfilter_conntrack/libnetfilter_conntrack.h>
+#include <libnetfilter_conntrack/libnetfilter_conntrack_tcp.h>
+}
+
+
+#define IPA_MAX_FILE_LEN 64
+#define IPA_IFACE_NAME_LEN 16
+#define IPA_ALG_PROTOCOL_NAME_LEN 10
+
+#define IPA_WLAN_PARTIAL_HDR_OFFSET 12 // dst mac first then src mac
+#define IPA_VIRTUAL_IFACE_NAME "bridge0"
+#define IPA_WLAN_PARTIAL_HDR_NAME "IEEE802_3"
+#define IPA_MAX_IFACE_ENTRIES 15
+#define IPA_MAX_PRIVATE_SUBNET_ENTRIES 3
+#define IPA_MAX_ALG_ENTRIES 10
+
+#define V4_LAN_ROUTE_TABLE_NAME "COMRTBLLANv4"
+#define V4_WAN_ROUTE_TABLE_NAME "WANRTBLv4"
+#define V6_COMMON_ROUTE_TABLE_NAME "COMRTBLv6"
+
+
+
+/*---------------------------------------------------------------------------
+ Return values indicating error status
+---------------------------------------------------------------------------*/
+
+#define IPACM_SUCCESS 0 /* Successful operation */
+#define IPACM_FAILURE -1 /* Unsuccessful operation */
+
+#define IPACM_IP_NULL (ipa_ip_type)0xFF
+#define IPACM_INVALID_INDEX (ipa_ip_type)0xFF
+
+#define IPA_MAX_NUM_WIFI_CLIENTS 15
+#define IPA_MAX_NUM_AMPDU_RULE 15
+#define IPA_MAC_ADDR_SIZE 6
+
+/*===========================================================================
+ GLOBAL DEFINITIONS AND DECLARATIONS
+===========================================================================*/
+typedef enum
+{
+ IPA_LINK_UP_EVENT = 1, /* ipacm_event_data_fid */
+ IPA_LINK_DOWN_EVENT, /* 2 ipacm_event_data_fid */
+ IPA_ADDR_ADD_EVENT, /* 3 ipacm_event_data_addr */
+ IPA_ADDR_DEL_EVENT, /* 4 no use */
+ IPA_ROUTE_ADD_EVENT, /* 5 ipacm_event_data_addr */
+ IPA_ROUTE_DEL_EVENT, /* 6 ipacm_event_data_addr */
+ IPA_FIREWALL_CHANGE_EVENT, /* 7 NULL */
+ IPA_WLAN_CLIENT_ADD_EVENT, /* 8 ipacm_event_data_mac */
+ IPA_WLAN_CLIENT_DEL_EVENT, /* 9 ipacm_event_data_mac */
+ IPA_WLAN_CLIENT_POWER_SAVE_EVENT, /* 10 ipacm_event_data_mac */
+ IPA_WLAN_CLIENT_RECOVER_EVENT, /* 11 ipacm_event_data_mac */
+ IPA_NEW_NEIGH_EVENT, /* 12 ipacm_event_data_all */
+ IPA_DEL_NEIGH_EVENT, /* 13 ipacm_event_data_all */
+ IPA_NEIGH_CLIENT_IP_ADDR_ADD_EVENT, /* 14 ipacm_event_data_all */
+ IPA_NEIGH_CLIENT_IP_ADDR_DEL_EVENT, /* 15 ipacm_event_data_all */
+ IPA_SW_ROUTING_ENABLE, /* 16 NULL */
+ IPA_SW_ROUTING_DISABLE, /* 17 NULL */
+ IPA_PROCESS_CT_MESSAGE, /* 18 ipacm_ct_evt_data */
+ IPA_HANDLE_WAN_UP, /* 19 unsigned long */
+ IPA_HANDLE_WAN_DOWN, /* 20 unsigned long */
+ IPA_HANDLE_WLAN_UP, /* 21 unsigned long */
+ IPA_HANDLE_LAN_UP /* 22 unsigned long */
+} ipa_cm_event_id;
+
+typedef enum
+{
+ LAN_IF = 0,
+ WLAN_IF,
+ WAN_IF,
+ VIRTUAL_IF
+} ipacm_iface_type;
+
+typedef struct
+{
+ struct nf_conntrack *ct;
+ enum nf_conntrack_msg_type type;
+}ipacm_ct_evt_data;
+
+typedef struct
+{
+ char iface_name[IPA_IFACE_NAME_LEN];
+ ipacm_iface_type if_cat;
+ int netlink_interface_index;
+} ipa_ifi_dev_name_t;
+
+typedef struct
+{
+ uint32_t subnet_addr;
+ uint32_t subnet_mask;
+} ipa_private_subnet;
+
+
+typedef struct _ipacm_event_data_all
+{
+ enum ipa_ip_type iptype;
+ int if_index;
+ uint32_t ipv4_addr;
+ uint32_t ipv6_addr[4];
+ uint8_t mac_addr[6];
+} ipacm_event_data_all;
+
+typedef struct _ipacm_event_data_fid
+{
+ int if_index;
+} ipacm_event_data_fid;
+
+typedef struct _ipacm_event_data_addr
+{
+ enum ipa_ip_type iptype;
+ int if_index;
+ uint32_t ipv4_addr;
+ uint32_t ipv4_addr_mask;
+ uint32_t ipv6_addr[4];
+ uint32_t ipv6_addr_mask[4];
+} ipacm_event_data_addr;
+
+typedef struct _ipacm_event_data_mac
+{
+ int if_index;
+ uint8_t mac_addr[6];
+} ipacm_event_data_mac;
+
+typedef struct _ipacm_event_iface_up
+{
+ char ifname[IPA_IFACE_NAME_LEN];
+ uint32_t ipv4_addr;
+ uint32_t addr_mask;
+}ipacm_event_iface_up;
+
+#endif /* IPA_CM_DEFS_H */
diff --git a/ipacm/inc/IPACM_EvtDispatcher.h b/ipacm/inc/IPACM_EvtDispatcher.h
new file mode 100644
index 0000000..550f4d4
--- /dev/null
+++ b/ipacm/inc/IPACM_EvtDispatcher.h
@@ -0,0 +1,76 @@
+/*
+Copyright (c) 2013, The Linux Foundation. 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 name of The Linux 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 "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+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.
+*/
+
+/*!
+ @file
+ IPACM_EvtDispatcher.h
+
+ @brief
+ This file implements the IPAM event dispatcher definitions
+
+ @Author
+
+*/
+#ifndef IPACM_EvtDispatcher_H
+#define IPACM_EvtDispatcher_H
+
+#include <stdio.h>
+#include <IPACM_CmdQueue.h>
+#include "IPACM_Defs.h"
+#include "IPACM_Listener.h"
+
+/* queue */
+typedef struct _cmd_evts
+{
+ ipa_cm_event_id event;
+ IPACM_Listener *obj;
+ //int ipa_interface_index;
+ _cmd_evts *next;
+} cmd_evts;
+
+
+
+class IPACM_EvtDispatcher
+{
+public:
+
+ /* api for all iface instances to register events */
+ static int registr(ipa_cm_event_id event, IPACM_Listener *obj);
+
+ /* api for all iface instances to de-register events */
+ static int deregistr(IPACM_Listener *obj);
+
+ static int PostEvt(ipacm_cmd_q_data *);
+ static void ProcessEvt(ipacm_cmd_q_data *);
+
+private:
+ static cmd_evts *head;
+};
+
+#endif /* IPACM_EvtDispatcher_H */
diff --git a/ipacm/inc/IPACM_Filtering.h b/ipacm/inc/IPACM_Filtering.h
new file mode 100644
index 0000000..2d49abf
--- /dev/null
+++ b/ipacm/inc/IPACM_Filtering.h
@@ -0,0 +1,69 @@
+/*
+Copyright (c) 2013, The Linux Foundation. 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 name of The Linux 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 "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+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.
+*/
+
+/*!
+ @file
+ IPACM_Filtering.h
+
+ @brief
+ This file implements the IPACM filtering definitions
+
+ @Author
+ Skylar Chang
+
+*/
+
+#ifndef IPACM_FILTERING_H
+#define IPACM_FILTERING_H
+
+#include <stdint.h>
+#include <linux/msm_ipa.h>
+#include <IPACM_Defs.h>
+
+class IPACM_Filtering
+{
+public:
+ IPACM_Filtering();
+ ~IPACM_Filtering();
+ bool AddFilteringRule(struct ipa_ioc_add_flt_rule const *ruleTable);
+ bool DeleteFilteringRule(struct ipa_ioc_del_flt_rule *ruleTable);
+ bool Commit(enum ipa_ip_type ip);
+ bool Reset(enum ipa_ip_type ip);
+ bool DeviceNodeIsOpened();
+ bool DeleteFilteringHdls(uint32_t *flt_rule_hdls,
+ ipa_ip_type ip,
+ uint8_t num_rules);
+
+private:
+ static const char *DEVICE_NAME;
+ int fd; /* File descriptor of the IPA device node /dev/ipa */
+};
+
+#endif //IPACM_FILTERING_H
+
diff --git a/ipacm/inc/IPACM_Header.h b/ipacm/inc/IPACM_Header.h
new file mode 100644
index 0000000..b6973cb
--- /dev/null
+++ b/ipacm/inc/IPACM_Header.h
@@ -0,0 +1,68 @@
+/*
+Copyright (c) 2013, The Linux Foundation. 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 name of The Linux 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 "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+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.
+*/
+
+/*
+ * IPACM_Header.h
+ *
+ * Created on: Jun 20, 2012
+ * Author: tatias
+ */
+
+//////////////////////////////////////////////////////////////////////////////////
+
+#ifndef IPACM_HEADER_H
+#define IPACM_HEADER_H
+
+#include <stdint.h>
+#include "linux/msm_ipa.h"
+
+//////////////////////////////////////////////////////////////////////////////////
+
+class IPACM_Header
+{
+private:
+ int m_fd;
+public:
+ bool AddHeader(struct ipa_ioc_add_hdr *pHeaderTable);
+ bool DeleteHeader(struct ipa_ioc_del_hdr *pHeaderTable);
+ bool GetHeaderHandle(struct ipa_ioc_get_hdr *pHeaderStruct);
+ bool CopyHeader(struct ipa_ioc_copy_hdr *pCopyHeaderStruct);
+ bool Commit();
+ bool Reset();
+ bool DeleteHeaderHdl(uint32_t hdr_hdl);
+
+ IPACM_Header();
+ ~IPACM_Header();
+ bool DeviceNodeIsOpened();
+};
+
+
+#endif
+
+
diff --git a/ipacm/inc/IPACM_Iface.h b/ipacm/inc/IPACM_Iface.h
new file mode 100644
index 0000000..9e3cafd
--- /dev/null
+++ b/ipacm/inc/IPACM_Iface.h
@@ -0,0 +1,131 @@
+/*
+Copyright (c) 2013, The Linux Foundation. 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 name of The Linux 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 "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+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.
+*/
+/*!
+ @file
+ IPACM_iface.h
+
+ @brief
+ This file implements the basis Iface definitions.
+
+ @Author
+ Skylar Chang
+
+*/
+#ifndef IPACM_IFACE_H
+#define IPACM_IFACE_H
+
+#include <stdio.h>
+#include <IPACM_CmdQueue.h>
+#include <linux/msm_ipa.h>
+#include "IPACM_Routing.h"
+#include "IPACM_Filtering.h"
+#include "IPACM_Header.h"
+#include "IPACM_EvtDispatcher.h"
+#include "IPACM_Xml.h"
+#include "IPACM_Log.h"
+#include "IPACM_Netlink.h"
+#include "IPACM_Config.h"
+#include "IPACM_Defs.h"
+
+/* current support 2 ipv6-address*/
+#define MAX_DEFAULT_v6_ROUTE_RULES 2
+#define IPV4_DEFAULT_FILTERTING_RULES 3
+#define IPV6_DEFAULT_FILTERTING_RULES 1
+#define IPV6_DEFAULT_LAN_FILTERTING_RULES 1
+#define MAX_SOFTWAREROUTING_FILTERTING_RULES 2
+
+/* iface */
+class IPACM_Iface : public IPACM_Listener
+{
+public:
+
+ /* Static class for reading IPACM configuration from XML file*/
+ static IPACM_Config *ipacmcfg;
+
+ /* IPACM interface id */
+ int ipa_if_num;
+
+ /* IPACM interface name */
+ char dev_name[IF_NAME_LEN];
+
+ /* IPACM interface iptype v4, v6 or both */
+ ipa_ip_type ip_type;
+
+ uint32_t header_hdl;
+
+ uint32_t software_routing_fl_rule_hdl[MAX_SOFTWAREROUTING_FILTERTING_RULES];
+
+ bool softwarerouting_act;
+
+ int num_dft_rt;
+
+ uint32_t dft_v4fl_rule_hdl[IPV4_DEFAULT_FILTERTING_RULES];
+ uint32_t dft_v6fl_rule_hdl[IPV6_DEFAULT_FILTERTING_RULES + IPV6_DEFAULT_LAN_FILTERTING_RULES];
+ uint32_t dft_rt_rule_hdl[1+MAX_DEFAULT_v6_ROUTE_RULES]; /* 1 for ipv4 */
+
+ ipa_ioc_query_intf *iface_query;
+ ipa_ioc_query_intf_tx_props *tx_prop;
+ ipa_ioc_query_intf_rx_props *rx_prop;
+
+ virtual int handle_down_evt() = 0;
+
+ virtual int handle_addr_evt(ipacm_event_data_addr *data) = 0;
+
+ IPACM_Iface(int iface_index);
+
+ virtual void event_callback(ipa_cm_event_id event,
+ void *data) = 0;
+
+
+ /* Query ipa_interface_index by given linux interface_index */
+ static int iface_ipa_index_query(int interface_index);
+
+ /*Query the IPA endpoint property */
+ int query_iface_property(void);
+
+ /*Configure the initial filter rules */
+ virtual int init_fl_rule(ipa_ip_type iptype);
+
+ static IPACM_Routing m_routing;
+ static IPACM_Filtering m_filtering;
+ static IPACM_Header m_header;
+
+ /* software routing enable */
+ virtual int handle_software_routing_enable(void);
+
+ /* software routing disable */
+ virtual int handle_software_routing_disable(void);
+
+
+private:
+
+ static const char *DEVICE_NAME;
+};
+
+#endif /* IPACM_IFACE_H */
diff --git a/ipacm/inc/IPACM_IfaceManager.h b/ipacm/inc/IPACM_IfaceManager.h
new file mode 100644
index 0000000..b295658
--- /dev/null
+++ b/ipacm/inc/IPACM_IfaceManager.h
@@ -0,0 +1,91 @@
+/*
+Copyright (c) 2013, The Linux Foundation. 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 name of The Linux 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 "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+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.
+*/
+/*!
+ @file
+ IPACM_IfaceManager.h
+
+ @brief
+ This file implements the IPAM iface_manager definitions
+
+ @Author
+ Skylar Chang
+
+*/
+#ifndef IPACM_IFACEMANAGER_H
+#define IPACM_IFACEMANAGER_H
+
+#include <stdio.h>
+#include <IPACM_CmdQueue.h>
+
+#include "IPACM_Routing.h"
+#include "IPACM_Filtering.h"
+#include "IPACM_Listener.h"
+#include "IPACM_Iface.h"
+
+#define IPA_MAX_NUM_NEIGHBOR_CLIENTS 17
+#define IPA_INSTANCE_NOT_FOUND 0
+#define IPA_INSTANCE_FOUND 1
+
+/* queue */
+typedef struct _iface_instances
+{
+ /* Linux interface id */
+ int ipa_if_index;
+ IPACM_Listener *obj;
+ _iface_instances *next;
+} iface_instances;
+
+
+class IPACM_IfaceManager : public IPACM_Listener
+{
+
+public:
+
+ IPACM_IfaceManager();
+
+ void event_callback(ipa_cm_event_id event,
+ void *data);
+
+ /* api for all iface instances to de-register instances */
+ static int deregistr(IPACM_Listener *param);
+
+
+private:
+ int create_iface_instance(int if_index);
+
+ /* api to register instances */
+ int registr(int ipa_if_index, IPACM_Listener *obj);
+
+ int SearchInstance(int ipa_if_index);
+
+ static iface_instances *head;
+
+};
+
+#endif /* IPACM_IFACEMANAGER_H */
diff --git a/ipacm/inc/IPACM_Lan.h b/ipacm/inc/IPACM_Lan.h
new file mode 100644
index 0000000..849e5df
--- /dev/null
+++ b/ipacm/inc/IPACM_Lan.h
@@ -0,0 +1,118 @@
+/*
+Copyright (c) 2013, The Linux Foundation. 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 name of The Linux 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 "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+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.
+*/
+/*!
+ @file
+ IPACM_Lan.h
+
+ @brief
+ This file implements the LAN iface definitions
+
+ @Author
+ Skylar Chang
+
+*/
+#ifndef IPACM_LAN_H
+#define IPACM_LAN_H
+
+#include <stdio.h>
+#include <linux/msm_ipa.h>
+
+#include "IPACM_CmdQueue.h"
+#include "IPACM_Iface.h"
+#include "IPACM_Routing.h"
+#include "IPACM_Filtering.h"
+
+#define IPA_MAX_NUM_UNICAST_ROUTE_RULES 6
+#define IPA_WAN_DEFAULT_FILTER_RULE_HANDLES 1
+#define IPA_PRIV_SUBNET_FILTER_RULE_HANDLES 3
+
+/* store each lan-iface unicast routing rule and its handler*/
+struct ipa_lan_rt_rule
+{
+ enum ipa_ip_type ip;
+ ipa_rule_attrib rule;
+ uint32_t rt_rule_hdl[0];
+};
+
+/* lan iface */
+class IPACM_Lan : public IPACM_Iface
+{
+public:
+
+ IPACM_Lan(int iface_index);
+ ~IPACM_Lan();
+
+ /* store lan's wan-up filter rule handlers */
+ uint32_t lan_wan_fl_rule_hdl[IPA_WAN_DEFAULT_FILTER_RULE_HANDLES];
+
+ /* store private-subnet filter rule handlers */
+ uint32_t private_fl_rule_hdl[IPA_PRIV_SUBNET_FILTER_RULE_HANDLES];
+
+ /* LAN-iface's callback function */
+ void event_callback(ipa_cm_event_id event,
+ void *data);
+
+ /* configure filter rule for wan_up event*/
+ virtual int handle_wan_up(void);
+
+ /* delete filter rule for wan_down event*/
+ virtual int handle_wan_down(void);
+
+ /* configure private subnet filter rules*/
+ virtual int handle_private_subnet(ipa_ip_type iptype);
+
+ /* handle new_address event*/
+ int handle_addr_evt(ipacm_event_data_addr *data);
+
+private:
+
+ /* dynamically allocate lan iface's unicast routing rule structure */
+ int rt_rule_len;
+ ipa_lan_rt_rule *route_rule;
+
+ /* store the number of lan-iface's unicast routing rule */
+ int num_uni_rt;
+
+ inline ipa_lan_rt_rule* get_rt_ruleptr(ipa_lan_rt_rule *param, int cnt)
+ {
+ return (param + (rt_rule_len * cnt));
+ }
+
+ /* handle unicast routing rule add event */
+ int handle_route_add_evt(ipacm_event_data_addr *data);
+
+ /* handle unicast routing rule del event */
+ int handle_route_del_evt(ipacm_event_data_addr *data);
+
+ /*handle wlan iface down event*/
+ int handle_down_evt();
+
+};
+
+#endif /* IPACM_LAN_H */
diff --git a/ipacm/inc/IPACM_Listener.h b/ipacm/inc/IPACM_Listener.h
new file mode 100644
index 0000000..02a082e
--- /dev/null
+++ b/ipacm/inc/IPACM_Listener.h
@@ -0,0 +1,55 @@
+/*
+Copyright (c) 2013, The Linux Foundation. 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 name of The Linux 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 "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+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.
+*/
+/*!
+ @file
+ IPACM_Listener.h
+
+ @brief
+ This file implements the abstract class notifier.
+
+ @Author
+ Skylar Chang
+
+*/
+#ifndef IPACM_LISTENER_H
+#define IPACM_LISTENER_H
+
+#include "IPACM_Defs.h"
+#include "IPACM_CmdQueue.h"
+
+/* abstract class notifier */
+class IPACM_Listener
+{
+public:
+ virtual void event_callback(ipa_cm_event_id event,
+ void *data) = 0;
+};
+
+#endif /* IPACM_LISTENER_H */
+
diff --git a/ipacm/inc/IPACM_Log.h b/ipacm/inc/IPACM_Log.h
new file mode 100644
index 0000000..785b654
--- /dev/null
+++ b/ipacm/inc/IPACM_Log.h
@@ -0,0 +1,79 @@
+/*
+Copyright (c) 2013, The Linux Foundation. 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 name of The Linux 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 "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+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.
+*/
+/*!
+ @file
+ IPACM_log.h
+
+ @brief
+ This file implements the IPAM log functionality.
+
+ @Author
+ Skylar Chang
+
+*/
+
+#ifndef IPACM_LOG_H
+#define IPACM_LOG_H
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#include <stdio.h>
+#include <string.h>
+
+#define LOG_SIZE 200
+
+#define PERROR(fmt) printf("%s:%d %s()", __FILE__, __LINE__, __FUNCTION__);\
+ perror(fmt);
+
+#define IPACMDBG(fmt, ...) {\
+ int n =0; \
+ n = snprintf(log_buf, sizeof(log_buf), "%s:%d %s() ", __FILE__, __LINE__, __FUNCTION__);\
+ snprintf((log_buf+n), (sizeof(log_buf)-n-1), fmt, ##__VA_ARGS__);\
+ logmessage(log_buf);\
+ }
+
+
+#define IPACMERR(fmt, ...) {\
+ int n =0; \
+ n = snprintf(log_buf, sizeof(log_buf), "%s:%d %s() %s", __FILE__, __LINE__, __FUNCTION__, "Error:");\
+ snprintf((log_buf+n), (sizeof(log_buf)-n-1), fmt, ##__VA_ARGS__);\
+ logmessage(log_buf);\
+ }
+
+extern void logmessage(char *msg);
+extern char log_buf[LOG_SIZE];
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* IPACM_LOG_H */
diff --git a/ipacm/inc/IPACM_Neighbor.h b/ipacm/inc/IPACM_Neighbor.h
new file mode 100644
index 0000000..af7ab46
--- /dev/null
+++ b/ipacm/inc/IPACM_Neighbor.h
@@ -0,0 +1,79 @@
+/*
+Copyright (c) 2013, The Linux Foundation. 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 name of The Linux 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 "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+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.
+*/
+/*!
+ @file
+ IPACM_Neighbor.h
+
+ @brief
+ This file implements the functionality of handling IPACM Neighbor events.
+
+ @Author
+ Skylar Chang
+
+*/
+#ifndef IPACM_NEIGHBOR_H
+#define IPACM_NEIGHBOR_H
+
+#include <stdio.h>
+#include <IPACM_CmdQueue.h>
+#include <linux/msm_ipa.h>
+#include "IPACM_Routing.h"
+#include "IPACM_Filtering.h"
+#include "IPACM_Listener.h"
+#include "IPACM_Iface.h"
+
+#define IPA_MAX_NUM_NEIGHBOR_CLIENTS 17
+
+struct ipa_neighbor_client
+{
+ uint8_t mac_addr[6];
+ uint32_t v6_addr[4];
+ int iface_index;
+};
+
+class IPACM_Neighbor : public IPACM_Listener
+{
+
+public:
+
+ IPACM_Neighbor();
+
+ void event_callback(ipa_cm_event_id event,
+ void *data);
+
+private:
+
+ int num_neighbor_client;
+
+ ipa_neighbor_client neighbor_client[IPA_MAX_NUM_NEIGHBOR_CLIENTS];
+
+
+};
+
+#endif /* IPACM_NEIGHBOR_H */
diff --git a/ipacm/inc/IPACM_Netlink.h b/ipacm/inc/IPACM_Netlink.h
new file mode 100644
index 0000000..fe98375
--- /dev/null
+++ b/ipacm/inc/IPACM_Netlink.h
@@ -0,0 +1,221 @@
+/*
+Copyright (c) 2013, The Linux Foundation. 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 name of The Linux 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 "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+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.
+*/
+/*!
+ @file
+ IPA_Netlink.h
+
+ @brief
+ IPACM Netlink Messaging Implementation File
+
+ @Author
+ Skylar Chang
+
+*/
+#ifndef IPACM_NETLINK_H
+#define IPACM_NETLINK_H
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <pthread.h>
+#include <sys/select.h>
+#include <sys/socket.h>
+#include <linux/if.h>
+#include <linux/if_addr.h>
+#include <linux/rtnetlink.h>
+#include <linux/netlink.h>
+#include <netinet/in.h>
+#include "IPACM_Defs.h"
+
+#define MAX_NUM_OF_FD 10
+#define IPA_NL_MSG_MAX_LEN (1024)
+#define IF_NAME_LEN 16
+
+
+/*---------------------------------------------------------------------------
+ Type representing enumeration of NetLink event indication messages
+---------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------
+ Types representing parsed NetLink message
+---------------------------------------------------------------------------*/
+#define IPA_NLA_PARAM_NONE (0x0000)
+#define IPA_NLA_PARAM_PREFIXADDR (0x0001)
+#define IPA_NLA_PARAM_LOCALADDR (0x0002)
+#define IPA_NLA_PARAM_LABELNAME (0x0004)
+#define IPA_NLA_PARAM_BCASTADDR (0x0008)
+#define IPA_NLA_PARAM_ACASTADDR (0x0010)
+#define IPA_NLA_PARAM_MCASTADDR (0x0020)
+#define IPA_NLA_PARAM_CACHEINFO (0x0080)
+#define IPA_NLA_PARAM_PROTOINFO (0x0100)
+#define IPA_NLA_PARAM_FLAGS (0x0200)
+
+#define IPA_RTA_PARAM_NONE (0x0000)
+#define IPA_RTA_PARAM_DST (0x0001)
+#define IPA_RTA_PARAM_SRC (0x0002)
+#define IPA_RTA_PARAM_GATEWAY (0x0004)
+#define IPA_RTA_PARAM_IIF (0x0008)
+#define IPA_RTA_PARAM_OIF (0x0010)
+#define IPA_RTA_PARAM_CACHEINFO (0x0020)
+#define IPA_RTA_PARAM_PRIORITY (0x0080)
+#define IPA_RTA_PARAM_METRICS (0x0100)
+
+
+/*---------------------------------------------------------------------------
+ Type representing function callback registered with a socket listener
+ thread for reading from a socket on receipt of an incoming message
+---------------------------------------------------------------------------*/
+typedef int (*ipa_sock_thrd_fd_read_f)(int fd);
+
+typedef enum
+{
+ IPA_INIT = 0,
+ IPA_LINK_UP_WAIT,
+ IPA_LINK_UP,
+ IPA_LINK_DOWN_WAIT,
+ IPA_LINK_DOWN
+} ipa_nl_state_e;
+
+typedef struct
+{
+ int sk_fd;
+ ipa_sock_thrd_fd_read_f read_func;
+} ipa_nl_sk_fd_map_info_t;
+
+typedef struct
+{
+ ipa_nl_sk_fd_map_info_t sk_fds[MAX_NUM_OF_FD];
+ fd_set fdset;
+ int num_fd;
+ int max_fd;
+} ipa_nl_sk_fd_set_info_t;
+
+typedef struct
+{
+ int sk_fd; /* socket descriptor */
+ struct sockaddr_nl sk_addr_loc; /* local address of socket */
+} ipa_nl_sk_info_t;
+
+typedef struct ipa_nl_addr_s {
+ struct sockaddr_storage ip_addr;
+ unsigned int mask;
+} ipa_nl_addr_t;
+
+typedef struct ipa_nl_proto_info_s {
+ unsigned int param_mask;
+ unsigned int flags;
+ struct ifla_cacheinfo cache_info;
+} ipa_nl_proto_info_t;
+
+typedef struct
+{
+ struct ifinfomsg metainfo; /* from header */
+} ipa_nl_link_info_t;
+
+
+
+typedef struct ipa_nl_addr_info_s {
+ struct ifaddrmsg metainfo; /* from header */
+ struct /* attributes */
+ {
+ unsigned int param_mask;
+ unsigned char label_name[IF_NAME_LEN];
+ struct sockaddr_storage prefix_addr;
+ } attr_info;
+} ipa_nl_addr_info_t;
+
+
+typedef struct ipa_nl_neigh_info_s {
+ struct ndmsg metainfo; /* from header */
+ struct /* attributes */
+ {
+ unsigned int param_mask;
+ struct sockaddr_storage local_addr;
+ struct sockaddr lladdr_hwaddr;
+ } attr_info;
+} ipa_nl_neigh_info_t;
+
+
+
+typedef struct ipa_nl_route_info_s {
+ struct rtmsg metainfo; /* from header */
+ struct /* attributes */
+ {
+ unsigned int param_mask;
+ struct sockaddr_storage dst_addr;
+ struct sockaddr_storage src_addr;
+ struct sockaddr_storage gateway_addr;
+ struct sockaddr_storage mark_addr;
+ struct rta_cacheinfo cache_info;
+ __u32 iif_index; /* Link index */
+ __u32 oif_index; /* Link index */
+ __u32 priority;
+ __u32 metrics;
+ ipa_nl_proto_info_t proto_info;
+ } attr_info;
+} ipa_nl_route_info_t;
+
+#define IPA_FLOW_TYPE_INVALID (-1)
+
+typedef struct
+{
+ unsigned int type;
+ bool link_event;
+ /* Optional parameters */
+ ipa_nl_link_info_t nl_link_info;
+ ipa_nl_addr_info_t nl_addr_info;
+ ipa_nl_neigh_info_t nl_neigh_info;
+ ipa_nl_route_info_t nl_route_info;
+} ipa_nl_msg_t;
+
+/* Initialization routine for listener on NetLink sockets interface */
+int ipa_nl_listener_init
+(
+ unsigned int nl_type,
+ unsigned int nl_groups,
+ ipa_nl_sk_fd_set_info_t *sk_fdset,
+ ipa_sock_thrd_fd_read_f read_f
+ );
+
+/* Virtual function registered to receive incoming messages over the NETLINK routing socket*/
+int ipa_nl_recv_msg(int fd);
+
+/* map mask value for ipv6 */
+int mask_v6(int index, uint32_t *mask);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* IPACM_NETLINK_H */
diff --git a/ipacm/inc/IPACM_Routing.h b/ipacm/inc/IPACM_Routing.h
new file mode 100644
index 0000000..ca7a5fd
--- /dev/null
+++ b/ipacm/inc/IPACM_Routing.h
@@ -0,0 +1,75 @@
+/*
+Copyright (c) 2013, The Linux Foundation. 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 name of The Linux 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 "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+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.
+*/
+/*!
+ @file
+ IPACM_Routing.cpp
+
+ @brief
+ This file implements the IPACM routing functionality.
+
+ @Author
+ Skylar Chang
+
+*/
+
+
+#ifndef IPACM_ROUTING_H
+#define IPACM_ROUTING_H
+
+#include <stdint.h>
+#include <linux/msm_ipa.h>
+#include <IPACM_Defs.h>
+
+using namespace std;
+
+class IPACM_Routing
+{
+public:
+ IPACM_Routing();
+ ~IPACM_Routing();
+
+ bool AddRoutingRule(struct ipa_ioc_add_rt_rule *ruleTable);
+ bool DeleteRoutingRule(struct ipa_ioc_del_rt_rule *ruleTable);
+
+ bool Commit(enum ipa_ip_type ip);
+ bool Reset(enum ipa_ip_type ip);
+
+ bool GetRoutingTable(struct ipa_ioc_get_rt_tbl *routingTable);
+ bool PutRoutingTable(uint32_t routingTableHandle);
+
+ bool DeviceNodeIsOpened();
+ bool DeleteRoutingHdl(uint32_t rt_rule_hdl, ipa_ip_type ip);
+
+private:
+ static const char *DEVICE_NAME;
+ int m_fd; /* File descriptor of the IPA device node /dev/ipa */
+};
+
+#endif //IPACM_ROUTING_H
+
diff --git a/ipacm/inc/IPACM_Wan.h b/ipacm/inc/IPACM_Wan.h
new file mode 100644
index 0000000..5177fe1
--- /dev/null
+++ b/ipacm/inc/IPACM_Wan.h
@@ -0,0 +1,110 @@
+/*
+Copyright (c) 2013, The Linux Foundation. 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 name of The Linux 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 "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+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.
+*/
+/*!
+ @file
+ IPACM_Wan.cpp
+
+ @brief
+ This file implements the WAN iface functionality.
+
+ @Author
+ Skylar Chang
+
+*/
+#ifndef IPACM_WAN_H
+#define IPACM_WAN_H
+
+#include <stdio.h>
+#include <IPACM_CmdQueue.h>
+#include <linux/msm_ipa.h>
+#include "IPACM_Routing.h"
+#include "IPACM_Filtering.h"
+#include <IPACM_Iface.h>
+#include <IPACM_Defs.h>
+#include <IPACM_Xml.h>
+
+#define IPA_NUM_DEFAULT_WAN_FILTER_RULES 2
+
+/* wan iface */
+class IPACM_Wan : public IPACM_Iface
+{
+
+public:
+
+ static bool wan_up;
+
+ IPACM_Wan(int iface_index);
+ ~IPACM_Wan();
+
+ static bool isWanUP()
+ {
+ return wan_up;
+ }
+
+ void event_callback(ipa_cm_event_id event,
+ void *data);
+
+private:
+ uint32_t *wan_route_rule_v4_hdl;
+ uint32_t *wan_route_rule_v6_hdl;
+ uint32_t firewall_hdl_v4[IPACM_MAX_FIREWALL_ENTRIES];
+ uint32_t firewall_hdl_v6[IPACM_MAX_FIREWALL_ENTRIES];
+ uint32_t dft_wan_fl_hdl[IPA_NUM_DEFAULT_WAN_FILTER_RULES];
+ int num_firewall_v4,num_firewall_v6;
+ bool active_v4;
+ bool active_v6;
+ uint32_t wan_v4_addr;
+
+ /* IPACM firewall Configuration file*/
+ IPACM_firewall_conf_t firewall_config;
+
+ /* handle new_address event */
+ int handle_addr_evt(ipacm_event_data_addr *data);
+
+ /* wan default route/filter rule configuration */
+ int handle_route_add_evt(ipacm_event_data_addr *data);
+
+ /* wan default route/filter rule delete */
+ int handle_route_del_evt(ipa_ip_type iptype);
+
+ /* construct complete ethernet header */
+ int handle_header_add_evt(uint8_t mac_addr[6]);
+
+ /* configure the initial firewall filter rules */
+ int config_dft_firewall_rules(ipa_ip_type ip_type);
+
+ /*clean firewall filter rules */
+ int del_dft_firewall_rules(ipa_ip_type ip_type);
+
+ /*handle wan-iface down event */
+ int handle_down_evt();
+
+};
+
+#endif /* IPACM_WAN_H */
diff --git a/ipacm/inc/IPACM_Wlan.h b/ipacm/inc/IPACM_Wlan.h
new file mode 100644
index 0000000..0535584
--- /dev/null
+++ b/ipacm/inc/IPACM_Wlan.h
@@ -0,0 +1,224 @@
+/*
+Copyright (c) 2013, The Linux Foundation. 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 name of The Linux 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 "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+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.
+*/
+/*!
+ @file
+ IPACM_Wlan.h
+
+ @brief
+ This file implements the WLAN iface functionality.
+
+ @Author
+ Skylar Chang
+
+*/
+#ifndef IPACM_WLAN_H
+#define IPACM_WLAN_H
+
+#include <stdio.h>
+#include <IPACM_CmdQueue.h>
+#include <linux/msm_ipa.h>
+#include "IPACM_Routing.h"
+#include "IPACM_Filtering.h"
+#include "IPACM_Lan.h"
+#include "IPACM_Iface.h"
+
+typedef struct _wlan_client_rt_hdl
+{
+ uint32_t wifi_rt_rule_hdl_v4;
+ uint32_t wifi_rt_rule_hdl_v6;
+}wlan_client_rt_hdl;
+
+typedef struct _ipa_wlan_client
+{
+ uint8_t mac[IPA_MAC_ADDR_SIZE];
+ uint32_t v4_addr;
+ uint32_t v6_addr[4];
+ uint32_t hdr_hdl;
+ bool route_rule_set_v4;
+ bool route_rule_set_v6;
+ bool ipv4_set;
+ bool ipv6_set;
+ wlan_client_rt_hdl wifi_rt_hdl[0]; /* depends on number of tx properties */
+}ipa_wlan_client;
+
+typedef struct _wlan_ampdu_flt_rules
+{
+ uint32_t hdl[IPA_MAX_NUM_AMPDU_RULE];
+ ipa_ip_type ip[IPA_MAX_NUM_AMPDU_RULE];
+ int num_rules;
+}wlan_ampdu_flt_rules;
+
+
+
+/* wlan iface */
+class IPACM_Wlan : public IPACM_Lan
+{
+
+public:
+
+ IPACM_Wlan(int iface_index);
+ ~IPACM_Wlan(void);
+
+ static int total_num_wifi_clients;
+
+ void event_callback(ipa_cm_event_id event,
+ void *data);
+
+private:
+ int wlan_client_len;
+ ipa_wlan_client *wlan_client;
+
+ int header_name_count;
+ int num_wifi_client;
+ wlan_ampdu_flt_rules wlan_ampdu_flt_rule;
+
+ inline ipa_wlan_client* get_client_memptr(ipa_wlan_client *param, int cnt)
+ {
+ return (param + (wlan_client_len * cnt));
+ }
+
+ inline int get_wlan_client_index(uint8_t *mac_addr)
+ {
+ int cnt;
+ int num_wifi_client_tmp = num_wifi_client;
+
+ IPACMDBG("Passed MAC %02x:%02x:%02x:%02x:%02x:%02x\n",
+ mac_addr[0], mac_addr[1], mac_addr[2],
+ mac_addr[3], mac_addr[4], mac_addr[5]);
+
+ for(cnt = 0; cnt < num_wifi_client_tmp; cnt++)
+ {
+ IPACMDBG("stored MAC %02x:%02x:%02x:%02x:%02x:%02x\n",
+ get_client_memptr(wlan_client, cnt)->mac[0],
+ get_client_memptr(wlan_client, cnt)->mac[1],
+ get_client_memptr(wlan_client, cnt)->mac[2],
+ get_client_memptr(wlan_client, cnt)->mac[3],
+ get_client_memptr(wlan_client, cnt)->mac[4],
+ get_client_memptr(wlan_client, cnt)->mac[5]);
+
+ if(memcmp(get_client_memptr(wlan_client, cnt)->mac,
+ mac_addr,
+ sizeof(get_client_memptr(wlan_client, cnt)->mac)) == 0)
+ {
+ IPACMDBG("Matched client index: %d\n", cnt);
+ return cnt;
+ }
+ }
+
+ return IPACM_INVALID_INDEX;
+ }
+
+ inline int delete_default_qos_rtrules(int clt_indx)
+ {
+ uint32_t tx_index;
+ uint32_t rt_hdl;
+
+ for(tx_index = 0; tx_index < iface_query->num_tx_props; tx_index++)
+ {
+ if((ip_type != IPA_IP_v6) && (get_client_memptr(wlan_client, clt_indx)->route_rule_set_v4==true)) /* for ipv4 */
+ {
+ IPACMDBG("Delete client index %d ipv4 Qos rules \n", clt_indx);
+ rt_hdl = get_client_memptr(wlan_client, clt_indx)->wifi_rt_hdl[tx_index].wifi_rt_rule_hdl_v4;
+
+ if(m_routing.DeleteRoutingHdl(rt_hdl, IPA_IP_v4) == false)
+ {
+ return IPACM_FAILURE;
+ }
+ }
+
+ if((ip_type != IPA_IP_v4) && (get_client_memptr(wlan_client, clt_indx)->route_rule_set_v6==true)) /* for ipv6 */
+ {
+ IPACMDBG("Delete client index %d ipv6 Qos rules \n", clt_indx);
+ rt_hdl = get_client_memptr(wlan_client, clt_indx)->wifi_rt_hdl[tx_index].wifi_rt_rule_hdl_v6;
+
+ if(m_routing.DeleteRoutingHdl(rt_hdl, IPA_IP_v6) == false)
+ {
+ return IPACM_FAILURE;
+ }
+ }
+
+ } /* end of for loop */
+
+ /* clean the 4 Qos ipv4 RT rules for client:clt_indx */
+ if(ip_type != IPA_IP_v6) /* for ipv4 */
+ {
+ get_client_memptr(wlan_client, clt_indx)->route_rule_set_v4=false;
+ }
+
+ /* clean the 4 Qos ipv6 RT rules for client:clt_indx */
+ if(ip_type != IPA_IP_v4) /* for ipv6 */
+ {
+ get_client_memptr(wlan_client, clt_indx)->route_rule_set_v6=false;
+ }
+
+ return IPACM_SUCCESS;
+ }
+
+ /* handle wifi client initial,copy all partial headers (tx property) */
+ int handle_wlan_client_init(uint8_t *mac_addr);
+
+ /*handle wifi client */
+ int handle_wlan_client_ipaddr(ipacm_event_data_all *data);
+
+ /*handle wifi client routing rule*/
+ int handle_wlan_client_route_rule(uint8_t *mac_addr, ipa_ip_type iptype);
+
+ /*handle wifi client power-save mode*/
+ int handle_wlan_client_pwrsave(uint8_t *mac_addr);
+
+ /*handle wifi client del mode*/
+ int handle_wlan_client_down_evt(uint8_t *mac_addr);
+
+ /*duplicate ampdu filter rules for private subnet configuration*/
+ int handle_private_subnet(ipa_ip_type iptype);
+
+ /*duplicate ampdu filter rules for initial iface configuration*/
+ int init_fl_rule(ipa_ip_type iptype);
+
+ /*duplicate ampdu filter rules for new_address event*/
+ int handle_addr_evt(ipacm_event_data_addr *data);
+
+ /*duplicate ampdu filter rules for wan_up event*/
+ int handle_wan_up(void);
+
+ /*delete ampdu filter rules for wan_down event*/
+ int handle_wan_down(void);
+
+ /*duplicate ampdu filter rules for software_routing event*/
+ int handle_software_routing_enable(void);
+
+ /*delete ampdu filter rules for disabling software_routing event*/
+ int handle_software_routing_disable(void);
+
+ /*handle wlan iface down event*/
+ int handle_down_evt();
+};
+
+
+#endif /* IPACM_WLAN_H */
diff --git a/ipacm/inc/IPACM_Xml.h b/ipacm/inc/IPACM_Xml.h
new file mode 100644
index 0000000..84f6c6f
--- /dev/null
+++ b/ipacm/inc/IPACM_Xml.h
@@ -0,0 +1,277 @@
+/*
+Copyright (c) 2013, The Linux Foundation. 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 name of The Linux 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 "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+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.
+*/
+/*!
+ @file
+ IPACM_Xml.h
+
+ @brief
+ This file implements the XML specific parsing functionality.
+
+ @Author
+ Skylar Chang/Shihuan Liu
+
+*/
+#ifndef IPACM_XML_H
+#define IPACM_XML_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <linux/msm_ipa.h>
+#include "IPACM_Defs.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <arpa/inet.h>
+#include <stdint.h>
+#include "libxml/parser.h"
+#include "libxml/tree.h"
+
+#define IPACM_ASSERT(a) \
+if (!(a)) { \
+ fprintf(stderr, "%s, %d: assertion (a) failed!", \
+ __FILE__, \
+ __LINE__); \
+ abort(); \
+}
+
+/* Max allowed size of the XML file (2 MB) */
+#define IPACM_XML_MAX_FILESIZE (2 << 20)
+#define IPACM_MAX_FIREWALL_ENTRIES 50
+#define IPACM_IPV6_ADDR_LEN 16
+
+/* Defines for clipping space or space & quotes (single, double) */
+#define IPACM_XML_CLIP_SPACE " "
+#define IPACM_XML_CLIP_SPACE_QUOTES " '\""
+
+#define MAX_XML_STR_LEN 120
+
+/* IPA Config Entries */
+#define system_TAG "system"
+#define IPACMCFG_TAG "IPACM"
+#define IPACMIFACECFG_TAG "IPACMIface"
+#define IFACE_TAG "Iface"
+#define NAME_TAG "Name"
+#define CATEGORY_TAG "Category"
+#define IPACMPRIVATESUBNETCFG_TAG "IPACMPrivateSubnet"
+#define SUBNET_TAG "Subnet"
+#define SUBNETADDRESS_TAG "SubnetAddress"
+#define SUBNETMASK_TAG "SubnetMask"
+#define WANIF_TAG "WAN"
+#define LANIF_TAG "LAN"
+#define WLANIF_TAG "WLAN"
+#define VIRTUALIF_TAG "VIRTUAL"
+#define IPACMALG_TAG "IPACMALG"
+#define ALG_TAG "ALG"
+#define Protocol_TAG "Protocol"
+#define Port_TAG "Port"
+#define TCP_PROTOCOL_TAG "TCP"
+#define UDP_PROTOCOL_TAG "UDP"
+
+/* FIREWALL Config Entries */
+#define Firewall_TAG "Firewall"
+#define MobileAPFirewallCfg_TAG "MobileAPFirewallCfg"
+#define IPFamily_TAG "IPFamily"
+#define IPV4SourceAddress_TAG "IPV4SourceAddress"
+#define IPV4SourceIPAddress_TAG "IPV4SourceIPAddress"
+#define IPV4SourceSubnetMask_TAG "IPV4SourceSubnetMask"
+
+#define IPV4DestinationAddress_TAG "IPV4DestinationAddress"
+#define IPV4DestinationIPAddress_TAG "IPV4DestinationIPAddress"
+#define IPV4DestinationSubnetMask_TAG "IPV4DestinationSubnetMask"
+
+#define IPV4TypeOfService_TAG "IPV4TypeOfService"
+#define TOSValue_TAG "TOSValue"
+#define TOSMask_TAG "TOSMask"
+
+#define IPV4NextHeaderProtocol_TAG "IPV4NextHeaderProtocol"
+
+#define IPV6SourceAddress_TAG "IPV6SourceAddress"
+#define IPV6SourceIPAddress_TAG "IPV6SourceIPAddress"
+#define IPV6SourcePrefix_TAG "IPV6SourcePrefix"
+
+#define IPV6DestinationAddress_TAG "IPV6DestinationAddress"
+#define IPV6DestinationIPAddress_TAG "IPV6DestinationIPAddress"
+#define IPV6DestinationPrefix_TAG "IPV6DestinationPrefix"
+
+#define IPV6TrafficClass_TAG "IPV6TrafficClass"
+#define TrfClsValue_TAG "TrfClsValue"
+#define TrfClsMask_TAG "TrfClsMask"
+
+#define IPV6NextHeaderProtocol_TAG "IPV6NextHeaderProtocol"
+
+#define TCPSource_TAG "TCPSource"
+#define TCPSourcePort_TAG "TCPSourcePort"
+#define TCPSourceRange_TAG "TCPSourceRange"
+
+#define TCPDestination_TAG "TCPDestination"
+#define TCPDestinationPort_TAG "TCPDestinationPort"
+#define TCPDestinationRange_TAG "TCPDestinationRange"
+
+#define UDPSource_TAG "UDPSource"
+#define UDPSourcePort_TAG "UDPSourcePort"
+#define UDPSourceRange_TAG "UDPSourceRange"
+
+#define UDPDestination_TAG "UDPDestination"
+#define UDPDestinationPort_TAG "UDPDestinationPort"
+#define UDPDestinationRange_TAG "UDPDestinationRange"
+
+#define ICMPType_TAG "ICMPType"
+#define ICMPCode_TAG "ICMPCode"
+
+#define ESP_TAG "ESP"
+#define ESPSPI_TAG "ESPSPI"
+
+#define TCP_UDPSource_TAG "TCP_UDPSource"
+#define TCP_UDPSourcePort_TAG "TCP_UDPSourcePort"
+#define TCP_UDPSourceRange_TAG "TCP_UDPSourceRange"
+
+#define TCP_UDPDestination_TAG "TCP_UDPDestination"
+#define TCP_UDPDestinationPort_TAG "TCP_UDPDestinationPort"
+#define TCP_UDPDestinationRange_TAG "TCP_UDPDestinationRange"
+
+#define IPACMNat_TAG "IPACMNAT"
+#define NAT_MaxEntries_TAG "MaxNatEntries"
+
+
+/*---------------------------------------------------------------------------
+ IP protocol numbers - use in dss_socket() to identify protocols.
+ Also contains the extension header types for IPv6.
+---------------------------------------------------------------------------*/
+typedef enum
+{
+ IPACM_FIREWALL_IPV6_BASE_HDR = 4, /* IPv6 Base Header */
+ IPACM_FIREWALL_IPPROTO_HOP_BY_HOP_OPT_HDR = 0, /* Hop-by-hop Option Header */
+ IPACM_FIREWALL_IPPROTO_ICMP = 1, /* ICMP protocol */
+ IPACM_FIREWALL_IPPROTO_IGMP = 2, /* IGMP protocol */
+ IPACM_FIREWALL_IPPROTO_IP = IPACM_FIREWALL_IPV6_BASE_HDR, /* IPv4 */
+ IPACM_FIREWALL_IPPROTO_TCP = 6, /* TCP Protocol */
+ IPACM_FIREWALL_IPPROTO_UDP = 17, /* UDP Protocol */
+ IPACM_FIREWALL_IPPROTO_IPV6 = 41, /* IPv6 */
+ IPACM_FIREWALL_IPPROTO_ROUTING_HDR = 43, /* Routing Header */
+ IPACM_FIREWALL_IPPROTO_FRAG_HDR = 44, /* Fragmentation Header */
+ IPACM_FIREWALL_IPPROTO_GRE = 47, /* GRE Protocol */
+ IPACM_FIREWALL_IPPROTO_ESP = 50, /* ESP Protocol */
+ IPACM_FIREWALL_IPPROTO_AH = 51, /* Authentication Header */
+ IPACM_FIREWALL_IPPROTO_ICMP6 = 58, /* ICMPv6 */
+ IPACM_FIREWALL_NO_NEXT_HDR = 59, /* No Next Header for IPv6 */
+ IPACM_FIREWALL_IPPROTO_DEST_OPT_HDR = 60, /* Destination Options Header */
+ IPACM_FIREWALL_IPPROTO_MOBILITY_HDR = 135, /* Mobility Header */
+ IPACM_FIREWALL_IPPROTO_TCP_UDP = 253 /* Unspecified protocol used for IPACM */
+} ipacm_firewall_ip_protocol_enum_type;
+
+/* define as mobileap firewall rule format*/
+typedef enum
+{
+ IP_V4 = 4,
+ IP_V6 = 6
+} firewall_ip_version_enum;
+
+/*---------------------------------------------------------------------------
+ Extended FireWall Entry Configuration.
+---------------------------------------------------------------------------*/
+typedef struct
+{
+ struct ipa_rule_attrib attrib;
+ firewall_ip_version_enum ip_vsn;
+} IPACM_extd_firewall_entry_conf_t;
+
+
+/*---------------------------------------------------------------------------
+ Extended FireWall configuration.
+---------------------------------------------------------------------------*/
+typedef union
+{
+ IPACM_extd_firewall_entry_conf_t extd_firewall_entry;
+} IPACM_extd_firewall_conf_t;
+
+
+typedef struct
+{
+ char firewall_config_file[IPA_MAX_FILE_LEN];
+ uint8_t num_extd_firewall_entries;
+ IPACM_extd_firewall_entry_conf_t extd_firewall_entries[IPACM_MAX_FIREWALL_ENTRIES];
+} IPACM_firewall_conf_t;
+
+
+
+typedef struct
+{
+ uint8_t num_iface_entries;
+ ipa_ifi_dev_name_t iface_entries[IPA_MAX_IFACE_ENTRIES];
+} ipacm_iface_conf_t;
+
+typedef struct
+{
+ uint8_t num_subnet_entries;
+ ipa_private_subnet private_subnet_entries[IPA_MAX_PRIVATE_SUBNET_ENTRIES];
+} ipacm_private_subnet_conf_t;
+
+typedef struct
+{
+ uint8_t protocol;
+ uint16_t port;
+} ipacm_alg;
+
+typedef struct
+{
+ uint8_t num_alg_entries;
+ ipacm_alg alg_entries[IPA_MAX_ALG_ENTRIES];
+} ipacm_alg_conf_t;
+
+
+typedef struct _IPACM_conf_t
+{
+ ipacm_iface_conf_t iface_config;
+ ipacm_private_subnet_conf_t private_subnet_config;
+ ipacm_alg_conf_t alg_config;
+ int nat_max_entries;
+} IPACM_conf_t;
+
+/* This function read IPACM XML configuration*/
+int ipacm_read_cfg_xml
+(
+ char *xml_file, /* Filename and path */
+ IPACM_conf_t *config /* Mobile AP config data */
+);
+
+/* This function reads QCMAP Firewall XML and store in IPACM Firewall stucture */
+int IPACM_read_firewall_xml
+(
+ char *xml_file, /* Filename and path */
+ IPACM_firewall_conf_t *config /* Mobile AP config data */
+);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif //IPACM_XML
diff --git a/ipacm/src/IPACM_CmdQueue.cpp b/ipacm/src/IPACM_CmdQueue.cpp
new file mode 100644
index 0000000..632ae5d
--- /dev/null
+++ b/ipacm/src/IPACM_CmdQueue.cpp
@@ -0,0 +1,165 @@
+/*
+Copyright (c) 2013, The Linux Foundation. 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 name of The Linux 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 "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+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.
+*/
+/*!
+ @file
+ IPACM_CmdQueue.cpp
+
+ @brief
+ This file implements the IPAM Comment Queue functionality
+
+ @Author
+ Sunil
+
+*/
+#include <string.h>
+#include "IPACM_CmdQueue.h"
+#include "IPACM_Log.h"
+
+pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
+pthread_cond_t cond_var = PTHREAD_COND_INITIALIZER;
+
+MessageQueue* MessageQueue::inst = NULL;
+MessageQueue* MessageQueue::getInstance()
+{
+ if(inst == NULL)
+ {
+ inst = new MessageQueue();
+ if(inst == NULL)
+ {
+ IPACMERR("unable to create Message Queue instance\n");
+ return NULL;
+ }
+ }
+
+ return inst;
+}
+
+void MessageQueue::enqueue(Message *item)
+{
+ if(!Head)
+ {
+ Tail = item;
+ Head = item;
+ }
+ else
+ {
+ if(Tail == NULL)
+ {
+ IPACMDBG("Tail is null\n");
+ Head->setnext(item);
+ }
+ else
+ {
+ Tail->setnext(item);
+ }
+ Tail = item;
+ }
+}
+
+
+Message* MessageQueue::dequeue(void)
+{
+ if(Head == NULL)
+ {
+ return NULL;
+ }
+ else
+ {
+ Message *tmp = Head;
+ Head = Head->getnext();
+
+ return tmp;
+ }
+}
+
+
+void* MessageQueue::Process(void *param)
+{
+ MessageQueue *MsgQueue = NULL;
+ Message *item = NULL;
+ IPACMDBG("MessageQueue::Process()\n");
+
+ MsgQueue = MessageQueue::getInstance();
+ if(MsgQueue == NULL)
+ {
+ IPACMDBG("unable to start cmd queue process\n");
+ return NULL;
+ }
+
+ while(1)
+ {
+ if(pthread_mutex_lock(&mutex) != 0)
+ {
+ IPACMERR("unable to lock the mutex\n");
+ return NULL;
+ }
+
+ item = MsgQueue->dequeue();
+
+ if(item == NULL)
+ {
+ IPACMDBG("Waiting for Message\n");
+
+ if(pthread_cond_wait(&cond_var, &mutex) != 0)
+ {
+ IPACMERR("unable to lock the mutex\n");
+
+ if(pthread_mutex_unlock(&mutex) != 0)
+ {
+ IPACMERR("unable to unlock the mutex\n");
+ return NULL;
+ }
+
+ return NULL;
+ }
+
+ if(pthread_mutex_unlock(&mutex) != 0)
+ {
+ IPACMERR("unable to unlock the mutex\n");
+ return NULL;
+ }
+
+ }
+ else
+ {
+ if(pthread_mutex_unlock(&mutex) != 0)
+ {
+ IPACMERR("unable to unlock the mutex\n");
+ return NULL;
+ }
+
+ IPACMDBG("Processing item %p\n",item);
+ item->evt.callback_ptr(&item->evt.data);
+ delete item;
+ item = NULL;
+ }
+
+ } /* Go forever until a termination indication is received */
+
+}
diff --git a/ipacm/src/IPACM_Config.cpp b/ipacm/src/IPACM_Config.cpp
new file mode 100644
index 0000000..413d1ba
--- /dev/null
+++ b/ipacm/src/IPACM_Config.cpp
@@ -0,0 +1,190 @@
+/*
+Copyright (c) 2013, The Linux Foundation. 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 name of The Linux 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 "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+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.
+*/
+/*!
+ @file
+ IPACM_Config.cpp
+
+ @brief
+ This file implements the IPACM Configuration from XML file
+
+ @Author
+ Skylar Chang
+
+*/
+#include <IPACM_Config.h>
+#include <IPACM_Log.h>
+#include <IPACM_Iface.h>
+
+IPACM_Config *IPACM_Config::pInstance = NULL;
+
+IPACM_Config::IPACM_Config()
+{
+ iface_table = NULL;
+ alg_table = NULL;
+ memset(&private_subnet_table, 0, sizeof(private_subnet_table));
+
+ ipa_num_ipa_interfaces = 0;
+ ipa_num_private_subnet = 0;
+ ipa_num_alg_ports = 0;
+ ipa_nat_max_entries = 0;
+
+ memset(&rt_tbl_lan_v4, 0, sizeof(rt_tbl_lan_v4));
+ memset(&rt_tbl_wan_v4, 0, sizeof(rt_tbl_wan_v4));
+ memset(&rt_tbl_v6, 0, sizeof(rt_tbl_v6));
+
+ IPACMDBG(" create IPACM_Config constructor\n");
+ return;
+}
+
+int IPACM_Config::Init(void)
+{
+ /* Read IPACM Config file */
+ char IPACM_config_file[IPA_MAX_FILE_LEN];
+ IPACM_conf_t *cfg;
+ cfg = (IPACM_conf_t *)malloc(sizeof(IPACM_conf_t));
+ uint32_t subnet_addr;
+ uint32_t subnet_mask;
+ int i, ret = IPACM_SUCCESS;
+
+ strncpy(IPACM_config_file, "/etc/IPACM_cfg.xml", sizeof(IPACM_config_file));
+
+
+ IPACMDBG("\n IPACM XML file is %s \n", IPACM_config_file);
+ if (IPACM_SUCCESS == ipacm_read_cfg_xml(IPACM_config_file, cfg))
+ {
+ IPACMDBG("\n IPACM XML read OK \n");
+ }
+ else
+ {
+ IPACMERR("\n IPACM XML read failed \n");
+ ret = IPACM_FAILURE;
+ goto fail;
+ }
+
+ /* Construct IPACM Iface table */
+ ipa_num_ipa_interfaces = cfg->iface_config.num_iface_entries;
+ iface_table = (ipa_ifi_dev_name_t *)calloc(ipa_num_ipa_interfaces,
+ sizeof(ipa_ifi_dev_name_t));
+
+ for (i = 0; i < cfg->iface_config.num_iface_entries; i++)
+ {
+ strncpy(iface_table[i].iface_name, cfg->iface_config.iface_entries[i].iface_name, sizeof(iface_table[i].iface_name));
+ iface_table[i].if_cat = cfg->iface_config.iface_entries[i].if_cat;
+ IPACMDBG("IPACM_Config::iface_table[%d] = %s, cat=%d\n", i, iface_table[i].iface_name, iface_table[i].if_cat);
+ }
+
+ /* Construct IPACM Private_Subnet table */
+ ipa_num_private_subnet = cfg->private_subnet_config.num_subnet_entries;
+
+ for (i = 0; i < cfg->private_subnet_config.num_subnet_entries; i++)
+ {
+ memcpy(&private_subnet_table[i].subnet_addr,
+ &cfg->private_subnet_config.private_subnet_entries[i].subnet_addr,
+ sizeof(cfg->private_subnet_config.private_subnet_entries[i].subnet_addr));
+
+ memcpy(&private_subnet_table[i].subnet_mask,
+ &cfg->private_subnet_config.private_subnet_entries[i].subnet_mask,
+ sizeof(cfg->private_subnet_config.private_subnet_entries[i].subnet_mask));
+
+ subnet_addr = htonl(private_subnet_table[i].subnet_addr);
+ IPACMDBG("%dst::private_subnet_table= %s \n ", i,
+ inet_ntoa(*(struct in_addr *)&(subnet_addr)));
+
+ subnet_mask = htonl(private_subnet_table[i].subnet_mask);
+ IPACMDBG("%dst::private_subnet_table= %s \n ", i,
+ inet_ntoa(*(struct in_addr *)&(subnet_mask)));
+ }
+
+ /* Construct IPACM ALG table */
+ ipa_num_alg_ports = cfg->alg_config.num_alg_entries;
+ alg_table = (ipacm_alg *)calloc(ipa_num_alg_ports,
+ sizeof(ipacm_alg));
+
+ for (i = 0; i < cfg->alg_config.num_alg_entries; i++)
+ {
+ //strncpy(alg_table[i].protocol, cfg->alg_config.alg_entries[i].protocol, sizeof(alg_table[i].protocol));
+ alg_table[i].protocol = cfg->alg_config.alg_entries[i].protocol;
+ alg_table[i].port = cfg->alg_config.alg_entries[i].port;
+ IPACMDBG("IPACM_Config::ipacm_alg[%d] = %d, port=%d\n", i, alg_table[i].protocol, alg_table[i].port);
+ }
+
+ ipa_nat_max_entries = cfg->nat_max_entries;
+ IPACMDBG("Nat Maximum Entries %d\n", ipa_nat_max_entries);
+
+ /* Construct the routing table ictol name in iface static member*/
+ rt_tbl_lan_v4.ip = IPA_IP_v4;
+ strncpy(rt_tbl_lan_v4.name, V4_LAN_ROUTE_TABLE_NAME, sizeof(rt_tbl_lan_v4.name));
+
+ rt_tbl_v6.ip = IPA_IP_v6;
+ strncpy(rt_tbl_v6.name, V6_COMMON_ROUTE_TABLE_NAME, sizeof(rt_tbl_v6.name));
+
+ rt_tbl_wan_v4.ip = IPA_IP_v4;
+ strncpy(rt_tbl_wan_v4.name, V4_WAN_ROUTE_TABLE_NAME, sizeof(rt_tbl_wan_v4.name));
+
+fail:
+ free(cfg);
+
+ return ret;
+}
+
+IPACM_Config* IPACM_Config::GetInstance()
+{
+ int res = IPACM_SUCCESS;
+
+ if (pInstance == NULL)
+ {
+ pInstance = new IPACM_Config();
+
+ res = pInstance->Init();
+ if (res != IPACM_SUCCESS)
+ {
+ delete pInstance;
+ return NULL;
+ }
+ }
+
+ return pInstance;
+}
+
+int IPACM_Config::GetAlgPorts(int nPorts, ipacm_alg *pAlgPorts)
+{
+ if (nPorts <= 0 || pAlgPorts == NULL)
+ {
+ IPACMERR("Invalid input\n");
+ return -1;
+ }
+
+ for (int cnt = 0; cnt < nPorts; cnt++)
+ {
+ pAlgPorts[cnt].protocol = alg_table[cnt].protocol;
+ pAlgPorts[cnt].port = alg_table[cnt].port;
+ }
+
+ return 0;
+}
diff --git a/ipacm/src/IPACM_ConntrackClient.cpp b/ipacm/src/IPACM_ConntrackClient.cpp
new file mode 100644
index 0000000..7e48822
--- /dev/null
+++ b/ipacm/src/IPACM_ConntrackClient.cpp
@@ -0,0 +1,699 @@
+/*
+Copyright (c) 2013, The Linux Foundation. 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 name of The Linux 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 "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+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 <iostream>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <sys/ioctl.h>
+#include <net/if.h>
+
+#include "IPACM_ConntrackListener.h"
+#include "IPACM_ConntrackClient.h"
+#include "IPACM_Log.h"
+
+#define LO_NAME "lo"
+
+extern IPACM_EvtDispatcher cm_dis;
+
+IPACM_ConntrackClient *IPACM_ConntrackClient::pInstance = NULL;
+IPACM_ConntrackListener *ct = new IPACM_ConntrackListener();
+
+/* ================================
+ Local Function Definitions
+ =================================
+*/
+#ifdef IPACM_DEBUG
+void IPACM_ConntrackClient::iptodot(const char *type, uint32_t ipAddr)
+{
+ int i;
+ unsigned char octet[4] = { 0 };
+ IPACMDBG("Received IPv4 addr: 0x%x\n", ipAddr);
+
+ for(i = 0; i < 4; i++)
+ {
+ octet[i] = (ipAddr >> (i * 8)) & 0xFF;
+ }
+
+ IPACMDBG("%s:", type);
+ IPACMDBG("%d.%d.%d.%d\n", octet[3], octet[2], octet[1], octet[0]);
+}
+#endif
+
+IPACM_ConntrackClient::IPACM_ConntrackClient()
+{
+ IPACMDBG("%s %d", __FUNCTION__, __LINE__);
+
+ tcp_hdl = NULL;
+ udp_hdl = NULL;
+ tcp_filter = NULL;
+ udp_filter = NULL;
+}
+
+IPACM_ConntrackClient* IPACM_ConntrackClient::GetInstance()
+{
+ if(pInstance == NULL)
+ {
+ pInstance = new IPACM_ConntrackClient();
+ }
+
+ return pInstance;
+}
+
+int IPACM_ConntrackClient::IPAConntrackEventCB
+(
+ enum nf_conntrack_msg_type type,
+ struct nf_conntrack *ct,
+ void *data
+ )
+{
+ ipacm_cmd_q_data evt_data;
+ ipacm_ct_evt_data *ct_data;
+
+ IPACMDBG("Event callback called with msgtype: %d\n",type);
+
+ ct_data = (ipacm_ct_evt_data *)malloc(sizeof(ipacm_ct_evt_data));
+ if(ct_data == NULL)
+ {
+ IPACMERR("unable to allocate memory \n");
+ return -1;
+ }
+
+ ct_data->ct = ct;
+ ct_data->type = type;
+
+ evt_data.event = IPA_PROCESS_CT_MESSAGE;
+ evt_data.evt_data = (void *)ct_data;
+
+ if(0 != IPACM_EvtDispatcher::PostEvt(&evt_data))
+ {
+ IPACMERR("Error sending Conntrack message to processing thread!\n");
+ free(ct_data);
+ }
+
+#if 0
+ IPACMDBG("Posted message to Cmd Queue\n");
+#endif
+
+ /* NFCT_CB_STOLEN means that the conntrack object is not released after the
+ callback That must be manually done later when the object is no longer needed. */
+ return NFCT_CB_STOLEN;
+}
+
+
+/* Function which sets up filters to ignore
+ connections to and from local interfaces */
+int IPACM_ConntrackClient::IPA_Conntrack_Filters_Ignore_Local_Addrs
+(
+ struct nfct_filter *filter
+)
+{
+ char buf[1024];
+ struct ifconf ifc;
+ struct ifreq *ifr;
+ int i, sck, nInterfaces;
+ struct nfct_filter_ipv4 filter_ipv4;
+
+ /* ignore whatever is destined to or originates from broadcast ip address */
+ filter_ipv4.addr = 0xffffffff;
+ filter_ipv4.mask = 0xffffffff;
+
+ nfct_filter_set_logic(filter,
+ NFCT_FILTER_DST_IPV4,
+ NFCT_FILTER_LOGIC_NEGATIVE);
+
+ nfct_filter_add_attr(filter, NFCT_FILTER_DST_IPV4, &filter_ipv4);
+
+ nfct_filter_set_logic(filter,
+ NFCT_FILTER_SRC_IPV4,
+ NFCT_FILTER_LOGIC_NEGATIVE);
+
+ nfct_filter_add_attr(filter, NFCT_FILTER_SRC_IPV4, &filter_ipv4);
+
+
+
+ /* Get a socket handle. */
+ sck = socket(AF_INET, SOCK_DGRAM, 0);
+ if(sck < 0)
+ {
+ PERROR("socket");
+ return -1;
+ }
+
+ /* Query available interfaces. */
+ ifc.ifc_len = sizeof(buf);
+ ifc.ifc_buf = buf;
+
+ /* get iface list */
+ if(ioctl(sck, SIOCGIFCONF, &ifc) < 0)
+ {
+ PERROR("ioctl(SIOCGIFCONF)");
+ return -1;
+ }
+
+ /* Iterate through the list of interfaces. */
+ ifr = ifc.ifc_req;
+ nInterfaces = ifc.ifc_len / sizeof(struct ifreq);
+
+#ifdef IPACM_DEBUG
+ IPACMDBG("====Printing Local Interfaces=====\n");
+#endif
+
+ for(i = 0; i < nInterfaces; i++)
+ {
+ /* Interface request structure */
+ struct ifreq *item = &ifr[i];
+
+#ifdef IPACM_DEBUG
+ /* Show the device name and IP address */
+ if(item->ifr_name != NULL)
+ {
+ IPACMDBG("%s: IP %s\n",
+ item->ifr_name,
+ inet_ntoa(((struct sockaddr_in *)&item->ifr_addr)->sin_addr));
+ }
+#endif
+
+ /* Convert data to host-byte order */
+ filter_ipv4.addr =
+ ntohl(inet_addr(inet_ntoa(((struct sockaddr_in *)&item->ifr_addr)->sin_addr)));
+ filter_ipv4.mask = 0xffffffff;
+
+ /* ignore whatever is destined to or originates from local interfaces */
+ if(item->ifr_name != NULL)
+ {
+ if(strncmp(ct->wan_ifname, item->ifr_name, strlen(item->ifr_name)) != 0)
+ {
+ IPACMDBG("ignore connections destinated to interface %s\n", item->ifr_name);
+ IPACM_ConntrackClient::iptodot("with ipv4 address:", filter_ipv4.addr);
+ nfct_filter_set_logic(filter,
+ NFCT_FILTER_DST_IPV4,
+ NFCT_FILTER_LOGIC_NEGATIVE);
+
+ nfct_filter_add_attr(filter, NFCT_FILTER_DST_IPV4, &filter_ipv4);
+ }
+ }
+
+ IPACMDBG("ignore connections orignated to interface %s\n", item->ifr_name);
+ IPACM_ConntrackClient::iptodot("with ipv4 address:", filter_ipv4.addr);
+ nfct_filter_set_logic(filter,
+ NFCT_FILTER_SRC_IPV4,
+ NFCT_FILTER_LOGIC_NEGATIVE);
+
+ nfct_filter_add_attr(filter, NFCT_FILTER_SRC_IPV4, &filter_ipv4);
+
+ /* Find broadcast address for non lo interfaces */
+ if(strncmp(LO_NAME, item->ifr_name, 2) != 0)
+ {
+ /* Get the broadcast address */
+ if(ioctl(sck, SIOCGIFBRDADDR, item) < 0)
+ {
+ PERROR("broadcast address error: ioctl(SIOCGIFBRDADDR)");
+ return -1;
+ }
+
+#ifdef IPACM_DEBUG
+ /* Show the device name and IP address */
+ if(item->ifr_name != NULL)
+ {
+ IPACMDBG("%s: BroadCast IP %s\n",
+ item->ifr_name,
+ inet_ntoa(((struct sockaddr_in *)&item->ifr_broadaddr)->sin_addr));
+ }
+#endif
+
+ /* Convert data to host-byte order */
+ filter_ipv4.addr =
+ ntohl(inet_addr(inet_ntoa(((struct sockaddr_in *)&item->ifr_broadaddr)->sin_addr)));
+ filter_ipv4.mask = 0xffffffff;
+
+ IPACMDBG("ignore connections destinated to interface %s broadcast\n", item->ifr_name);
+ IPACM_ConntrackClient::iptodot("with ipv4 address:", filter_ipv4.addr);
+ nfct_filter_set_logic(filter,
+ NFCT_FILTER_DST_IPV4,
+ NFCT_FILTER_LOGIC_NEGATIVE);
+
+ nfct_filter_add_attr(filter, NFCT_FILTER_DST_IPV4, &filter_ipv4);
+ }
+
+ }
+
+ close(sck);
+ return 0;
+} /* IPA_Conntrack_Filters_Ignore_Local_Addrs() */
+
+/* Initialize TCP Filter */
+int IPACM_ConntrackClient::IPA_Conntrack_TCP_Filter_Init(void)
+{
+ int ret = 0;
+ IPACM_ConntrackClient *pClient;
+
+ IPACMDBG("\n");
+
+ pClient = IPACM_ConntrackClient::GetInstance();
+ if(pClient == NULL)
+ {
+ IPACMERR("unable to get conntrack client instance\n");
+ return -1;
+ }
+
+ ret = IPA_Conntrack_Filters_Ignore_Local_Addrs(pClient->tcp_filter);
+ if(ret == -1)
+ {
+ IPACMERR("Unable to set local addr filters\n");
+ return -1;
+ }
+
+ ret = nfct_filter_set_logic(pClient->tcp_filter,
+ NFCT_FILTER_L4PROTO,
+ NFCT_FILTER_LOGIC_POSITIVE);
+ if(ret == -1)
+ {
+ IPACMERR("Unable to set filter logic\n");
+ return -1;
+ }
+
+ /* set protocol filters as tcp and udp */
+ nfct_filter_add_attr_u32(pClient->tcp_filter, NFCT_FILTER_L4PROTO, IPPROTO_TCP);
+
+
+ struct nfct_filter_proto tcp_proto_state;
+ tcp_proto_state.proto = IPPROTO_TCP;
+ tcp_proto_state.state = TCP_CONNTRACK_ESTABLISHED;
+
+ ret = nfct_filter_set_logic(pClient->tcp_filter,
+ NFCT_FILTER_L4PROTO_STATE,
+ NFCT_FILTER_LOGIC_POSITIVE);
+ if(ret == -1)
+ {
+ IPACMERR("unable to set filter logic\n");
+ return -1;
+ }
+ nfct_filter_add_attr(pClient->tcp_filter,
+ NFCT_FILTER_L4PROTO_STATE,
+ &tcp_proto_state);
+
+
+ tcp_proto_state.proto = IPPROTO_TCP;
+ tcp_proto_state.state = TCP_CONNTRACK_FIN_WAIT;
+ ret = nfct_filter_set_logic(pClient->tcp_filter,
+ NFCT_FILTER_L4PROTO_STATE,
+ NFCT_FILTER_LOGIC_POSITIVE);
+ if(ret == -1)
+ {
+ IPACMERR("unable to set filter logic\n");
+ return -1;
+ }
+
+ nfct_filter_add_attr(pClient->tcp_filter,
+ NFCT_FILTER_L4PROTO_STATE,
+ &tcp_proto_state);
+ return 0;
+}
+
+
+/* Initialize UDP Filter */
+int IPACM_ConntrackClient::IPA_Conntrack_UDP_Filter_Init(void)
+{
+ int ret = 0;
+ IPACM_ConntrackClient *pClient = IPACM_ConntrackClient::GetInstance();
+
+ ret = IPA_Conntrack_Filters_Ignore_Local_Addrs(pClient->udp_filter);
+ if(ret == -1)
+ {
+ IPACMERR("Unable to set local addr filters\n");
+ return -1;
+ }
+
+ ret = nfct_filter_set_logic(pClient->udp_filter,
+ NFCT_FILTER_L4PROTO,
+ NFCT_FILTER_LOGIC_POSITIVE);
+ if(ret == -1)
+ {
+ IPACMERR("unable to set filter logic\n");
+ }
+ /* set protocol filters as tcp and udp */
+ nfct_filter_add_attr_u32(pClient->udp_filter, NFCT_FILTER_L4PROTO, IPPROTO_UDP);
+
+ return 0;
+}
+
+void* IPACM_ConntrackClient::UDPConnTimeoutUpdate(void *ptr)
+{
+
+#ifdef IPACM_DEBUG
+ IPACMDBG("\n");
+#endif
+
+ while(1)
+ {
+ NatApp::GetInstance()->UpdateUDPTimeStamp();
+ sleep(UDP_TIMEOUT_UPDATE);
+ } /* end of while(1) loop */
+
+#ifdef IPACM_DEBUG
+ IPACMDBG("Returning from %s() %d\n", __FUNCTION__, __LINE__);
+#endif
+
+ return NULL;
+}
+
+/* Thread to initialize TCP Conntrack Filters*/
+void* IPACM_ConntrackClient::TCPRegisterWithConnTrack(void *)
+{
+ int ret;
+ IPACM_ConntrackClient *pClient;
+
+ IPACMDBG("\n");
+
+ pClient = IPACM_ConntrackClient::GetInstance();
+ if(pClient == NULL)
+ {
+ IPACMERR("unable to get conntrack client instance\n");
+ return -1;
+ }
+
+ pClient->tcp_hdl = nfct_open(CONNTRACK, NF_NETLINK_CONNTRACK_UPDATE);
+ if(pClient->tcp_hdl == NULL)
+ {
+ PERROR("nfct_open\n");
+ return NULL;
+ }
+
+ /* Allocate new filter */
+ pClient->tcp_filter = nfct_filter_create();
+ if(pClient->tcp_filter == NULL)
+ {
+ IPACMERR("unable to create TCP filter\n");
+ return NULL;
+ }
+
+ /* Initialize the filter */
+ ret = IPA_Conntrack_TCP_Filter_Init();
+ if(ret == -1)
+ {
+ IPACMERR("Unable to initliaze TCP Filter\n");
+ return NULL;
+ }
+
+ /* Attach the filter to net filter handler */
+ ret = nfct_filter_attach(nfct_fd(pClient->tcp_hdl),
+ pClient->tcp_filter);
+ if(ret == -1)
+ {
+ IPACMDBG("unable to attach TCP filter\n");
+ return NULL;
+ }
+
+ /* Register callback with netfilter handler */
+ IPACMDBG("tcp handle:%p, fd:%d\n", pClient->tcp_hdl, nfct_fd(pClient->tcp_hdl));
+ nfct_callback_register(pClient->tcp_hdl, NFCT_T_UPDATE, IPAConntrackEventCB, NULL);
+
+ /* Block to catch events from net filter connection track */
+ /* nfct_catch() receives conntrack events from kernel-space, by default it
+ blocks waiting for events. */
+ IPACMDBG("Waiting for events\n");
+
+ ret = nfct_catch(pClient->tcp_hdl);
+ if(ret == -1)
+ {
+ IPACMERR("(%d)(%s)\n", ret, strerror(errno));
+ return NULL;
+ }
+
+ IPACMDBG("Exit from tcp thread\n");
+
+ /* destroy the filter.. this will not detach the filter */
+ nfct_filter_destroy(pClient->tcp_filter);
+ pClient->tcp_filter = NULL;
+
+ /* de-register the callback */
+ nfct_callback_unregister(pClient->tcp_hdl);
+ /* close the handle */
+ nfct_close(pClient->tcp_hdl);
+ pClient->tcp_hdl = NULL;
+
+ pthread_exit(NULL);
+ return NULL;
+}
+
+/* Thread to initialize UDP Conntrack Filters*/
+void* IPACM_ConntrackClient::UDPRegisterWithConnTrack(void *)
+{
+ int ret;
+ IPACM_ConntrackClient *pClient = NULL;
+
+ IPACMDBG("\n");
+
+ pClient = IPACM_ConntrackClient::GetInstance();
+ if(pClient == NULL)
+ {
+ IPACMERR("unable to retrieve instance of conntrack client\n");
+ return NULL;
+ }
+
+ pClient->udp_hdl = nfct_open(CONNTRACK,
+ NF_NETLINK_CONNTRACK_NEW | NF_NETLINK_CONNTRACK_DESTROY);
+ if(pClient->udp_hdl == NULL)
+ {
+ PERROR("nfct_open\n");
+ return NULL;
+ }
+
+ /* Add filter */
+ //struct nfct_filter *udp_filter = NULL;
+
+ /* Allocate new filter */
+ pClient->udp_filter = nfct_filter_create();
+ if(pClient->udp_filter == NULL)
+ {
+ IPACMERR("unable to create UDP filter\n");
+ return NULL;
+ }
+
+ /* Initialize Filter */
+ ret = IPA_Conntrack_UDP_Filter_Init();
+ if(-1 == ret)
+ {
+ IPACMDBG("Unable to initalize udp filters\n");
+ return NULL;
+ }
+
+ /* Attach the filter to net filter handler */
+ ret = nfct_filter_attach(nfct_fd(pClient->udp_hdl), pClient->udp_filter);
+ if(ret == -1)
+ {
+ IPACMDBG("unable to attach the filter\n");
+ return NULL;
+ }
+
+ /* Register callback with netfilter handler */
+ IPACMDBG("udp handle:%p, fd:%d\n", pClient->udp_hdl, nfct_fd(pClient->udp_hdl));
+ nfct_callback_register(pClient->udp_hdl,
+ (nf_conntrack_msg_type)(NFCT_T_NEW | NFCT_T_DESTROY),
+ IPAConntrackEventCB,
+ NULL);
+
+ /* Block to catch events from net filter connection track */
+ ret = nfct_catch(pClient->udp_hdl);
+ if(ret == -1)
+ {
+ IPACMDBG("(%d)(%s)\n", ret, strerror(errno));
+ return NULL;
+ }
+
+
+ IPACMDBG("Exit from udp thread\n");
+
+ /* destroy the filter.. this will not detach the filter */
+ nfct_filter_destroy(pClient->udp_filter);
+ pClient->udp_filter = NULL;
+
+ /* de-register the callback */
+ nfct_callback_unregister(pClient->udp_hdl);
+ /* close the handle */
+ nfct_close(pClient->udp_hdl);
+ pClient->udp_hdl = NULL;
+
+ pthread_exit(NULL);
+ return NULL;
+}
+
+void IPACM_ConntrackClient::UpdateUDPFilters(void *param)
+{
+ int ret = 0;
+ struct nfct_filter_ipv4 filter_ipv4;
+ IPACM_ConntrackClient *pClient = NULL;
+
+ /* Intialize with 255.255.255.255 */
+ uint32_t bc_ip_addr = 0xFFFFFFFF;
+
+ uint32_t ipv4_addr = ((ipacm_event_iface_up *)param)->ipv4_addr;
+ uint32_t ipv4_addr_mask = ((ipacm_event_iface_up *)param)->addr_mask;
+
+ IPACM_ConntrackClient::iptodot("Received ipv4 address and", ipv4_addr);
+ IPACM_ConntrackClient::iptodot("ipv4 address mask", ipv4_addr_mask);
+
+ pClient = IPACM_ConntrackClient::GetInstance();
+ if(pClient == NULL)
+ {
+ IPACMERR("unable to retrieve conntrack client instance\n");
+ return;
+ }
+
+ /* calculate broadcast address from addr and addr_mask */
+ bc_ip_addr = (bc_ip_addr & (~ipv4_addr_mask));
+ bc_ip_addr = (bc_ip_addr | (ipv4_addr & ipv4_addr_mask));
+
+ /* netfitler expecting in host-byte order */
+ filter_ipv4.addr = ipv4_addr;
+ filter_ipv4.mask = 0xffffffff;
+
+ IPACMDBG("ignoring interface:%s", ((ipacm_event_iface_up *)param)->ifname);
+ IPACM_ConntrackClient::iptodot("with ipv4 address", filter_ipv4.addr);
+ if(pClient->udp_filter != NULL)
+ {
+ nfct_filter_set_logic(pClient->udp_filter,
+ NFCT_FILTER_DST_IPV4,
+ NFCT_FILTER_LOGIC_NEGATIVE);
+
+ nfct_filter_add_attr(pClient->udp_filter, NFCT_FILTER_DST_IPV4, &filter_ipv4);
+
+ nfct_filter_set_logic(pClient->udp_filter,
+ NFCT_FILTER_SRC_IPV4,
+ NFCT_FILTER_LOGIC_NEGATIVE);
+
+ nfct_filter_add_attr(pClient->udp_filter, NFCT_FILTER_SRC_IPV4, &filter_ipv4);
+ }
+
+ /* netfitler expecting in host-byte order */
+ filter_ipv4.addr = bc_ip_addr;
+ filter_ipv4.mask = 0xffffffff;
+
+ IPACM_ConntrackClient::iptodot("with broadcast address", filter_ipv4.addr);
+ if(pClient->udp_filter != NULL)
+ {
+ nfct_filter_set_logic(pClient->udp_filter,
+ NFCT_FILTER_DST_IPV4,
+ NFCT_FILTER_LOGIC_NEGATIVE);
+
+ nfct_filter_add_attr(pClient->udp_filter, NFCT_FILTER_DST_IPV4, &filter_ipv4);
+ }
+
+ /* Attach the filter to udp handle */
+ if(pClient->udp_hdl != NULL)
+ {
+ IPACMDBG("attaching the filter to udp handle\n");
+ ret = nfct_filter_attach(nfct_fd(pClient->udp_hdl), pClient->udp_filter);
+ if(ret == -1)
+ {
+ PERROR("unable to attach the filter to udp handle\n");
+ IPACMERR("udp handle:%p, fd:%d Error: %d\n",pClient->udp_hdl, nfct_fd(pClient->udp_hdl), ret);
+ return;
+ }
+ }
+
+ return;
+}
+
+void IPACM_ConntrackClient::UpdateTCPFilters(void *param)
+{
+ int ret = 0;
+ uint32_t ipv4_addr = ((ipacm_event_iface_up *)param)->ipv4_addr;
+ uint32_t ipv4_addr_mask = ((ipacm_event_iface_up *)param)->addr_mask;
+ struct nfct_filter_ipv4 filter_ipv4;
+ IPACM_ConntrackClient *pClient = NULL;
+ /* Intialize with 255.255.255.255 */
+ uint32_t bc_ip_addr = 0xFFFFFFFF;
+
+ pClient = IPACM_ConntrackClient::GetInstance();
+ if(pClient == NULL)
+ {
+ IPACMERR("unable to retrieve conntrack client instance\n");
+ return;
+ }
+
+ /* calculate broadcast address from addr and addr_mask */
+ bc_ip_addr = (bc_ip_addr & (~ipv4_addr_mask));
+ bc_ip_addr = (bc_ip_addr | (ipv4_addr & ipv4_addr_mask));
+
+ /* netfitler expecting in host-byte order */
+ filter_ipv4.addr = ipv4_addr;
+ filter_ipv4.mask = 0xffffffff;
+
+ IPACMDBG("ignoring interface:%s", ((ipacm_event_iface_up *)param)->ifname);
+ IPACM_ConntrackClient::iptodot("with ipv4 address", filter_ipv4.addr);
+
+ if(pClient->tcp_filter != NULL)
+ {
+ nfct_filter_set_logic(pClient->tcp_filter,
+ NFCT_FILTER_DST_IPV4,
+ NFCT_FILTER_LOGIC_NEGATIVE);
+
+ nfct_filter_add_attr(pClient->tcp_filter, NFCT_FILTER_DST_IPV4, &filter_ipv4);
+
+ nfct_filter_set_logic(pClient->tcp_filter,
+ NFCT_FILTER_SRC_IPV4,
+ NFCT_FILTER_LOGIC_NEGATIVE);
+
+ nfct_filter_add_attr(pClient->tcp_filter, NFCT_FILTER_SRC_IPV4, &filter_ipv4);
+ }
+
+ /* netfitler expecting in host-byte order */
+ filter_ipv4.addr = bc_ip_addr;
+ filter_ipv4.mask = 0xffffffff;
+
+ IPACM_ConntrackClient::iptodot("with broadcast address", filter_ipv4.addr);
+ if(pClient->tcp_filter != NULL)
+ {
+ nfct_filter_set_logic(pClient->tcp_filter,
+ NFCT_FILTER_DST_IPV4,
+ NFCT_FILTER_LOGIC_NEGATIVE);
+
+ nfct_filter_add_attr(pClient->tcp_filter, NFCT_FILTER_DST_IPV4, &filter_ipv4);
+ }
+
+ /* Attach the filter to tcp handle */
+ if(pClient->tcp_hdl != NULL)
+ {
+ IPACMDBG("attaching the filter to tcp handle\n");
+ ret = nfct_filter_attach(nfct_fd(pClient->tcp_hdl), pClient->tcp_filter);
+ if(ret == -1)
+ {
+ PERROR("unable to attach the filter to tcp handle\n");
+ IPACMERR("tcp handle:%p, fd:%d Error: %d\n",pClient->tcp_hdl, nfct_fd(pClient->tcp_hdl), ret);
+ return;
+ }
+ }
+
+ return;
+}
diff --git a/ipacm/src/IPACM_ConntrackListener.cpp b/ipacm/src/IPACM_ConntrackListener.cpp
new file mode 100644
index 0000000..66a6355
--- /dev/null
+++ b/ipacm/src/IPACM_ConntrackListener.cpp
@@ -0,0 +1,429 @@
+/*
+Copyright (c) 2013, The Linux Foundation. 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 name of The Linux 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 "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+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 "IPACM_ConntrackListener.h"
+#include "IPACM_ConntrackClient.h"
+#include "IPACM_EvtDispatcher.h"
+
+IPACM_ConntrackListener::IPACM_ConntrackListener()
+{
+ IPACMDBG("%d %s()\n", __LINE__, __FUNCTION__);
+
+ isCTReg = false;
+ isWanUp = false;
+
+ IPACM_EvtDispatcher::registr(IPA_HANDLE_WAN_UP, this);
+ IPACM_EvtDispatcher::registr(IPA_HANDLE_WAN_DOWN, this);
+ IPACM_EvtDispatcher::registr(IPA_PROCESS_CT_MESSAGE, this);
+ IPACM_EvtDispatcher::registr(IPA_HANDLE_WLAN_UP, this);
+}
+
+void IPACM_ConntrackListener::event_callback(ipa_cm_event_id evt,
+ void *data)
+{
+ ipacm_ct_evt_data *evt_data = NULL;
+ uint32_t *pub_addr = NULL;
+
+ if(data == NULL)
+ {
+ IPACMERR("Invalid Data\n");
+ return;
+ }
+
+ switch(evt)
+ {
+ case IPA_PROCESS_CT_MESSAGE:
+ IPACMDBG("Received IPA_PROCESS_CT_MESSAGE event\n");
+ evt_data = (ipacm_ct_evt_data *)data;
+ ProcessCTMessage(evt_data);
+ break;
+
+ case IPA_HANDLE_WAN_UP:
+ IPACMDBG("Received IPA_HANDLE_WAN_UP event\n");
+ TriggerWANUp(data);
+ break;
+
+ case IPA_HANDLE_WAN_DOWN:
+ IPACMDBG("Received IPA_HANDLE_WAN_DOWN event\n");
+ pub_addr = (uint32_t *)data;
+ TriggerWANDown(*pub_addr);
+ break;
+
+ /* if wlan or lan comes up after wan interface, modify
+ tcp/udp filters to ignore local wlan or lan connections */
+ case IPA_HANDLE_WLAN_UP:
+ case IPA_HANDLE_LAN_UP:
+ IPACMDBG("Received event: %d\n", evt);
+ if(isWanUp == true)
+ {
+ IPACM_ConntrackClient::UpdateUDPFilters(data);
+ IPACM_ConntrackClient::UpdateTCPFilters(data);
+ }
+ break;
+
+ default:
+ IPACMDBG("Ignore cmd %d\n", evt);
+ break;
+ }
+}
+
+void IPACM_ConntrackListener::TriggerWANUp(void *in_param)
+{
+ ipacm_event_iface_up *wanup_data = (ipacm_event_iface_up *)in_param;
+
+ IPACMDBG("Recevied below informatoin during wanup:\n");
+ IPACMDBG("if_name:%s, ipv4_address:0x%x\n",
+ wanup_data->ifname, wanup_data->ipv4_addr);
+
+ isWanUp = true;
+ wan_ipaddr = wanup_data->ipv4_addr;
+ IPACM_ConntrackClient::iptodot("public ip address", wanup_data->ipv4_addr);
+
+ memcpy(wan_ifname, wanup_data->ifname, sizeof(wan_ifname));
+ NatApp::GetInstance()->AddTable(wanup_data->ipv4_addr);
+
+ IPACMDBG("creating nat threads\n");
+ CreateNatThreads();
+}
+
+int IPACM_ConntrackListener::CreateNatThreads(void)
+{
+ int ret;
+ pthread_t tcp_thread = 0, udp_thread = 0, udpcto_thread = 0;
+
+ if(isCTReg == false)
+ {
+
+ if(!tcp_thread)
+ {
+ ret = pthread_create(&tcp_thread, NULL, IPACM_ConntrackClient::TCPRegisterWithConnTrack, NULL);
+ if(0 != ret)
+ {
+ IPACMERR("unable to create TCP conntrack event listner thread\n");
+ return -1;
+ }
+
+ IPACMDBG("created TCP conntrack event listner thread\n");
+ }
+
+ if(!udp_thread)
+ {
+ ret = pthread_create(&udp_thread, NULL, IPACM_ConntrackClient::UDPRegisterWithConnTrack, NULL);
+ if(0 != ret)
+ {
+ IPACMERR("unable to create UDP conntrack event listner thread\n");
+ goto error;
+ }
+
+ IPACMDBG("created UDP conntrack event listner thread\n");
+ }
+
+ if(!udpcto_thread)
+ {
+ ret = pthread_create(&udpcto_thread, NULL, IPACM_ConntrackClient::UDPConnTimeoutUpdate, NULL);
+ if(0 != ret)
+ {
+ IPACMERR("unable to create udp conn timeout thread\n");
+ goto error;
+ }
+
+ IPACMDBG("created upd conn timeout thread\n");
+ }
+
+ isCTReg = true;
+ }
+
+ //pthread_join(tcp_thread, NULL);
+ //pthread_join(udp_thread, NULL);
+ //pthread_join(udpcto_thread, NULL);
+
+ return 0;
+
+error:
+ if(tcp_thread)
+ {
+ pthread_cancel(tcp_thread);
+ }
+
+ if(udp_thread)
+ {
+ pthread_cancel(tcp_thread);
+ }
+
+ if(udpcto_thread)
+ {
+ pthread_cancel(udpcto_thread);
+ }
+
+ return -1;
+}
+
+void IPACM_ConntrackListener::TriggerWANDown(uint32_t wan_addr)
+{
+ IPACMDBG("Deleting ipv4 nat table with ");
+ IPACM_ConntrackClient::iptodot("public ip address", wan_addr);
+ isWanUp = false;
+
+ NatApp::GetInstance()->DeleteTable(wan_addr);
+}
+
+
+void ParseCTMessage(struct nf_conntrack *ct)
+{
+ uint32_t status;
+ IPACMDBG("Printing conntrack parameters\n");
+
+ IPACM_ConntrackClient::iptodot("ATTR_IPV4_SRC = ATTR_ORIG_IPV4_SRC:", nfct_get_attr_u32(ct, ATTR_ORIG_IPV4_SRC));
+ IPACM_ConntrackClient::iptodot("ATTR_IPV4_DST = ATTR_ORIG_IPV4_DST:", nfct_get_attr_u32(ct, ATTR_ORIG_IPV4_DST));
+ IPACMDBG("ATTR_PORT_SRC = ATTR_ORIG_PORT_SRC: 0x:%x\n", nfct_get_attr_u16(ct, ATTR_ORIG_PORT_SRC));
+ IPACMDBG("ATTR_PORT_DST = ATTR_ORIG_PORT_DST: 0x:%x\n", nfct_get_attr_u16(ct, ATTR_ORIG_PORT_DST));
+
+ IPACM_ConntrackClient::iptodot("ATTR_REPL_IPV4_SRC:", nfct_get_attr_u32(ct, ATTR_REPL_IPV4_SRC));
+ IPACM_ConntrackClient::iptodot("ATTR_REPL_IPV4_DST:", nfct_get_attr_u32(ct, ATTR_REPL_IPV4_DST));
+ IPACMDBG("ATTR_REPL_PORT_SRC: 0x:%x\n", nfct_get_attr_u16(ct, ATTR_REPL_PORT_SRC));
+ IPACMDBG("ATTR_REPL_PORT_DST: 0x:%x\n", nfct_get_attr_u16(ct, ATTR_REPL_PORT_DST));
+
+ IPACM_ConntrackClient::iptodot("ATTR_SNAT_IPV4:", nfct_get_attr_u32(ct, ATTR_SNAT_IPV4));
+ IPACM_ConntrackClient::iptodot("ATTR_DNAT_IPV4:", nfct_get_attr_u32(ct, ATTR_DNAT_IPV4));
+ IPACMDBG("ATTR_SNAT_PORT: 0x:%x\n", nfct_get_attr_u16(ct, ATTR_SNAT_PORT));
+ IPACMDBG("ATTR_DNAT_PORT: 0x:%x\n", nfct_get_attr_u16(ct, ATTR_DNAT_PORT));
+
+ IPACMDBG("ATTR_MARK: 0x%x\n", nfct_get_attr_u32(ct, ATTR_MARK));
+ IPACMDBG("ATTR_USE: 0x:%x\n", nfct_get_attr_u32(ct, ATTR_USE));
+ IPACMDBG("ATTR_ID: 0x:%x\n", nfct_get_attr_u32(ct, ATTR_ID));
+
+ status = nfct_get_attr_u32(ct, ATTR_STATUS);
+ IPACMDBG("ATTR_STATUS: 0x:%x\n", status);
+
+ if(IPS_SRC_NAT & status)
+ {
+ IPACMDBG("IPS_SRC_NAT set\n");
+ }
+
+ if(IPS_DST_NAT & status)
+ {
+ IPACMDBG("IPS_SRC_NAT set\n");
+ }
+
+ if(IPS_SRC_NAT_DONE & status)
+ {
+ IPACMDBG("IPS_SRC_NAT_DONE set\n");
+ }
+
+ if(IPS_DST_NAT_DONE & status)
+ {
+ IPACMDBG(" IPS_DST_NAT_DONE set\n");
+ }
+
+ IPACMDBG("\n");
+ return;
+}
+
+void IPACM_ConntrackListener::ProcessCTMessage(void *param)
+{
+ ipacm_ct_evt_data *evt_data = (ipacm_ct_evt_data *)param;
+ u_int8_t l4proto = 0;
+
+#ifdef IPACM_DEBUG
+ char buf[1024];
+
+ /* Process message and generate ioctl call to kernel thread */
+ nfct_snprintf(buf, sizeof(buf), evt_data->ct,
+ evt_data->type, NFCT_O_PLAIN, NFCT_OF_TIME);
+ IPACMDBG("%s\n", buf);
+ IPACMDBG("\n");
+
+ ParseCTMessage(evt_data->ct);
+#endif
+
+ l4proto = nfct_get_attr_u8(evt_data->ct, ATTR_ORIG_L4PROTO);
+ if(IPPROTO_UDP != l4proto && IPPROTO_TCP != l4proto)
+ {
+ IPACMDBG("Received unexpected protocl %d conntrack message\n", l4proto);
+ }
+ else
+ {
+ ProcessTCPorUDPMsg(evt_data->ct, evt_data->type, l4proto);
+ }
+
+ /* Cleanup item that was allocated during the original CT callback */
+ nfct_destroy(evt_data->ct);
+ return;
+}
+
+
+/* conntrack send in host order and ipa expects in host order */
+void IPACM_ConntrackListener::ProcessTCPorUDPMsg(
+ struct nf_conntrack *ct,
+ enum nf_conntrack_msg_type type,
+ u_int8_t l4proto)
+{
+ nat_table_entry rule;
+ u_int8_t tcp_state;
+ uint32_t status = 0;
+
+ status = nfct_get_attr_u32(ct, ATTR_STATUS);
+
+ if(IPS_DST_NAT & status)
+ {
+ IPACMDBG("Destination nat flag set\n");
+ rule.dst_nat = true;
+
+ IPACMDBG("Parse reply tuple\n");
+ rule.target_ip = nfct_get_attr_u32(ct, ATTR_ORIG_IPV4_SRC);
+ rule.target_ip = ntohl(rule.target_ip);
+
+ /* Retriev target/dst port */
+ rule.target_port = nfct_get_attr_u16(ct, ATTR_ORIG_PORT_SRC);
+ rule.target_port = ntohs(rule.target_port);
+ if(0 == rule.target_port)
+ {
+ IPACMDBG("unable to retrieve target port\n");
+ }
+
+ rule.public_port = nfct_get_attr_u16(ct, ATTR_ORIG_PORT_DST);
+ rule.public_port = ntohs(rule.public_port);
+
+ /* Retriev src/private ip address */
+ rule.private_ip = nfct_get_attr_u32(ct, ATTR_REPL_IPV4_SRC);
+ rule.private_ip = ntohl(rule.private_ip);
+ if(0 == rule.private_ip)
+ {
+ IPACMDBG("unable to retrieve private ip address\n");
+ }
+
+ /* Retriev src/private port */
+ rule.private_port = nfct_get_attr_u16(ct, ATTR_REPL_PORT_SRC);
+ rule.private_port = ntohs(rule.private_port);
+ if(0 == rule.private_port)
+ {
+ IPACMDBG("unable to retrieve private port\n");
+ }
+ }
+ else
+ {
+ IPACMDBG("destination nat flag reset\n");
+ rule.dst_nat = false;
+
+ /* Retriev target/dst ip address */
+ IPACMDBG("Parse source tuple\n");
+ rule.target_ip = nfct_get_attr_u32(ct, ATTR_ORIG_IPV4_DST);
+ rule.target_ip = ntohl(rule.target_ip);
+ if(0 == rule.target_ip)
+ {
+ IPACMDBG("unable to retrieve target ip address\n");
+ }
+ /* Retriev target/dst port */
+ rule.target_port = nfct_get_attr_u16(ct, ATTR_ORIG_PORT_DST);
+ rule.target_port = ntohs(rule.target_port);
+ if(0 == rule.target_port)
+ {
+ IPACMDBG("unable to retrieve target port\n");
+ }
+
+ /* Retriev public port */
+ rule.public_port = nfct_get_attr_u16(ct, ATTR_REPL_PORT_DST);
+ rule.public_port = ntohs(rule.public_port);
+ if(0 == rule.public_port)
+ {
+ IPACMDBG("unable to retrieve public port\n");
+ }
+
+ /* Retriev src/private ip address */
+ rule.private_ip = nfct_get_attr_u32(ct, ATTR_ORIG_IPV4_SRC);
+ rule.private_ip = ntohl(rule.private_ip);
+ if(0 == rule.private_ip)
+ {
+ IPACMDBG("unable to retrieve private ip address\n");
+ }
+
+ /* Retriev src/private port */
+ rule.private_port = nfct_get_attr_u16(ct, ATTR_ORIG_PORT_SRC);
+ rule.private_port = ntohs(rule.private_port);
+ if(0 == rule.private_port)
+ {
+ IPACMDBG("unable to retrieve private port\n");
+ }
+ }
+ /* Retrieve Protocol */
+ rule.protocol = nfct_get_attr_u8(ct, ATTR_REPL_L4PROTO);
+
+
+ IPACMDBG("Nat Entry with below information will be added\n");
+ IPACM_ConntrackClient::iptodot("target ip or dst ip", rule.target_ip);
+ IPACMDBG("target port or dst port: 0x%x Decimal:%d\n", rule.target_port, rule.target_port);
+ IPACM_ConntrackClient::iptodot("private ip or src ip", rule.private_ip);
+ IPACMDBG("private port or src port: 0x%x, Decimal:%d\n", rule.private_port, rule.private_port);
+ IPACMDBG("public port or reply dst port: 0x%x, Decimal:%d\n", rule.public_port, rule.public_port);
+ IPACMDBG("Protocol: %d, destination nat flag: %d\n", rule.protocol, rule.dst_nat);
+
+ if(IPPROTO_TCP == rule.protocol)
+ {
+ tcp_state = nfct_get_attr_u8(ct, ATTR_TCP_STATE);
+ if(TCP_CONNTRACK_ESTABLISHED == tcp_state)
+ {
+ IPACMDBG("TCP state TCP_CONNTRACK_ESTABLISHED(%d)\n", tcp_state);
+ NatApp::GetInstance()->AddEntry(&rule);
+ }
+ else if(TCP_CONNTRACK_FIN_WAIT == tcp_state)
+ {
+ IPACMDBG("TCP state TCP_CONNTRACK_FIN_WAIT(%d)\n", tcp_state);
+ NatApp::GetInstance()->DeleteEntry(&rule);
+ }
+ else
+ {
+ IPACMDBG("Ignore tcp state: %d and type: %d\n", tcp_state, type);
+ }
+
+ }
+ else if(IPPROTO_UDP == rule.protocol)
+ {
+ if(NFCT_T_NEW == type)
+ {
+ IPACMDBG("New UDP connection at time %ld\n", time(NULL));
+ NatApp::GetInstance()->AddEntry(&rule);
+ }
+ else if(NFCT_T_DESTROY == type)
+ {
+ IPACMDBG("UDP connection close at time %ld\n", time(NULL));
+ NatApp::GetInstance()->DeleteEntry(&rule);
+ }
+ }
+ else
+ {
+ IPACMDBG("Ignore protocol: %d and type: %d\n", rule.protocol, type);
+ }
+
+ return;
+}
+
+
+
+
+
+
diff --git a/ipacm/src/IPACM_Conntrack_NATApp.cpp b/ipacm/src/IPACM_Conntrack_NATApp.cpp
new file mode 100644
index 0000000..63b158c
--- /dev/null
+++ b/ipacm/src/IPACM_Conntrack_NATApp.cpp
@@ -0,0 +1,504 @@
+/*
+Copyright (c) 2013, The Linux Foundation. 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 name of The Linux 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 "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+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 "IPACM_Conntrack_NATApp.h"
+#include "IPACM_ConntrackClient.h"
+
+#define UDP_TIMEOUT_VALUE 30
+
+/* NatApp class Implementation */
+NatApp *NatApp::pInstance = NULL;
+NatApp::NatApp()
+{
+ max_entries = 0;
+ cache = NULL;
+
+ nat_table_hdl = 0;
+ pub_ip_addr = 0;
+
+ curCnt = 0;
+
+ pALGPorts = NULL;
+ nALGPort = 0;
+
+ ct = NULL;
+ ct_hdl = NULL;
+}
+
+int NatApp::Init(void)
+{
+ IPACM_Config *pConfig;
+
+ pConfig = IPACM_Config::GetInstance();
+ if(pConfig == NULL)
+ {
+ IPACMERR("Unable to get Config instance\n");
+ return -1;
+ }
+
+ max_entries = pConfig->GetNatMaxEntries();
+
+ cache = (nat_table_entry *)malloc(sizeof(nat_table_entry) * max_entries);
+ if(cache == NULL)
+ {
+ IPACMERR("Unable to allocate memory for cache\n");
+ goto fail;
+ }
+ memset(cache, 0, sizeof(nat_table_entry) * max_entries);
+
+ nALGPort = pConfig->GetAlgPortCnt();
+ pALGPorts = (ipacm_alg *)malloc(sizeof(ipacm_alg) * nALGPort);
+ if(pALGPorts == NULL)
+ {
+ IPACMERR("Unable to allocate memory for alg prots\n");
+ goto fail;
+ }
+ memset(pALGPorts, 0, sizeof(ipacm_alg) * nALGPort);
+
+ if(pConfig->GetAlgPorts(nALGPort, pALGPorts) != 0)
+ {
+ IPACMERR("Unable to retrieve ALG prots\n");
+ goto fail;
+ }
+
+ IPACMDBG("Printing %d alg ports information\n", nALGPort);
+ for(int cnt=0; cnt<nALGPort; cnt++)
+ {
+ IPACMDBG("%d: Proto[%d], port[%d]\n", cnt, pALGPorts[cnt].protocol, pALGPorts[cnt].port);
+ }
+
+ return 0;
+
+fail:
+ free(cache);
+ free(pALGPorts);
+ return -1;
+}
+
+NatApp* NatApp::GetInstance()
+{
+ if(pInstance == NULL)
+ {
+ pInstance = new NatApp();
+
+ if(pInstance->Init())
+ {
+ delete pInstance;
+ return NULL;
+ }
+ }
+
+ return pInstance;
+}
+
+/* NAT APP related object function definitions */
+
+int NatApp::AddTable(uint32_t pub_ip)
+{
+ int ret;
+ IPACMDBG("%s() %d\n", __FUNCTION__, __LINE__);
+
+ ret = ipa_nat_add_ipv4_tbl(pub_ip, max_entries, &nat_table_hdl);
+ if(ret)
+ {
+ IPACMERR("unable to create nat table Error:%d\n", ret);
+ return ret;
+ }
+
+ pub_ip_addr = pub_ip;
+ return 0;
+}
+
+void NatApp::Reset()
+{
+ memset(cache, 0, sizeof(nat_table_entry) * max_entries);
+
+ nat_table_hdl = 0;
+ pub_ip_addr = 0;
+ curCnt = 0;
+}
+
+int NatApp::DeleteTable(uint32_t pub_ip)
+{
+ int ret;
+ IPACMDBG("%s() %d\n", __FUNCTION__, __LINE__);
+
+ CHK_TBL_HDL();
+
+ if(pub_ip_addr != pub_ip)
+ {
+ IPACMDBG("Public ip address is not matching\n");
+ IPACMERR("unable to delete the nat table\n");
+ return -1;
+ }
+
+ ret = ipa_nat_del_ipv4_tbl(nat_table_hdl);
+ if(ret)
+ {
+ IPACMERR("unable to delete nat table Error: %d\n", ret);;
+ return ret;
+ }
+
+ Reset();
+ return 0;
+}
+
+/* Check for duplicate entries */
+bool NatApp::ChkForDup(const nat_table_entry *rule)
+{
+ int cnt = 0;
+ IPACMDBG("%s() %d\n", __FUNCTION__, __LINE__);
+
+ for(; cnt < curCnt; cnt++)
+ {
+ if(cache[cnt].private_ip == rule->private_ip &&
+ cache[cnt].target_ip == rule->target_ip &&
+ cache[cnt].private_port == rule->private_port &&
+ cache[cnt].target_port == rule->target_port &&
+ cache[cnt].protocol == rule->protocol)
+ {
+ IPACMDBG("Duplicate Rule\n");
+ return true;
+ }
+ }
+
+ return false;
+}
+
+/* Delete the entry from Nat table on connection close */
+int NatApp::DeleteEntry(const nat_table_entry *rule)
+{
+ int cnt = 0;
+ IPACMDBG("%s() %d\n", __FUNCTION__, __LINE__);
+
+ CHK_TBL_HDL();
+
+#ifdef IPACM_DEBUG
+ IPACM_ConntrackClient::iptodot("Private IP", rule->private_ip);
+ IPACM_ConntrackClient::iptodot("Target IP", rule->target_ip);
+ IPACMDBG("Private Port: %d\t Target Port: %d\t", rule->private_port, rule->target_port);
+ IPACMDBG("protocolcol: %d\n", rule->protocol);
+#endif
+
+ for(; cnt < max_entries; cnt++)
+ {
+ if(cache[cnt].private_ip == rule->private_ip &&
+ cache[cnt].target_ip == rule->target_ip &&
+ cache[cnt].private_port == rule->private_port &&
+ cache[cnt].target_port == rule->target_port &&
+ cache[cnt].protocol == rule->protocol)
+ {
+
+ if(ipa_nat_del_ipv4_rule(nat_table_hdl, cache[cnt].rule_hdl) < 0)
+ {
+ IPACMERR("%s() %d\n", __FUNCTION__, __LINE__);
+ return -1;
+ }
+
+ memset(&cache[cnt], 0, sizeof(cache[cnt]));
+ curCnt--;
+ }
+ }
+
+ return 0;
+}
+
+/* Add new entry to the nat table on new connection */
+int NatApp::AddEntry(const nat_table_entry *rule)
+{
+
+ int cnt = 0;
+ ipa_nat_ipv4_rule nat_rule;
+ IPACMDBG("%s() %d\n", __FUNCTION__, __LINE__);
+
+ CHK_TBL_HDL();
+
+ if(isAlgPort(rule->protocol, rule->private_port) ||
+ isAlgPort(rule->protocol, rule->target_port))
+ {
+ IPACMERR("connection using ALG Port. Dont insert into nat table\n");
+ return -1;
+ }
+
+ if(isPwrSaveIf(rule->private_ip) ||
+ isPwrSaveIf(rule->target_ip))
+ {
+ IPACMERR("Device is Power Save mode: Dont insert into nat table\n");
+ return -1;
+ }
+
+ if(!ChkForDup(rule))
+ {
+ for(; cnt < max_entries; cnt++)
+ {
+ if(cache[cnt].private_ip == 0 &&
+ cache[cnt].target_ip == 0 &&
+ cache[cnt].private_port == 0 &&
+ cache[cnt].target_port == 0 &&
+ cache[cnt].protocol == 0)
+ {
+ break;
+ }
+ }
+
+ if(max_entries == cnt)
+ {
+ IPACMERR("Error: Unable to add, reached maximum rules\n");
+ return -1;
+ }
+ else
+ {
+ nat_rule.private_ip = rule->private_ip;
+ nat_rule.target_ip = rule->target_ip;
+ nat_rule.target_port = rule->target_port;
+ nat_rule.private_port = rule->private_port;
+ nat_rule.public_port = rule->public_port;
+ nat_rule.protocol = rule->protocol;
+
+ if(ipa_nat_add_ipv4_rule(nat_table_hdl, &nat_rule, &cache[cnt].rule_hdl) < 0)
+ {
+ IPACMERR("unable to add the rule\n");
+ return -1;
+ }
+
+ cache[cnt].private_ip = rule->private_ip;
+ cache[cnt].target_ip = rule->target_ip;
+ cache[cnt].target_port = rule->target_port;
+ cache[cnt].private_port = rule->private_port;
+ cache[cnt].protocol = rule->protocol;
+ cache[cnt].timestamp = 0;
+ cache[cnt].public_port = rule->public_port;
+ cache[cnt].dst_nat = rule->dst_nat;
+ curCnt++;
+ }
+
+ }
+ else
+ {
+ IPACMERR("Duplicate rule. Ignore it\n");
+ return -1;
+ }
+
+
+#ifdef IPACM_DEBUG
+ IPACMDBG("Added below rule successfully\n");
+ IPACM_ConntrackClient::iptodot("Private IP", rule->private_ip);
+ IPACM_ConntrackClient::iptodot("Target IP", rule->target_ip);
+ IPACMDBG("Private Port:%d \t Target Port: %d\t", rule->private_port, rule->target_port);
+ IPACMDBG("Public Port:%d\n", rule->public_port);
+ IPACMDBG("protocol: %d\n", rule->protocol);
+#endif
+
+ return 0;
+}
+
+void NatApp::UpdateCTUdpTs(nat_table_entry *rule, uint32_t new_ts)
+{
+ int ret;
+
+#ifdef IPACM_DEBUG
+ IPACM_ConntrackClient::iptodot("Private IP:", rule->private_ip);
+ IPACM_ConntrackClient::iptodot("Target IP:", rule->target_ip);
+ IPACMDBG("Private Port: %d, Target Port: %d\n", rule->private_port, rule->target_port);
+#endif
+
+ if(!ct_hdl)
+ {
+ ct_hdl = nfct_open(CONNTRACK, 0);
+ if(!ct_hdl)
+ {
+ PERROR("nfct_open");
+ return;
+ }
+ }
+
+ if(!ct)
+ {
+ ct = nfct_new();
+ if(!ct)
+ {
+ PERROR("nfct_new");
+ return;
+ }
+ }
+
+ nfct_set_attr_u8(ct, ATTR_L3PROTO, AF_INET);
+ nfct_set_attr_u8(ct, ATTR_L4PROTO, IPPROTO_UDP);
+ nfct_set_attr_u32(ct, ATTR_TIMEOUT, UDP_TIMEOUT_VALUE);
+
+ if(rule->dst_nat == false)
+ {
+ nfct_set_attr_u32(ct, ATTR_IPV4_SRC, htonl(rule->private_ip));
+ nfct_set_attr_u16(ct, ATTR_PORT_SRC, htons(rule->private_port));
+
+ nfct_set_attr_u32(ct, ATTR_IPV4_DST, htonl(rule->target_ip));
+ nfct_set_attr_u16(ct, ATTR_PORT_DST, htons(rule->target_port));
+
+ IPACMDBG("dst nat is not set\n");
+ }
+ else
+ {
+ nfct_set_attr_u32(ct, ATTR_IPV4_SRC, htonl(rule->target_ip));
+ nfct_set_attr_u16(ct, ATTR_PORT_SRC, htons(rule->target_port));
+
+ nfct_set_attr_u32(ct, ATTR_IPV4_DST, htonl(pub_ip_addr));
+ nfct_set_attr_u16(ct, ATTR_PORT_DST, htons(rule->public_port));
+
+ IPACMDBG("dst nat is set\n");
+ }
+
+ IPACM_ConntrackClient::iptodot("Source IP:", nfct_get_attr_u32(ct, ATTR_IPV4_SRC));
+ IPACM_ConntrackClient::iptodot("Destination IP:", nfct_get_attr_u32(ct, ATTR_IPV4_DST));
+ IPACMDBG("Source Port: %d, Destination Port: %d\n",
+ nfct_get_attr_u16(ct, ATTR_PORT_SRC), nfct_get_attr_u16(ct, ATTR_PORT_DST));
+
+ IPACMDBG("updating udp connection with time: %d\n", UDP_TIMEOUT_VALUE);
+ ret = nfct_query(ct_hdl, NFCT_Q_UPDATE, ct);
+ if(ret == -1)
+ {
+ PERROR("unable to update time stamp");
+ }
+ else
+ {
+ rule->timestamp = new_ts;
+ IPACMDBG("Updated time stamp successfully\n");
+ }
+
+ return;
+}
+
+void NatApp::UpdateUDPTimeStamp()
+{
+ int cnt;
+ uint32_t ts;
+
+ for(cnt = 0; cnt < curCnt; cnt++)
+ {
+ ts = 0;
+ if(IPPROTO_UDP == cache[cnt].protocol)
+ {
+ IPACMDBG("\n");
+ if(ipa_nat_query_timestamp(nat_table_hdl, cache[cnt].rule_hdl, &ts) < 0)
+ {
+ IPACMERR("unable to retrieve timeout for rule hanle: %d\n", cache[cnt].rule_hdl);
+ continue;
+ }
+
+ if(ts == cache[cnt].timestamp)
+ {
+ continue;
+ }
+
+ UpdateCTUdpTs(&cache[cnt], ts);
+ } /* end of outer if */
+
+ } /* end of for loop */
+
+}
+
+bool NatApp::isAlgPort(uint8_t proto, uint16_t port)
+{
+ int cnt;
+ for(cnt = 0; cnt < nALGPort; cnt++)
+ {
+ if(proto == pALGPorts[cnt].protocol &&
+ port == pALGPorts[cnt].port)
+ {
+ return true;
+ }
+ }
+
+ return false;
+}
+
+bool NatApp::isPwrSaveIf(uint32_t ip_addr)
+{
+ int cnt;
+
+ for(cnt = 0; cnt < IPA_MAX_NUM_WIFI_CLIENTS; cnt++)
+ {
+ if(0 != PwrSaveIfs[cnt] &&
+ ip_addr == PwrSaveIfs[cnt])
+ {
+ return true;
+ }
+ }
+
+ return false;
+}
+
+int NatApp::UpdatePwrSaveIf(uint32_t client_lan_ip)
+{
+ int cnt;
+
+ CHK_TBL_HDL();
+
+ for(cnt = 0; cnt < IPA_MAX_NUM_WIFI_CLIENTS; cnt++)
+ {
+ if(PwrSaveIfs[cnt] == 0)
+ {
+ PwrSaveIfs[cnt] = client_lan_ip;
+ }
+ }
+
+ for(cnt = 0; cnt < curCnt; cnt++)
+ {
+ if(cache[cnt].private_ip == client_lan_ip)
+ {
+ if(ipa_nat_del_ipv4_rule(nat_table_hdl, cache[cnt].rule_hdl) < 0)
+ {
+ IPACMERR("unable to delete the rule\n");
+ continue;
+ }
+
+ memset(&cache[cnt], 0, sizeof(cache[cnt]));
+ curCnt--;
+ }
+ }
+
+ return 0;
+}
+
+int NatApp::ResetPwrSaveIf(uint32_t client_lan_ip)
+{
+ int cnt;
+
+ for(cnt = 0; cnt < IPA_MAX_NUM_WIFI_CLIENTS; cnt++)
+ {
+ if(PwrSaveIfs[cnt] == client_lan_ip)
+ {
+ PwrSaveIfs[cnt] = 0;
+ return 0;
+ }
+ }
+
+ return -1;
+}
+
+
+
diff --git a/ipacm/src/IPACM_EvtDispatcher.cpp b/ipacm/src/IPACM_EvtDispatcher.cpp
new file mode 100644
index 0000000..2d2909b
--- /dev/null
+++ b/ipacm/src/IPACM_EvtDispatcher.cpp
@@ -0,0 +1,199 @@
+/*
+Copyright (c) 2013, The Linux Foundation. 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 name of The Linux 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 "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+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.
+*/
+/*!
+ @file
+ IPACM_EvtDispatcher.cpp
+
+ @brief
+ This file implements the IPAM event dispatcher functionality
+
+ @Author
+
+*/
+#include <string.h>
+#include <pthread.h>
+#include <IPACM_EvtDispatcher.h>
+#include <IPACM_Neighbor.h>
+#include "IPACM_CmdQueue.h"
+#include "IPACM_Defs.h"
+
+
+extern pthread_mutex_t mutex;
+extern pthread_cond_t cond_var;
+
+cmd_evts *IPACM_EvtDispatcher::head = NULL;
+
+int IPACM_EvtDispatcher::PostEvt
+(
+ ipacm_cmd_q_data *data
+)
+{
+ Message *item = NULL;
+ MessageQueue *MsgQueue = NULL;
+
+ MsgQueue = MessageQueue::getInstance();
+ if(MsgQueue == NULL)
+ {
+ IPACMERR("unable to retrieve MsgQueue instance\n");
+ return IPACM_FAILURE;
+ }
+
+ item = new Message();
+ if(item == NULL)
+ {
+ IPACMERR("unable to create new message item\n");
+ return IPACM_FAILURE;
+ }
+
+ IPACMDBG("Populating item to post to queue\n");
+ item->evt.callback_ptr = IPACM_EvtDispatcher::ProcessEvt;
+ memcpy(&item->evt.data, data, sizeof(ipacm_cmd_q_data));
+
+ if(pthread_mutex_lock(&mutex) != 0)
+ {
+ IPACMERR("unable to lock the mutex\n");
+ return IPACM_FAILURE;
+ }
+
+ IPACMDBG("Enqueing item\n");
+ MsgQueue->enqueue(item);
+ IPACMDBG("Enqueued item %p\n", item);
+
+ if(pthread_cond_signal(&cond_var) != 0)
+ {
+ IPACMDBG("unable to lock the mutex\n");
+ /* Release the mutex before you return failure */
+ if(pthread_mutex_unlock(&mutex) != 0)
+ {
+ IPACMERR("unable to unlock the mutex\n");
+ return IPACM_FAILURE;
+ }
+ return IPACM_FAILURE;
+ }
+
+ if(pthread_mutex_unlock(&mutex) != 0)
+ {
+ IPACMERR("unable to unlock the mutex\n");
+ return IPACM_FAILURE;
+ }
+
+ return IPACM_SUCCESS;
+}
+
+void IPACM_EvtDispatcher::ProcessEvt(ipacm_cmd_q_data *data)
+{
+
+ cmd_evts *tmp = head;
+
+ if(head == NULL)
+ {
+ IPACMDBG("Queue is empty\n");
+ }
+
+ while(tmp != NULL)
+ {
+ if(data->event == tmp->event)
+ {
+ tmp->obj->event_callback(data->event, data->evt_data);
+ }
+ tmp = tmp->next;
+ }
+
+ if(data->evt_data != NULL)
+ {
+ free(data->evt_data);
+ }
+ return;
+}
+
+int IPACM_EvtDispatcher::registr(ipa_cm_event_id event, IPACM_Listener *obj)
+{
+ cmd_evts *tmp = head,*nw;
+
+ nw = (cmd_evts *)malloc(sizeof(cmd_evts));
+ if(nw != NULL)
+ {
+ nw->event = event;
+ nw->obj = obj;
+ nw->next = NULL;
+ }
+ else
+ {
+ return IPACM_FAILURE;
+ }
+
+ if(head == NULL)
+ {
+ head = nw;
+ }
+ else
+ {
+ while(tmp->next)
+ {
+ tmp = tmp->next;
+ }
+ tmp->next = nw;
+ }
+ return IPACM_SUCCESS;
+}
+
+
+int IPACM_EvtDispatcher::deregistr(IPACM_Listener *param)
+{
+ cmd_evts *tmp = head,*tmp1,*prev = head;
+
+ while(tmp != NULL)
+ {
+ if(tmp->obj == param)
+ {
+ tmp1 = tmp;
+ if(tmp == head)
+ {
+ head = head->next;
+ }
+ else if(tmp->next == NULL)
+ {
+ prev->next = NULL;
+ }
+ else
+ {
+ prev->next = tmp->next;
+ }
+
+ tmp = tmp->next;
+ free(tmp1);
+ }
+ else
+ {
+ prev = tmp;
+ tmp = tmp->next;
+ }
+ }
+ return IPACM_SUCCESS;
+}
diff --git a/ipacm/src/IPACM_Filtering.cpp b/ipacm/src/IPACM_Filtering.cpp
new file mode 100644
index 0000000..4241549
--- /dev/null
+++ b/ipacm/src/IPACM_Filtering.cpp
@@ -0,0 +1,223 @@
+/*
+Copyright (c) 2013, The Linux Foundation. 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 name of The Linux 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 "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+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.
+*/
+/*!
+ @file
+ IPACM_Filtering.cpp
+
+ @brief
+ This file implements the IPACM filtering functionality.
+
+ @Author
+ Skylar Chang
+
+*/
+#include <unistd.h>
+#include <sys/ioctl.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "IPACM_Filtering.h"
+#include <IPACM_Log.h>
+
+const char *IPACM_Filtering::DEVICE_NAME = "/dev/ipa";
+
+IPACM_Filtering::IPACM_Filtering()
+{
+ fd = open(DEVICE_NAME, O_RDWR);
+ if (0 == fd)
+ {
+ IPACMERR("Failed opening %s.\n", DEVICE_NAME);
+ }
+}
+
+IPACM_Filtering::~IPACM_Filtering()
+{
+ close(fd);
+}
+
+bool IPACM_Filtering::DeviceNodeIsOpened()
+{
+ return fd;
+}
+
+bool IPACM_Filtering::AddFilteringRule(struct ipa_ioc_add_flt_rule const *ruleTable)
+{
+ int retval = 0;
+
+ IPACMDBG("Printing filter add attributes\n");
+ IPACMDBG("ip type: %d\n", ruleTable->ip);
+ IPACMDBG("Number of rules: %d\n", ruleTable->num_rules);
+ IPACMDBG("End point: %d and global value: %d\n", ruleTable->ep, ruleTable->global);
+ IPACMDBG("commit value: %d\n", ruleTable->commit);
+ for (int cnt=0; cnt<ruleTable->num_rules; cnt++)
+ {
+ IPACMDBG("Filter rule:%d attrib mask: 0x%x\n",
+ cnt,
+ ruleTable->rules[cnt].rule.attrib.attrib_mask);
+ }
+
+ retval = ioctl(fd, IPA_IOC_ADD_FLT_RULE, ruleTable);
+ if (retval != 0)
+ {
+ IPACMERR("Failed adding Filtering rule %p\n", ruleTable);
+ PERROR("unable to add filter rule:");
+
+ for (int cnt = 0; cnt < ruleTable->num_rules; cnt++)
+ {
+ if (ruleTable->rules[cnt].status != 0)
+ {
+ IPACMERR("Adding Filter rule:%d failed with status:%d\n",
+ cnt, ruleTable->rules[cnt].status);
+ }
+ }
+ return false;
+ }
+
+ for (int cnt = 0; cnt<ruleTable->num_rules; cnt++)
+ {
+ if(ruleTable->rules[cnt].status != 0)
+ {
+ IPACMERR("Adding Filter rule:%d failed with status:%d\n",
+ cnt, ruleTable->rules[cnt].status);
+ }
+ }
+
+ IPACMDBG("Added Filtering rule %p\n", ruleTable);
+ return true;
+}
+
+bool IPACM_Filtering::DeleteFilteringRule(struct ipa_ioc_del_flt_rule *ruleTable)
+{
+ int retval = 0;
+
+ retval = ioctl(fd, IPA_IOC_DEL_FLT_RULE, ruleTable);
+ if (retval != 0)
+ {
+ IPACMERR("Failed deleting Filtering rule %p\n", ruleTable);
+ return false;
+ }
+
+ IPACMDBG("Deleted Filtering rule %p\n", ruleTable);
+ return true;
+}
+
+bool IPACM_Filtering::Commit(enum ipa_ip_type ip)
+{
+ int retval = 0;
+
+ retval = ioctl(fd, IPA_IOC_COMMIT_FLT, ip);
+ if (retval != 0)
+ {
+ IPACMERR("failed committing Filtering rules.\n");
+ return false;
+ }
+
+ IPACMDBG("Committed Filtering rules to IPA HW.\n");
+ return true;
+}
+
+bool IPACM_Filtering::Reset(enum ipa_ip_type ip)
+{
+ int retval = 0;
+
+ retval = ioctl(fd, IPA_IOC_RESET_FLT, ip);
+ retval |= ioctl(fd, IPA_IOC_COMMIT_FLT, ip);
+ if (retval)
+ {
+ IPACMERR("failed resetting Filtering block.\n");
+ return false;
+ }
+
+ IPACMDBG("Reset command issued to IPA Filtering block.\n");
+ return true;
+}
+
+bool IPACM_Filtering::DeleteFilteringHdls
+(
+ uint32_t *flt_rule_hdls,
+ ipa_ip_type ip,
+ uint8_t num_rules
+ )
+{
+ struct ipa_ioc_del_flt_rule *flt_rule;
+ bool res = true;
+ int len = 0, cnt = 0;
+
+ len = (sizeof(struct ipa_ioc_del_flt_rule)) + (num_rules * sizeof(struct ipa_flt_rule_del));
+ flt_rule = (struct ipa_ioc_del_flt_rule *)malloc(len);
+ if (flt_rule == NULL)
+ {
+ IPACMERR("unable to allocate memory for del filter rule\n");
+ return false;
+ }
+
+ memset(flt_rule, 0, len);
+ flt_rule->commit = 1;
+ flt_rule->num_hdls = num_rules;
+ flt_rule->ip = ip;
+
+ for (cnt = 0; cnt < flt_rule->num_hdls; cnt++)
+ {
+
+ if (flt_rule_hdls[cnt] == 0)
+ {
+ IPACMERR("invalid filter handle passed, ignoring it: %d\n", cnt)
+ res = false;
+ goto fail;
+ }
+
+ flt_rule->hdl[cnt].status = -1;
+ flt_rule->hdl[cnt].hdl = flt_rule_hdls[cnt];
+ IPACMDBG("Deleting filter hdl:(0x%x) with ip type: %d\n", flt_rule_hdls[cnt], ip);
+ }
+
+ if (DeleteFilteringRule(flt_rule) == false)
+ {
+ PERROR("Filter rule deletion failed!\n");
+ res = false;
+ goto fail;
+ }
+
+ for (cnt = 0; cnt < flt_rule->num_hdls; cnt++)
+ {
+ if (flt_rule->hdl[cnt].status != 0)
+ {
+ IPACMERR("Filter rule hdl 0x%x deletion failed with error:%d\n",
+ flt_rule->hdl[cnt].hdl, flt_rule->hdl[cnt].status);
+ res = false;
+ }
+ }
+
+fail:
+ free(flt_rule);
+
+ return res;
+}
+
diff --git a/ipacm/src/IPACM_Header.cpp b/ipacm/src/IPACM_Header.cpp
new file mode 100644
index 0000000..0ebb83d
--- /dev/null
+++ b/ipacm/src/IPACM_Header.cpp
@@ -0,0 +1,200 @@
+/*
+Copyright (c) 2013, The Linux Foundation. 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 name of The Linux 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 "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+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 <unistd.h>
+#include <sys/ioctl.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "IPACM_Header.h"
+#include "IPACM_Log.h"
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+//All interaction through the driver are made through this inode.
+static const char *DEVICE_NAME = "/dev/ipa";
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+IPACM_Header::IPACM_Header()
+{
+ m_fd = open(DEVICE_NAME, O_RDWR);
+ if (-1 == m_fd)
+ {
+ IPACMDBG("Failed to open %s in IPACM_Header test application constructor.\n", DEVICE_NAME);
+ }
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+IPACM_Header::~IPACM_Header()
+{
+ if (-1 != m_fd)
+ {
+ close(m_fd);
+ }
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+bool IPACM_Header::DeviceNodeIsOpened()
+{
+ return (-1 != m_fd);
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+bool IPACM_Header::AddHeader(struct ipa_ioc_add_hdr *pHeaderTableToAdd)
+{
+ int nRetVal = 0;
+ //call the Driver ioctl in order to add header
+ nRetVal = ioctl(m_fd, IPA_IOC_ADD_HDR, pHeaderTableToAdd);
+ IPACMDBG("return value: %d\n", nRetVal);
+ return (-1 != nRetVal);
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+bool IPACM_Header::DeleteHeader(struct ipa_ioc_del_hdr *pHeaderTableToDelete)
+{
+ int nRetVal = 0;
+ //call the Driver ioctl in order to remove header
+ nRetVal = ioctl(m_fd, IPA_IOC_DEL_HDR, pHeaderTableToDelete);
+ IPACMDBG("return value: %d\n", nRetVal);
+ return (-1 != nRetVal);
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+bool IPACM_Header::Commit()
+{
+ int nRetVal = 0;
+ nRetVal = ioctl(m_fd, IPA_IOC_COMMIT_HDR);
+ IPACMDBG("return value: %d\n", nRetVal);
+ return true;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+bool IPACM_Header::Reset()
+{
+ int nRetVal = 0;
+
+ nRetVal = ioctl(m_fd, IPA_IOC_RESET_HDR);
+ nRetVal |= ioctl(m_fd, IPA_IOC_COMMIT_HDR);
+ IPACMDBG("return value: %d\n", nRetVal);
+ return true;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+bool IPACM_Header::GetHeaderHandle(struct ipa_ioc_get_hdr *pHeaderStruct)
+{
+ int retval = 0;
+
+ if (!DeviceNodeIsOpened()) return false;
+
+ retval = ioctl(m_fd, IPA_IOC_GET_HDR, pHeaderStruct);
+ if (retval)
+ {
+ IPACMERR("IPA_IOC_GET_HDR ioctl failed, routingTable =0x%p, retval=0x%x.\n", pHeaderStruct, retval);
+ return false;
+ }
+
+ IPACMDBG("IPA_IOC_GET_HDR ioctl issued to IPA header insertion block.\n");
+ return true;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+bool IPACM_Header::CopyHeader(struct ipa_ioc_copy_hdr *pCopyHeaderStruct)
+{
+ int retval = 0;
+
+ if (!DeviceNodeIsOpened()) return false;
+
+ retval = ioctl(m_fd, IPA_IOC_COPY_HDR, pCopyHeaderStruct);
+ if (retval)
+ {
+ IPACMERR("IPA_IOC_COPY_HDR ioctl failed, retval=0x%x.\n", retval);
+ return false;
+ }
+
+ IPACMDBG("IPA_IOC_COPY_HDR ioctl issued to IPA header insertion block.\n");
+ return true;
+}
+
+bool IPACM_Header::DeleteHeaderHdl(uint32_t hdr_hdl)
+{
+ const uint8_t NUM_HDLS = 1;
+ struct ipa_ioc_del_hdr *pHeaderDescriptor = NULL;
+ struct ipa_hdr_del *hd_rule_entry;
+ int len = 0;
+ bool res = true;
+
+ if (hdr_hdl == 0)
+ {
+ IPACMERR("Invalid header handle passed. Ignoring it\n");
+ return false;
+ }
+
+ len = (sizeof(struct ipa_ioc_del_hdr)) + (NUM_HDLS * sizeof(struct ipa_hdr_del));
+ pHeaderDescriptor = (struct ipa_ioc_del_hdr *)malloc(len);
+ if (pHeaderDescriptor == NULL)
+ {
+ IPACMERR("Unable to allocate memory for del header\n");
+ return false;
+ }
+
+ memset(pHeaderDescriptor, 0, len);
+ pHeaderDescriptor->commit = true;
+ pHeaderDescriptor->num_hdls = NUM_HDLS;
+ hd_rule_entry = &pHeaderDescriptor->hdl[0];
+
+ hd_rule_entry->hdl = hdr_hdl;
+ hd_rule_entry->status = -1;
+
+ IPACMDBG("Deleting Header hdl:(%x)\n", hd_rule_entry->hdl);
+ if ((false == DeleteHeader(pHeaderDescriptor)) ||
+ (hd_rule_entry->status))
+ {
+ PERROR("Header deletion failed!\n");
+ res = false;
+ goto fail;
+ }
+
+ IPACMDBG("Deleted Header hdl:(%x) successfully\n", hd_rule_entry->hdl);
+
+fail:
+ free(pHeaderDescriptor);
+
+ return res;
+
+}
+
diff --git a/ipacm/src/IPACM_Iface.cpp b/ipacm/src/IPACM_Iface.cpp
new file mode 100644
index 0000000..cc6ce13
--- /dev/null
+++ b/ipacm/src/IPACM_Iface.cpp
@@ -0,0 +1,598 @@
+/*
+Copyright (c) 2013, The Linux Foundation. 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 name of The Linux 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 "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+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.Z
+*/
+/*!
+ @file
+ IPACM_Iface.cpp
+
+ @brief
+ This file implements the basis Iface functionality.
+
+ @Author
+ Skylar Chang
+
+*/
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <ifaddrs.h>
+
+#include <IPACM_Netlink.h>
+#include <IPACM_Iface.h>
+#include <IPACM_Lan.h>
+#include <IPACM_Wan.h>
+#include <IPACM_Wlan.h>
+
+const char *IPACM_Iface::DEVICE_NAME = "/dev/ipa";
+IPACM_Routing IPACM_Iface::m_routing;
+IPACM_Filtering IPACM_Iface::m_filtering;
+IPACM_Header IPACM_Iface::m_header;
+
+IPACM_Config *IPACM_Iface::ipacmcfg = IPACM_Config::GetInstance();
+
+IPACM_Iface::IPACM_Iface(int iface_index)
+{
+ ip_type = IPACM_IP_NULL; /* initially set invalid */
+ num_dft_rt = 0;
+ softwarerouting_act = false;
+ ipa_if_num = iface_index;
+
+ memcpy(dev_name,
+ IPACM_Iface::ipacmcfg->iface_table[iface_index].iface_name,
+ sizeof(IPACM_Iface::ipacmcfg->iface_table[iface_index].iface_name));
+
+ memset(dft_v4fl_rule_hdl, 0, sizeof(dft_v4fl_rule_hdl));
+ memset(dft_v6fl_rule_hdl, 0, sizeof(dft_v6fl_rule_hdl));
+
+ memset(dft_rt_rule_hdl, 0, sizeof(dft_rt_rule_hdl));
+ memset(software_routing_fl_rule_hdl, 0, sizeof(software_routing_fl_rule_hdl));
+
+ query_iface_property();
+ IPACMDBG(" create iface-index(%d) constructor\n", ipa_if_num);
+ return;
+}
+
+/* software routing enable */
+int IPACM_Iface::handle_software_routing_enable(void)
+{
+
+ int res = IPACM_SUCCESS;
+ struct ipa_flt_rule_add flt_rule_entry;
+ ipa_ioc_add_flt_rule *m_pFilteringTable;
+
+ IPACMDBG("\n");
+
+ m_pFilteringTable = (struct ipa_ioc_add_flt_rule *)
+ calloc(1,
+ sizeof(struct ipa_ioc_add_flt_rule) +
+ 1 * sizeof(struct ipa_flt_rule_add)
+ );
+ if (!m_pFilteringTable)
+ {
+ PERROR("Error Locate ipa_flt_rule_add memory...\n");
+ return IPACM_FAILURE;
+ }
+
+ m_pFilteringTable->commit = 1;
+ m_pFilteringTable->ep = rx_prop->rx[0].src_pipe;
+ m_pFilteringTable->global = false;
+ m_pFilteringTable->num_rules = (uint8_t)1;
+
+
+ /* Configuring Software-Routing Filtering Rule */
+ memset(&flt_rule_entry, 0, sizeof(struct ipa_flt_rule_add));
+
+ flt_rule_entry.at_rear = false;
+ flt_rule_entry.flt_rule_hdl = -1;
+ flt_rule_entry.status = -1;
+ flt_rule_entry.rule.action = IPA_PASS_TO_EXCEPTION;
+ memcpy(&flt_rule_entry.rule.attrib,
+ &rx_prop->rx[0].attrib,
+ sizeof(flt_rule_entry.rule.attrib));
+
+ memcpy(&(m_pFilteringTable->rules[0]), &flt_rule_entry, sizeof(struct ipa_flt_rule_add));
+
+ /* check iface is v4 or v6 or both*/
+ if (ip_type == IPA_IP_MAX)
+ {
+ /* handle v4 */
+ m_pFilteringTable->ip = IPA_IP_v4;
+ if (false == m_filtering.AddFilteringRule(m_pFilteringTable))
+ {
+ PERROR("Error Adding Filtering rule, aborting...\n");
+ res = IPACM_FAILURE;
+ goto fail;
+ }
+ else if (m_pFilteringTable->rules[0].status)
+ {
+ IPACMERR("adding flt rule failed status=0x%x\n", m_pFilteringTable->rules[0].status);
+ res = IPACM_FAILURE;
+ goto fail;
+ }
+
+ IPACMDBG("soft-routing flt rule hdl0=0x%x\n", m_pFilteringTable->rules[0].flt_rule_hdl);
+ /* copy filter hdls */
+ software_routing_fl_rule_hdl[0] = m_pFilteringTable->rules[0].flt_rule_hdl;
+
+
+ /* handle v6*/
+ m_pFilteringTable->ip = IPA_IP_v6;
+ if (false == m_filtering.AddFilteringRule(m_pFilteringTable))
+ {
+ PERROR("Error Adding Filtering rule, aborting...\n");
+ res = IPACM_FAILURE;
+ goto fail;
+ }
+ else if (m_pFilteringTable->rules[0].status)
+ {
+ IPACMDBG("adding flt rule failed status=0x%x\n", m_pFilteringTable->rules[0].status);
+ res = IPACM_FAILURE;
+ goto fail;
+ }
+
+ IPACMDBG("soft-routing flt rule hdl0=0x%x\n", m_pFilteringTable->rules[0].flt_rule_hdl);
+ /* copy filter hdls */
+ software_routing_fl_rule_hdl[1] = m_pFilteringTable->rules[0].flt_rule_hdl;
+ softwarerouting_act = true;
+ }
+ else
+ {
+ if (ip_type == IPA_IP_v4)
+ {
+ m_pFilteringTable->ip = IPA_IP_v4;
+ }
+ else
+ {
+ m_pFilteringTable->ip = IPA_IP_v6;
+ }
+
+ if (false == m_filtering.AddFilteringRule(m_pFilteringTable))
+ {
+ PERROR("Error Adding Filtering rule, aborting...\n");
+ res = IPACM_FAILURE;
+ goto fail;
+ }
+ else if (m_pFilteringTable->rules[0].status)
+ {
+ IPACMERR("adding flt rule failed status=0x%x\n", m_pFilteringTable->rules[0].status);
+ res = IPACM_FAILURE;
+ goto fail;
+ }
+
+ IPACMDBG("soft-routing flt rule hdl0=0x%x\n", m_pFilteringTable->rules[0].flt_rule_hdl);
+ /* copy filter hdls */
+ if (ip_type == IPA_IP_v4)
+ {
+ software_routing_fl_rule_hdl[0] = m_pFilteringTable->rules[0].flt_rule_hdl;
+ }
+ else
+ {
+ software_routing_fl_rule_hdl[1] = m_pFilteringTable->rules[0].flt_rule_hdl;
+ }
+ softwarerouting_act = true;
+ }
+
+fail:
+ free(m_pFilteringTable);
+
+ return res;
+}
+
+/* software routing disable */
+int IPACM_Iface::handle_software_routing_disable(void)
+{
+ int res = IPACM_SUCCESS;
+ ipa_ip_type ip;
+ uint32_t flt_hdl;
+
+ IPACMDBG("ip-type: %d\n", ip_type);
+
+ if (ip_type == IPA_IP_MAX)
+ {
+ /* ipv4 case */
+ if (m_filtering.DeleteFilteringHdls(&software_routing_fl_rule_hdl[0],
+ IPA_IP_v4, 1) == false)
+ {
+ PERROR("Error Adding Filtering rule, aborting...\n");
+ res = IPACM_FAILURE;
+ goto fail;
+ }
+
+ /* ipv6 case */
+ if (m_filtering.DeleteFilteringHdls(&software_routing_fl_rule_hdl[1],
+ IPA_IP_v6, 1) == false)
+ {
+ PERROR("Error Adding Filtering rule, aborting...\n");
+ res = IPACM_FAILURE;
+ goto fail;
+ }
+ softwarerouting_act = false;
+ }
+ else
+ {
+ if (ip_type == IPA_IP_v4)
+ {
+ ip = IPA_IP_v4;
+ }
+ else
+ {
+ ip = IPA_IP_v6;
+ }
+
+
+ if (ip_type == IPA_IP_v4)
+ {
+ flt_hdl = software_routing_fl_rule_hdl[0];
+ }
+ else
+ {
+ flt_hdl = software_routing_fl_rule_hdl[1];
+ }
+
+ if (m_filtering.DeleteFilteringHdls(&flt_hdl, ip, 1) == false)
+ {
+ PERROR("Error Adding Filtering rule, aborting...\n");
+ res = IPACM_FAILURE;
+ goto fail;
+ }
+ softwarerouting_act = false;
+ }
+
+fail:
+ return res;
+}
+
+/* Query ipa_interface_index by given linux interface_index */
+int IPACM_Iface::iface_ipa_index_query
+(
+ int interface_index
+)
+{
+ int fd;
+ int link = -1;
+ int i = 0;
+ struct ifreq ifr;
+
+
+ /* Search known linux interface-index and map to IPA interface-index*/
+ for (i = 0; i < IPACM_Iface::ipacmcfg->ipa_num_ipa_interfaces; i++)
+ {
+ if (interface_index == IPACM_Iface::ipacmcfg->iface_table[i].netlink_interface_index)
+ {
+ link = i;
+ IPACMDBG("Interface (%s) found: linux(%d) ipa(%d) \n",
+ IPACM_Iface::ipacmcfg->iface_table[i].iface_name,
+ IPACM_Iface::ipacmcfg->iface_table[i].netlink_interface_index,
+ link);
+ return link;
+ break;
+ }
+ }
+
+ /* Search/Configure linux interface-index and map it to IPA interface-index */
+ if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
+ {
+ PERROR("get interface name socket create failed");
+ return IPACM_FAILURE;
+ }
+
+ memset(&ifr, 0, sizeof(struct ifreq));
+
+ ifr.ifr_ifindex = interface_index;
+ IPACMDBG("Interface index %d\n", interface_index);
+
+ if (ioctl(fd, SIOCGIFNAME, &ifr) < 0)
+ {
+ PERROR("call_ioctl_on_dev: ioctl failed:");
+ close(fd);
+ return IPACM_FAILURE;
+ }
+ close(fd);
+
+ IPACMDBG("Received interface name %s\n", ifr.ifr_name);
+ for (i = 0; i < IPACM_Iface::ipacmcfg->ipa_num_ipa_interfaces; i++)
+ {
+ if (strncmp(ifr.ifr_name,
+ IPACM_Iface::ipacmcfg->iface_table[i].iface_name,
+ sizeof(IPACM_Iface::ipacmcfg->iface_table[i].iface_name)) == 0)
+ {
+ IPACMDBG("Interface (%s) linux(%d) mapped to ipa(%d) \n", ifr.ifr_name,
+ IPACM_Iface::ipacmcfg->iface_table[i].netlink_interface_index, i);
+
+ link = i;
+ IPACM_Iface::ipacmcfg->iface_table[i].netlink_interface_index = interface_index;
+ break;
+ }
+ }
+
+ return link;
+}
+
+/*Query the IPA endpoint property */
+int IPACM_Iface::query_iface_property(void)
+{
+ int res = IPACM_SUCCESS, fd = 0;
+
+ fd = open(DEVICE_NAME, O_RDWR);
+ IPACMDBG("iface query-property \n");
+ if (0 == fd)
+ {
+ IPACMERR("Failed opening %s.\n", DEVICE_NAME);
+ return IPACM_FAILURE;
+ }
+
+ iface_query = (struct ipa_ioc_query_intf *)
+ calloc(1, sizeof(struct ipa_ioc_query_intf));
+
+ IPACMDBG("iface name %s\n", dev_name);
+ memcpy(iface_query->name, dev_name, sizeof(dev_name));
+
+ if (ioctl(fd, IPA_IOC_QUERY_INTF, iface_query) < 0)
+ {
+ PERROR("ioctl IPA_IOC_QUERY_INTF failed\n");
+ /* iface_query memory will free when iface-down*/
+ res = IPACM_FAILURE;
+ }
+
+ tx_prop = (struct ipa_ioc_query_intf_tx_props *)
+ calloc(1, sizeof(struct ipa_ioc_query_intf_tx_props) +
+ iface_query->num_tx_props * sizeof(struct ipa_ioc_tx_intf_prop));
+
+ memcpy(tx_prop->name, dev_name, sizeof(tx_prop->name));
+ tx_prop->num_tx_props = iface_query->num_tx_props;
+
+ if (ioctl(fd, IPA_IOC_QUERY_INTF_TX_PROPS, tx_prop) < 0)
+ {
+ PERROR("ioctl IPA_IOC_QUERY_INTF_TX_PROPS failed\n");
+ /* tx_prop memory will free when iface-down*/
+ res = IPACM_FAILURE;
+ }
+
+ rx_prop = (struct ipa_ioc_query_intf_rx_props *)
+ calloc(1, sizeof(struct ipa_ioc_query_intf_rx_props) +
+ iface_query->num_rx_props * sizeof(struct ipa_ioc_rx_intf_prop));
+
+ memcpy(rx_prop->name, dev_name,
+ sizeof(rx_prop->name));
+ rx_prop->num_rx_props = iface_query->num_rx_props;
+
+ if (ioctl(fd, IPA_IOC_QUERY_INTF_RX_PROPS, rx_prop) < 0)
+ {
+ PERROR("ioctl IPA_IOC_QUERY_INTF_RX_PROPS failed\n");
+ /* rx_prop memory will free when iface-down*/
+ res = IPACM_FAILURE;
+ }
+
+ if (res != IPACM_FAILURE)
+ {
+ IPACMDBG("Rx property attribute mask:0x%x\n", rx_prop->rx[0].attrib.attrib_mask);
+ for(uint32_t cnt=0; cnt<tx_prop->num_tx_props; cnt++)
+ {
+ IPACMDBG("Tx property:%d attribute mask:0x%x, ip-type: %d\n",
+ cnt, tx_prop->tx[0].attrib.attrib_mask,tx_prop->tx[0].ip);
+ }
+ }
+
+ close(fd);
+ return res;
+}
+
+/*Configure the initial filter rules */
+int IPACM_Iface::init_fl_rule(ipa_ip_type iptype)
+{
+
+ int res = IPACM_SUCCESS, len = 0;
+ struct ipa_flt_rule_add flt_rule_entry;
+ ipa_ioc_add_flt_rule *m_pFilteringTable;
+
+ /* update the iface ip-type to be IPA_IP_v4, IPA_IP_v6 or both*/
+ if (iptype == IPA_IP_v4)
+ {
+
+ if ((ip_type == IPA_IP_v4) || (ip_type == IPA_IP_MAX))
+ {
+ IPACMDBG(" interface(%s:%d) already in ip-type %d\n", dev_name, ipa_if_num, ip_type);
+ return res;
+ }
+
+ if (ip_type == IPA_IP_v6)
+ {
+ ip_type = IPA_IP_MAX;
+ }
+ else
+ {
+ ip_type = IPA_IP_v4;
+ }
+
+ IPACMDBG(" interface(%s:%d) now ip-type is %d\n", dev_name, ipa_if_num, ip_type);
+ }
+ else
+ {
+
+ if ((ip_type == IPA_IP_v6) || (ip_type == IPA_IP_MAX))
+ {
+ IPACMDBG(" interface(%s:%d) already in ip-type %d\n", dev_name, ipa_if_num, ip_type);
+ return res;
+ }
+
+ if (ip_type == IPA_IP_v4)
+ {
+ ip_type = IPA_IP_MAX;
+ }
+ else
+ {
+ ip_type = IPA_IP_v6;
+ }
+
+ IPACMDBG(" interface(%s:%d) now ip-type is %d\n", dev_name, ipa_if_num, ip_type);
+ }
+
+
+ /* construct ipa_ioc_add_flt_rule with default filter rules */
+ if (iptype == IPA_IP_v4)
+ {
+ len = sizeof(struct ipa_ioc_add_flt_rule) +
+ (IPV4_DEFAULT_FILTERTING_RULES * sizeof(struct ipa_flt_rule_add));
+
+ m_pFilteringTable = (struct ipa_ioc_add_flt_rule *)calloc(1, len);
+ if (!m_pFilteringTable)
+ {
+ PERROR("Error Locate ipa_flt_rule_add memory...\n");
+ return IPACM_FAILURE;
+ }
+
+ m_pFilteringTable->commit = 1;
+ m_pFilteringTable->ep = rx_prop->rx[0].src_pipe;
+ m_pFilteringTable->global = false;
+ m_pFilteringTable->ip = iptype;
+ m_pFilteringTable->num_rules = (uint8_t)IPV4_DEFAULT_FILTERTING_RULES;
+
+ /* Configuring Fragment Filtering Rule */
+ memset(&flt_rule_entry, 0, sizeof(struct ipa_flt_rule_add));
+
+ flt_rule_entry.at_rear = true;
+ flt_rule_entry.flt_rule_hdl = -1;
+ flt_rule_entry.status = -1;
+ flt_rule_entry.rule.action = IPA_PASS_TO_EXCEPTION;
+ IPACMDBG("rx property attrib mask:0x%x\n", rx_prop->rx[0].attrib.attrib_mask);
+ memcpy(&flt_rule_entry.rule.attrib,
+ &rx_prop->rx[0].attrib,
+ sizeof(flt_rule_entry.rule.attrib));
+
+ flt_rule_entry.rule.attrib.attrib_mask |= IPA_FLT_FRAGMENT;
+ memcpy(&(m_pFilteringTable->rules[0]), &flt_rule_entry, sizeof(struct ipa_flt_rule_add));
+
+ /* Configuring Multicast Filtering Rule */
+ memcpy(&flt_rule_entry.rule.attrib,
+ &rx_prop->rx[0].attrib,
+ sizeof(flt_rule_entry.rule.attrib));
+ flt_rule_entry.rule.attrib.attrib_mask |= IPA_FLT_DST_ADDR;
+ flt_rule_entry.rule.attrib.u.v4.dst_addr_mask = 0xF0000000;
+ flt_rule_entry.rule.attrib.u.v4.dst_addr = 0xE0000000;
+ memcpy(&(m_pFilteringTable->rules[1]), &flt_rule_entry, sizeof(struct ipa_flt_rule_add));
+
+ /* Configuring Broadcast Filtering Rule */
+ flt_rule_entry.rule.attrib.u.v4.dst_addr_mask = 0xFFFFFFFF;
+ flt_rule_entry.rule.attrib.u.v4.dst_addr = 0xFFFFFFFF;
+ memcpy(&(m_pFilteringTable->rules[2]), &flt_rule_entry, sizeof(struct ipa_flt_rule_add));
+
+ if (false == m_filtering.AddFilteringRule(m_pFilteringTable))
+ {
+ PERROR("Error Adding Filtering rule, aborting...\n");
+ res = IPACM_FAILURE;
+ goto fail;
+ }
+ else
+ {
+ /* copy filter hdls */
+ for (int i = 0; i < IPV4_DEFAULT_FILTERTING_RULES; i++)
+ {
+ if (m_pFilteringTable->rules[i].status == 0)
+ {
+ dft_v4fl_rule_hdl[i] = m_pFilteringTable->rules[i].flt_rule_hdl;
+ IPACMDBG("Default v4 filter Rule %d HDL:0x%x\n", i, dft_v4fl_rule_hdl[i]);
+ }
+ else
+ {
+ IPACMDBG("Failed adding default v4 Filtering rule %d\n", i);
+ }
+ }
+ }
+ }
+ else
+ {
+ len = sizeof(struct ipa_ioc_add_flt_rule) +
+ (IPV6_DEFAULT_FILTERTING_RULES * sizeof(struct ipa_flt_rule_add));
+
+ m_pFilteringTable = (struct ipa_ioc_add_flt_rule *)calloc(1, len);
+ if (!m_pFilteringTable)
+ {
+ PERROR("Error Locate ipa_flt_rule_add memory...\n");
+ return IPACM_FAILURE;
+ }
+
+ m_pFilteringTable->commit = 1;
+ m_pFilteringTable->ep = rx_prop->rx[0].src_pipe;
+ m_pFilteringTable->global = false;
+ m_pFilteringTable->ip = iptype;
+ m_pFilteringTable->num_rules = (uint8_t)IPV6_DEFAULT_FILTERTING_RULES;
+
+ /* Configuring Fragment Filtering Rule */
+ memset(&flt_rule_entry, 0, sizeof(struct ipa_flt_rule_add));
+
+ flt_rule_entry.at_rear = true;
+ flt_rule_entry.flt_rule_hdl = -1;
+ flt_rule_entry.status = -1;
+ flt_rule_entry.rule.action = IPA_PASS_TO_EXCEPTION;
+
+ /* Configuring Multicast Filtering Rule */
+ memcpy(&flt_rule_entry.rule.attrib,
+ &rx_prop->rx[0].attrib,
+ sizeof(flt_rule_entry.rule.attrib));
+ flt_rule_entry.rule.attrib.attrib_mask |= IPA_FLT_DST_ADDR;
+ flt_rule_entry.rule.attrib.u.v6.dst_addr_mask[0] = 0xFF000000;
+ flt_rule_entry.rule.attrib.u.v6.dst_addr_mask[1] = 0x00000000;
+ flt_rule_entry.rule.attrib.u.v6.dst_addr_mask[2] = 0x00000000;
+ flt_rule_entry.rule.attrib.u.v6.dst_addr_mask[3] = 0x00000000;
+ flt_rule_entry.rule.attrib.u.v6.dst_addr[0] = 0XFF000000;
+ flt_rule_entry.rule.attrib.u.v6.dst_addr[1] = 0x00000000;
+ flt_rule_entry.rule.attrib.u.v6.dst_addr[2] = 0x00000000;
+ flt_rule_entry.rule.attrib.u.v6.dst_addr[3] = 0X00000000;
+ memcpy(&(m_pFilteringTable->rules[0]), &flt_rule_entry, sizeof(struct ipa_flt_rule_add));
+
+ if (m_filtering.AddFilteringRule(m_pFilteringTable) == false)
+ {
+ PERROR("Error Adding Filtering rule, aborting...\n");
+ res = IPACM_FAILURE;
+ goto fail;
+ }
+ else
+ {
+ /* copy filter hdls */
+ for (int i = 0;
+ i < IPV6_DEFAULT_FILTERTING_RULES;
+ i++)
+ {
+ if (m_pFilteringTable->rules[i].status == 0)
+ {
+ dft_v6fl_rule_hdl[i] = m_pFilteringTable->rules[i].flt_rule_hdl;
+ IPACMDBG("Default v6 Filter Rule %d HDL:0x%x\n", i, dft_v6fl_rule_hdl[i]);
+ }
+ else
+ {
+ IPACMERR("Failing adding v6 default IPV6 rule %d\n", i);
+ }
+ }
+ }
+ }
+
+
+fail:
+ free(m_pFilteringTable);
+
+ return res;
+}
diff --git a/ipacm/src/IPACM_IfaceManager.cpp b/ipacm/src/IPACM_IfaceManager.cpp
new file mode 100644
index 0000000..747cbfe
--- /dev/null
+++ b/ipacm/src/IPACM_IfaceManager.cpp
@@ -0,0 +1,242 @@
+/*
+Copyright (c) 2013, The Linux Foundation. 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 name of The Linux 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 "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+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.
+*/
+/*!
+ @file
+ IPACM_IfaceManager.cpp
+
+ @brief
+ This file implements the IPAM iface_manager functionality.
+
+ @Author
+ Skylar Chang
+
+*/
+#include <string.h>
+#include <sys/ioctl.h>
+
+#include <IPACM_IfaceManager.h>
+#include <IPACM_EvtDispatcher.h>
+#include <IPACM_Defs.h>
+#include <IPACM_Wlan.h>
+#include <IPACM_Lan.h>
+#include <IPACM_Wan.h>
+#include <IPACM_Iface.h>
+#include <IPACM_Log.h>
+
+iface_instances *IPACM_IfaceManager::head = NULL;
+
+IPACM_IfaceManager::IPACM_IfaceManager()
+{
+ IPACM_EvtDispatcher::registr(IPA_LINK_UP_EVENT, this); // skylar fix register name, class name
+ return; //skylar no interface_id
+}
+
+void IPACM_IfaceManager::event_callback(ipa_cm_event_id event, void *param) //skylar rename:event_callback
+{
+ ipacm_event_data_fid *evt_data = (ipacm_event_data_fid *)param;
+ IPACMDBG("\n");
+ switch(event)
+ {
+
+ case IPA_LINK_UP_EVENT:
+ IPACMDBG("link up %d: \n", evt_data->if_index);
+ create_iface_instance(evt_data->if_index);
+ break;
+
+ default:
+ break;
+ }
+ return;
+}
+
+int IPACM_IfaceManager::create_iface_instance(int if_index)
+{
+ int ipa_interface_index;
+ ipa_interface_index = IPACM_Iface::iface_ipa_index_query(if_index);
+
+ /* check if duplicate instance*/
+ if(SearchInstance(ipa_interface_index) == IPA_INSTANCE_NOT_FOUND)
+ {
+ /* IPA_INSTANCE_NOT_FOUND */
+ switch(IPACM_Iface::ipacmcfg->iface_table[ipa_interface_index].if_cat)
+ {
+
+ case LAN_IF:
+ {
+ IPACMDBG("Creating Lan interface\n");
+ IPACM_Lan *lan = new IPACM_Lan(ipa_interface_index);
+ IPACM_EvtDispatcher::registr(IPA_ADDR_ADD_EVENT, lan);
+ IPACM_EvtDispatcher::registr(IPA_ROUTE_ADD_EVENT, lan);
+ IPACM_EvtDispatcher::registr(IPA_ROUTE_DEL_EVENT, lan);
+ IPACM_EvtDispatcher::registr(IPA_NEIGH_CLIENT_IP_ADDR_ADD_EVENT, lan);
+ IPACM_EvtDispatcher::registr(IPA_NEIGH_CLIENT_IP_ADDR_DEL_EVENT, lan);
+ IPACM_EvtDispatcher::registr(IPA_SW_ROUTING_ENABLE, lan);
+ IPACM_EvtDispatcher::registr(IPA_SW_ROUTING_DISABLE, lan);
+ IPACM_EvtDispatcher::registr(IPA_LINK_DOWN_EVENT, lan);
+ IPACM_EvtDispatcher::registr(IPA_HANDLE_WAN_UP, lan);
+ IPACM_EvtDispatcher::registr(IPA_HANDLE_WAN_DOWN, lan);
+ IPACMDBG("ipa_LAN (%s):ipa_index (%d) instance open/registr ok\n", lan->dev_name, lan->ipa_if_num);
+ registr(ipa_interface_index, lan);
+ }
+ break;
+
+ case WLAN_IF:
+ {
+ IPACMDBG("Creating WLan interface\n");
+ IPACM_Wlan *wl = new IPACM_Wlan(ipa_interface_index);
+ IPACM_EvtDispatcher::registr(IPA_ADDR_ADD_EVENT, wl);
+ IPACM_EvtDispatcher::registr(IPA_ROUTE_DEL_EVENT, wl);
+ IPACM_EvtDispatcher::registr(IPA_WLAN_CLIENT_ADD_EVENT, wl);
+ IPACM_EvtDispatcher::registr(IPA_WLAN_CLIENT_DEL_EVENT, wl);
+ IPACM_EvtDispatcher::registr(IPA_WLAN_CLIENT_POWER_SAVE_EVENT, wl);
+ IPACM_EvtDispatcher::registr(IPA_WLAN_CLIENT_RECOVER_EVENT, wl);
+ IPACM_EvtDispatcher::registr(IPA_NEIGH_CLIENT_IP_ADDR_ADD_EVENT, wl);
+ IPACM_EvtDispatcher::registr(IPA_SW_ROUTING_ENABLE, wl);
+ IPACM_EvtDispatcher::registr(IPA_SW_ROUTING_DISABLE, wl);
+ IPACM_EvtDispatcher::registr(IPA_LINK_DOWN_EVENT, wl);
+ IPACM_EvtDispatcher::registr(IPA_HANDLE_WAN_UP, wl);
+ IPACM_EvtDispatcher::registr(IPA_HANDLE_WAN_DOWN, wl);
+ IPACMDBG("ipa_WLAN (%s):ipa_index (%d) instance open/registr ok\n", wl->dev_name, wl->ipa_if_num);
+ registr(ipa_interface_index, wl);
+ }
+ break;
+
+ case WAN_IF:
+ {
+ IPACMDBG("Creating Wan interface\n");
+ IPACM_Wan *w = new IPACM_Wan(ipa_interface_index);
+ IPACM_EvtDispatcher::registr(IPA_ADDR_ADD_EVENT, w);
+ IPACM_EvtDispatcher::registr(IPA_ROUTE_ADD_EVENT, w);
+ IPACM_EvtDispatcher::registr(IPA_ROUTE_DEL_EVENT, w);
+ IPACM_EvtDispatcher::registr(IPA_FIREWALL_CHANGE_EVENT, w);
+ IPACM_EvtDispatcher::registr(IPA_NEIGH_CLIENT_IP_ADDR_ADD_EVENT, w);
+ IPACM_EvtDispatcher::registr(IPA_SW_ROUTING_ENABLE, w);
+ IPACM_EvtDispatcher::registr(IPA_SW_ROUTING_DISABLE, w);
+ IPACM_EvtDispatcher::registr(IPA_LINK_DOWN_EVENT, w);
+ IPACMDBG("ipa_WAN (%s):ipa_index (%d) instance open/registr ok\n", w->dev_name, w->ipa_if_num);
+ registr(ipa_interface_index, w);
+ }
+ break;
+
+ default:
+ IPACMERR("Unhandled interface received\n");
+ return IPACM_SUCCESS;
+ }
+ }
+ return IPACM_SUCCESS;
+}
+
+
+int IPACM_IfaceManager::registr(int ipa_if_index, IPACM_Listener *obj)
+{
+ iface_instances *tmp = head,*nw;
+
+ nw = (iface_instances *)malloc(sizeof(iface_instances));
+ if(nw != NULL)
+ {
+ nw->ipa_if_index = ipa_if_index;
+ nw->obj = obj;
+ nw->next = NULL;
+ }
+ else
+ {
+ return IPACM_FAILURE;
+ }
+
+ if(head == NULL)
+ {
+ head = nw;
+ }
+ else
+ {
+ while(tmp->next)
+ {
+ tmp = tmp->next;
+ }
+ tmp->next = nw;
+ }
+ return IPACM_SUCCESS;
+}
+
+int IPACM_IfaceManager::deregistr(IPACM_Listener *param)
+{
+ iface_instances *tmp = head,*tmp1,*prev = head;
+
+ while(tmp != NULL)
+ {
+ if(tmp->obj == param)
+ {
+ tmp1 = tmp;
+ if(tmp == head)
+ {
+ head = head->next;
+ }
+ else if(tmp->next == NULL)
+ {
+ prev->next = NULL;
+ }
+ else
+ {
+ prev->next = tmp->next;
+ }
+
+ tmp = tmp->next;
+ free(tmp1);
+ }
+ else
+ {
+ prev = tmp;
+ tmp = tmp->next;
+ }
+ }
+ return IPACM_SUCCESS;
+}
+
+
+int IPACM_IfaceManager::SearchInstance(int ipa_if_index)
+{
+
+ iface_instances *tmp = head;
+
+ while(tmp != NULL)
+ {
+ if(ipa_if_index == tmp->ipa_if_index)
+ {
+ IPACMDBG("Find existed iface-instance name: %s\n",
+ IPACM_Iface::ipacmcfg->iface_table[ipa_if_index].iface_name);
+ return IPA_INSTANCE_FOUND;
+ }
+ tmp = tmp->next;
+ }
+
+ IPACMDBG("No existed iface-instance name: %s,\n",
+ IPACM_Iface::ipacmcfg->iface_table[ipa_if_index].iface_name);
+
+ return IPA_INSTANCE_NOT_FOUND;
+}
diff --git a/ipacm/src/IPACM_Lan.cpp b/ipacm/src/IPACM_Lan.cpp
new file mode 100644
index 0000000..8b47985
--- /dev/null
+++ b/ipacm/src/IPACM_Lan.cpp
@@ -0,0 +1,902 @@
+/*
+Copyright (c) 2013, The Linux Foundation. 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 name of The Linux 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 "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+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.
+*/
+/*!
+ @file
+ IPACM_Lan.cpp
+
+ @brief
+ This file implements the LAN iface functionality.
+
+ @Author
+ Skylar Chang
+
+*/
+#include <string.h>
+#include <sys/ioctl.h>
+#include <IPACM_Netlink.h>
+#include <IPACM_Lan.h>
+#include <IPACM_Wan.h>
+#include <IPACM_IfaceManager.h>
+
+IPACM_Lan::IPACM_Lan(int iface_index) : IPACM_Iface(iface_index)
+{
+ num_uni_rt = 0;
+ num_dft_rt = 0;
+
+ rt_rule_len = sizeof(struct ipa_lan_rt_rule) + (iface_query->num_tx_props * sizeof(uint32_t));
+ route_rule = (struct ipa_lan_rt_rule *)calloc(IPA_MAX_NUM_UNICAST_ROUTE_RULES, rt_rule_len);
+ if (route_rule == NULL)
+ {
+ IPACMERR("unable to allocate memory\n");
+ return;
+ }
+
+ IPACMDBG(" IPACM->IPACM_Lan(%d) constructor: Tx:%d Rx:%d\n", ipa_if_num,
+ iface_query->num_tx_props, iface_query->num_rx_props);
+
+ return;
+}
+
+IPACM_Lan::~IPACM_Lan()
+{
+ IPACM_EvtDispatcher::deregistr(this);
+ IPACM_IfaceManager::deregistr(this);
+ return;
+}
+
+
+/* LAN-iface's callback function */
+void IPACM_Lan::event_callback(ipa_cm_event_id event, void *param)
+{
+ int ipa_interface_index;
+
+ switch (event)
+ {
+ case IPA_LINK_DOWN_EVENT:
+ {
+ ipacm_event_data_fid *data = (ipacm_event_data_fid *)param;
+ ipa_interface_index = iface_ipa_index_query(data->if_index);
+ if (ipa_interface_index == ipa_if_num)
+ {
+ IPACMDBG("Received IPA_LINK_DOWN_EVENT\n");
+ handle_down_evt();
+ IPACMDBG("ipa_LAN (%s):ipa_index (%d) instance close \n", IPACM_Iface::ipacmcfg->iface_table[ipa_if_num].iface_name, ipa_if_num);
+ delete this;
+ return;
+ }
+ }
+ break;
+
+ case IPA_ADDR_ADD_EVENT:
+ {
+ ipacm_event_data_addr *data = (ipacm_event_data_addr *)param;
+ ipa_interface_index = iface_ipa_index_query(data->if_index);
+ if (ipa_interface_index == ipa_if_num)
+ {
+ IPACMDBG("Received IPA_ADDR_ADD_EVENT\n");
+
+ if ((data->iptype != ip_type) && (ip_type != IPA_IP_MAX)) // check not setup before
+ {
+ handle_addr_evt(data);
+ handle_private_subnet(data->iptype);
+ if (IPACM_Wan::isWanUP() && (data->iptype == IPA_IP_v4))
+ {
+ handle_wan_up();
+ }
+
+ /* Post event to NAT */
+ if (data->iptype == IPA_IP_v4)
+ {
+ ipacm_cmd_q_data evt_data;
+ ipacm_event_iface_up *info;
+
+ info = (ipacm_event_iface_up *)
+ malloc(sizeof(ipacm_event_iface_up));
+ if (info == NULL)
+ {
+ IPACMERR("Unable to allocate memory\n");
+ return;
+ }
+
+ memcpy(info->ifname, dev_name, IF_NAME_LEN);
+ info->ipv4_addr = data->ipv4_addr;
+ info->addr_mask = IPACM_Iface::ipacmcfg->private_subnet_table[0].subnet_mask;
+
+ evt_data.event = IPA_HANDLE_LAN_UP;
+ evt_data.evt_data = (void *)info;
+
+ /* Insert IPA_HANDLE_LAN_UP to command queue */
+ IPACMDBG("posting IPA_HANDLE_LAN_UP for IPv4 with below information\n");
+ IPACMDBG("IPv4 address:0x%x, IPv4 address mask:0x%x\n",
+ info->ipv4_addr, info->addr_mask);
+ IPACM_EvtDispatcher::PostEvt(&evt_data);
+ }
+ }
+ }
+ }
+ break;
+
+ case IPA_HANDLE_WAN_UP:
+ IPACMDBG("Received IPA_HANDLE_WAN_UP event\n");
+ handle_wan_up();
+ break;
+
+ case IPA_ROUTE_ADD_EVENT:
+ {
+ ipacm_event_data_addr *data = (ipacm_event_data_addr *)param;
+ ipa_interface_index = iface_ipa_index_query(data->if_index);
+
+ /* unicast routing rule add */
+ if (ipa_interface_index == ipa_if_num)
+ {
+ IPACMDBG("Received IPA_ROUTE_ADD_EVENT\n");
+ handle_route_add_evt(data);
+ }
+ }
+ break;
+
+ case IPA_HANDLE_WAN_DOWN:
+ IPACMDBG("Received IPA_HANDLE_WAN_DOWN event\n");
+ handle_wan_down();
+ break;
+
+ case IPA_ROUTE_DEL_EVENT:
+ {
+ ipacm_event_data_addr *data = (ipacm_event_data_addr *)param;
+ ipa_interface_index = iface_ipa_index_query(data->if_index);
+
+ /* unicast routing rule del */
+ if (ipa_interface_index == ipa_if_num)
+ {
+ IPACMDBG("Received IPA_ROUTE_DEL_EVENT\n");
+ handle_route_del_evt(data);
+ }
+ }
+ break;
+
+ case IPA_NEIGH_CLIENT_IP_ADDR_ADD_EVENT:
+ {
+ ipacm_event_data_all *data = (ipacm_event_data_all *)param;
+ ipa_interface_index = iface_ipa_index_query(data->if_index);
+ if (ipa_interface_index == ipa_if_num)
+ {
+ IPACMDBG("Received IPA_NEIGH_CLIENT_IP_ADDR_ADD_EVENT\n");
+ ipacm_event_data_addr *data_addr;
+ data_addr = (ipacm_event_data_addr *)malloc(sizeof(ipacm_event_data_addr));
+ if (data_addr == NULL)
+ {
+ IPACMERR("unable to allocate memory for event data_addr\n");
+ return;
+ }
+
+ data_addr->if_index = data->if_index;
+ data_addr->iptype = data->iptype;
+ if (data->iptype == IPA_IP_v4)
+ {
+ data_addr->ipv4_addr = data->ipv4_addr;
+ data_addr->ipv4_addr_mask = 0xFFFFFFFF;
+ }
+ else
+ {
+ memcpy(data_addr->ipv6_addr,
+ data->ipv6_addr,
+ sizeof(data_addr->ipv6_addr));
+ data_addr->ipv6_addr_mask[0] = 0xFFFFFFFF;
+ data_addr->ipv6_addr_mask[1] = 0xFFFFFFFF;
+ data_addr->ipv6_addr_mask[2] = 0xFFFFFFFF;
+ data_addr->ipv6_addr_mask[3] = 0xFFFFFFFF;
+ }
+ handle_route_add_evt(data_addr);
+ }
+ }
+ break;
+
+ case IPA_NEIGH_CLIENT_IP_ADDR_DEL_EVENT:
+ {
+ ipacm_event_data_all *data = (ipacm_event_data_all *)param;
+ ipa_interface_index = iface_ipa_index_query(data->if_index);
+ if (ipa_interface_index == ipa_if_num)
+ {
+ IPACMDBG("Received IPA_NEIGH_CLIENT_IP_ADDR_DEL_EVENT\n");
+ ipacm_event_data_addr *data_addr;
+ data_addr = (ipacm_event_data_addr *)malloc(sizeof(ipacm_event_data_addr));
+ if (data_addr == NULL)
+ {
+ IPACMERR("unable to allocate memory for event data_addr\n");
+ return;
+ }
+
+ data_addr->if_index = data->if_index;
+ data_addr->iptype = data->iptype;
+ if (data->iptype == IPA_IP_v4)
+ {
+ data_addr->ipv4_addr = data->ipv4_addr;
+ data_addr->ipv4_addr_mask = 0xFFFFFFFF;
+ }
+ else
+ {
+ memcpy(data_addr->ipv6_addr,
+ data->ipv6_addr,
+ sizeof(data_addr->ipv6_addr));
+ data_addr->ipv6_addr_mask[0] = 0xFFFFFFFF;
+ data_addr->ipv6_addr_mask[1] = 0xFFFFFFFF;
+ data_addr->ipv6_addr_mask[2] = 0xFFFFFFFF;
+ data_addr->ipv6_addr_mask[3] = 0xFFFFFFFF;
+ }
+ handle_route_del_evt(data_addr);
+ }
+ }
+ break;
+
+ case IPA_SW_ROUTING_ENABLE:
+ IPACMDBG("Received IPA_SW_ROUTING_ENABLE\n");
+ /* handle software routing enable event*/
+ handle_software_routing_enable();
+ break;
+
+ case IPA_SW_ROUTING_DISABLE:
+ IPACMDBG("Received IPA_SW_ROUTING_DISABLE\n");
+ /* handle software routing disable event*/
+ handle_software_routing_disable();
+ break;
+
+ default:
+ break;
+ }
+
+ return;
+}
+
+/* handle unicast routing rule add event */
+int IPACM_Lan::handle_route_add_evt(ipacm_event_data_addr *data)
+{
+ /* add unicate route for LAN */
+ struct ipa_ioc_add_rt_rule *rt_rule;
+ struct ipa_rt_rule_add *rt_rule_entry;
+ struct ipa_ioc_get_hdr sRetHeader;
+ uint32_t tx_index;
+
+ IPACMDBG("LAN callback: unicast IPA_ROUTE_ADD_EVENT\n");
+
+ if (num_uni_rt < IPA_MAX_NUM_UNICAST_ROUTE_RULES)
+ {
+ /* unicast RT rule add start */
+ rt_rule = (struct ipa_ioc_add_rt_rule *)
+ calloc(1, sizeof(struct ipa_ioc_add_rt_rule) +
+ 1 * sizeof(struct ipa_rt_rule_add));
+ if (!rt_rule)
+ {
+ IPACMERR("fail\n");
+ return IPACM_FAILURE;
+ }
+
+ rt_rule->commit = 1;
+ rt_rule->num_rules = (uint8_t)1;
+ rt_rule->ip = data->iptype;
+
+ if (data->iptype == IPA_IP_v4) strcpy(rt_rule->rt_tbl_name, IPACM_Iface::ipacmcfg->rt_tbl_lan_v4.name);
+ else strcpy(rt_rule->rt_tbl_name, IPACM_Iface::ipacmcfg->rt_tbl_v6.name);
+
+
+ rt_rule_entry = &rt_rule->rules[0];
+ rt_rule_entry->at_rear = 1;
+
+ for (tx_index = 0; tx_index < iface_query->num_tx_props; tx_index++)
+ {
+ if (tx_prop->tx[tx_index].hdr_name)
+ {
+ memset(&sRetHeader, 0, sizeof(sRetHeader));
+ strncpy(sRetHeader.name,
+ tx_prop->tx[tx_index].hdr_name,
+ sizeof(tx_prop->tx[tx_index].hdr_name));
+
+ if (false == m_header.GetHeaderHandle(&sRetHeader))
+ {
+ IPACMDBG(" ioctl failed\n");
+ }
+
+ rt_rule_entry->rule.hdr_hdl = sRetHeader.hdl;
+ }
+ rt_rule_entry->rule.dst = tx_prop->tx[tx_index].dst_pipe;
+ memcpy(&rt_rule_entry->rule.attrib,
+ &tx_prop->tx[tx_index].attrib,
+ sizeof(rt_rule_entry->rule.attrib));
+ rt_rule_entry->rule.attrib.attrib_mask |= IPA_FLT_DST_ADDR;
+ if (data->iptype == IPA_IP_v4)
+ {
+ rt_rule_entry->rule.attrib.u.v4.dst_addr = data->ipv4_addr;
+ rt_rule_entry->rule.attrib.u.v4.dst_addr_mask = data->ipv4_addr_mask;
+ }
+ else
+ {
+ rt_rule_entry->rule.attrib.u.v6.dst_addr[0] = data->ipv6_addr[0];
+ rt_rule_entry->rule.attrib.u.v6.dst_addr[1] = data->ipv6_addr[1];
+ rt_rule_entry->rule.attrib.u.v6.dst_addr[2] = data->ipv6_addr[2];
+ rt_rule_entry->rule.attrib.u.v6.dst_addr[3] = data->ipv6_addr[3];
+ rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[0] = data->ipv6_addr_mask[0];
+ rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[1] = data->ipv6_addr_mask[1];
+ rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[2] = data->ipv6_addr_mask[2];
+ rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[3] = data->ipv6_addr_mask[3];
+ }
+ IPACMDBG("m_routing = %p\n", &m_routing);
+
+ if (false == m_routing.AddRoutingRule(rt_rule))
+ {
+ IPACMERR("Routing rule addition failed!\n");
+ free(rt_rule);
+ return IPACM_FAILURE;
+ }
+
+ IPACMDBG("rt rule hdl1=%x\n", rt_rule_entry->rt_rule_hdl);
+ get_rt_ruleptr(route_rule, num_uni_rt)->rt_rule_hdl[tx_index]
+ = rt_rule_entry->rt_rule_hdl;
+ }
+ memcpy(&get_rt_ruleptr(route_rule, num_uni_rt)->rule,
+ &rt_rule_entry->rule.attrib,
+ sizeof(get_rt_ruleptr(route_rule, num_uni_rt)->rule));
+
+ get_rt_ruleptr(route_rule, num_uni_rt)->ip = data->iptype;
+ free(rt_rule);
+ num_uni_rt++;
+ }
+ else
+ {
+ IPACMDBG("unicast rule oversize\n");
+ return IPACM_FAILURE;
+ }
+
+ return IPACM_SUCCESS;
+}
+
+/* handle unicast routing rule del event */
+int IPACM_Lan::handle_route_del_evt(ipacm_event_data_addr *data)
+{
+ int i;
+ uint32_t tx_index;
+
+ /* delete 1 unicast RT rule */
+ for (i = 0; i <= num_uni_rt; i++)
+ {
+
+ if (data->iptype == IPA_IP_v4)
+ {
+ if ((data->ipv4_addr == get_rt_ruleptr(route_rule, i)->rule.u.v4.dst_addr) &&
+ (data->ipv4_addr_mask == get_rt_ruleptr(route_rule, i)->rule.u.v4.dst_addr_mask))
+ {
+ for (tx_index = 0; tx_index < iface_query->num_tx_props; tx_index++)
+ {
+ if (m_routing.DeleteRoutingHdl(get_rt_ruleptr(route_rule, i)->rt_rule_hdl[tx_index],
+ IPA_IP_v4) == false)
+ {
+ IPACMDBG("Routing rule deletion failed!\n");
+ return IPACM_FAILURE;
+ }
+ }
+
+ /* remove that delted route rule entry*/
+ for (; i <= num_uni_rt; i++)
+ {
+ get_rt_ruleptr(route_rule, i)->rule = get_rt_ruleptr(route_rule, (i + 1))->rule;
+ get_rt_ruleptr(route_rule, i)->ip = get_rt_ruleptr(route_rule, (i + 1))->ip;
+
+ for (tx_index = 0; tx_index < iface_query->num_tx_props; tx_index++)
+ {
+ get_rt_ruleptr(route_rule, i)->rt_rule_hdl[tx_index] = get_rt_ruleptr(route_rule, (i + 1))->rt_rule_hdl[tx_index];
+ }
+ }
+
+ num_uni_rt -= 1;
+ return IPACM_SUCCESS;
+ }
+ }
+ else
+ {
+ if ((data->ipv6_addr[0] == get_rt_ruleptr(route_rule, i)->rule.u.v6.dst_addr[0]) &&
+ (data->ipv6_addr[1] == get_rt_ruleptr(route_rule, i)->rule.u.v6.dst_addr[1]) &&
+ (data->ipv6_addr[2] == get_rt_ruleptr(route_rule, i)->rule.u.v6.dst_addr[2]) &&
+ (data->ipv6_addr[3] == get_rt_ruleptr(route_rule, i)->rule.u.v6.dst_addr[3]) &&
+ (data->ipv6_addr_mask[0] == get_rt_ruleptr(route_rule, i)->rule.u.v6.dst_addr_mask[0]) &&
+ (data->ipv6_addr_mask[1] == get_rt_ruleptr(route_rule, i)->rule.u.v6.dst_addr_mask[1]) &&
+ (data->ipv6_addr_mask[2] == get_rt_ruleptr(route_rule, i)->rule.u.v6.dst_addr_mask[2]) &&
+ (data->ipv6_addr_mask[3] == get_rt_ruleptr(route_rule, i)->rule.u.v6.dst_addr_mask[3]))
+ {
+
+ for (tx_index = 0; tx_index < iface_query->num_tx_props; tx_index++)
+ {
+ if (m_routing.DeleteRoutingHdl(get_rt_ruleptr(route_rule, i)->rt_rule_hdl[tx_index],
+ IPA_IP_v6) == false)
+ {
+ IPACMERR("Routing rule deletion failed!\n");
+ return IPACM_FAILURE;
+ }
+ }
+
+ /* remove that delted route rule entry*/
+ for (; i <= num_uni_rt; i++)
+ {
+ for (tx_index = 0; tx_index < iface_query->num_tx_props; tx_index++)
+ {
+ get_rt_ruleptr(route_rule, i)->rt_rule_hdl[tx_index] = get_rt_ruleptr(route_rule, (i + 1))->rt_rule_hdl[tx_index];
+ }
+ get_rt_ruleptr(route_rule, i)->rule = get_rt_ruleptr(route_rule, (i + 1))->rule;
+ get_rt_ruleptr(route_rule, i)->ip = get_rt_ruleptr(route_rule, (i + 1))->ip;
+ }
+
+ num_uni_rt -= 1;
+ return IPACM_SUCCESS;
+ }
+ }
+ }
+
+ return IPACM_FAILURE;
+}
+
+
+
+
+/* configure filter rule for wan_up event*/
+int IPACM_Lan::handle_wan_up(void)
+{
+ struct ipa_flt_rule_add flt_rule_entry;
+ int len = 0;
+ ipa_ioc_add_flt_rule *m_pFilteringTable;
+
+ IPACMDBG("set WAN interface as default filter rule\n");
+
+ len = sizeof(struct ipa_ioc_add_flt_rule) + (1 * sizeof(struct ipa_flt_rule_add));
+ m_pFilteringTable = (struct ipa_ioc_add_flt_rule *)calloc(1, len);
+ if (m_pFilteringTable == NULL)
+ {
+ PERROR("Error Locate ipa_flt_rule_add memory...\n");
+ return IPACM_FAILURE;
+ }
+
+ m_pFilteringTable->commit = 1;
+ m_pFilteringTable->ep = rx_prop->rx[0].src_pipe;
+ m_pFilteringTable->global = false;
+ m_pFilteringTable->ip = IPA_IP_v4;
+ m_pFilteringTable->num_rules = (uint8_t)1;
+
+ IPACMDBG("Retrieving routing hanle for table: %s\n",
+ IPACM_Iface::ipacmcfg->rt_tbl_wan_v4.name);
+ if (false == m_routing.GetRoutingTable(&IPACM_Iface::ipacmcfg->rt_tbl_wan_v4))
+ {
+ IPACMERR("m_routing.GetRoutingTable(&IPACM_Iface::ipacmcfg->rt_tbl_wan_v4=0x%p) Failed.\n",
+ &IPACM_Iface::ipacmcfg->rt_tbl_wan_v4);
+ return IPACM_FAILURE;
+ }
+ IPACMDBG("Routing hanle for table: %d\n", IPACM_Iface::ipacmcfg->rt_tbl_wan_v4.hdl);
+
+
+ memset(&flt_rule_entry, 0, sizeof(struct ipa_flt_rule_add)); // Zero All Fields
+ flt_rule_entry.at_rear = true;
+ flt_rule_entry.flt_rule_hdl = -1;
+ flt_rule_entry.status = -1;
+ flt_rule_entry.rule.action = IPA_PASS_TO_SRC_NAT; //IPA_PASS_TO_ROUTING
+ flt_rule_entry.rule.rt_tbl_hdl = IPACM_Iface::ipacmcfg->rt_tbl_wan_v4.hdl;
+
+ memcpy(&flt_rule_entry.rule.attrib,
+ &rx_prop->rx[0].attrib,
+ sizeof(flt_rule_entry.rule.attrib));
+
+ flt_rule_entry.rule.attrib.attrib_mask |= IPA_FLT_DST_ADDR;
+ flt_rule_entry.rule.attrib.u.v4.dst_addr_mask = 0x0;
+ flt_rule_entry.rule.attrib.u.v4.dst_addr = 0x0;
+
+ memcpy(&m_pFilteringTable->rules[0], &flt_rule_entry, sizeof(flt_rule_entry));
+ if (false == m_filtering.AddFilteringRule(m_pFilteringTable))
+ {
+ IPACMDBG("Error Adding RuleTable(0) to Filtering, aborting...\n");
+ perror("Lan: Unable to add filter rule");
+ free(m_pFilteringTable);
+ return IPACM_FAILURE;
+ }
+ else
+ {
+ IPACMDBG("flt rule hdl0=0x%x, status=0x%x\n",
+ m_pFilteringTable->rules[0].flt_rule_hdl,
+ m_pFilteringTable->rules[0].status);
+ }
+
+
+ /* copy filter hdls */
+ lan_wan_fl_rule_hdl[0] = m_pFilteringTable->rules[0].flt_rule_hdl;
+ free(m_pFilteringTable);
+
+ return IPACM_SUCCESS;
+}
+
+
+/* delete filter rule for wan_down event*/
+int IPACM_Lan::handle_wan_down(void)
+{
+
+ if (m_filtering.DeleteFilteringHdls(&lan_wan_fl_rule_hdl[0],
+ IPA_IP_v4, 1) == false)
+ {
+ IPACMDBG("Error Adding RuleTable(1) to Filtering, aborting...\n");
+ return IPACM_FAILURE;
+ }
+
+ return IPACM_SUCCESS;
+}
+
+/* handle new_address event*/
+int IPACM_Lan::handle_addr_evt(ipacm_event_data_addr *data)
+{
+ struct ipa_ioc_add_rt_rule *rt_rule;
+ struct ipa_rt_rule_add *rt_rule_entry;
+ struct ipa_flt_rule_add flt_rule_entry;
+ const int NUM_RULES = 1;
+ int res = IPACM_SUCCESS;
+
+ /* construct ipa_ioc_add_flt_rule with 1 rules */
+ ipa_ioc_add_flt_rule *m_pFilteringTable;
+
+ IPACMDBG("set route/filter rule ip-type: %d \n", data->iptype);
+
+ rt_rule = (struct ipa_ioc_add_rt_rule *)
+ calloc(1, sizeof(struct ipa_ioc_add_rt_rule) +
+ NUM_RULES * sizeof(struct ipa_rt_rule_add));
+
+ if (rt_rule == NULL)
+ {
+ IPACMERR("fail to allocate ipa_ioc_add_rt_rule \n");
+ return IPACM_FAILURE;
+ }
+
+ rt_rule->commit = 1;
+ rt_rule->num_rules = NUM_RULES;
+ rt_rule->ip = data->iptype;
+
+ if (data->iptype == IPA_IP_v4) strcpy(rt_rule->rt_tbl_name, IPACM_Iface::ipacmcfg->rt_tbl_lan_v4.name);
+ else strcpy(rt_rule->rt_tbl_name, IPACM_Iface::ipacmcfg->rt_tbl_v6.name);
+
+ rt_rule_entry = &rt_rule->rules[0];
+ rt_rule_entry->at_rear = 1;
+ rt_rule_entry->rule.dst = IPA_CLIENT_A5_LAN_WAN_CONS; //go to A5
+ rt_rule_entry->rule.attrib.attrib_mask = IPA_FLT_DST_ADDR;
+
+ if (data->iptype == IPA_IP_v4)
+ {
+ rt_rule_entry->rule.attrib.u.v4.dst_addr = data->ipv4_addr;
+ rt_rule_entry->rule.attrib.u.v4.dst_addr_mask = 0xFFFFFFFF;
+ }
+ else
+ {
+ rt_rule_entry->rule.attrib.u.v6.dst_addr[0] = data->ipv6_addr[0];
+ rt_rule_entry->rule.attrib.u.v6.dst_addr[1] = data->ipv6_addr[1];
+ rt_rule_entry->rule.attrib.u.v6.dst_addr[2] = data->ipv6_addr[2];
+ rt_rule_entry->rule.attrib.u.v6.dst_addr[3] = data->ipv6_addr[3];
+ rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[0] = 0xFFFFFFFF;
+ rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[1] = 0xFFFFFFFF;
+ rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[2] = 0xFFFFFFFF;
+ rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[3] = 0xFFFFFFFF;
+ }
+
+ if (false == m_routing.AddRoutingRule(rt_rule))
+ {
+ IPACMERR("Routing rule addition failed!\n");
+ res = IPACM_FAILURE;
+ goto fail;
+ }
+ else if (rt_rule_entry->status)
+ {
+ IPACMERR("rt rule adding failed. Result=%d\n", rt_rule_entry->status);
+ res = rt_rule_entry->status;
+ goto fail;
+ }
+ IPACMDBG("rt rule hdl=%x with ip-type: %d\n", rt_rule_entry->rt_rule_hdl, data->iptype);
+
+ if (data->iptype == IPA_IP_v4)
+ {
+ dft_rt_rule_hdl[0] = rt_rule_entry->rt_rule_hdl;
+
+ /* initial multicast/broadcast/fragment filter rule */
+ IPACM_Iface::init_fl_rule(data->iptype);
+ }
+ else
+ {
+ if (num_dft_rt == 0)
+ {
+ /* initial multicast/broadcast/fragment filter rule */
+ IPACM_Iface::init_fl_rule(data->iptype);
+
+ /* add default v6 filter rule */
+ m_pFilteringTable = (struct ipa_ioc_add_flt_rule *)
+ calloc(1,
+ sizeof(struct ipa_ioc_add_flt_rule) +
+ 1 * sizeof(struct ipa_flt_rule_add)
+ );
+
+ if (!m_pFilteringTable)
+ {
+ PERROR("Error Locate ipa_flt_rule_add memory...\n");
+ return IPACM_FAILURE;
+ }
+
+ m_pFilteringTable->commit = 1;
+ m_pFilteringTable->ep = rx_prop->rx[0].src_pipe;
+ m_pFilteringTable->global = false;
+ m_pFilteringTable->ip = IPA_IP_v6;
+ m_pFilteringTable->num_rules = (uint8_t)1;
+
+
+ if (false == m_routing.GetRoutingTable(&IPACM_Iface::ipacmcfg->rt_tbl_v6))
+ {
+ IPACMDBG("m_routing.GetRoutingTable(&IPACM_Iface::ipacmcfg->rt_tbl_v6=0x%p) Failed.\n", &IPACM_Iface::ipacmcfg->rt_tbl_v6);
+ free(m_pFilteringTable);
+ res = IPACM_FAILURE;
+ goto fail;
+ }
+
+
+ memset(&flt_rule_entry, 0, sizeof(struct ipa_flt_rule_add));
+
+ flt_rule_entry.at_rear = true;
+ flt_rule_entry.flt_rule_hdl = -1;
+ flt_rule_entry.status = -1;
+ flt_rule_entry.rule.action = IPA_PASS_TO_ROUTING;
+ flt_rule_entry.rule.rt_tbl_hdl = IPACM_Iface::ipacmcfg->rt_tbl_v6.hdl;
+ memcpy(&flt_rule_entry.rule.attrib,
+ &rx_prop->rx[0].attrib,
+ sizeof(flt_rule_entry.rule.attrib));
+
+ flt_rule_entry.rule.attrib.attrib_mask |= IPA_FLT_DST_ADDR;
+ flt_rule_entry.rule.attrib.u.v6.dst_addr_mask[0] = 0x00000000;
+ flt_rule_entry.rule.attrib.u.v6.dst_addr_mask[1] = 0x00000000;
+ flt_rule_entry.rule.attrib.u.v6.dst_addr_mask[2] = 0x00000000;
+ flt_rule_entry.rule.attrib.u.v6.dst_addr_mask[3] = 0x00000000;
+ flt_rule_entry.rule.attrib.u.v6.dst_addr[0] = 0X00000000;
+ flt_rule_entry.rule.attrib.u.v6.dst_addr[1] = 0x00000000;
+ flt_rule_entry.rule.attrib.u.v6.dst_addr[2] = 0x00000000;
+ flt_rule_entry.rule.attrib.u.v6.dst_addr[3] = 0X00000000;
+
+ memcpy(&(m_pFilteringTable->rules[0]), &flt_rule_entry, sizeof(struct ipa_flt_rule_add));
+ if (false == m_filtering.AddFilteringRule(m_pFilteringTable))
+ {
+ IPACMERR("Error Adding Filtering rule, aborting...\n");
+ free(m_pFilteringTable);
+ res = IPACM_FAILURE;
+ goto fail;
+ }
+ else
+ {
+ IPACMDBG("flt rule hdl0=0x%x, status=0x%x\n", m_pFilteringTable->rules[0].flt_rule_hdl, m_pFilteringTable->rules[0].status);
+ }
+
+ /* copy filter hdls */
+ dft_v6fl_rule_hdl[1] = m_pFilteringTable->rules[0].flt_rule_hdl;
+ free(m_pFilteringTable);
+ }
+
+ dft_rt_rule_hdl[1 + num_dft_rt] = rt_rule_entry->rt_rule_hdl;
+ num_dft_rt++;
+ }
+
+ IPACMDBG("number of default route rules %d\n", num_dft_rt);
+
+fail:
+ free(rt_rule);
+
+ return res;
+}
+
+/* configure private subnet filter rules*/
+int IPACM_Lan::handle_private_subnet(ipa_ip_type iptype)
+{
+ struct ipa_flt_rule_add flt_rule_entry;
+ int i;
+
+ ipa_ioc_add_flt_rule *m_pFilteringTable;
+
+ IPACMDBG("lan->handle_private_subnet(); set route/filter rule \n");
+
+ if (iptype == IPA_IP_v4)
+ {
+
+ m_pFilteringTable = (struct ipa_ioc_add_flt_rule *)
+ calloc(1,
+ sizeof(struct ipa_ioc_add_flt_rule) +
+ (IPACM_Iface::ipacmcfg->ipa_num_private_subnet) * sizeof(struct ipa_flt_rule_add)
+ );
+ if (!m_pFilteringTable)
+ {
+ PERROR("Error Locate ipa_flt_rule_add memory...\n");
+ return IPACM_FAILURE;
+ }
+ m_pFilteringTable->commit = 1;
+ m_pFilteringTable->ep = rx_prop->rx[0].src_pipe;
+ m_pFilteringTable->global = false;
+ m_pFilteringTable->ip = IPA_IP_v4;
+ m_pFilteringTable->num_rules = (uint8_t)IPACM_Iface::ipacmcfg->ipa_num_private_subnet;
+
+ if (false == m_routing.GetRoutingTable(&IPACM_Iface::ipacmcfg->rt_tbl_lan_v4))
+ {
+ IPACMERR("LAN m_routing.GetRoutingTable(&IPACM_Iface::ipacmcfg->rt_tbl_lan_v4=0x%p) Failed.\n", &IPACM_Iface::ipacmcfg->rt_tbl_lan_v4);
+ free(m_pFilteringTable);
+ return IPACM_FAILURE;
+ }
+
+ for (i = 0; i < (IPACM_Iface::ipacmcfg->ipa_num_private_subnet); i++)
+ {
+ memset(&flt_rule_entry, 0, sizeof(struct ipa_flt_rule_add));
+ flt_rule_entry.at_rear = true;
+ flt_rule_entry.flt_rule_hdl = -1;
+ flt_rule_entry.status = -1;
+ flt_rule_entry.rule.action = IPA_PASS_TO_ROUTING;
+ flt_rule_entry.rule.rt_tbl_hdl = IPACM_Iface::ipacmcfg->rt_tbl_lan_v4.hdl;
+ memcpy(&flt_rule_entry.rule.attrib,
+ &rx_prop->rx[0].attrib,
+ sizeof(flt_rule_entry.rule.attrib));
+ flt_rule_entry.rule.attrib.attrib_mask |= IPA_FLT_DST_ADDR;
+ flt_rule_entry.rule.attrib.u.v4.dst_addr_mask = IPACM_Iface::ipacmcfg->private_subnet_table[i].subnet_mask;
+ flt_rule_entry.rule.attrib.u.v4.dst_addr = IPACM_Iface::ipacmcfg->private_subnet_table[i].subnet_addr;
+ memcpy(&(m_pFilteringTable->rules[i]), &flt_rule_entry, sizeof(struct ipa_flt_rule_add));
+ IPACMDBG("Loop %d 5\n", i);
+ }
+
+ if (false == m_filtering.AddFilteringRule(m_pFilteringTable))
+ {
+ IPACMDBG("Error Adding RuleTable(0) to Filtering, aborting...\n");
+ free(m_pFilteringTable);
+ return IPACM_FAILURE;
+ }
+
+ /* copy filter rule hdls */
+ for (i = 0; i < IPACM_Iface::ipacmcfg->ipa_num_private_subnet; i++)
+ {
+
+ private_fl_rule_hdl[i] = m_pFilteringTable->rules[i].flt_rule_hdl;
+ }
+ free(m_pFilteringTable);
+ }
+ return IPACM_SUCCESS;
+}
+
+
+
+/*handle wlan iface down event*/
+int IPACM_Lan::handle_down_evt()
+{
+ int i;
+ uint32_t tx_index;
+ int res = IPACM_SUCCESS;
+
+ /* no iface address up, directly close iface*/
+ if (ip_type == IPACM_IP_NULL)
+ {
+ goto fail;
+ }
+
+ IPACMDBG("lan handle_down_evt\n ");
+
+ if (ip_type != IPA_IP_v6)
+ {
+ if (m_routing.DeleteRoutingHdl(dft_rt_rule_hdl[0], IPA_IP_v4)
+ == false)
+ {
+ IPACMERR("Routing rule deletion failed!\n");
+ res = IPACM_FAILURE;
+ goto fail;
+ }
+ }
+
+ /* delete default v6 routing rule */
+ if (ip_type != IPA_IP_v4)
+ {
+ /* may have multiple ipv6 iface-RT rules*/
+ for (i = 0; i < num_dft_rt; i++)
+ {
+ if (m_routing.DeleteRoutingHdl(dft_rt_rule_hdl[1 + i], IPA_IP_v6)
+ == false)
+ {
+ IPACMERR("Routing rule deletion failed!\n");
+ res = IPACM_FAILURE;
+ goto fail;
+ }
+ }
+ }
+
+
+ /* free unicast routing rule */
+ for (i = 0; i < num_uni_rt; i++)
+ {
+ for (tx_index = 0; tx_index < iface_query->num_tx_props; tx_index++)
+ {
+ if (m_routing.DeleteRoutingHdl(get_rt_ruleptr(route_rule, i)->rt_rule_hdl[tx_index],
+ get_rt_ruleptr(route_rule, i)->ip) == false)
+ {
+ IPACMERR("Routing rule deletion failed!\n");
+ res = IPACM_FAILURE;
+ goto fail;
+ }
+ }
+
+ }
+
+ /* check software routing fl rule hdl */
+ if (softwarerouting_act == true)
+ {
+ IPACM_Iface::handle_software_routing_disable();
+ }
+
+
+ /* delete default filter rules */
+ if (ip_type != IPA_IP_v6)
+ {
+ if (m_filtering.DeleteFilteringHdls(dft_v4fl_rule_hdl,
+ IPA_IP_v4,
+ IPV4_DEFAULT_FILTERTING_RULES) == false)
+ {
+ IPACMERR("Error Adding Filtering Rule, aborting...\n");
+ res = IPACM_FAILURE;
+ goto fail;
+ }
+
+ /* free private-subnet ipv4 filter rules */
+ if (m_filtering.DeleteFilteringHdls(
+ private_fl_rule_hdl,
+ IPA_IP_v4,
+ IPACM_Iface::ipacmcfg->ipa_num_private_subnet) == false)
+ {
+ IPACMERR("Error Deleting RuleTable(1) to Filtering, aborting...\n");
+ res = IPACM_FAILURE;
+ goto fail;
+ }
+ }
+
+
+ if (ip_type != IPA_IP_v4)
+ {
+ if (m_filtering.DeleteFilteringHdls(dft_v6fl_rule_hdl,
+ IPA_IP_v6,
+ (IPV6_DEFAULT_FILTERTING_RULES + IPV6_DEFAULT_LAN_FILTERTING_RULES)) == false)
+ {
+ IPACMERR("Error Adding RuleTable(1) to Filtering, aborting...\n");
+ res = IPACM_FAILURE;
+ goto fail;
+ }
+ }
+
+ /* delete wan filter rule */
+ if (IPACM_Wan::isWanUP())
+ {
+ handle_wan_down();
+ }
+
+fail:
+ free(tx_prop);
+ free(rx_prop);
+ free(iface_query);
+
+ return res;
+}
diff --git a/ipacm/src/IPACM_Log.cpp b/ipacm/src/IPACM_Log.cpp
new file mode 100644
index 0000000..3333358
--- /dev/null
+++ b/ipacm/src/IPACM_Log.cpp
@@ -0,0 +1,68 @@
+/*
+Copyright (c) 2013, The Linux Foundation. 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 name of The Linux 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 "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+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.
+*/
+/*!
+ @file
+ IPACM_log.cpp
+
+ @brief
+ This file implements the IPAM log functionality.
+
+ @Author
+ Skylar Chang
+
+*/
+#include "IPACM_Log.h"
+#include <stdlib.h>
+
+#define FILE_NAME "/usr/ipacm_log.txt"
+
+static FILE *fp = NULL;
+char log_buf[LOG_SIZE];
+
+void logmessage(char *msg)
+{
+ printf("%s\n", msg);
+#if 0
+ if(fp == NULL)
+ {
+ fp = fopen(FILE_NAME, "wb+");
+ if(fp == NULL)
+ {
+ printf("unable to open file\n");
+ return;
+ }
+ }
+
+ fprintf(fp, msg);
+ fflush(fp);
+#endif
+ return;
+}
+
+
diff --git a/ipacm/src/IPACM_Main.cpp b/ipacm/src/IPACM_Main.cpp
new file mode 100644
index 0000000..6369e10
--- /dev/null
+++ b/ipacm/src/IPACM_Main.cpp
@@ -0,0 +1,424 @@
+/*
+Copyright (c) 2013, The Linux Foundation. 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 name of The Linux Foundation nor the names of its
+ contributors may be used to endorse or promote products derived
+ from this software without specific prior written permission. from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+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.
+*/
+/*!
+ @file
+ IPACM_Main.cpp
+
+ @brief
+ This file implements the IPAM functionality.
+
+ @Author
+ Skylar Chang
+
+*/
+/******************************************************************************
+
+ IP_MAIN.C
+
+******************************************************************************/
+
+#include <sys/socket.h>
+#include <signal.h>
+#include <fcntl.h>
+#include <pthread.h>
+#include <sys/ioctl.h>
+#include <linux/if.h>
+#include <linux/netlink.h>
+#include <linux/rtnetlink.h>
+#include <fcntl.h>
+#include <sys/inotify.h>
+#include <stdlib.h>
+
+#include "IPACM_CmdQueue.h"
+#include "IPACM_EvtDispatcher.h"
+#include "IPACM_Defs.h"
+#include "IPACM_Neighbor.h"
+#include "IPACM_IfaceManager.h"
+#include "IPACM_Log.h"
+
+#include "IPACM_ConntrackListener.h"
+
+#define IPA_DRIVER "/dev/ipa"
+
+#define IPACM_DIR_NAME "/etc"
+#define IPACM_FILE_NAME "mobileap_firewall.xml"
+
+#define INOTIFY_EVENT_SIZE (sizeof(struct inotify_event))
+#define INOTIFY_BUF_LEN (INOTIFY_EVENT_SIZE + 2*sizeof(IPACM_FILE_NAME))
+
+#define IPA_DRIVER_WLAN_EVENT_SIZE (sizeof(struct ipa_wlan_msg))
+#define IPA_DRIVER_WLAN_META_MSG (sizeof(struct ipa_msg_meta))
+#define IPA_DRIVER_WLAN_BUF_LEN (IPA_DRIVER_WLAN_EVENT_SIZE + IPA_DRIVER_WLAN_META_MSG)
+
+//char *log_buf = (char *)malloc(LOG_SIZE);
+int ipa_get_if_index(char *if_name, int *if_index);
+
+/* start netlink socket monitor*/
+void* netlink_start(void *param)
+{
+ ipa_nl_sk_fd_set_info_t sk_fdset;
+ int ret_val = 0;
+
+ memset(&sk_fdset, 0, sizeof(ipa_nl_sk_fd_set_info_t));
+ IPACMDBG("netlink starter memset sk_fdset succeeds\n");
+ ret_val = ipa_nl_listener_init(NETLINK_ROUTE, (RTMGRP_IPV4_ROUTE | RTMGRP_IPV6_ROUTE | RTMGRP_LINK |
+ RTMGRP_IPV4_IFADDR | RTMGRP_IPV6_IFADDR | RTMGRP_NEIGH |
+ RTNLGRP_IPV6_PREFIX),
+ &sk_fdset, ipa_nl_recv_msg);
+
+ if (ret_val != IPACM_SUCCESS)
+ {
+ IPACMERR("Failed to initialize IPA netlink event listener\n");
+ return NULL;
+ }
+
+ return NULL;
+}
+
+/* start firewall-rule monitor*/
+void* firewall_monitor(void *param)
+{
+ int length;
+ int wd;
+ char buffer[INOTIFY_BUF_LEN];
+ int inotify_fd;
+ ipacm_cmd_q_data evt_data;
+ uint32_t mask = IN_MODIFY;
+
+ inotify_fd = inotify_init();
+ if (inotify_fd < 0)
+ {
+ PERROR("inotify_init");
+ }
+
+ IPACMDBG("Waiting for nofications in dir %s with mask: 0x%x\n", IPACM_DIR_NAME, mask);
+
+ wd = inotify_add_watch(inotify_fd,
+ IPACM_DIR_NAME,
+ mask);
+
+ while (1)
+ {
+ length = read(inotify_fd, buffer, INOTIFY_BUF_LEN);
+ struct inotify_event *event = (struct inotify_event *)buffer;
+
+ if (length < 0)
+ {
+ IPACMDBG("inotify read() error return length: %d and mask: 0x%x 0x%x\n", length, event->mask, mask);
+ return NULL;
+ }
+
+ if (event->len > 0)
+ {
+ if (event->mask & IN_MODIFY)
+ {
+ if (event->mask & IN_ISDIR)
+ {
+ IPACMDBG("The directory %s was 0x%x\n", event->name, event->mask);
+ }
+ else if (!strncmp(event->name, IPACM_FILE_NAME, event->len))
+ {
+ IPACMDBG("File \"%s\" was 0x%x\n", event->name, event->mask);
+ IPACMDBG("The interested file %s .\n", IPACM_FILE_NAME);
+
+ evt_data.event = IPA_FIREWALL_CHANGE_EVENT;
+ evt_data.evt_data = NULL;
+
+ /* Insert IPA_FIREWALL_CHANGE_EVENT to command queue */
+ IPACM_EvtDispatcher::PostEvt(&evt_data);
+ }
+ }
+ IPACMDBG("Received monitoring event %s.\n", event->name);
+ }
+ }
+
+ (void)inotify_rm_watch(inotify_fd, wd);
+ (void)close(inotify_fd);
+ return NULL;
+}
+
+
+/* start IPACM WLAN-driver notifier */
+void* ipa_driver_wlan_notifier(void *param)
+{
+ int length, fd;
+ char buffer[IPA_DRIVER_WLAN_BUF_LEN];
+ struct ipa_msg_meta *event_hdr = NULL;
+ struct ipa_wlan_msg *event = NULL;
+
+ ipacm_cmd_q_data evt_data;
+ ipacm_event_data_mac *data;
+
+ fd = open(IPA_DRIVER, O_RDWR);
+ if (fd == 0)
+ {
+ IPACMERR("Failed opening %s.\n", IPA_DRIVER);
+ }
+
+ while (1)
+ {
+ IPACMDBG("Waiting for nofications from IPA driver \n");
+ memset(buffer, 0, sizeof(buffer));
+
+ length = read(fd, buffer, IPA_DRIVER_WLAN_BUF_LEN);
+ if (length < 0)
+ {
+ PERROR("didn't read IPA_driver correctly");
+ return NULL;
+ }
+
+ event_hdr = (struct ipa_msg_meta *)buffer;
+ IPACMDBG("Message type: %d\n", event_hdr->msg_type);
+ IPACMDBG("Event header length received: %d\n",event_hdr->msg_len);
+
+ if (event_hdr->msg_len > 0)
+ {
+ event = (struct ipa_wlan_msg *)(buffer + sizeof(struct ipa_msg_meta));
+ }
+
+ /* Insert WLAN_DRIVER_EVENT to command queue */
+ data = (ipacm_event_data_mac *)malloc(sizeof(ipacm_event_data_mac));
+ if (data == NULL)
+ {
+ PERROR("unable to allocate memory for event data\n");
+ return NULL;
+ }
+
+ switch (event_hdr->msg_type)
+ {
+
+ case SW_ROUTING_ENABLE:
+ IPACMDBG("Received SW_ROUTING_ENABLE\n");
+ evt_data.event = IPA_SW_ROUTING_ENABLE;
+ evt_data.evt_data = NULL;
+ break;
+
+ case SW_ROUTING_DISABLE:
+ IPACMDBG("Received SW_ROUTING_DISABLE\n");
+ evt_data.event = IPA_SW_ROUTING_DISABLE;
+ evt_data.evt_data = NULL;
+ break;
+
+ case WLAN_CLIENT_CONNECT:
+ IPACMDBG("Received WLAN_CLIENT_CONNECT\n");
+ IPACMDBG("Mac Address %02x:%02x:%02x:%02x:%02x:%02x\n",
+ event->mac_addr[0], event->mac_addr[1], event->mac_addr[2],
+ event->mac_addr[3], event->mac_addr[4], event->mac_addr[5]);
+
+ evt_data.event = IPA_WLAN_CLIENT_ADD_EVENT;
+ evt_data.evt_data = data;
+ ipa_get_if_index(event->name, &(data->if_index));
+ memcpy(data->mac_addr,
+ event->mac_addr,
+ sizeof(event->mac_addr));
+ break;
+
+ case WLAN_CLIENT_DISCONNECT:
+ IPACMDBG("Received WLAN_CLIENT_DISCONNECT\n");
+ IPACMDBG("Mac Address %02x:%02x:%02x:%02x:%02x:%02x\n",
+ event->mac_addr[0], event->mac_addr[1], event->mac_addr[2],
+ event->mac_addr[3], event->mac_addr[4], event->mac_addr[5]);
+
+ memcpy(data->mac_addr,
+ event->mac_addr,
+ sizeof(event->mac_addr));
+ ipa_get_if_index(event->name, &(data->if_index));
+
+ evt_data.event = IPA_WLAN_CLIENT_DEL_EVENT;
+ evt_data.evt_data = data;
+
+ break;
+
+ case WLAN_CLIENT_POWER_SAVE_MODE:
+ IPACMDBG("Received WLAN_CLIENT_POWER_SAVE_MODE\n");
+ IPACMDBG("Mac Address [0]:%2d [1]:%2d [2]:%2d [3]:%2d [4]:%2d [5]%2d\n",
+ event->mac_addr[0], event->mac_addr[1], event->mac_addr[2],
+ event->mac_addr[3], event->mac_addr[4], event->mac_addr[5]);
+
+ ipa_get_if_index(event->name, &(data->if_index));
+
+ evt_data.event = IPA_WLAN_CLIENT_POWER_SAVE_EVENT;
+ evt_data.evt_data = data;
+ memcpy(data->mac_addr,
+ event->mac_addr,
+ sizeof(event->mac_addr));
+
+ break;
+
+ case WLAN_CLIENT_NORMAL_MODE:
+ IPACMDBG("Received WLAN_CLIENT_NORMAL_MODE\n");
+ IPACMDBG("Mac Address [0]:%2d [1]:%2d [2]:%2d [3]:%2d [4]:%2d [5]%2d\n",
+ event->mac_addr[0], event->mac_addr[1], event->mac_addr[2],
+ event->mac_addr[3], event->mac_addr[4], event->mac_addr[5]);
+
+ memcpy(data->mac_addr,
+ event->mac_addr,
+ sizeof(event->mac_addr));
+ ipa_get_if_index(event->name, &(data->if_index));
+ evt_data.evt_data = data;
+ evt_data.event = IPA_WLAN_CLIENT_RECOVER_EVENT;
+ break;
+
+ default:
+ IPACMDBG("Invalid message\n");
+ free(data);
+ continue;
+
+ }
+
+ /* finish command queue */
+ if (evt_data.evt_data == NULL)
+ {
+ free(data);
+ }
+
+ IPACMDBG("Posting event:%d\n", evt_data.event);
+ IPACM_EvtDispatcher::PostEvt(&evt_data);
+ }
+
+ (void)close(fd);
+ return NULL;
+}
+
+
+int main(int argc, char **argv)
+{
+ int ret;
+ pthread_t netlink_thread = 0, monitor_thread = 0, ipa_driver_thread = 0;
+ pthread_t cmd_queue_thread = 0;
+
+ IPACM_Neighbor *neigh = new IPACM_Neighbor();
+ IPACM_IfaceManager *ifacemgr = new IPACM_IfaceManager();
+
+ IPACMDBG("Staring IPA main\n");
+ IPACMDBG("ipa_cmdq_successful\n");
+
+
+ if (IPACM_SUCCESS == cmd_queue_thread)
+ {
+ ret = pthread_create(&cmd_queue_thread, NULL, MessageQueue::Process, NULL);
+ if (IPACM_SUCCESS != ret)
+ {
+ IPACMERR("unable to command queue thread\n");
+ return ret;
+ }
+ IPACMDBG("created command queue thread\n");
+ }
+
+ if (IPACM_SUCCESS == netlink_thread)
+ {
+ ret = pthread_create(&netlink_thread, NULL, netlink_start, NULL);
+ if (IPACM_SUCCESS != ret)
+ {
+ IPACMERR("unable to create netlink thread\n");
+ return ret;
+ }
+ IPACMDBG("created netlink thread\n");
+ }
+
+
+ if (IPACM_SUCCESS == monitor_thread)
+ {
+ ret = pthread_create(&monitor_thread, NULL, firewall_monitor, NULL);
+ if (IPACM_SUCCESS != ret)
+ {
+ IPACMERR("unable to create monitor thread\n");
+ return ret;
+ }
+ IPACMDBG("created firewall monitor thread\n");
+ }
+
+ if (IPACM_SUCCESS == ipa_driver_thread)
+ {
+ ret = pthread_create(&ipa_driver_thread, NULL, ipa_driver_wlan_notifier, NULL);
+ if (IPACM_SUCCESS != ret)
+ {
+ IPACMERR("unable to create ipa_driver_wlan thread\n");
+ return ret;
+ }
+ IPACMDBG("created ipa_driver_wlan thread\n");
+ }
+
+ pthread_join(cmd_queue_thread, NULL);
+ pthread_join(netlink_thread, NULL);
+ pthread_join(monitor_thread, NULL);
+ pthread_join(ipa_driver_thread, NULL);
+ return IPACM_SUCCESS;
+}
+
+
+/*===========================================================================
+ FUNCTION ipa_get_if_index
+===========================================================================*/
+/*!
+@brief
+ get ipa interface index by given the interface name
+
+@return
+ IPACM_SUCCESS or IPA_FALUIRE
+
+@note
+
+- Dependencies
+ - None
+
+- Side Effects
+ - None
+*/
+/*=========================================================================*/
+int ipa_get_if_index
+(
+ char *if_name,
+ int *if_index
+ )
+{
+ int fd;
+ struct ifreq ifr;
+
+ if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
+ {
+ PERROR("get interface index socket create failed");
+ return IPACM_FAILURE;
+ }
+
+ memset(&ifr, 0, sizeof(struct ifreq));
+
+ (void)strncpy(ifr.ifr_name, if_name, sizeof(ifr.ifr_name));
+
+ if (ioctl(fd, SIOCGIFINDEX, &ifr) < 0)
+ {
+ PERROR("call_ioctl_on_dev: ioctl failed:");
+ close(fd);
+ return IPACM_FAILURE;
+ }
+
+ *if_index = ifr.ifr_ifindex;
+ close(fd);
+ return IPACM_SUCCESS;
+}
diff --git a/ipacm/src/IPACM_Neighbor.cpp b/ipacm/src/IPACM_Neighbor.cpp
new file mode 100644
index 0000000..327b681
--- /dev/null
+++ b/ipacm/src/IPACM_Neighbor.cpp
@@ -0,0 +1,252 @@
+/*
+Copyright (c) 2013, The Linux Foundation. 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 name of The Linux 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 "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+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.
+*/
+/*!
+ @file
+ IPACM_Neighbor.cpp
+
+ @brief
+ This file implements the functionality of handling IPACM Neighbor events.
+
+ @Author
+ Skylar Chang
+
+*/
+
+#include <sys/ioctl.h>
+#include <IPACM_Neighbor.h>
+#include <IPACM_EvtDispatcher.h>
+#include "IPACM_Defs.h"
+#include "IPACM_Log.h"
+
+
+IPACM_Neighbor::IPACM_Neighbor()
+{
+ num_neighbor_client = 0;
+ IPACM_EvtDispatcher::registr(IPA_NEW_NEIGH_EVENT, this);
+ IPACM_EvtDispatcher::registr(IPA_DEL_NEIGH_EVENT, this);
+ return;
+}
+
+void IPACM_Neighbor::event_callback(ipa_cm_event_id event, void *param)
+{
+ ipacm_event_data_all *data = NULL;
+ int i, ipa_interface_index;
+ ipacm_cmd_q_data evt_data;
+ int num_neighbor_client_temp = num_neighbor_client;
+
+ IPACMDBG("Recieved event %d\n", event);
+
+ data = (ipacm_event_data_all *)malloc(sizeof(ipacm_event_data_all));
+ memcpy(data, param, sizeof(ipacm_event_data_all));
+
+ ipa_interface_index = IPACM_Iface::iface_ipa_index_query(data->if_index);
+ /*No that interface existed in ipa list*/
+ if(ipa_interface_index==-1)
+ return;
+
+ if (data->iptype == IPA_IP_v4)
+ {
+ /* construct IPA_NEIGH_CLIENT_IP_ADDR_ADD_EVENT command and insert to command-queue*/
+ if (event == IPA_NEW_NEIGH_EVENT)
+ evt_data.event = IPA_NEIGH_CLIENT_IP_ADDR_ADD_EVENT;
+ else
+ evt_data.event = IPA_NEIGH_CLIENT_IP_ADDR_DEL_EVENT;
+
+ memcpy(&evt_data.evt_data, &data, sizeof(evt_data.evt_data));
+ IPACM_EvtDispatcher::PostEvt(&evt_data);
+ IPACMDBG("Posted event %d with %s\n", evt_data.event,
+ IPACM_Iface::ipacmcfg->iface_table[ipa_interface_index].iface_name);
+ }
+ else
+ {
+ if ((data->ipv6_addr[0]) || (data->ipv6_addr[1]) || (data->ipv6_addr[2]) || (data->ipv6_addr[3]))
+ {
+ /* check if iface is not bridge0*/
+ if (strcmp(IPA_VIRTUAL_IFACE_NAME, IPACM_Iface::ipacmcfg->iface_table[ipa_interface_index].iface_name) == 0)
+ {
+ /* searh if seen this client or not*/
+ for (i = 0; i < num_neighbor_client_temp; i++)
+ {
+ if (memcmp(neighbor_client[i].mac_addr, data->mac_addr, sizeof(neighbor_client[i].mac_addr)) == 0)
+ {
+ data->if_index = neighbor_client[i].iface_index;
+ /* construct IPA_NEIGH_CLIENT_IP_ADDR_ADD_EVENT command and insert to command-queue */
+ if (event == IPA_NEW_NEIGH_EVENT) evt_data.event = IPA_NEIGH_CLIENT_IP_ADDR_ADD_EVENT;
+ else evt_data.event = IPA_NEIGH_CLIENT_IP_ADDR_DEL_EVENT;
+ //evt_data.evt_data=data;
+ memcpy(&evt_data.evt_data, &data, sizeof(evt_data.evt_data));
+ IPACM_EvtDispatcher::PostEvt(&evt_data);
+ /* ask for replaced iface name*/
+ ipa_interface_index = IPACM_Iface::iface_ipa_index_query(data->if_index);
+ /*No that interface existed in ipa list*/
+ if(ipa_interface_index==-1)
+ return;
+
+ IPACMDBG("Posted event %d, with %s\n",
+ evt_data.event,
+ IPACM_Iface::ipacmcfg->iface_table[ipa_interface_index].iface_name);
+
+ /* delete that entry*/
+ for (; i < num_neighbor_client_temp - 1; i++)
+ {
+ memcpy(neighbor_client[i].mac_addr, neighbor_client[i + 1].mac_addr, sizeof(neighbor_client[i].mac_addr));
+ neighbor_client[i].v6_addr[0] = neighbor_client[i + 1].v6_addr[0];
+ neighbor_client[i].v6_addr[1] = neighbor_client[i + 1].v6_addr[1];
+ neighbor_client[i].v6_addr[2] = neighbor_client[i + 1].v6_addr[2];
+ neighbor_client[i].v6_addr[3] = neighbor_client[i + 1].v6_addr[3];
+ neighbor_client[i].iface_index = neighbor_client[i + 1].iface_index;
+ }
+ num_neighbor_client -= 1;
+ break;
+
+ };
+ }
+
+ /* cannot find neighbor client*/
+ if (i == num_neighbor_client_temp)
+ {
+ IPACMDBG("ipv6 with bridge0 with mac, not seen before\n");
+ if (num_neighbor_client_temp < IPA_MAX_NUM_NEIGHBOR_CLIENTS)
+ {
+ memcpy(neighbor_client[num_neighbor_client_temp].mac_addr,
+ data->mac_addr,
+ sizeof(data->mac_addr));
+ neighbor_client[num_neighbor_client_temp].v6_addr[0] = data->ipv6_addr[0];
+ neighbor_client[num_neighbor_client_temp].v6_addr[1] = data->ipv6_addr[1];
+ neighbor_client[num_neighbor_client_temp].v6_addr[2] = data->ipv6_addr[2];
+ neighbor_client[num_neighbor_client_temp].v6_addr[3] = data->ipv6_addr[3];
+ IPACMDBG("Copy bridge0 MAC %02x:%02x:%02x:%02x:%02x:%02x\n, total client: %d\n",
+ neighbor_client[num_neighbor_client_temp].mac_addr[0],
+ neighbor_client[num_neighbor_client_temp].mac_addr[1],
+ neighbor_client[num_neighbor_client_temp].mac_addr[2],
+ neighbor_client[num_neighbor_client_temp].mac_addr[3],
+ neighbor_client[num_neighbor_client_temp].mac_addr[4],
+ neighbor_client[num_neighbor_client_temp].mac_addr[5],
+ num_neighbor_client_temp);
+ num_neighbor_client++;
+ return;
+ }
+ else
+ {
+ IPACMERR("error: neighbor client oversize!");
+ return;
+ }
+ }
+ }
+ else
+ {
+ /* construct IPA_NEIGH_CLIENT_IP_ADDR_ADD_EVENT command and insert to command-queue */
+ if (event == IPA_NEW_NEIGH_EVENT)
+ evt_data.event = IPA_NEIGH_CLIENT_IP_ADDR_ADD_EVENT;
+ else
+ evt_data.event = IPA_NEIGH_CLIENT_IP_ADDR_DEL_EVENT;
+
+ memcpy(&evt_data.evt_data, &data, sizeof(evt_data.evt_data));
+ //evt_data.evt_data=data;
+ IPACM_EvtDispatcher::PostEvt(&evt_data);
+ IPACMDBG("Posted event %d with %s\n",
+ evt_data.event,
+ IPACM_Iface::ipacmcfg->iface_table[ipa_interface_index].iface_name);
+
+
+ }
+ }
+ else
+ {
+ /*no ipv6 in data searh if seen this client or not*/
+ for (i = 0; i < num_neighbor_client_temp; i++)
+ {
+ if (memcmp(neighbor_client[i].mac_addr, data->mac_addr, sizeof(neighbor_client[i].mac_addr)) == 0)
+ {
+ data->ipv6_addr[0] = neighbor_client[i].v6_addr[0];
+ data->ipv6_addr[1] = neighbor_client[i].v6_addr[1];
+ data->ipv6_addr[2] = neighbor_client[i].v6_addr[2];
+ data->ipv6_addr[3] = neighbor_client[i].v6_addr[3];
+
+ /* check if iface is not bridge0*/
+ if (strcmp(IPA_VIRTUAL_IFACE_NAME, IPACM_Iface::ipacmcfg->iface_table[ipa_interface_index].iface_name) != 0)
+ {
+ /* construct IPA_NEIGH_CLIENT_IP_ADDR_ADD_EVENT command and insert to command-queue */
+ if (event == IPA_NEW_NEIGH_EVENT) evt_data.event = IPA_NEIGH_CLIENT_IP_ADDR_ADD_EVENT;
+ else evt_data.event = IPA_NEIGH_CLIENT_IP_ADDR_DEL_EVENT;
+ memcpy(&evt_data.evt_data, &data, sizeof(evt_data.evt_data));
+ IPACM_EvtDispatcher::PostEvt(&evt_data);
+ IPACMDBG("Posted event %d with %s\n",
+ evt_data.event,
+ IPACM_Iface::ipacmcfg->iface_table[ipa_interface_index].iface_name);
+
+
+ /* delete that entry*/
+ for (; i <= num_neighbor_client_temp; i++)
+ {
+ memcpy(neighbor_client[i].mac_addr, neighbor_client[i + 1].mac_addr, sizeof(neighbor_client[i].mac_addr));
+ neighbor_client[i].v6_addr[0] = neighbor_client[i + 1].v6_addr[0];
+ neighbor_client[i].v6_addr[1] = neighbor_client[i + 1].v6_addr[1];
+ neighbor_client[i].v6_addr[2] = neighbor_client[i + 1].v6_addr[2];
+ neighbor_client[i].v6_addr[3] = neighbor_client[i + 1].v6_addr[3];
+ neighbor_client[i].iface_index = neighbor_client[i + 1].iface_index;
+ }
+ num_neighbor_client -= 1;
+ };
+ break;
+ };
+ }
+ /* not find client */
+ if (i == num_neighbor_client_temp)
+ {
+ IPACMDBG("ipv6 with bridge0 with mac, not seen before\n");
+ if (num_neighbor_client_temp < IPA_MAX_NUM_NEIGHBOR_CLIENTS)
+ {
+ memcpy(neighbor_client[num_neighbor_client_temp].mac_addr,
+ data->mac_addr,
+ sizeof(data->mac_addr));
+ neighbor_client[num_neighbor_client_temp].iface_index = data->if_index;
+ IPACMDBG("Copy wlan-iface client MAC %02x:%02x:%02x:%02x:%02x:%02x\n, total client: %d\n",
+ neighbor_client[num_neighbor_client_temp].mac_addr[0],
+ neighbor_client[num_neighbor_client_temp].mac_addr[1],
+ neighbor_client[num_neighbor_client_temp].mac_addr[2],
+ neighbor_client[num_neighbor_client_temp].mac_addr[3],
+ neighbor_client[num_neighbor_client_temp].mac_addr[4],
+ neighbor_client[num_neighbor_client_temp].mac_addr[5],
+ num_neighbor_client);
+ num_neighbor_client++;
+ return;
+ }
+ else
+ {
+ IPACMDBG("error: neighbor client oversize!");
+ return;
+ }
+ };
+ }
+ }
+
+ return;
+}
+
diff --git a/ipacm/src/IPACM_Netlink.cpp b/ipacm/src/IPACM_Netlink.cpp
new file mode 100644
index 0000000..eea98ea
--- /dev/null
+++ b/ipacm/src/IPACM_Netlink.cpp
@@ -0,0 +1,1823 @@
+/*
+Copyright (c) 2013, The Linux Foundation. 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 name of The Linux 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 "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+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.
+*/
+/*!
+ @file
+ IPACM_Netlink.cpp
+
+ @brief
+ This file implements the IPAM Netlink Socket Parer functionality.
+
+ @Author
+ Skylar Chang
+
+*/
+#include <string.h>
+#include <unistd.h>
+#include <sys/ioctl.h>
+#include <netinet/in.h>
+#include "IPACM_CmdQueue.h"
+#include "IPACM_Defs.h"
+#include "IPACM_Netlink.h"
+#include "IPACM_EvtDispatcher.h"
+#include "IPACM_Log.h"
+
+char dev_pre_name[IF_NAME_LEN];
+struct sockaddr_storage dst_pre_addr;
+
+int ipa_get_if_name(char *if_name, int if_index);
+int find_mask(int ip_v4_last, int *mask_value);
+
+#define NDA_RTA(r) ((struct rtattr*)(((char*)(r)) + NLMSG_ALIGN(sizeof(struct ndmsg))))
+
+/* Opens a netlink socket*/
+static int ipa_nl_open_socket
+(
+ ipa_nl_sk_info_t *sk_info,
+ int protocol,
+ unsigned int grps
+ )
+{
+ int *p_sk_fd;
+ struct sockaddr_nl *p_sk_addr_loc;
+
+ p_sk_fd = &(sk_info->sk_fd);
+ p_sk_addr_loc = &(sk_info->sk_addr_loc);
+
+ /* Open netlink socket for specified protocol */
+ if((*p_sk_fd = socket(AF_NETLINK, SOCK_RAW, protocol)) < 0)
+ {
+ IPACMERR("cannot open netlink socket\n");
+ return IPACM_FAILURE;
+ }
+
+ /* Initialize socket addresses to null */
+ memset(p_sk_addr_loc, 0, sizeof(struct sockaddr_nl));
+
+ /* Populate local socket address using specified groups */
+ p_sk_addr_loc->nl_family = AF_NETLINK;
+ p_sk_addr_loc->nl_pid = getpid();
+ p_sk_addr_loc->nl_groups = grps;
+
+ /* Bind socket to the local address, i.e. specified groups. This ensures
+ that multicast messages for these groups are delivered over this
+ socket. */
+
+ if(bind(*p_sk_fd,
+ (struct sockaddr *)p_sk_addr_loc,
+ sizeof(struct sockaddr_nl)) < 0)
+ {
+ IPACMDBG("Socket bind failed\n");
+ return IPACM_FAILURE;
+ }
+
+ return IPACM_SUCCESS;
+}
+
+/* Add fd to fdmap array and store read handler function ptr (up to MAX_NUM_OF_FD).*/
+static int ipa_nl_addfd_map
+(
+ ipa_nl_sk_fd_set_info_t *fd_set,
+ int fd,
+ ipa_sock_thrd_fd_read_f read_f
+ )
+{
+ if(fd_set->num_fd < MAX_NUM_OF_FD)
+ {
+ FD_SET(fd, &(fd_set->fdset));
+
+ /* Add fd to fdmap array and store read handler function ptr */
+ fd_set->sk_fds[fd_set->num_fd].sk_fd = fd;
+ fd_set->sk_fds[fd_set->num_fd].read_func = read_f;
+
+ /* Increment number of fds stored in fdmap */
+ fd_set->num_fd++;
+ if(fd_set->max_fd < fd)
+ {
+ fd_set->max_fd = fd;
+ }
+ }
+ else
+ {
+ return IPACM_FAILURE;
+ }
+
+ return IPACM_SUCCESS;
+}
+
+/* start socket listener */
+static int ipa_nl_sock_listener_start
+(
+ ipa_nl_sk_fd_set_info_t *sk_fd_set
+ )
+{
+ int i, ret;
+
+ while(true)
+ {
+ if((ret = select(sk_fd_set->max_fd + 1, &(sk_fd_set->fdset), NULL, NULL, NULL)) < 0)
+ {
+ IPACMERR("ipa_nl select failed\n");
+ }
+ else
+ {
+ for(i = 0; i < sk_fd_set->num_fd; i++)
+ {
+
+ if(FD_ISSET(sk_fd_set->sk_fds[i].sk_fd, &(sk_fd_set->fdset)))
+ {
+
+ if(sk_fd_set->sk_fds[i].read_func)
+ {
+ if(IPACM_SUCCESS != ((sk_fd_set->sk_fds[i].read_func)(sk_fd_set->sk_fds[i].sk_fd)))
+ {
+ IPACMERR("Error on read callback[%d] fd=%d\n",
+ i,
+ sk_fd_set->sk_fds[i].sk_fd);
+ }
+ }
+ else
+ {
+ IPACMDBG("No read function\n");
+ }
+ }
+
+ } /* end of for loop*/
+ } /* end of else */
+ } /* end of while */
+
+ return IPACM_SUCCESS;
+}
+
+/* allocate memory for ipa_nl__msg */
+static struct msghdr* ipa_nl_alloc_msg
+(
+ uint32_t msglen
+ )
+{
+ unsigned char *buf = NULL;
+ struct sockaddr_nl *nladdr = NULL;
+ struct iovec *iov = NULL;
+ struct msghdr *msgh = NULL;
+
+ if(IPA_NL_MSG_MAX_LEN < msglen)
+ {
+ IPACMERR("Netlink message exceeds maximum length\n");
+ return NULL;
+ }
+
+ msgh = (struct msghdr *)malloc(sizeof(struct msghdr));
+ if(msgh == NULL)
+ {
+ IPACMERR("Failed malloc for msghdr\n");
+ free(msgh);
+ return NULL;
+ }
+
+ nladdr = (struct sockaddr_nl *)malloc(sizeof(struct sockaddr_nl));
+ if(nladdr == NULL)
+ {
+ IPACMERR("Failed malloc for sockaddr\n");
+ free(nladdr);
+ free(msgh);
+ return NULL;
+ }
+
+ iov = (struct iovec *)malloc(sizeof(struct iovec));
+ if(iov == NULL)
+ {
+ PERROR("Failed malloc for iovec");
+ free(iov);
+ free(nladdr);
+ free(msgh);
+ return NULL;
+ }
+
+ buf = (unsigned char *)malloc(msglen);
+ if(buf == NULL)
+ {
+ IPACMERR("Failed malloc for mglen\n");
+ free(buf);
+ free(iov);
+ free(nladdr);
+ free(msgh);
+ return NULL;
+ }
+
+ memset(nladdr, 0, sizeof(struct sockaddr_nl));
+ nladdr->nl_family = AF_NETLINK;
+
+ memset(msgh, 0x0, sizeof(struct msghdr));
+ msgh->msg_name = nladdr;
+ msgh->msg_namelen = sizeof(struct sockaddr_nl);
+ msgh->msg_iov = iov;
+ msgh->msg_iovlen = 1;
+
+ memset(iov, 0x0, sizeof(struct iovec));
+ iov->iov_base = buf;
+ iov->iov_len = msglen;
+
+ return msgh;
+}
+
+/* release IPA message */
+static void ipa_nl_release_msg
+(
+ struct msghdr *msgh
+ )
+{
+ unsigned char *buf = NULL;
+ struct sockaddr_nl *nladdr = NULL;
+ struct iovec *iov = NULL;
+
+ if(NULL == msgh)
+ {
+ return;
+ }
+
+ nladdr = (struct sockaddr_nl *)msgh->msg_name;
+ iov = msgh->msg_iov;
+ if(msgh->msg_iov)
+ {
+ buf = (unsigned char *)msgh->msg_iov->iov_base;
+ }
+
+ free(buf);
+ free(iov);
+ free(nladdr);
+ free(msgh);
+
+ return;
+}
+
+/* receive and process nl message */
+static int ipa_nl_recv
+(
+ int fd,
+ struct msghdr **msg_pptr,
+ unsigned int *msglen_ptr
+ )
+{
+ struct msghdr *msgh = NULL;
+ int rmsgl;
+
+ msgh = ipa_nl_alloc_msg(IPA_NL_MSG_MAX_LEN);
+ if(NULL == msgh)
+ {
+ IPACMERR("Failed to allocate NL message\n");
+ goto error;
+ }
+
+
+ /* Receive message over the socket */
+ rmsgl = recvmsg(fd, msgh, 0);
+
+ /* Verify that something was read */
+ if(rmsgl <= 0)
+ {
+ PERROR("NL recv error");
+ goto error;
+ }
+
+ /* Verify that NL address length in the received message is expected value */
+ if(sizeof(struct sockaddr_nl) != msgh->msg_namelen)
+ {
+ IPACMERR("rcvd msg with namelen != sizeof sockaddr_nl\n");
+ goto error;
+ }
+
+ /* Verify that message was not truncated. This should not occur */
+ if(msgh->msg_flags & MSG_TRUNC)
+ {
+ IPACMERR("Rcvd msg truncated!\n");
+ goto error;
+ }
+
+ *msg_pptr = msgh;
+ *msglen_ptr = rmsgl;
+
+ return IPACM_SUCCESS;
+
+/* An error occurred while receiving the message. Free all memory before
+ returning. */
+error:
+ ipa_nl_release_msg(msgh);
+ *msg_pptr = NULL;
+ *msglen_ptr = 0;
+
+ return IPACM_FAILURE;
+}
+
+/* decode the rtm netlink message */
+static int ipa_nl_decode_rtm_link
+(
+ const char *buffer,
+ unsigned int buflen,
+ ipa_nl_link_info_t *link_info
+)
+{
+ struct rtattr *rtah = NULL;
+ /* NL message header */
+ struct nlmsghdr *nlh = (struct nlmsghdr *)buffer;
+
+ /* Extract the header data */
+ link_info->metainfo = *(struct ifinfomsg *)NLMSG_DATA(nlh);
+ buflen -= sizeof(struct nlmsghdr);
+ rtah = IFA_RTA(NLMSG_DATA(nlh));
+
+ return IPACM_SUCCESS;
+}
+
+/* Decode kernel address message parameters from Netlink attribute TLVs. */
+static int ipa_nl_decode_rtm_addr
+(
+ const char *buffer,
+ unsigned int buflen,
+ ipa_nl_addr_info_t *addr_info
+ )
+{
+ struct nlmsghdr *nlh = (struct nlmsghdr *)buffer; /* NL message header */
+ struct rtattr *rtah = NULL;
+
+ /* Extract the header data */
+ addr_info->metainfo = *((struct ifaddrmsg *)NLMSG_DATA(nlh));
+ buflen -= sizeof(struct nlmsghdr);
+
+ /* Extract the available attributes */
+ addr_info->attr_info.param_mask = IPA_NLA_PARAM_NONE;
+
+ rtah = IFA_RTA(NLMSG_DATA(nlh));
+
+ while(RTA_OK(rtah, buflen))
+ {
+ switch(rtah->rta_type)
+ {
+
+ case IFA_ADDRESS:
+ addr_info->attr_info.prefix_addr.ss_family = addr_info->metainfo.ifa_family;
+ memcpy(&addr_info->attr_info.prefix_addr.__ss_padding,
+ RTA_DATA(rtah),
+ sizeof(addr_info->attr_info.prefix_addr.__ss_padding));
+ addr_info->attr_info.param_mask |= IPA_NLA_PARAM_PREFIXADDR;
+ break;
+
+ default:
+ break;
+
+ }
+ /* Advance to next attribute */
+ rtah = RTA_NEXT(rtah, buflen);
+ }
+
+ return IPACM_SUCCESS;
+}
+
+/* Decode kernel neighbor message parameters from Netlink attribute TLVs. */
+static int ipa_nl_decode_rtm_neigh
+(
+ const char *buffer,
+ unsigned int buflen,
+ ipa_nl_neigh_info_t *neigh_info
+ )
+{
+ struct nlmsghdr *nlh = (struct nlmsghdr *)buffer; /* NL message header */
+ struct rtattr *rtah = NULL;
+
+ /* Extract the header data */
+ neigh_info->metainfo = *((struct ndmsg *)NLMSG_DATA(nlh));
+ buflen -= sizeof(struct nlmsghdr);
+
+ /* Extract the available attributes */
+ neigh_info->attr_info.param_mask = IPA_NLA_PARAM_NONE;
+
+ rtah = NDA_RTA(NLMSG_DATA(nlh));
+
+ while(RTA_OK(rtah, buflen))
+ {
+ switch(rtah->rta_type)
+ {
+
+ case NDA_DST:
+ neigh_info->attr_info.local_addr.ss_family = neigh_info->metainfo.ndm_family;
+ memcpy(&neigh_info->attr_info.local_addr.__ss_padding,
+ RTA_DATA(rtah),
+ sizeof(neigh_info->attr_info.local_addr.__ss_padding));
+ break;
+
+ case NDA_LLADDR:
+ memcpy(neigh_info->attr_info.lladdr_hwaddr.sa_data,
+ RTA_DATA(rtah),
+ sizeof(neigh_info->attr_info.lladdr_hwaddr.sa_data));
+ break;
+
+ default:
+ break;
+
+ }
+
+ /* Advance to next attribute */
+ rtah = RTA_NEXT(rtah, buflen);
+ }
+
+ return IPACM_SUCCESS;
+}
+
+/* Decode kernel route message parameters from Netlink attribute TLVs. */
+static int ipa_nl_decode_rtm_route
+(
+ const char *buffer,
+ unsigned int buflen,
+ ipa_nl_route_info_t *route_info
+ )
+{
+ struct nlmsghdr *nlh = (struct nlmsghdr *)buffer; /* NL message header */
+ struct rtattr *rtah = NULL;
+
+ /* Extract the header data */
+ route_info->metainfo = *((struct rtmsg *)NLMSG_DATA(nlh));
+ buflen -= sizeof(struct nlmsghdr);
+
+ route_info->attr_info.param_mask = IPA_RTA_PARAM_NONE;
+ rtah = RTM_RTA(NLMSG_DATA(nlh));
+
+ while(RTA_OK(rtah, buflen))
+ {
+ switch(rtah->rta_type)
+ {
+
+ case RTA_DST:
+ if((route_info->metainfo.rtm_type == RTN_UNICAST) &&
+ (route_info->metainfo.rtm_protocol == RTPROT_BOOT) &&
+ (route_info->metainfo.rtm_scope == RT_SCOPE_LINK) &&
+ (route_info->metainfo.rtm_table == RT_TABLE_MAIN))
+ {
+ route_info->metainfo.rtm_type = RTN_BROADCAST;
+ memcpy(&route_info->attr_info.dst_addr.__ss_padding,
+ dst_pre_addr.__ss_padding,
+ sizeof(route_info->attr_info.dst_addr.__ss_padding));
+ route_info->attr_info.param_mask |= IPA_RTA_PARAM_DST;
+ }
+ else
+ {
+ route_info->attr_info.dst_addr.ss_family = route_info->metainfo.rtm_family;
+ memcpy(&route_info->attr_info.dst_addr.__ss_padding,
+ RTA_DATA(rtah),
+ sizeof(route_info->attr_info.dst_addr.__ss_padding));
+ route_info->attr_info.param_mask |= IPA_RTA_PARAM_DST;
+ }
+ break;
+
+ case RTA_SRC:
+ route_info->attr_info.src_addr.ss_family = route_info->metainfo.rtm_family;
+ memcpy(&route_info->attr_info.src_addr.__ss_padding,
+ RTA_DATA(rtah),
+ sizeof(route_info->attr_info.src_addr.__ss_padding));
+ route_info->attr_info.param_mask |= IPA_RTA_PARAM_SRC;
+ break;
+
+ case RTA_GATEWAY:
+ route_info->attr_info.gateway_addr.ss_family = route_info->metainfo.rtm_family;
+ memcpy(&route_info->attr_info.gateway_addr.__ss_padding,
+ RTA_DATA(rtah),
+ sizeof(route_info->attr_info.gateway_addr.__ss_padding));
+ route_info->attr_info.param_mask |= IPA_RTA_PARAM_GATEWAY;
+ break;
+
+ case RTA_IIF:
+ memcpy(&route_info->attr_info.iif_index,
+ RTA_DATA(rtah),
+ sizeof(route_info->attr_info.iif_index));
+ route_info->attr_info.param_mask |= IPA_RTA_PARAM_IIF;
+ break;
+
+ case RTA_OIF:
+ memcpy(&route_info->attr_info.oif_index,
+ RTA_DATA(rtah),
+ sizeof(route_info->attr_info.oif_index));
+ route_info->attr_info.param_mask |= IPA_RTA_PARAM_OIF;
+ break;
+
+ case RTA_PRIORITY:
+ memcpy(&route_info->attr_info.priority,
+ RTA_DATA(rtah),
+ sizeof(route_info->attr_info.priority));
+ route_info->attr_info.param_mask |= IPA_RTA_PARAM_PRIORITY;
+ break;
+
+ default:
+ break;
+
+ }
+
+ /* Advance to next attribute */
+ rtah = RTA_NEXT(rtah, buflen);
+ }
+
+ return IPACM_SUCCESS;
+}
+
+/* decode the ipa nl-message */
+static int ipa_nl_decode_nlmsg
+(
+ const char *buffer,
+ unsigned int buflen,
+ ipa_nl_msg_t *msg_ptr
+ )
+{
+ char dev_name[IF_NAME_LEN];
+ int ret_val, mask_value, mask_index, mask_value_v6;
+ struct nlmsghdr *nlh = (struct nlmsghdr *)buffer;
+
+ uint32_t if_ipv4_addr =0, if_ipipv4_addr_mask =0, temp =0;
+
+ ipacm_cmd_q_data evt_data;
+ ipacm_event_data_all *data_all;
+ ipacm_event_data_fid *data_fid;
+ ipacm_event_data_addr *data_addr;
+
+
+ while(NLMSG_OK(nlh, buflen))
+ {
+ IPACMDBG("Received msg:%d from netlink\n", nlh->nlmsg_type)
+ switch(nlh->nlmsg_type)
+ {
+ case RTM_NEWLINK:
+ msg_ptr->type = nlh->nlmsg_type;
+ msg_ptr->link_event = true;
+ if(IPACM_SUCCESS != ipa_nl_decode_rtm_link(buffer, buflen, &(msg_ptr->nl_link_info)))
+ {
+ IPACMERR("Failed to decode rtm link message\n");
+ return IPACM_FAILURE;
+ }
+ else
+ {
+ IPACMDBG("Got RTM_NEWLINK with below values\n");
+ IPACMDBG("RTM_NEWLINK, ifi_change:%d\n", msg_ptr->nl_link_info.metainfo.ifi_change);
+ IPACMDBG("RTM_NEWLINK, ifi_flags:%d\n", msg_ptr->nl_link_info.metainfo.ifi_flags);
+ IPACMDBG("RTM_NEWLINK, ifi_index:%d\n", msg_ptr->nl_link_info.metainfo.ifi_index);
+ IPACMDBG("RTM_NEWLINK, family:%d\n", msg_ptr->nl_link_info.metainfo.ifi_family);
+
+ if(IFF_UP & msg_ptr->nl_link_info.metainfo.ifi_change)
+ {
+ IPACMDBG("\n GOT useful newlink event\n");
+ ret_val = ipa_get_if_name(dev_name, msg_ptr->nl_link_info.metainfo.ifi_index);
+ if(msg_ptr->nl_link_info.metainfo.ifi_flags & IFF_UP)
+ {
+ IPACMDBG("Interface %s bring up with IP-family: %d \n", dev_name, msg_ptr->nl_link_info.metainfo.ifi_family);
+ /* post link up to command queue */
+ evt_data.event = IPA_LINK_UP_EVENT;
+ IPACMDBG("Posting IPA_LINK_UP_EVENT with if index: %d\n",
+ data_fid->if_index);
+ }
+ else
+ {
+ IPACMDBG("Interface %s bring down with IP-family: %d \n", dev_name, msg_ptr->nl_link_info.metainfo.ifi_family);
+ /* post link down to command queue */
+ evt_data.event = IPA_LINK_DOWN_EVENT;
+ IPACMDBG("Posting IPA_LINK_DOWN_EVENT with if index: %d\n",
+ data_fid->if_index);
+ }
+
+ data_fid = (ipacm_event_data_fid *)malloc(sizeof(ipacm_event_data_fid));
+ if(data_fid == NULL)
+ {
+ IPACMDBG("unable to allocate memory for event data_fid\n");
+ return IPACM_FAILURE;
+ }
+ data_fid->if_index = msg_ptr->nl_link_info.metainfo.ifi_index;
+
+
+ evt_data.evt_data = data_fid;
+ IPACM_EvtDispatcher::PostEvt(&evt_data);
+
+ }
+ }
+ break;
+
+ case RTM_DELLINK:
+ IPACMDBG("\n GOT dellink event\n");
+ msg_ptr->type = nlh->nlmsg_type;
+ msg_ptr->link_event = true;
+ IPACMDBG("entering rtm decode\n");
+ if(IPACM_SUCCESS != ipa_nl_decode_rtm_link(buffer, buflen, &(msg_ptr->nl_link_info)))
+ {
+ IPACMERR("Failed to decode rtm link message\n");
+ return IPACM_FAILURE;
+ }
+ else
+ {
+ ret_val = ipa_get_if_name(dev_name, msg_ptr->nl_link_info.metainfo.ifi_index);
+ if(ret_val != IPACM_SUCCESS)
+ {
+ IPACMERR("Error while getting interface name\n");
+ }
+ IPACMDBG("Interface %s bring down \n", dev_name);
+
+ /* post link down to command queue */
+ evt_data.event = IPA_LINK_DOWN_EVENT;
+ data_fid = (ipacm_event_data_fid *)malloc(sizeof(ipacm_event_data_fid));
+ if(data_fid == NULL)
+ {
+ IPACMDBG("unable to allocate memory for event data_fid\n");
+ return IPACM_FAILURE;
+ }
+
+ data_fid->if_index = msg_ptr->nl_link_info.metainfo.ifi_index;
+
+ IPACMDBG("posting IPA_LINK_DOWN_EVENT with if idnex:%d\n",
+ data_fid->if_index);
+ evt_data.evt_data = data_fid;
+ IPACM_EvtDispatcher::PostEvt(&evt_data);
+ /* finish command queue */
+ }
+ break;
+
+ case RTM_NEWADDR:
+ IPACMDBG("\n GOT RTM_NEWADDR event\n");
+ if(IPACM_SUCCESS != ipa_nl_decode_rtm_addr(buffer, buflen, &(msg_ptr->nl_addr_info)))
+ {
+ IPACMERR("Failed to decode rtm addr message\n");
+ return IPACM_FAILURE;
+ }
+ else
+ {
+ ret_val = ipa_get_if_name(dev_name, msg_ptr->nl_addr_info.metainfo.ifa_index);
+ if(ret_val != IPACM_SUCCESS)
+ {
+ IPACMERR("Error while getting interface name\n");
+ }
+ IPACMDBG("Interface %s \n", dev_name);
+
+ data_addr = (ipacm_event_data_addr *)malloc(sizeof(ipacm_event_data_addr));
+ if(data_addr == NULL)
+ {
+ IPACMDBG("unable to allocate memory for event data_addr\n");
+ return IPACM_FAILURE;
+ }
+
+ if(AF_INET6 == msg_ptr->nl_addr_info.attr_info.prefix_addr.ss_family)
+ {
+ data_addr->iptype = IPA_IP_v6;
+ IPACMDBG("IFA_ADDRESS:IPV6 %04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x\n",
+ (uint16_t)(ntohs(((uint64_t *)&(msg_ptr->nl_addr_info.attr_info.prefix_addr).__ss_padding)[0])),
+ (uint16_t)(ntohs(((uint64_t *)&(msg_ptr->nl_addr_info.attr_info.prefix_addr).__ss_padding)[0] >> 16)),
+ (uint16_t)(ntohs(((uint64_t *)&(msg_ptr->nl_addr_info.attr_info.prefix_addr).__ss_padding)[0] >> 32)),
+ (uint16_t)(ntohs(((uint64_t *)&(msg_ptr->nl_addr_info.attr_info.prefix_addr).__ss_padding)[0] >> 48)),
+ (uint16_t)(ntohs(((uint64_t *)&(msg_ptr->nl_addr_info.attr_info.prefix_addr).__ss_padding)[1])),
+ (uint16_t)(ntohs(((uint64_t *)&(msg_ptr->nl_addr_info.attr_info.prefix_addr).__ss_padding)[1] >> 16)),
+ (uint16_t)(ntohs(((uint64_t *)&(msg_ptr->nl_addr_info.attr_info.prefix_addr).__ss_padding)[1] >> 32)),
+ (uint16_t)(ntohs(((uint64_t *)&(msg_ptr->nl_addr_info.attr_info.prefix_addr).__ss_padding)[1] >> 48)));
+
+ memcpy(data_addr->ipv6_addr,
+ msg_ptr->nl_addr_info.attr_info.prefix_addr.__ss_padding,
+ sizeof(data_addr->ipv6_addr));
+ }
+ else
+ {
+ data_addr->iptype = IPA_IP_v4;
+ IPACMDBG("IFA_ADDRESS:IPV4 %d.%d.%d.%d\n",
+ (unsigned char)(*(unsigned int *)&(msg_ptr->nl_addr_info.attr_info.prefix_addr).__ss_padding),
+ (unsigned char)(*(unsigned int *)&(msg_ptr->nl_addr_info.attr_info.prefix_addr).__ss_padding >> 8),
+ (unsigned char)(*(unsigned int *)&(msg_ptr->nl_addr_info.attr_info.prefix_addr).__ss_padding >> 16),
+ (unsigned char)(*(unsigned int *)&(msg_ptr->nl_addr_info.attr_info.prefix_addr).__ss_padding >> 24));
+
+ memcpy(&data_addr->ipv4_addr,
+ msg_ptr->nl_addr_info.attr_info.prefix_addr.__ss_padding,
+ sizeof(data_addr->ipv4_addr));
+ data_addr->ipv4_addr = ntohl(data_addr->ipv4_addr);
+
+ }
+
+ evt_data.event = IPA_ADDR_ADD_EVENT;
+ data_addr->if_index = msg_ptr->nl_addr_info.metainfo.ifa_index;
+
+ IPACMDBG("Posting IPA_ADDR_ADD_EVENT with if index:%d, ipv4 addr:0x%x\n",
+ data_addr->if_index,
+ data_addr->ipv4_addr);
+ evt_data.evt_data = data_addr;
+ IPACM_EvtDispatcher::PostEvt(&evt_data);
+ }
+ break;
+
+ case RTM_NEWROUTE:
+
+ if(IPACM_SUCCESS != ipa_nl_decode_rtm_route(buffer, buflen, &(msg_ptr->nl_route_info)))
+ {
+ IPACMERR("Failed to decode rtm route message\n");
+ return IPACM_FAILURE;
+ }
+
+ IPACMDBG("In case RTM_NEWROUTE\n");
+ IPACMDBG("rtm_type: %d\n", msg_ptr->nl_route_info.metainfo.rtm_type);
+ IPACMDBG("ss_padding: %d\n", ((unsigned char)(*(unsigned int *)&(msg_ptr->nl_route_info.attr_info.dst_addr).__ss_padding >> 24)));
+ IPACMDBG("rtm_type: %d\n", msg_ptr->nl_route_info.metainfo.rtm_type);
+ IPACMDBG("protocol: %d\n", msg_ptr->nl_route_info.metainfo.rtm_protocol);
+ IPACMDBG("rtm_scope: %d\n", msg_ptr->nl_route_info.metainfo.rtm_scope);
+ IPACMDBG("rtm_table: %d\n", msg_ptr->nl_route_info.metainfo.rtm_table);
+ IPACMDBG("rtm_family: %d\n", msg_ptr->nl_route_info.metainfo.rtm_family);
+ IPACMDBG("param_mask: 0x%x\n", msg_ptr->nl_route_info.attr_info.param_mask);
+
+ /* ipv4 interface route and its subnet mask */
+ if((msg_ptr->nl_route_info.metainfo.rtm_type == RTN_BROADCAST) &&
+ ((unsigned char)(*(unsigned int *)&(msg_ptr->nl_route_info.attr_info.dst_addr).__ss_padding >> 24)) != 0)
+ {
+ if(IPACM_SUCCESS !=
+ find_mask((unsigned char)(*(unsigned int *)&(msg_ptr->nl_route_info.attr_info.dst_addr).__ss_padding >> 24), &mask_value))
+ {
+ IPACMERR("Failed to decode rtm_addroute message\n");
+ }
+ else
+ {
+ IPACMDBG("\n GOT useful RTM_NEWROUTE event\n");
+
+ /* take care of subnet mask */
+ if(msg_ptr->nl_route_info.attr_info.param_mask & IPA_RTA_PARAM_DST)
+ {
+ IPACMDBG("DST_ADDRESS:IPV4 %d.%d.%d.0\n",
+ (unsigned char)(*(unsigned int *)&(msg_ptr->nl_route_info.attr_info.dst_addr).__ss_padding),
+ (unsigned char)(*(unsigned int *)&(msg_ptr->nl_route_info.attr_info.dst_addr).__ss_padding >> 8),
+ (unsigned char)(*(unsigned int *)&(msg_ptr->nl_route_info.attr_info.dst_addr).__ss_padding >> 16));
+ IPACMDBG("MASK:IPV4 255.255.255.%d\n", mask_value);
+ ret_val = ipa_get_if_name(dev_name, msg_ptr->nl_route_info.attr_info.oif_index);
+ if(ret_val != IPACM_SUCCESS)
+ {
+ IPACMERR("Error while getting interface name");
+ }
+ IPACMDBG("RTA_OIF, output Interface %s \n", dev_name);
+ memcpy(&dst_pre_addr.__ss_padding,
+ msg_ptr->nl_route_info.attr_info.dst_addr.__ss_padding,
+ sizeof(dst_pre_addr.__ss_padding));
+ memcpy(&dev_pre_name,
+ dev_name,
+ sizeof(dev_pre_name));
+ IPACMDBG("save pre_DST_ADDRESS:IPV4 %d.%d.%d.%d %s\n",
+ (unsigned char)(*(unsigned int *)&(dst_pre_addr).__ss_padding),
+ (unsigned char)(*(unsigned int *)&(dst_pre_addr).__ss_padding >> 8),
+ (unsigned char)(*(unsigned int *)&(dst_pre_addr).__ss_padding >> 16),
+ (unsigned char)(*(unsigned int *)&(dst_pre_addr).__ss_padding >> 24), dev_pre_name);
+ }
+
+ data_addr = (ipacm_event_data_addr *)malloc(sizeof(ipacm_event_data_addr));
+ if(data_addr == NULL)
+ {
+ IPACMERR("unable to allocate memory for event data_addr\n");
+ return IPACM_FAILURE;
+ }
+
+ if(msg_ptr->nl_route_info.attr_info.param_mask & IPA_RTA_PARAM_PRIORITY)
+ {
+ IPACMDBG("route add -net %d.%d.%d.0 netmask 255.255.255.%d dev %s metric %d \n",
+ (unsigned char)(*(unsigned int *)&(msg_ptr->nl_route_info.attr_info.dst_addr).__ss_padding),
+ (unsigned char)(*(unsigned int *)&(msg_ptr->nl_route_info.attr_info.dst_addr).__ss_padding >> 8),
+ (unsigned char)(*(unsigned int *)&(msg_ptr->nl_route_info.attr_info.dst_addr).__ss_padding >> 16),
+ mask_value,
+ dev_pre_name,
+ msg_ptr->nl_route_info.attr_info.priority);
+ }
+ else
+ {
+ IPACMDBG("route add -net %d.%d.%d.0 netmask 255.255.255.%d dev %s \n",
+ (unsigned char)(*(unsigned int *)&(msg_ptr->nl_route_info.attr_info.dst_addr).__ss_padding),
+ (unsigned char)(*(unsigned int *)&(msg_ptr->nl_route_info.attr_info.dst_addr).__ss_padding >> 8),
+ (unsigned char)(*(unsigned int *)&(msg_ptr->nl_route_info.attr_info.dst_addr).__ss_padding >> 16),
+ mask_value,
+ dev_name);
+ }
+
+ memcpy(&if_ipv4_addr, msg_ptr->nl_route_info.attr_info.dst_addr.__ss_padding,
+ sizeof(if_ipv4_addr));
+ if_ipv4_addr = (if_ipv4_addr << 8) >> 8;
+ temp = (-1) << 8;
+ temp = temp | mask_value;
+
+ /* insert to command queue */
+ evt_data.event = IPA_ROUTE_ADD_EVENT;
+
+ data_addr->if_index = msg_ptr->nl_route_info.attr_info.oif_index;
+ data_addr->iptype = IPA_IP_v4;
+ data_addr->ipv4_addr = ntohl(if_ipv4_addr);
+ data_addr->ipv4_addr_mask = ntohl(if_ipipv4_addr_mask);
+
+ IPACMDBG("Posting IPA_ROUTE_ADD_EVENT with if index:%d, ipv4 address 0x%x\n",
+ data_addr->if_index,
+ data_addr->ipv4_addr);
+ evt_data.evt_data = data_addr;
+ IPACM_EvtDispatcher::PostEvt(&evt_data);
+ /* finish command queue */
+ }
+ }
+
+
+ /* take care of route add default route & uniroute */
+ if((msg_ptr->nl_route_info.metainfo.rtm_type == RTN_UNICAST) &&
+ (msg_ptr->nl_route_info.metainfo.rtm_protocol == RTPROT_BOOT) &&
+ (msg_ptr->nl_route_info.metainfo.rtm_scope == RT_SCOPE_UNIVERSE) &&
+ (msg_ptr->nl_route_info.metainfo.rtm_table == RT_TABLE_MAIN))
+ {
+ IPACMDBG("\n GOT RTM_NEWROUTE event\n");
+
+ if(msg_ptr->nl_route_info.attr_info.param_mask & IPA_RTA_PARAM_DST)
+ {
+ ret_val = ipa_get_if_name(dev_name, msg_ptr->nl_route_info.attr_info.oif_index);
+ if(ret_val != IPACM_SUCCESS)
+ {
+ IPACMERR("Error while getting interface name\n");
+ }
+
+ IPACMDBG("route add -host %d.%d.%d.%d gw %d.%d.%d.%d dev %s\n",
+ (unsigned char)(*(unsigned int *)&(msg_ptr->nl_route_info.attr_info.dst_addr).__ss_padding),
+ (unsigned char)(*(unsigned int *)&(msg_ptr->nl_route_info.attr_info.dst_addr).__ss_padding >> 8),
+ (unsigned char)(*(unsigned int *)&(msg_ptr->nl_route_info.attr_info.dst_addr).__ss_padding >> 16),
+ (unsigned char)(*(unsigned int *)&(msg_ptr->nl_route_info.attr_info.dst_addr).__ss_padding >> 24),
+ (unsigned char)(*(unsigned int *)&(msg_ptr->nl_route_info.attr_info.gateway_addr).__ss_padding),
+ (unsigned char)(*(unsigned int *)&(msg_ptr->nl_route_info.attr_info.gateway_addr).__ss_padding >> 8),
+ (unsigned char)(*(unsigned int *)&(msg_ptr->nl_route_info.attr_info.gateway_addr).__ss_padding >> 16),
+ (unsigned char)(*(unsigned int *)&(msg_ptr->nl_route_info.attr_info.gateway_addr).__ss_padding >> 24),
+ dev_name
+ );
+
+ /* insert to command queue */
+ memcpy(&if_ipv4_addr, msg_ptr->nl_route_info.attr_info.dst_addr.__ss_padding,
+ sizeof(if_ipv4_addr));
+ temp = (-1);
+
+ evt_data.event = IPA_ROUTE_ADD_EVENT;
+ data_addr = (ipacm_event_data_addr *)malloc(sizeof(ipacm_event_data_addr));
+ if(data_addr == NULL)
+ {
+ IPACMDBG("unable to allocate memory for event data_addr\n");
+ return IPACM_FAILURE;
+ }
+
+ data_addr->if_index = msg_ptr->nl_route_info.attr_info.oif_index;
+ data_addr->iptype = IPA_IP_v4;
+ data_addr->ipv4_addr = ntohl(if_ipv4_addr);
+ data_addr->ipv4_addr_mask = ntohl(if_ipipv4_addr_mask);
+
+ IPACMDBG("Posting IPA_ROUTE_ADD_EVENT with if index:%d, ipv4 address 0x%x, mask:0x%x\n",
+ data_addr->if_index,
+ data_addr->ipv4_addr,
+ data_addr->ipv4_addr_mask);
+ evt_data.evt_data = data_addr;
+ IPACM_EvtDispatcher::PostEvt(&evt_data);
+ /* finish command queue */
+
+ }
+ else
+ {
+ ret_val = ipa_get_if_name(dev_name, msg_ptr->nl_route_info.attr_info.oif_index);
+ if(ret_val != IPACM_SUCCESS)
+ {
+ IPACMERR("Error while getting interface name\n");
+ }
+
+ if(AF_INET6 == msg_ptr->nl_route_info.metainfo.rtm_family)
+ {
+ /* insert to command queue */
+ data_addr = (ipacm_event_data_addr *)malloc(sizeof(ipacm_event_data_addr));
+ if(data_addr == NULL)
+ {
+ IPACMERR("unable to allocate memory for event data_addr\n");
+ return IPACM_FAILURE;
+ }
+
+ if(msg_ptr->nl_route_info.attr_info.param_mask & IPA_RTA_PARAM_PRIORITY)
+ {
+ IPACMDBG("ip -6 route add default dev %s metric %d\n",
+ dev_name,
+ msg_ptr->nl_route_info.attr_info.priority);
+ }
+ else
+ {
+ IPACMDBG("ip -6 route add default dev %s\n", dev_name);
+ }
+
+ memcpy(data_addr->ipv6_addr,
+ msg_ptr->nl_route_info.attr_info.dst_addr.__ss_padding,
+ sizeof(data_addr->ipv6_addr));
+
+ memcpy(data_addr->ipv6_addr_mask,
+ msg_ptr->nl_route_info.attr_info.dst_addr.__ss_padding,
+ sizeof(data_addr->ipv6_addr_mask));
+
+ evt_data.event = IPA_ROUTE_ADD_EVENT;
+ data_addr->if_index = msg_ptr->nl_route_info.attr_info.oif_index;
+ data_addr->iptype = IPA_IP_v6;
+
+ IPACMDBG("Posting IPA_ROUTE_ADD_EVENT with if index:%d, ipv6 address\n",
+ data_addr->if_index);
+ evt_data.evt_data = data_addr;
+ IPACM_EvtDispatcher::PostEvt(&evt_data);
+ /* finish command queue */
+
+ }
+ else
+ {
+ IPACMDBG("route add default gw %d.%d.%d.%d dev %s dstIP: %d.%d.%d.%d\n",
+ (unsigned char)(*(unsigned int *)&(msg_ptr->nl_route_info.attr_info.gateway_addr).__ss_padding),
+ (unsigned char)(*(unsigned int *)&(msg_ptr->nl_route_info.attr_info.gateway_addr).__ss_padding >> 8),
+ (unsigned char)(*(unsigned int *)&(msg_ptr->nl_route_info.attr_info.gateway_addr).__ss_padding >> 16),
+ (unsigned char)(*(unsigned int *)&(msg_ptr->nl_route_info.attr_info.gateway_addr).__ss_padding >> 24),
+ dev_name,
+ (unsigned char)(*(unsigned int *)&(msg_ptr->nl_route_info.attr_info.dst_addr).__ss_padding),
+ (unsigned char)(*(unsigned int *)&(msg_ptr->nl_route_info.attr_info.dst_addr).__ss_padding >> 8),
+ (unsigned char)(*(unsigned int *)&(msg_ptr->nl_route_info.attr_info.dst_addr).__ss_padding >> 16),
+ (unsigned char)(*(unsigned int *)&(msg_ptr->nl_route_info.attr_info.dst_addr).__ss_padding >> 24)
+ );
+
+ /* insert to command queue */
+ data_addr = (ipacm_event_data_addr *)malloc(sizeof(ipacm_event_data_addr));
+ if(data_addr == NULL)
+ {
+ IPACMERR("unable to allocate memory for event data_addr\n");
+ return IPACM_FAILURE;
+ }
+
+ memcpy(&if_ipv4_addr, msg_ptr->nl_route_info.attr_info.dst_addr.__ss_padding,
+ sizeof(if_ipv4_addr));
+ memcpy(&if_ipipv4_addr_mask, msg_ptr->nl_route_info.attr_info.dst_addr.__ss_padding,
+ sizeof(if_ipipv4_addr_mask));
+
+ evt_data.event = IPA_ROUTE_ADD_EVENT;
+ data_addr->if_index = msg_ptr->nl_route_info.attr_info.oif_index;
+ data_addr->iptype = IPA_IP_v4;
+ data_addr->ipv4_addr = ntohl(if_ipv4_addr);
+ data_addr->ipv4_addr_mask = ntohl(if_ipipv4_addr_mask);
+
+ IPACMDBG("Posting IPA_ROUTE_ADD_EVENT with if index:%d, ipv4 addr:0x%x and maxk: 0x%x\n",
+ data_addr->if_index,
+ data_addr->ipv4_addr,
+ data_addr->ipv4_addr_mask);
+ evt_data.evt_data = data_addr;
+ IPACM_EvtDispatcher::PostEvt(&evt_data);
+ /* finish command queue */
+ }
+ }
+ }
+
+ /* ipv6 routing table */
+ if((AF_INET6 == msg_ptr->nl_route_info.metainfo.rtm_family) &&
+ (msg_ptr->nl_route_info.metainfo.rtm_type == RTN_UNICAST) &&
+ (msg_ptr->nl_route_info.metainfo.rtm_protocol == RTPROT_KERNEL) &&
+ (msg_ptr->nl_route_info.metainfo.rtm_table == RT_TABLE_MAIN))
+ {
+ IPACMDBG("\n GOT valid v6-RTM_NEWROUTE event\n");
+ ret_val = ipa_get_if_name(dev_name, msg_ptr->nl_route_info.attr_info.oif_index);
+ if(ret_val != IPACM_SUCCESS)
+ {
+ IPACMERR("Error while getting interface name\n");
+ return IPACM_FAILURE;
+ }
+
+ if(msg_ptr->nl_route_info.attr_info.param_mask & IPA_RTA_PARAM_DST)
+ {
+ IPACMDBG("Route ADD IPV6 DST: %04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x/%d, metric %d, dev %s\n",
+ (uint16_t)(ntohs(((uint64_t *)&(msg_ptr->nl_route_info.attr_info.dst_addr).__ss_padding)[0])),
+ (uint16_t)(ntohs(((uint64_t *)&(msg_ptr->nl_route_info.attr_info.dst_addr).__ss_padding)[0] >> 16)),
+ (uint16_t)(ntohs(((uint64_t *)&(msg_ptr->nl_route_info.attr_info.dst_addr).__ss_padding)[0] >> 32)),
+ (uint16_t)(ntohs(((uint64_t *)&(msg_ptr->nl_route_info.attr_info.dst_addr).__ss_padding)[0] >> 48)),
+ (uint16_t)(ntohs(((uint64_t *)&(msg_ptr->nl_route_info.attr_info.dst_addr).__ss_padding)[1])),
+ (uint16_t)(ntohs(((uint64_t *)&(msg_ptr->nl_route_info.attr_info.dst_addr).__ss_padding)[1] >> 16)),
+ (uint16_t)(ntohs(((uint64_t *)&(msg_ptr->nl_route_info.attr_info.dst_addr).__ss_padding)[1] >> 32)),
+ (uint16_t)(ntohs(((uint64_t *)&(msg_ptr->nl_route_info.attr_info.dst_addr).__ss_padding)[1] >> 48)),
+ msg_ptr->nl_route_info.metainfo.rtm_dst_len,
+ msg_ptr->nl_route_info.attr_info.priority,
+ dev_name);
+
+ /* insert to command queue */
+ data_addr = (ipacm_event_data_addr *)malloc(sizeof(ipacm_event_data_addr));
+ if(data_addr == NULL)
+ {
+ IPACMDBG("unable to allocate memory for event data_addr\n");
+ return IPACM_FAILURE;
+ }
+
+ memcpy(data_addr->ipv6_addr,
+ msg_ptr->nl_route_info.attr_info.dst_addr.__ss_padding,
+ sizeof(data_addr->ipv6_addr));
+
+ mask_value_v6 = msg_ptr->nl_route_info.metainfo.rtm_dst_len;
+ for(mask_index = 0; mask_index < 4; mask_index++)
+ {
+ if(mask_value_v6 >= 32)
+ {
+ mask_v6(32, &data_addr->ipv6_addr_mask[mask_index]);
+ mask_value_v6 -= 32;
+ }
+ else
+ {
+ mask_v6(mask_value_v6, &data_addr->ipv6_addr_mask[mask_index]);
+ mask_value_v6 = 0;
+ }
+ }
+
+ IPACMDBG("ADD IPV6 MASK %d: %08x:%08x:%08x:%08x \n",
+ msg_ptr->nl_route_info.metainfo.rtm_dst_len,
+ data_addr->ipv6_addr_mask[0],
+ data_addr->ipv6_addr_mask[1],
+ data_addr->ipv6_addr_mask[2],
+ data_addr->ipv6_addr_mask[3]);
+
+ evt_data.event = IPA_ROUTE_ADD_EVENT;
+ data_addr->if_index = msg_ptr->nl_route_info.attr_info.oif_index;
+ data_addr->iptype = IPA_IP_v6;
+
+ IPACMDBG("Posting IPA_ROUTE_ADD_EVENT with if index:%d, ipv6 addr\n",
+ data_addr->if_index);
+ evt_data.evt_data = data_addr;
+ IPACM_EvtDispatcher::PostEvt(&evt_data);
+ /* finish command queue */
+ }
+
+ if(msg_ptr->nl_route_info.attr_info.param_mask & IPA_RTA_PARAM_GATEWAY)
+ {
+ IPACMDBG("Route ADD ::/0 Next Hop: %04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x, metric %d, dev %s\n",
+ (uint16_t)(ntohs(((uint64_t *)&(msg_ptr->nl_route_info.attr_info.gateway_addr).__ss_padding)[0])),
+ (uint16_t)(ntohs(((uint64_t *)&(msg_ptr->nl_route_info.attr_info.gateway_addr).__ss_padding)[0] >> 16)),
+ (uint16_t)(ntohs(((uint64_t *)&(msg_ptr->nl_route_info.attr_info.gateway_addr).__ss_padding)[0] >> 32)),
+ (uint16_t)(ntohs(((uint64_t *)&(msg_ptr->nl_route_info.attr_info.gateway_addr).__ss_padding)[0] >> 48)),
+ (uint16_t)(ntohs(((uint64_t *)&(msg_ptr->nl_route_info.attr_info.gateway_addr).__ss_padding)[1])),
+ (uint16_t)(ntohs(((uint64_t *)&(msg_ptr->nl_route_info.attr_info.gateway_addr).__ss_padding)[1] >> 16)),
+ (uint16_t)(ntohs(((uint64_t *)&(msg_ptr->nl_route_info.attr_info.gateway_addr).__ss_padding)[1] >> 32)),
+ (uint16_t)(ntohs(((uint64_t *)&(msg_ptr->nl_route_info.attr_info.gateway_addr).__ss_padding)[1] >> 48)),
+ msg_ptr->nl_route_info.attr_info.priority,
+ dev_name);
+
+ /* insert to command queue */
+ data_addr = (ipacm_event_data_addr *)malloc(sizeof(ipacm_event_data_addr));
+ if(data_addr == NULL)
+ {
+ IPACMERR("unable to allocate memory for event data_addr\n");
+ return IPACM_FAILURE;
+ }
+
+ memcpy(data_addr->ipv6_addr, msg_ptr->nl_route_info.attr_info.dst_addr.__ss_padding,
+ sizeof(data_addr->ipv6_addr));
+ memcpy(data_addr->ipv6_addr_mask, msg_ptr->nl_route_info.attr_info.dst_addr.__ss_padding,
+ sizeof(data_addr->ipv6_addr_mask));
+
+ evt_data.event = IPA_ROUTE_ADD_EVENT;
+ data_addr->if_index = msg_ptr->nl_route_info.attr_info.oif_index;
+ data_addr->iptype = IPA_IP_v6;
+
+ IPACMDBG("posting IPA_ROUTE_ADD_EVENT with if index:%d, ipv6 address\n",
+ data_addr->if_index);
+ evt_data.evt_data = data_addr;
+ IPACM_EvtDispatcher::PostEvt(&evt_data);
+ /* finish command queue */
+ }
+
+ }
+ break;
+
+ case RTM_DELROUTE:
+ if(IPACM_SUCCESS != ipa_nl_decode_rtm_route(buffer, buflen, &(msg_ptr->nl_route_info)))
+ {
+ IPACMDBG("Failed to decode rtm route message\n");
+ return IPACM_FAILURE;
+ }
+
+ if((msg_ptr->nl_route_info.metainfo.rtm_type == RTN_BROADCAST) &&
+ ((unsigned char)(*(unsigned int *)&(msg_ptr->nl_route_info.attr_info.dst_addr).__ss_padding >> 24)) != 0)
+ {
+ if(IPACM_SUCCESS != find_mask((unsigned char)(*(unsigned int *)&(msg_ptr->nl_route_info.attr_info.dst_addr).__ss_padding >> 24), &mask_value))
+ {
+ IPACMERR("Failed to decode rtm_delroute message\n");
+ }
+ else
+ {
+ IPACMDBG("\n GOT useful RTM_DELROUTE event\n");
+
+ /* take care of subnet mask */
+ if(msg_ptr->nl_route_info.attr_info.param_mask & IPA_RTA_PARAM_DST)
+ {
+ IPACMDBG("DST_ADDRESS:IPV4 %d.%d.%d.0\n",
+ (unsigned char)(*(unsigned int *)&(msg_ptr->nl_route_info.attr_info.dst_addr).__ss_padding),
+ (unsigned char)(*(unsigned int *)&(msg_ptr->nl_route_info.attr_info.dst_addr).__ss_padding >> 8),
+ (unsigned char)(*(unsigned int *)&(msg_ptr->nl_route_info.attr_info.dst_addr).__ss_padding >> 16));
+ IPACMDBG("MASK:IPV4 255.255.255.%d\n", mask_value);
+ ret_val = ipa_get_if_name(dev_name, msg_ptr->nl_route_info.attr_info.oif_index);
+ if(ret_val != IPACM_SUCCESS)
+ {
+ IPACMERR("Error while getting interface name\n");
+ }
+ IPACMDBG("RTA_OIF, output Interface %s \n", dev_name);
+ }
+ IPACMDBG("route del -net %d.%d.%d.0 netmask 255.255.255.%d dev %s \n",
+ (unsigned char)(*(unsigned int *)&(msg_ptr->nl_route_info.attr_info.dst_addr).__ss_padding),
+ (unsigned char)(*(unsigned int *)&(msg_ptr->nl_route_info.attr_info.dst_addr).__ss_padding >> 8),
+ (unsigned char)(*(unsigned int *)&(msg_ptr->nl_route_info.attr_info.dst_addr).__ss_padding >> 16),
+ mask_value,
+ dev_name);
+
+ /* post event to command queue */
+ data_addr = (ipacm_event_data_addr *)malloc(sizeof(ipacm_event_data_addr));
+ if(data_addr == NULL)
+ {
+ IPACMERR("unable to allocate memory for event data_addr\n");
+ return IPACM_FAILURE;
+ }
+
+ if(msg_ptr->nl_route_info.attr_info.param_mask & IPA_RTA_PARAM_PRIORITY)
+ {
+ IPACMDBG("Priority %d \n",
+ msg_ptr->nl_route_info.attr_info.priority);
+ }
+ else;
+
+ memcpy(&if_ipv4_addr, msg_ptr->nl_route_info.attr_info.dst_addr.__ss_padding,
+ sizeof(if_ipv4_addr));
+ if_ipv4_addr = (if_ipv4_addr << 8) >> 8;
+ temp = (-1) << 8;
+ temp = temp | mask_value;
+ if_ipipv4_addr_mask = ntohl(temp);
+
+ evt_data.event = IPA_ROUTE_DEL_EVENT;
+ data_addr->if_index = msg_ptr->nl_route_info.attr_info.oif_index;
+ data_addr->iptype = IPA_IP_v4;
+ data_addr->ipv4_addr = ntohl(if_ipv4_addr);
+ data_addr->ipv4_addr_mask = ntohl(if_ipipv4_addr_mask);
+
+ IPACMDBG("Posting IPA_ROUTE_DEL_EVENT with ifindex:%d, ipv4 address 0x%x, mask:0x%x\n",
+ data_addr->if_index,
+ data_addr->ipv4_addr,
+ data_addr->ipv4_addr_mask);
+ evt_data.evt_data = data_addr;
+ IPACM_EvtDispatcher::PostEvt(&evt_data);
+ /* finish command queue */
+ }
+ }
+
+ /* take care of route delete of default route & uniroute */
+ if((msg_ptr->nl_route_info.metainfo.rtm_type == RTN_UNICAST) &&
+ (msg_ptr->nl_route_info.metainfo.rtm_protocol == RTPROT_BOOT) &&
+ (msg_ptr->nl_route_info.metainfo.rtm_scope == 0) &&
+ (msg_ptr->nl_route_info.metainfo.rtm_table == RT_TABLE_MAIN))
+ {
+
+ if(msg_ptr->nl_route_info.attr_info.param_mask & IPA_RTA_PARAM_DST)
+ {
+ ret_val = ipa_get_if_name(dev_name, msg_ptr->nl_route_info.attr_info.oif_index);
+ if(ret_val != IPACM_SUCCESS)
+ {
+ IPACMERR("Error while getting interface name\n");
+ }
+ IPACMDBG("route del -host %d.%d.%d.%d gw %d.%d.%d.%d dev %s\n",
+ (unsigned char)(*(unsigned int *)&(msg_ptr->nl_route_info.attr_info.dst_addr).__ss_padding),
+ (unsigned char)(*(unsigned int *)&(msg_ptr->nl_route_info.attr_info.dst_addr).__ss_padding >> 8),
+ (unsigned char)(*(unsigned int *)&(msg_ptr->nl_route_info.attr_info.dst_addr).__ss_padding >> 16),
+ (unsigned char)(*(unsigned int *)&(msg_ptr->nl_route_info.attr_info.dst_addr).__ss_padding >> 24),
+ (unsigned char)(*(unsigned int *)&(msg_ptr->nl_route_info.attr_info.gateway_addr).__ss_padding),
+ (unsigned char)(*(unsigned int *)&(msg_ptr->nl_route_info.attr_info.gateway_addr).__ss_padding >> 8),
+ (unsigned char)(*(unsigned int *)&(msg_ptr->nl_route_info.attr_info.gateway_addr).__ss_padding >> 16),
+ (unsigned char)(*(unsigned int *)&(msg_ptr->nl_route_info.attr_info.gateway_addr).__ss_padding >> 24),
+ dev_name
+ );
+
+ /* insert to command queue */
+ data_addr = (ipacm_event_data_addr *)malloc(sizeof(ipacm_event_data_addr));
+ if(data_addr == NULL)
+ {
+ IPACMERR("unable to allocate memory for event data_addr\n");
+ return IPACM_FAILURE;
+ }
+ memcpy(&if_ipv4_addr, msg_ptr->nl_route_info.attr_info.dst_addr.__ss_padding,
+ sizeof(if_ipv4_addr));
+ temp = (-1);
+ if_ipipv4_addr_mask = ntohl(temp);
+
+ evt_data.event = IPA_ROUTE_DEL_EVENT;
+ data_addr->if_index = msg_ptr->nl_route_info.attr_info.oif_index;
+ data_addr->iptype = IPA_IP_v4;
+ data_addr->ipv4_addr = ntohl(if_ipv4_addr);
+ data_addr->ipv4_addr_mask = ntohl(if_ipipv4_addr_mask);
+
+ IPACMDBG("Posting event IPA_ROUTE_DEL_EVENT with if index:%d, ipv4 address 0x%x, mask:0x%x\n",
+ data_addr->if_index,
+ data_addr->ipv4_addr,
+ data_addr->ipv4_addr_mask);
+ evt_data.evt_data = data_addr;
+ IPACM_EvtDispatcher::PostEvt(&evt_data);
+ /* finish command queue */
+ }
+ else
+ {
+ ret_val = ipa_get_if_name(dev_name, msg_ptr->nl_route_info.attr_info.oif_index);
+ if(ret_val != IPACM_SUCCESS)
+ {
+ IPACMERR("Error while getting interface name\n");
+ }
+
+ /* insert to command queue */
+ data_addr = (ipacm_event_data_addr *)malloc(sizeof(ipacm_event_data_addr));
+ if(data_addr == NULL)
+ {
+ IPACMERR("unable to allocate memory for event data_addr\n");
+ return IPACM_FAILURE;
+ }
+
+ if(AF_INET6 == msg_ptr->nl_route_info.metainfo.rtm_family)
+ {
+ if(msg_ptr->nl_route_info.attr_info.param_mask & IPA_RTA_PARAM_PRIORITY)
+ {
+ IPACMDBG("ip -6 route del default dev %s metric %d\n",
+ dev_name,
+ msg_ptr->nl_route_info.attr_info.priority);
+ }
+ else
+ {
+ IPACMDBG("ip -6 route del default dev %s\n", dev_name);
+ }
+ memcpy(data_addr->ipv6_addr, msg_ptr->nl_route_info.attr_info.dst_addr.__ss_padding,
+ sizeof(data_addr->ipv6_addr));
+ memcpy(data_addr->ipv6_addr_mask, msg_ptr->nl_route_info.attr_info.dst_addr.__ss_padding,
+ sizeof(data_addr->ipv6_addr_mask));
+ data_addr->iptype = IPA_IP_v6;
+ }
+ else
+ {
+ IPACMDBG("route del default gw %d.%d.%d.%d dev %s\n",
+ (unsigned char)(*(unsigned int *)&(msg_ptr->nl_route_info.attr_info.gateway_addr).__ss_padding),
+ (unsigned char)(*(unsigned int *)&(msg_ptr->nl_route_info.attr_info.gateway_addr).__ss_padding >> 8),
+ (unsigned char)(*(unsigned int *)&(msg_ptr->nl_route_info.attr_info.gateway_addr).__ss_padding >> 16),
+ (unsigned char)(*(unsigned int *)&(msg_ptr->nl_route_info.attr_info.gateway_addr).__ss_padding >> 24),
+ dev_name);
+
+ memcpy(&data_addr->ipv4_addr,
+ msg_ptr->nl_route_info.attr_info.dst_addr.__ss_padding,
+ sizeof(data_addr->ipv4_addr));
+ data_addr->ipv4_addr = ntohl(data_addr->ipv4_addr);
+
+ memcpy(&data_addr->ipv4_addr_mask,
+ msg_ptr->nl_route_info.attr_info.dst_addr.__ss_padding,
+ sizeof(data_addr->ipv4_addr_mask));
+ data_addr->ipv4_addr_mask = ntohl(data_addr->ipv4_addr_mask);
+
+ data_addr->iptype = IPA_IP_v4;
+ }
+
+ evt_data.event = IPA_ROUTE_DEL_EVENT;
+ data_addr->if_index = msg_ptr->nl_route_info.attr_info.oif_index;
+
+ IPACMDBG("Posting IPA_ROUTE_DEL_EVENT with if index:%d\n",
+ data_addr->if_index);
+ evt_data.evt_data = data_addr;
+ IPACM_EvtDispatcher::PostEvt(&evt_data);
+ /* finish command queue */
+ }
+ }
+
+ /* ipv6 routing table */
+ if((AF_INET6 == msg_ptr->nl_route_info.metainfo.rtm_family) &&
+ (msg_ptr->nl_route_info.metainfo.rtm_type == RTN_UNICAST) &&
+ (msg_ptr->nl_route_info.metainfo.rtm_protocol == RTPROT_KERNEL) &&
+ (msg_ptr->nl_route_info.metainfo.rtm_table == RT_TABLE_MAIN))
+ {
+ IPACMDBG("\n GOT valid v6-RTM_DELROUTE event\n");
+ ret_val = ipa_get_if_name(dev_name, msg_ptr->nl_route_info.attr_info.oif_index);
+ if(ret_val != IPACM_SUCCESS)
+ {
+ IPACMERR("Error while getting interface name");
+ }
+
+ if(msg_ptr->nl_route_info.attr_info.param_mask & IPA_RTA_PARAM_DST)
+ {
+ IPACMDBG("DEL IPV6 DST: %04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x/%d, metric %d, dev %s\n",
+ (uint16_t)(ntohs(((uint64_t *)&(msg_ptr->nl_route_info.attr_info.dst_addr).__ss_padding)[0])),
+ (uint16_t)(ntohs(((uint64_t *)&(msg_ptr->nl_route_info.attr_info.dst_addr).__ss_padding)[0] >> 16)),
+ (uint16_t)(ntohs(((uint64_t *)&(msg_ptr->nl_route_info.attr_info.dst_addr).__ss_padding)[0] >> 32)),
+ (uint16_t)(ntohs(((uint64_t *)&(msg_ptr->nl_route_info.attr_info.dst_addr).__ss_padding)[0] >> 48)),
+ (uint16_t)(ntohs(((uint64_t *)&(msg_ptr->nl_route_info.attr_info.dst_addr).__ss_padding)[1])),
+ (uint16_t)(ntohs(((uint64_t *)&(msg_ptr->nl_route_info.attr_info.dst_addr).__ss_padding)[1] >> 16)),
+ (uint16_t)(ntohs(((uint64_t *)&(msg_ptr->nl_route_info.attr_info.dst_addr).__ss_padding)[1] >> 32)),
+ (uint16_t)(ntohs(((uint64_t *)&(msg_ptr->nl_route_info.attr_info.dst_addr).__ss_padding)[1] >> 48)),
+ msg_ptr->nl_route_info.metainfo.rtm_dst_len,
+ msg_ptr->nl_route_info.attr_info.priority,
+ dev_name);
+
+ /* insert to command queue */
+ data_addr = (ipacm_event_data_addr *)malloc(sizeof(ipacm_event_data_addr));
+ if(data_addr == NULL)
+ {
+ IPACMERR("unable to allocate memory for event data_addr\n");
+ return IPACM_FAILURE;
+ }
+
+ memcpy(data_addr->ipv6_addr, msg_ptr->nl_route_info.attr_info.dst_addr.__ss_padding,
+ sizeof(data_addr->ipv6_addr));
+
+ mask_value_v6 = msg_ptr->nl_route_info.metainfo.rtm_dst_len;
+ for(mask_index = 0; mask_index < 4; mask_index++)
+ {
+ IPACMDBG("%dst %d \n",
+ mask_index,
+ mask_value_v6);
+ if(mask_value_v6 >= 32)
+ {
+ mask_v6(32, &data_addr->ipv6_addr_mask[mask_index]);
+ mask_value_v6 -= 32;
+ IPACMDBG("%dst: %08x \n",
+ mask_index,
+ data_addr->ipv6_addr_mask[mask_index]);
+ }
+ else
+ {
+ mask_v6(mask_value_v6, data_addr->ipv6_addr_mask);
+ mask_value_v6 = 0;
+ IPACMDBG("%dst: %08x \n",
+ mask_index,
+ data_addr->ipv6_addr_mask[mask_index]);
+ }
+ }
+
+ IPACMDBG("DEL IPV6 MASK 0st: %08x ",
+ data_addr->ipv6_addr_mask[0]);
+ IPACMDBG("1st: %08x ",
+ data_addr->ipv6_addr_mask[1]);
+ IPACMDBG("2st: %08x ",
+ data_addr->ipv6_addr_mask[2]);
+ IPACMDBG("3st: %08x \n",
+ data_addr->ipv6_addr_mask[3]);
+
+ evt_data.event = IPA_ROUTE_DEL_EVENT;
+ data_addr->if_index = msg_ptr->nl_route_info.attr_info.oif_index;
+ data_addr->iptype = IPA_IP_v6;
+
+ IPACMDBG("posting event IPA_ROUTE_DEL_EVENT with if index:%d, ipv4 address\n",
+ data_addr->if_index);
+ evt_data.evt_data = data_addr;
+ IPACM_EvtDispatcher::PostEvt(&evt_data);
+ /* finish command queue */
+ }
+
+ if(msg_ptr->nl_route_info.attr_info.param_mask & IPA_RTA_PARAM_GATEWAY)
+ {
+ IPACMDBG("DEL ::/0 Next Hop: %04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x, metric %d, dev %s\n",
+ (uint16_t)(ntohs(((uint64_t *)&(msg_ptr->nl_route_info.attr_info.gateway_addr).__ss_padding)[0])),
+ (uint16_t)(ntohs(((uint64_t *)&(msg_ptr->nl_route_info.attr_info.gateway_addr).__ss_padding)[0] >> 16)),
+ (uint16_t)(ntohs(((uint64_t *)&(msg_ptr->nl_route_info.attr_info.gateway_addr).__ss_padding)[0] >> 32)),
+ (uint16_t)(ntohs(((uint64_t *)&(msg_ptr->nl_route_info.attr_info.gateway_addr).__ss_padding)[0] >> 48)),
+ (uint16_t)(ntohs(((uint64_t *)&(msg_ptr->nl_route_info.attr_info.gateway_addr).__ss_padding)[1])),
+ (uint16_t)(ntohs(((uint64_t *)&(msg_ptr->nl_route_info.attr_info.gateway_addr).__ss_padding)[1] >> 16)),
+ (uint16_t)(ntohs(((uint64_t *)&(msg_ptr->nl_route_info.attr_info.gateway_addr).__ss_padding)[1] >> 32)),
+ (uint16_t)(ntohs(((uint64_t *)&(msg_ptr->nl_route_info.attr_info.gateway_addr).__ss_padding)[1] >> 48)),
+ msg_ptr->nl_route_info.attr_info.priority,
+ dev_name);
+
+ /* insert to command queue */
+ data_addr = (ipacm_event_data_addr *)malloc(sizeof(ipacm_event_data_addr));
+ if(data_addr == NULL)
+ {
+ IPACMERR("unable to allocate memory for event data_addr\n");
+ return IPACM_FAILURE;
+ }
+ memcpy(data_addr->ipv6_addr, msg_ptr->nl_route_info.attr_info.dst_addr.__ss_padding,
+ sizeof(data_addr->ipv6_addr));
+ memcpy(data_addr->ipv6_addr_mask, msg_ptr->nl_route_info.attr_info.dst_addr.__ss_padding,
+ sizeof(data_addr->ipv6_addr_mask));
+
+ evt_data.event = IPA_ROUTE_DEL_EVENT;
+ data_addr->if_index = msg_ptr->nl_route_info.attr_info.oif_index;
+ data_addr->iptype = IPA_IP_v6;
+
+ IPACMDBG("Posting IPA_ROUTE_DEL_EVENT with if index: %d, ipv6 addr\n",
+ data_addr->if_index)
+ evt_data.evt_data = data_addr;
+ IPACM_EvtDispatcher::PostEvt(&evt_data);
+ /* finish command queue */
+ }
+
+ }
+ break;
+
+ case RTM_NEWNEIGH:
+ if(IPACM_SUCCESS != ipa_nl_decode_rtm_neigh(buffer, buflen, &(msg_ptr->nl_neigh_info)))
+ {
+ IPACMERR("Failed to decode rtm neighbor message\n");
+ return IPACM_FAILURE;
+ }
+
+ IPACMDBG("RTM_NEWNEIGH, ndm_state:0x%x", msg_ptr->nl_neigh_info.metainfo.ndm_state)
+ if((NUD_PERMANENT | NUD_STALE) & (msg_ptr->nl_neigh_info.metainfo.ndm_state))
+ {
+ IPACMDBG("\n GOT RTM_NEWNEIGH event\n");
+ /* insert to command queue */
+ data_all = (ipacm_event_data_all *)malloc(sizeof(ipacm_event_data_all));
+ if(data_all == NULL)
+ {
+ IPACMERR("unable to allocate memory for event data_all\n");
+ return IPACM_FAILURE;
+ }
+
+ if(AF_INET6 == msg_ptr->nl_neigh_info.attr_info.local_addr.ss_family)
+ {
+ IPACMDBG("IPV6 %04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x\n",
+ (uint16_t)(ntohs(((uint64_t *)&(msg_ptr->nl_neigh_info.attr_info.local_addr).__ss_padding)[0])),
+ (uint16_t)(ntohs(((uint64_t *)&(msg_ptr->nl_neigh_info.attr_info.local_addr).__ss_padding)[0] >> 16)),
+ (uint16_t)(ntohs(((uint64_t *)&(msg_ptr->nl_neigh_info.attr_info.local_addr).__ss_padding)[0] >> 32)),
+ (uint16_t)(ntohs(((uint64_t *)&(msg_ptr->nl_neigh_info.attr_info.local_addr).__ss_padding)[0] >> 48)),
+ (uint16_t)(ntohs(((uint64_t *)&(msg_ptr->nl_neigh_info.attr_info.local_addr).__ss_padding)[1])),
+ (uint16_t)(ntohs(((uint64_t *)&(msg_ptr->nl_neigh_info.attr_info.local_addr).__ss_padding)[1] >> 16)),
+ (uint16_t)(ntohs(((uint64_t *)&(msg_ptr->nl_neigh_info.attr_info.local_addr).__ss_padding)[1] >> 32)),
+ (uint16_t)(ntohs(((uint64_t *)&(msg_ptr->nl_neigh_info.attr_info.local_addr).__ss_padding)[1] >> 48)));
+
+ memcpy(data_all->ipv6_addr,
+ msg_ptr->nl_neigh_info.attr_info.local_addr.__ss_padding,
+ sizeof(data_all->ipv6_addr));
+ data_all->iptype = IPA_IP_v6;
+ }
+ else
+ {
+ IPACMDBG("IPV4 %d.%d.%d.%d\n",
+ (unsigned char)(*(unsigned int *)&(msg_ptr->nl_neigh_info.attr_info.local_addr).__ss_padding),
+ (unsigned char)(*(unsigned int *)&(msg_ptr->nl_neigh_info.attr_info.local_addr).__ss_padding >> 8),
+ (unsigned char)(*(unsigned int *)&(msg_ptr->nl_neigh_info.attr_info.local_addr).__ss_padding >> 16),
+ (unsigned char)(*(unsigned int *)&(msg_ptr->nl_neigh_info.attr_info.local_addr).__ss_padding >> 24));
+
+
+ memcpy(&data_all->ipv4_addr,
+ msg_ptr->nl_neigh_info.attr_info.local_addr.__ss_padding,
+ sizeof(data_all->ipv4_addr));
+ data_all->ipv4_addr = ntohl(data_all->ipv4_addr);
+ data_all->iptype = IPA_IP_v4;
+ }
+
+ memcpy(data_all->mac_addr,
+ msg_ptr->nl_neigh_info.attr_info.lladdr_hwaddr.sa_data,
+ sizeof(data_all->mac_addr));
+ evt_data.event = IPA_NEW_NEIGH_EVENT;
+ data_all->if_index = msg_ptr->nl_neigh_info.metainfo.ndm_ifindex;
+
+ IPACMDBG("posting IPA_NEW_NEIGH_EVENT with if index:%d\n",
+ data_all->if_index);
+ evt_data.evt_data = data_all;
+ IPACM_EvtDispatcher::PostEvt(&evt_data);
+ /* finish command queue */
+
+ IPACMDBG("NDA_LLADDR:MAC %02x:%02x:%02x:%02x:%02x:%02x\n",
+ (unsigned char)(msg_ptr->nl_neigh_info.attr_info.lladdr_hwaddr).sa_data[0],
+ (unsigned char)(msg_ptr->nl_neigh_info.attr_info.lladdr_hwaddr).sa_data[1],
+ (unsigned char)(msg_ptr->nl_neigh_info.attr_info.lladdr_hwaddr).sa_data[2],
+ (unsigned char)(msg_ptr->nl_neigh_info.attr_info.lladdr_hwaddr).sa_data[3],
+ (unsigned char)(msg_ptr->nl_neigh_info.attr_info.lladdr_hwaddr).sa_data[4],
+ (unsigned char)(msg_ptr->nl_neigh_info.attr_info.lladdr_hwaddr).sa_data[5]);
+
+ ret_val = ipa_get_if_name(dev_name, msg_ptr->nl_neigh_info.metainfo.ndm_ifindex);
+ if(ret_val != IPACM_SUCCESS)
+ {
+ IPACMERR("Error while getting interface index\n");
+ }
+ else
+ {
+ IPACMDBG("Interface %s \n", dev_name);
+ }
+ }
+ break;
+
+ case RTM_DELNEIGH:
+ if(IPACM_SUCCESS != ipa_nl_decode_rtm_neigh(buffer, buflen, &(msg_ptr->nl_neigh_info)))
+ {
+ IPACMERR("Failed to decode rtm neighbor message\n");
+ return IPACM_FAILURE;
+ }
+
+ if((NUD_PERMANENT | NUD_STALE) & (msg_ptr->nl_neigh_info.metainfo.ndm_state))
+ {
+ IPACMDBG("\n GOT RTM_DELNEIGH event\n");
+ /* insert to command queue */
+ data_all = (ipacm_event_data_all *)malloc(sizeof(ipacm_event_data_all));
+ if(data_all == NULL)
+ {
+ IPACMERR("unable to allocate memory for event data_all\n");
+ return IPACM_FAILURE;
+ }
+
+ if(AF_INET6 == msg_ptr->nl_neigh_info.attr_info.local_addr.ss_family)
+ {
+ IPACMDBG("IPV6 %04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x\n",
+ (uint16_t)(ntohs(((uint64_t *)&(msg_ptr->nl_neigh_info.attr_info.local_addr).__ss_padding)[0])),
+ (uint16_t)(ntohs(((uint64_t *)&(msg_ptr->nl_neigh_info.attr_info.local_addr).__ss_padding)[0] >> 16)),
+ (uint16_t)(ntohs(((uint64_t *)&(msg_ptr->nl_neigh_info.attr_info.local_addr).__ss_padding)[0] >> 32)),
+ (uint16_t)(ntohs(((uint64_t *)&(msg_ptr->nl_neigh_info.attr_info.local_addr).__ss_padding)[0] >> 48)),
+ (uint16_t)(ntohs(((uint64_t *)&(msg_ptr->nl_neigh_info.attr_info.local_addr).__ss_padding)[1])),
+ (uint16_t)(ntohs(((uint64_t *)&(msg_ptr->nl_neigh_info.attr_info.local_addr).__ss_padding)[1] >> 16)),
+ (uint16_t)(ntohs(((uint64_t *)&(msg_ptr->nl_neigh_info.attr_info.local_addr).__ss_padding)[1] >> 32)),
+ (uint16_t)(ntohs(((uint64_t *)&(msg_ptr->nl_neigh_info.attr_info.local_addr).__ss_padding)[1] >> 48)));
+
+ memcpy(data_all->ipv6_addr, msg_ptr->nl_neigh_info.attr_info.local_addr.__ss_padding,
+ sizeof(data_all->ipv6_addr));
+ data_all->iptype = IPA_IP_v6;
+ }
+ else
+ {
+ IPACMDBG("IPV4 %d.%d.%d.%d\n",
+ (unsigned char)(*(unsigned int *)&(msg_ptr->nl_neigh_info.attr_info.local_addr).__ss_padding),
+ (unsigned char)(*(unsigned int *)&(msg_ptr->nl_neigh_info.attr_info.local_addr).__ss_padding >> 8),
+ (unsigned char)(*(unsigned int *)&(msg_ptr->nl_neigh_info.attr_info.local_addr).__ss_padding >> 16),
+ (unsigned char)(*(unsigned int *)&(msg_ptr->nl_neigh_info.attr_info.local_addr).__ss_padding >> 24));
+
+
+ memcpy(&data_all->ipv4_addr, msg_ptr->nl_neigh_info.attr_info.local_addr.__ss_padding,
+ sizeof(data_all->ipv4_addr));
+ data_all->iptype = IPA_IP_v4;
+ }
+
+ memcpy(data_all->mac_addr,
+ msg_ptr->nl_neigh_info.attr_info.lladdr_hwaddr.sa_data,
+ sizeof(data_all->mac_addr));
+ evt_data.event = IPA_DEL_NEIGH_EVENT;
+ data_all->if_index = msg_ptr->nl_neigh_info.metainfo.ndm_ifindex;
+
+ IPACMDBG("posting IPA_DEL_NEIGH_EVENT with if index:%d\n",
+ data_all->if_index);
+ evt_data.evt_data = data_all;
+ IPACM_EvtDispatcher::PostEvt(&evt_data);
+ /* finish command queue */
+
+ IPACMDBG("NDA_LLADDR:MAC %02x:%02x:%02x:%02x:%02x:%02x\n",
+ (unsigned char)(msg_ptr->nl_neigh_info.attr_info.lladdr_hwaddr).sa_data[0],
+ (unsigned char)(msg_ptr->nl_neigh_info.attr_info.lladdr_hwaddr).sa_data[1],
+ (unsigned char)(msg_ptr->nl_neigh_info.attr_info.lladdr_hwaddr).sa_data[2],
+ (unsigned char)(msg_ptr->nl_neigh_info.attr_info.lladdr_hwaddr).sa_data[3],
+ (unsigned char)(msg_ptr->nl_neigh_info.attr_info.lladdr_hwaddr).sa_data[4],
+ (unsigned char)(msg_ptr->nl_neigh_info.attr_info.lladdr_hwaddr).sa_data[5]);
+
+ ret_val = ipa_get_if_name(dev_name, msg_ptr->nl_neigh_info.metainfo.ndm_ifindex);
+ if(ret_val != IPACM_SUCCESS)
+ {
+ //IPACM_LOG_MSG("Error while getting interface index");
+ }
+ else
+ {
+ IPACMDBG("Interface %s \n", dev_name);
+ }
+ }
+ break;
+
+ default:
+ IPACMDBG(" ignore NL event %d!!!\n ", nlh->nlmsg_type);
+ break;
+
+ }
+ nlh = NLMSG_NEXT(nlh, buflen);
+ }
+
+ return IPACM_SUCCESS;
+}
+
+
+/* Virtual function registered to receive incoming messages over the NETLINK routing socket*/
+int ipa_nl_recv_msg(int fd)
+{
+ struct msghdr *msghdr = NULL;
+ //struct sockaddr_nl *nladdr = NULL;
+ struct iovec *iov = NULL;
+ unsigned int msglen = 0;
+ ipa_nl_msg_t *nlmsg = NULL;
+
+ nlmsg = (ipa_nl_msg_t *)malloc(sizeof(ipa_nl_msg_t));
+ if(NULL == nlmsg)
+ {
+ IPACMERR("Failed alloc of nlmsg \n");
+ goto error;
+ }
+ else
+ {
+ if(IPACM_SUCCESS != ipa_nl_recv(fd, &msghdr, &msglen))
+ {
+ IPACMERR("Failed to receive nl message \n");
+ goto error;
+ }
+
+ //nladdr = (struct sockaddr_nl *)msghdr->msg_name;
+ iov = msghdr->msg_iov;
+
+ memset(nlmsg, 0, sizeof(ipa_nl_msg_t));
+ if(IPACM_SUCCESS != ipa_nl_decode_nlmsg((char *)iov->iov_base, msglen, nlmsg))
+ {
+ IPACMERR("Failed to decode nl message \n");
+ goto error;
+ }
+
+ ipa_nl_release_msg(msghdr);
+ free(nlmsg);
+ }
+
+ return IPACM_SUCCESS;
+
+error:
+ if(msghdr)
+ {
+ ipa_nl_release_msg(msghdr);
+ }
+ if(nlmsg)
+ {
+ free(nlmsg);
+ }
+
+ return IPACM_FAILURE;
+}
+
+/* get ipa interface name */
+int ipa_get_if_name
+(
+ char *if_name,
+ int if_index
+ )
+{
+ int fd;
+ struct ifreq ifr;
+
+ if((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
+ {
+ IPACMERR("get interface name socket create failed \n");
+ return IPACM_FAILURE;
+ }
+
+ memset(&ifr, 0, sizeof(struct ifreq));
+ ifr.ifr_ifindex = if_index;
+ IPACMDBG("Interface index %d\n", if_index);
+
+ if(ioctl(fd, SIOCGIFNAME, &ifr) < 0)
+ {
+ IPACMERR("call_ioctl_on_dev: ioctl failed:\n");
+ close(fd);
+ return IPACM_FAILURE;
+ }
+
+ (void)strncpy(if_name, ifr.ifr_name, sizeof(ifr.ifr_name));
+ IPACMDBG("interface name %s\n", ifr.ifr_name);
+ close(fd);
+
+ return IPACM_SUCCESS;
+}
+
+/* Initialization routine for listener on NetLink sockets interface */
+int ipa_nl_listener_init
+(
+ unsigned int nl_type,
+ unsigned int nl_groups,
+ ipa_nl_sk_fd_set_info_t *sk_fdset,
+ ipa_sock_thrd_fd_read_f read_f
+ )
+{
+ ipa_nl_sk_info_t sk_info, sk_info2;
+ int ret_val;
+
+ memset(&sk_info, 0, sizeof(ipa_nl_sk_info_t));
+ IPACMDBG("Entering IPA NL listener init\n");
+
+ if(ipa_nl_open_socket(&sk_info, nl_type, nl_groups) == IPACM_SUCCESS)
+ {
+ IPACMDBG("IPA Open netlink socket succeeds\n");
+ }
+ else
+ {
+ IPACMERR("Netlink socket open failed\n");
+ return IPACM_FAILURE;
+ }
+
+ /* Add NETLINK socket to the list of sockets that the listener
+ thread should listen on. */
+
+ if(ipa_nl_addfd_map(sk_fdset, sk_info.sk_fd, read_f) != IPACM_SUCCESS)
+ {
+ IPACMERR("cannot add nl routing sock for reading\n");
+ return IPACM_FAILURE;
+ }
+
+ /* Start the socket listener thread */
+ ret_val = ipa_nl_sock_listener_start(sk_fdset);
+
+ if(ret_val != IPACM_SUCCESS)
+ {
+ IPACMERR("Failed to start NL listener\n");
+ }
+
+ return IPACM_SUCCESS;
+}
+
+/* find the newroute subnet mask */
+int find_mask(int ip_v4_last, int *mask_value)
+{
+
+ switch(ip_v4_last)
+ {
+
+ case 3:
+ *mask_value = 252;
+ return IPACM_SUCCESS;
+ break;
+
+ case 7:
+ *mask_value = 248;
+ return IPACM_SUCCESS;
+ break;
+
+ case 15:
+ *mask_value = 240;
+ return IPACM_SUCCESS;
+ break;
+
+ case 31:
+ *mask_value = 224;
+ return IPACM_SUCCESS;
+ break;
+
+ case 63:
+ *mask_value = 192;
+ return IPACM_SUCCESS;
+ break;
+
+ case 127:
+ *mask_value = 128;
+ return IPACM_SUCCESS;
+ break;
+
+ case 255:
+ *mask_value = 0;
+ return IPACM_SUCCESS;
+ break;
+
+ default:
+ return IPACM_FAILURE;
+ break;
+
+ }
+}
+
+/* map mask value for ipv6 */
+int mask_v6(int index, uint32_t *mask)
+{
+ switch(index)
+ {
+
+ case 0:
+ *mask = 0x00000000;
+ return IPACM_SUCCESS;
+ break;
+ case 4:
+ *mask = 0xf0000000;
+ return IPACM_SUCCESS;
+ break;
+ case 8:
+ *mask = 0xff000000;
+ return IPACM_SUCCESS;
+ break;
+ case 12:
+ *mask = 0xfff00000;
+ return IPACM_SUCCESS;
+ break;
+ case 16:
+ *mask = 0xffff0000;
+ return IPACM_SUCCESS;
+ break;
+ case 20:
+ *mask = 0xfffff000;
+ return IPACM_SUCCESS;
+ break;
+ case 24:
+ *mask = 0xffffff00;
+ return IPACM_SUCCESS;
+ break;
+ case 28:
+ *mask = 0xfffffff0;
+ return IPACM_SUCCESS;
+ break;
+ case 32:
+ *mask = 0xffffffff;
+ return IPACM_SUCCESS;
+ break;
+ default:
+ return IPACM_FAILURE;
+ break;
+
+ }
+}
+
+
diff --git a/ipacm/src/IPACM_Routing.cpp b/ipacm/src/IPACM_Routing.cpp
new file mode 100644
index 0000000..1351fbe
--- /dev/null
+++ b/ipacm/src/IPACM_Routing.cpp
@@ -0,0 +1,226 @@
+/*
+Copyright (c) 2013, The Linux Foundation. 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 name of The Linux 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 "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+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.
+*/
+/*!
+ @file
+ IPACM_Routing.cpp
+
+ @brief
+ This file implements the IPACM routing functionality.
+
+ @Author
+
+*/
+
+#include <unistd.h>
+#include <sys/ioctl.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "IPACM_Routing.h"
+#include <IPACM_Log.h>
+
+const char *IPACM_Routing::DEVICE_NAME = "/dev/ipa";
+
+IPACM_Routing::IPACM_Routing()
+{
+ m_fd = open(DEVICE_NAME, O_RDWR);
+ if (0 == m_fd)
+ {
+ IPACMDBG("Failed opening %s.\n", DEVICE_NAME);
+ }
+}
+
+IPACM_Routing::~IPACM_Routing()
+{
+ close(m_fd);
+}
+
+bool IPACM_Routing::DeviceNodeIsOpened()
+{
+ int res = fcntl(m_fd, F_GETFL);
+
+ if (m_fd > 0 && res >= 0) return true;
+ else return false;
+
+}
+
+bool IPACM_Routing::AddRoutingRule(struct ipa_ioc_add_rt_rule *ruleTable)
+{
+ int retval = 0;
+
+ if (!DeviceNodeIsOpened())
+ {
+ IPACMDBG("Device is not opened\n");
+ return false;
+ }
+
+ retval = ioctl(m_fd, IPA_IOC_ADD_RT_RULE, ruleTable);
+ if (retval)
+ {
+ IPACMERR("Failed adding routing rule %p\n", ruleTable);
+ return false;
+ }
+
+ IPACMDBG("Added routing rule %p\n", ruleTable);
+ return true;
+}
+
+bool IPACM_Routing::DeleteRoutingRule(struct ipa_ioc_del_rt_rule *ruleTable)
+{
+ int retval = 0;
+
+ if (!DeviceNodeIsOpened()) return false;
+
+ retval = ioctl(m_fd, IPA_IOC_DEL_RT_RULE, ruleTable);
+ if (retval)
+ {
+ IPACMERR("Failed deleting routing rule table %p\n", ruleTable);
+ return false;
+ }
+
+ IPACMDBG("Deleted routing rule %p\n", ruleTable);
+ return true;
+}
+
+bool IPACM_Routing::Commit(enum ipa_ip_type ip)
+{
+ int retval = 0;
+
+ if (!DeviceNodeIsOpened()) return false;
+
+ retval = ioctl(m_fd, IPA_IOC_COMMIT_RT, ip);
+ if (retval)
+ {
+ IPACMERR("Failed commiting routing rules.\n");
+ return false;
+ }
+
+ IPACMDBG("Commited routing rules to IPA HW.\n");
+ return true;
+}
+
+bool IPACM_Routing::Reset(enum ipa_ip_type ip)
+{
+ int retval = 0;
+
+ if (!DeviceNodeIsOpened()) return false;
+
+ retval = ioctl(m_fd, IPA_IOC_RESET_RT, ip);
+ retval |= ioctl(m_fd, IPA_IOC_COMMIT_RT, ip);
+ if (retval)
+ {
+ IPACMERR("Failed resetting routing block.\n");
+ return false;
+ }
+
+ IPACMDBG("Reset command issued to IPA routing block.\n");
+ return true;
+}
+
+bool IPACM_Routing::GetRoutingTable(struct ipa_ioc_get_rt_tbl *routingTable)
+{
+ int retval = 0;
+
+ if (!DeviceNodeIsOpened()) return false;
+
+ retval = ioctl(m_fd, IPA_IOC_GET_RT_TBL, routingTable);
+ if (retval)
+ {
+ IPACMERR("IPA_IOCTL_GET_RT_TBL ioctl failed, routingTable =0x%p, retval=0x%x.\n", routingTable, retval);
+ return false;
+ }
+
+ IPACMDBG("IPA_IOCTL_GET_RT_TBL ioctl issued to IPA routing block.\n");
+ return true;
+}
+
+bool IPACM_Routing::PutRoutingTable(uint32_t routingTableHandle)
+{
+ int retval = 0;
+
+ if (!DeviceNodeIsOpened()) return false;
+
+ retval = ioctl(m_fd, IPA_IOC_PUT_RT_TBL, routingTableHandle);
+ if (retval)
+ {
+ IPACMERR("IPA_IOCTL_PUT_RT_TBL ioctl failed.\n");
+ return false;
+ }
+
+ IPACMDBG("IPA_IOCTL_PUT_RT_TBL ioctl issued to IPA routing block.\n");
+ return true;
+}
+
+bool IPACM_Routing::DeleteRoutingHdl(uint32_t rt_rule_hdl, ipa_ip_type ip)
+{
+ const uint8_t NUM_RULES = 1;
+ struct ipa_ioc_del_rt_rule *rt_rule;
+ struct ipa_rt_rule_del *rt_rule_entry;
+ bool res = true;
+ int len = 0;
+
+ if (rt_rule_hdl == 0)
+ {
+ IPACMERR("Invalid route handle passed. Ignoring it\n");
+ return false;
+ }
+
+ len = (sizeof(struct ipa_ioc_del_rt_rule)) + (NUM_RULES * sizeof(struct ipa_rt_rule_del));
+ rt_rule = (struct ipa_ioc_del_rt_rule *)malloc(len);
+ if (rt_rule == NULL)
+ {
+ IPACMERR("unable to allocate memory for del route rule\n");
+ return false;
+ }
+
+ memset(rt_rule, 0, len);
+ rt_rule->commit = 1;
+ rt_rule->num_hdls = NUM_RULES;
+ rt_rule->ip = ip;
+
+ rt_rule_entry = &rt_rule->hdl[0];
+ rt_rule_entry->status = -1;
+ rt_rule_entry->hdl = rt_rule_hdl;
+
+ IPACMDBG("Deleting Route hdl:(0x%x) with ip type: %d\n", rt_rule_entry->hdl, ip);
+ if ((false == DeleteRoutingRule(rt_rule)) ||
+ (rt_rule_entry->status))
+ {
+ PERROR("Routing rule deletion failed!\n");
+ goto fail;
+ res = false;
+ }
+
+fail:
+ free(rt_rule);
+
+ return res;
+}
+
diff --git a/ipacm/src/IPACM_Wan.cpp b/ipacm/src/IPACM_Wan.cpp
new file mode 100644
index 0000000..1a45dc5
--- /dev/null
+++ b/ipacm/src/IPACM_Wan.cpp
@@ -0,0 +1,1249 @@
+/*
+Copyright (c) 2013, The Linux Foundation. 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 name of The Linux 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 "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+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.
+*/
+/*!
+ @file
+ IPACM_Wan.cpp
+
+ @brief
+ This file implements the WAN iface functionality.
+
+ @Author
+ Skylar Chang
+
+*/
+#include <string.h>
+#include <sys/ioctl.h>
+#include <IPACM_Wan.h>
+#include <IPACM_Xml.h>
+#include <IPACM_Log.h>
+#include "IPACM_EvtDispatcher.h"
+#include <IPACM_IfaceManager.h>
+
+bool IPACM_Wan::wan_up = false;
+
+IPACM_Wan::IPACM_Wan(int iface_index) : IPACM_Iface(iface_index)
+{
+ num_firewall_v4 = 0;
+ num_firewall_v6 = 0;
+ num_dft_rt = 0;
+
+ wan_route_rule_v4_hdl = (uint32_t *)calloc(iface_query->num_tx_props, sizeof(uint32_t));
+ wan_route_rule_v6_hdl = (uint32_t *)calloc(iface_query->num_tx_props, sizeof(uint32_t));
+
+ active_v4 = false;
+ active_v6 = false;
+
+ IPACMDBG(" IPACM->IPACM_Wan(%d) constructor: Tx:%d\n", ipa_if_num, iface_query->num_tx_props);
+ return;
+}
+
+IPACM_Wan::~IPACM_Wan()
+{
+ IPACM_EvtDispatcher::deregistr(this);
+ IPACM_IfaceManager::deregistr(this);
+ return;
+}
+
+/* handle new_address event */
+int IPACM_Wan::handle_addr_evt(ipacm_event_data_addr *data)
+{
+ struct ipa_ioc_add_rt_rule *rt_rule;
+ struct ipa_rt_rule_add *rt_rule_entry;
+ const int NUM_RULES = 1;
+ int res = IPACM_SUCCESS;
+
+ /* initial multicast/broadcast/fragment filter rule */
+ init_fl_rule(data->iptype);
+
+ rt_rule = (struct ipa_ioc_add_rt_rule *)
+ calloc(1, sizeof(struct ipa_ioc_add_rt_rule) +
+ NUM_RULES * sizeof(struct ipa_rt_rule_add));
+
+ if (!rt_rule)
+ {
+ IPACMERR("Error Locate ipa_ioc_add_rt_rule memory...\n");
+ return IPACM_FAILURE;
+ }
+
+ rt_rule->commit = 1;
+ rt_rule->num_rules = NUM_RULES;
+ rt_rule->ip = data->iptype;
+
+ if (data->iptype == IPA_IP_v4)
+ {
+ strcpy(rt_rule->rt_tbl_name, IPACM_Iface::ipacmcfg->rt_tbl_lan_v4.name);
+ }
+ else
+ {
+ strcpy(rt_rule->rt_tbl_name, IPACM_Iface::ipacmcfg->rt_tbl_v6.name);
+ }
+
+ rt_rule_entry = &rt_rule->rules[0];
+ rt_rule_entry->at_rear = 1;
+ rt_rule_entry->rule.dst = IPA_CLIENT_A5_LAN_WAN_CONS; //go to A5
+ rt_rule_entry->rule.attrib.attrib_mask = IPA_FLT_DST_ADDR;
+
+
+ if (data->iptype == IPA_IP_v6)
+ {
+ rt_rule_entry->rule.attrib.u.v6.dst_addr[0] = data->ipv6_addr[0];
+ rt_rule_entry->rule.attrib.u.v6.dst_addr[1] = data->ipv6_addr[1];
+ rt_rule_entry->rule.attrib.u.v6.dst_addr[2] = data->ipv6_addr[2];
+ rt_rule_entry->rule.attrib.u.v6.dst_addr[3] = data->ipv6_addr[3];
+ rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[0] = 0xFFFFFFFF;
+ rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[1] = 0xFFFFFFFF;
+ rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[2] = 0xFFFFFFFF;
+ rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[3] = 0xFFFFFFFF;
+ }
+ else
+ {
+ /* still need setup v4 default routing rule to A5*/
+ rt_rule_entry->rule.attrib.u.v4.dst_addr = data->ipv4_addr;
+ rt_rule_entry->rule.attrib.u.v4.dst_addr_mask = 0xFFFFFFFF;
+
+ wan_v4_addr = data->ipv4_addr;
+ IPACMDBG("Receved wan address:0x%x\n", wan_v4_addr);
+ }
+
+
+ if (false == m_routing.AddRoutingRule(rt_rule))
+ {
+ IPACMERR("Routing rule addition failed!\n");
+ res = IPACM_FAILURE;
+ goto fail;
+ }
+ else if (rt_rule_entry->status)
+ {
+ IPACMERR("rt rule adding failed. Result=%d\n", rt_rule_entry->status);
+ res = rt_rule_entry->status;
+ goto fail;
+ }
+ IPACMDBG("rt rule hdl=%x with ip-type: %d\n", rt_rule_entry->rt_rule_hdl, data->iptype);
+
+ if (data->iptype == IPA_IP_v4)
+ {
+ dft_rt_rule_hdl[0] = rt_rule_entry->rt_rule_hdl;
+ IPACMDBG("ipv4 wan rt rule hdl1=0x%x\n", dft_rt_rule_hdl[0]);
+ }
+ else
+ {
+ dft_rt_rule_hdl[1 + num_dft_rt] = rt_rule_entry->rt_rule_hdl;
+ IPACMDBG("ipv6 wan rt rule hdl1=0x%x\n", dft_rt_rule_hdl[1 + num_dft_rt]);
+ num_dft_rt++;
+ }
+
+
+fail:
+ free(rt_rule);
+
+ return res;
+}
+
+void IPACM_Wan::event_callback(ipa_cm_event_id event, void *param)
+{
+ int ipa_interface_index;
+
+ switch (event)
+ {
+
+ case IPA_LINK_DOWN_EVENT:
+ {
+ ipacm_event_data_fid *data = (ipacm_event_data_fid *)param;
+ ipa_interface_index = iface_ipa_index_query(data->if_index);
+ if (ipa_interface_index == ipa_if_num)
+ {
+ IPACMDBG("Received IPA_LINK_DOWN_EVENT\n");
+ handle_down_evt();
+ IPACMDBG("ipa_WAN (%s):ipa_index (%d) instance close \n", IPACM_Iface::ipacmcfg->iface_table[ipa_if_num].iface_name, ipa_if_num);
+ delete this;
+ return;
+ }
+ }
+ break;
+
+ case IPA_ADDR_ADD_EVENT:
+ {
+ ipacm_event_data_addr *data = (ipacm_event_data_addr *)param;
+ ipa_interface_index = iface_ipa_index_query(data->if_index);
+ if (ipa_interface_index == ipa_if_num)
+ {
+ if ((data->iptype != ip_type) && (ip_type != IPA_IP_MAX)) // check not setup before
+ {
+ IPACMDBG("Received IPA_ADDR_ADD_EVENT\n");
+ handle_addr_evt(data);
+ }
+ }
+ }
+ break;
+
+ case IPA_ROUTE_ADD_EVENT:
+ {
+ ipacm_event_data_addr *data = (ipacm_event_data_addr *)param;
+ ipa_interface_index = iface_ipa_index_query(data->if_index);
+ if (ipa_interface_index == ipa_if_num)
+ {
+ IPACMDBG("Received IPA_ROUTE_ADD_EVENT\n");
+ IPACMDBG("ipv4 addr 0x%x\n", data->ipv4_addr);
+ IPACMDBG("ipv4 addr mask 0x%x\n", data->ipv4_addr_mask);
+
+ /* The special below condition is to handle default gateway */
+ if ((data->iptype == IPA_IP_v4) && (!data->ipv4_addr) && (!data->ipv4_addr_mask))
+ {
+ IPACMDBG("adding routing table\n");
+ handle_route_add_evt(data);
+ IPACM_Wan::wan_up = true;
+ active_v4 = true;
+ config_dft_firewall_rules(IPA_IP_v4);
+ }
+ else if ((data->iptype == IPA_IP_v6) &&
+ (!data->ipv6_addr[0]) && (!data->ipv6_addr[1]) && (!data->ipv6_addr[2]) && (!data->ipv6_addr[3]))
+ {
+ IPACMDBG("\n get default v6 route (dst:00.00.00.00)\n");
+ IPACMDBG(" IPV6 value: %08x:%08x:%08x:%08x \n",
+ data->ipv6_addr[0], data->ipv6_addr[1], data->ipv6_addr[2], data->ipv6_addr[3]);
+ handle_route_add_evt(data);
+ active_v6 = true;
+ config_dft_firewall_rules(IPA_IP_v6);
+ }
+ }
+ }
+ break;
+
+ case IPA_ROUTE_DEL_EVENT:
+ {
+ ipacm_event_data_addr *data = (ipacm_event_data_addr *)param;
+ ipa_interface_index = iface_ipa_index_query(data->if_index);
+ if (ipa_interface_index == ipa_if_num)
+ {
+ IPACMDBG("Received IPA_ROUTE_DEL_EVENT\n");
+ if ((data->iptype == IPA_IP_v4) && (!data->ipv4_addr) && (!data->ipv4_addr_mask))
+ {
+ IPACMDBG("get del default v4 route (dst:0.0.0.0)\n");
+ del_dft_firewall_rules(IPA_IP_v4);
+ handle_route_del_evt(data->iptype);
+ IPACM_Wan::wan_up = false;
+ }
+ else if ((data->iptype == IPA_IP_v6) && (!data->ipv6_addr[0]) && (!data->ipv6_addr[1]) && (!data->ipv6_addr[2]) && (!data->ipv6_addr[3]))
+ {
+ IPACMDBG("get del default v6 route (dst:00.00.00.00)\n");
+ del_dft_firewall_rules(IPA_IP_v6);
+ handle_route_del_evt(data->iptype);
+ }
+ }
+ }
+ break;
+
+ case IPA_NEIGH_CLIENT_IP_ADDR_ADD_EVENT:
+ {
+ ipacm_event_data_all *data = (ipacm_event_data_all *)param;
+ ipa_interface_index = iface_ipa_index_query(data->if_index);
+ if (ipa_interface_index == ipa_if_num)
+ {
+ IPACMDBG("Received IPA_NEIGH_CLIENT_IP_ADDR_ADD_EVENT\n");
+ IPACMDBG("I'm in the WAN\n");
+ handle_header_add_evt(data->mac_addr);
+ }
+ }
+ break;
+
+ case IPA_SW_ROUTING_ENABLE:
+ IPACMDBG("Received IPA_SW_ROUTING_ENABLE\n");
+ /* handle software routing enable event */
+ handle_software_routing_enable();
+ break;
+
+ case IPA_SW_ROUTING_DISABLE:
+ IPACMDBG("Received IPA_SW_ROUTING_DISABLE\n");
+ /* handle software routing disable event */
+ handle_software_routing_disable();
+ break;
+
+ case IPA_FIREWALL_CHANGE_EVENT:
+ IPACMDBG("Received IPA_FIREWALL_CHANGE_EVENT\n");
+ /* handle software routing enable event */
+ if (active_v4)
+ {
+ del_dft_firewall_rules(IPA_IP_v4);
+ config_dft_firewall_rules(IPA_IP_v4);
+ }
+
+ if (active_v6)
+ {
+ del_dft_firewall_rules(IPA_IP_v6);
+ config_dft_firewall_rules(IPA_IP_v6);
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ return;
+}
+
+/* wan default route/filter rule configuration */
+int IPACM_Wan::handle_route_add_evt(ipacm_event_data_addr *data)
+{
+
+ /* add default WAN route */
+ struct ipa_ioc_add_rt_rule *rt_rule;
+ struct ipa_rt_rule_add *rt_rule_entry;
+ struct ipa_ioc_get_hdr sRetHeader;
+ uint32_t tx_index;
+ const int NUM = 1;
+ ipacm_cmd_q_data evt_data;
+
+ IPACMDBG(" ip-type:%d\n", data->iptype);
+
+ rt_rule = (struct ipa_ioc_add_rt_rule *)
+ calloc(1, sizeof(struct ipa_ioc_add_rt_rule) +
+ NUM * sizeof(struct ipa_rt_rule_add));
+
+ if (!rt_rule)
+ {
+ IPACMERR("Error Locate ipa_ioc_add_rt_rule memory...\n");
+ return IPACM_FAILURE;
+ }
+
+ rt_rule->commit = 1;
+ rt_rule->num_rules = (uint8_t)NUM;
+ rt_rule->ip = data->iptype;
+
+ if (data->iptype == IPA_IP_v4)
+ {
+ strcpy(rt_rule->rt_tbl_name, IPACM_Iface::ipacmcfg->rt_tbl_wan_v4.name);
+ }
+ else
+ {
+ strcpy(rt_rule->rt_tbl_name, IPACM_Iface::ipacmcfg->rt_tbl_v6.name);
+ }
+
+ IPACMDBG(" WAN table created %s \n", rt_rule->rt_tbl_name);
+ rt_rule_entry = &rt_rule->rules[0];
+ rt_rule_entry->at_rear = 1;
+
+ for (tx_index = 0; tx_index < iface_query->num_tx_props; tx_index++)
+ {
+ if (data->iptype != tx_prop->tx[tx_index].ip)
+ {
+ continue;
+ }
+
+ if (tx_prop->tx[tx_index].hdr_name != NULL)
+ {
+ IPACMDBG(" TX- header hdl %s \n", tx_prop->tx[tx_index].hdr_name);
+ memset(&sRetHeader, 0, sizeof(sRetHeader));
+ strncpy(sRetHeader.name,
+ tx_prop->tx[tx_index].hdr_name,
+ sizeof(tx_prop->tx[tx_index].hdr_name));
+ if (false == m_header.GetHeaderHandle(&sRetHeader))
+
+ {
+ IPACMERR("\n ioctl failed\n");
+ free(rt_rule);
+ return IPACM_FAILURE;
+ }
+ rt_rule_entry->rule.hdr_hdl = sRetHeader.hdl;
+ }
+
+ rt_rule_entry->rule.dst = tx_prop->tx[tx_index].dst_pipe;
+ memcpy(&rt_rule_entry->rule.attrib,
+ &tx_prop->tx[tx_index].attrib,
+ sizeof(rt_rule_entry->rule.attrib));
+
+ rt_rule_entry->rule.attrib.attrib_mask |= IPA_FLT_DST_ADDR;
+ if (data->iptype == IPA_IP_v4)
+ {
+ rt_rule_entry->rule.attrib.u.v4.dst_addr = data->ipv4_addr;
+ rt_rule_entry->rule.attrib.u.v4.dst_addr_mask = data->ipv4_addr_mask;
+ }
+ else
+ {
+ rt_rule_entry->rule.attrib.u.v6.dst_addr[0] = data->ipv6_addr[0];
+ rt_rule_entry->rule.attrib.u.v6.dst_addr[1] = data->ipv6_addr[1];
+ rt_rule_entry->rule.attrib.u.v6.dst_addr[2] = data->ipv6_addr[2];
+ rt_rule_entry->rule.attrib.u.v6.dst_addr[3] = data->ipv6_addr[3];
+ rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[0] = data->ipv6_addr_mask[0];
+ rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[1] = data->ipv6_addr_mask[1];
+ rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[2] = data->ipv6_addr_mask[2];
+ rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[3] = data->ipv6_addr_mask[3];
+ }
+
+ if (false == m_routing.AddRoutingRule(rt_rule))
+ {
+ IPACMERR("Routing rule addition failed!\n");
+ free(rt_rule);
+ return IPACM_FAILURE;
+ }
+
+ if (data->iptype == IPA_IP_v4)
+ {
+ wan_route_rule_v4_hdl[tx_index] = rt_rule_entry->rt_rule_hdl;
+ IPACMDBG("Got ipv4 wan-route rule hdl:0x%x,tx:%d,ip-type: %d \n",
+ wan_route_rule_v4_hdl[tx_index],
+ tx_index,
+ data->iptype);
+ }
+ else
+ {
+ wan_route_rule_v6_hdl[tx_index] = rt_rule_entry->rt_rule_hdl;
+ IPACMDBG("Got ipv6 wan-route rule hdl:0x%x,tx:%d,ip-type: %d \n",
+ wan_route_rule_v6_hdl[tx_index],
+ tx_index,
+ data->iptype);
+ }
+ }
+ free(rt_rule);
+
+ if (data->iptype == IPA_IP_v4)
+ {
+ ipacm_event_iface_up *wanup_data;
+
+ wanup_data =
+ (ipacm_event_iface_up *)malloc(sizeof(ipacm_event_iface_up));
+ if (wanup_data == NULL)
+ {
+ IPACMERR("Unable to allocate memory\n");
+ return IPACM_FAILURE;
+ }
+
+ memcpy(wanup_data->ifname, dev_name, sizeof(wanup_data->ifname));
+ wanup_data->ipv4_addr = wan_v4_addr;
+ IPACMDBG("Posting IPA_HANDLE_WAN_UP with below information:\n");
+ IPACMDBG("if_name:%s, ipv4_address:0x%x\n",
+ wanup_data->ifname, wanup_data->ipv4_addr);
+
+ evt_data.event = IPA_HANDLE_WAN_UP;
+ evt_data.evt_data = (void *)wanup_data;
+ IPACM_EvtDispatcher::PostEvt(&evt_data);
+ }
+
+ return IPACM_SUCCESS;
+}
+
+/* wan default route/filter rule delete */
+int IPACM_Wan::handle_route_del_evt(ipa_ip_type iptype)
+{
+ uint32_t tx_index;
+ ipacm_cmd_q_data evt_data;
+
+ IPACMDBG("got handle_route_del_evt with ip-family:%d \n", iptype);
+
+ if (((iptype == IPA_IP_v4) && (active_v4 == true)) ||
+ ((iptype == IPA_IP_v6) && (active_v6 == true)))
+ {
+
+ for (tx_index = 0; tx_index < iface_query->num_tx_props; tx_index++)
+ {
+ if (iptype == IPA_IP_v4)
+ {
+
+ if (m_routing.DeleteRoutingHdl(wan_route_rule_v4_hdl[tx_index], IPA_IP_v4)
+ == false)
+ {
+ IPACMDBG("IP-family:%d, Routing rule(hdl:0x%x) deletion failed with tx_index %d!\n", IPA_IP_v4, wan_route_rule_v4_hdl[tx_index], tx_index);
+ return IPACM_FAILURE;
+ }
+
+ }
+ else
+ {
+ if (m_routing.DeleteRoutingHdl(wan_route_rule_v6_hdl[tx_index], IPA_IP_v6)
+ == false)
+ {
+ IPACMERR("IP-family:%d, Routing rule(hdl:0x%x) deletion failed with tx_index %d!\n", IPA_IP_v6, wan_route_rule_v6_hdl[tx_index], tx_index);
+ return IPACM_FAILURE;
+ }
+ }
+
+ }
+
+ if (iptype == IPA_IP_v4)
+ {
+
+ uint32_t *wan_ip_addr = (uint32_t *)malloc(sizeof(uint32_t));
+ if (wan_ip_addr == NULL)
+ {
+ IPACMERR("unable to allocate memory\n");
+ return IPACM_FAILURE;
+ }
+
+ *wan_ip_addr = wan_v4_addr;
+ evt_data.event = IPA_HANDLE_WAN_DOWN;
+ evt_data.evt_data = (void *)wan_ip_addr;
+ /* Insert IPA_HANDLE_WAN_DOWN to command queue */
+ IPACMDBG("posting IPA_HANDLE_WAN_DOWN for IPv4 \n");
+ IPACM_EvtDispatcher::PostEvt(&evt_data);
+ IPACM_Wan::wan_up = false;
+ active_v4 = false;
+ }
+ else
+ {
+ active_v6 = false;
+ }
+ }
+ else
+ {
+ IPACMDBG(" The default WAN routing rules are deleted already \n");
+ }
+
+ return IPACM_SUCCESS;
+}
+
+/* construct complete ethernet header */
+int IPACM_Wan::handle_header_add_evt(uint8_t mac_addr[6])
+{
+ char index[2];
+ struct ipa_ioc_copy_hdr sCopyHeader;
+ struct ipa_ioc_add_hdr *pHeaderDescriptor = NULL;
+ uint32_t tx_index;
+ int len = 0;
+
+ IPACMDBG("construct header\n");
+
+ /* start of add header */
+ for (tx_index = 0; tx_index < iface_query->num_tx_props; tx_index++)
+ {
+ /* add header to IPA */
+ len = sizeof(struct ipa_ioc_add_hdr) + (1 * sizeof(struct ipa_hdr_add));
+ pHeaderDescriptor = (struct ipa_ioc_add_hdr *)calloc(1, len);
+ if (!pHeaderDescriptor)
+ {
+ IPACMERR("calloc failed to allocate pHeaderDescriptor\n");
+ return IPACM_FAILURE;
+ }
+
+ /* copy partial header */
+ memset(&sCopyHeader, 0, sizeof(sCopyHeader));
+ memcpy(sCopyHeader.name, tx_prop->tx[tx_index].hdr_name,
+ sizeof(tx_prop->tx[tx_index].hdr_name));
+
+ IPACMDBG("header name: %s\n", sCopyHeader.name);
+ if (false == m_header.CopyHeader(&sCopyHeader))
+ {
+ IPACMERR("ioctl copy header failed\n");
+ free(pHeaderDescriptor);
+ return IPACM_FAILURE;
+ };
+
+ if (sCopyHeader.hdr_len > IPA_HDR_MAX_SIZE)
+ {
+ IPACMERR("header oversize\n");
+ free(pHeaderDescriptor);
+ return IPACM_FAILURE;
+ }
+ else
+ {
+ memcpy(pHeaderDescriptor->hdr[0].hdr, sCopyHeader.hdr,
+ sCopyHeader.hdr_len);
+ }
+
+ /* copy client mac_addr to partial header */
+ memcpy(&pHeaderDescriptor->hdr[0].hdr[IPA_WLAN_PARTIAL_HDR_OFFSET], mac_addr,
+ IPA_MAC_ADDR_SIZE); /* only copy 6 bytes mac-address */
+
+ pHeaderDescriptor->commit = true;
+ pHeaderDescriptor->num_hdrs = 1;
+ sprintf(index, "%d", ipa_if_num);
+ strncpy(pHeaderDescriptor->hdr[0].name, index, sizeof(index));
+ strncat(pHeaderDescriptor->hdr[0].name, IPA_WLAN_PARTIAL_HDR_NAME, sizeof(IPA_WLAN_PARTIAL_HDR_NAME));
+ strncat(pHeaderDescriptor->hdr[0].name, "tx", sizeof("tx"));
+ sprintf(index, "%d", tx_index);
+ strncat(pHeaderDescriptor->hdr[0].name, index, sizeof(index));
+
+ pHeaderDescriptor->hdr[0].hdr_len = sizeof(sCopyHeader.hdr_len);
+ pHeaderDescriptor->hdr[0].hdr_hdl = -1;
+ pHeaderDescriptor->hdr[0].is_partial = false;
+ pHeaderDescriptor->hdr[0].status = -1;
+
+ if (false == m_header.AddHeader(pHeaderDescriptor))
+ {
+ IPACMERR("ioctl add header failed\n");
+ free(pHeaderDescriptor);
+ return IPACM_FAILURE;
+ }
+
+ memcpy(tx_prop->tx[tx_index].hdr_name, pHeaderDescriptor->hdr[0].name,
+ sizeof(tx_prop->tx[tx_index].hdr_name));
+ IPACMDBG("add full header name: %s (%x)\n", tx_prop->tx[tx_index].hdr_name, pHeaderDescriptor->hdr[0].hdr_hdl);
+
+
+ free(pHeaderDescriptor);
+ }
+
+ return IPACM_SUCCESS;
+}
+
+/* configure the initial firewall filter rules */
+int IPACM_Wan::config_dft_firewall_rules(ipa_ip_type iptype)
+{
+ struct ipa_flt_rule_add flt_rule_entry;
+ int i, rule_v4 = 0, rule_v6 = 0;
+
+ IPACMDBG("ip-family: %d; \n", iptype);
+ memset(&firewall_config, 0, sizeof(firewall_config));
+ strncpy(firewall_config.firewall_config_file, "/etc/mobileap_firewall.xml", sizeof(firewall_config.firewall_config_file));
+
+ if (firewall_config.firewall_config_file)
+ {
+ IPACMDBG("Firewall XML file is %s \n", firewall_config.firewall_config_file);
+ if (IPACM_SUCCESS == IPACM_read_firewall_xml(firewall_config.firewall_config_file, &firewall_config))
+ {
+ IPACMDBG("QCMAP Firewall XML read OK \n");
+ }
+ else
+ {
+ IPACMERR("QCMAP Firewall XML read failed \n");
+ return IPACM_FAILURE;
+ }
+ }
+ else
+ {
+ IPACMERR("No firewall xml mentioned \n");
+ return IPACM_FAILURE;
+ }
+
+ /* find the number of v4/v6 firewall rules */
+ for (i = 0; i < firewall_config.num_extd_firewall_entries; i++)
+ {
+ if (firewall_config.extd_firewall_entries[i].ip_vsn == 4)
+ {
+ rule_v4++;
+ }
+ else
+ {
+ rule_v6++;
+ }
+ }
+
+ IPACMDBG("firewall rule v4:%d v6:%d total:%d\n", rule_v4, rule_v6, firewall_config.num_extd_firewall_entries);
+
+ /* construct ipa_ioc_add_flt_rule with N firewall rules */
+ ipa_ioc_add_flt_rule *m_pFilteringTable;
+
+ if (iptype == IPA_IP_v4)
+ {
+ if (rule_v4 == 0)
+ {
+ m_pFilteringTable = (struct ipa_ioc_add_flt_rule *)
+ calloc(1,
+ sizeof(struct ipa_ioc_add_flt_rule) +
+ 1 * sizeof(struct ipa_flt_rule_add));
+
+ if (!m_pFilteringTable)
+ {
+ IPACMERR("Error Locate ipa_flt_rule_add memory...\n");
+ return IPACM_FAILURE;
+ }
+ m_pFilteringTable->commit = 1;
+ m_pFilteringTable->ep = rx_prop->rx[0].src_pipe;
+ m_pFilteringTable->global = false;
+ m_pFilteringTable->ip = IPA_IP_v4;
+ m_pFilteringTable->num_rules = (uint8_t)1;
+
+ memset(&flt_rule_entry, 0, sizeof(struct ipa_flt_rule_add));
+
+ if (false == m_routing.GetRoutingTable(&IPACM_Iface::ipacmcfg->rt_tbl_lan_v4))
+ {
+ IPACMERR("m_routing.GetRoutingTable(rt_tbl_lan_v4) Failed.\n");
+ free(m_pFilteringTable);
+ return IPACM_FAILURE;
+ }
+
+ flt_rule_entry.at_rear = true;
+ flt_rule_entry.flt_rule_hdl = -1;
+ flt_rule_entry.status = -1;
+
+ flt_rule_entry.rule.action = IPA_PASS_TO_DST_NAT;
+ flt_rule_entry.rule.rt_tbl_hdl = IPACM_Iface::ipacmcfg->rt_tbl_lan_v4.hdl;
+ memcpy(&flt_rule_entry.rule.attrib,
+ &rx_prop->rx[0].attrib,
+ sizeof(struct ipa_rule_attrib));
+ flt_rule_entry.rule.attrib.attrib_mask |= IPA_FLT_DST_ADDR;
+ flt_rule_entry.rule.attrib.u.v4.dst_addr_mask = 0x00000000;
+ flt_rule_entry.rule.attrib.u.v4.dst_addr = 0x00000000;
+
+ memcpy(&(m_pFilteringTable->rules[0]), &flt_rule_entry, sizeof(struct ipa_flt_rule_add));
+
+ if (false == m_filtering.AddFilteringRule(m_pFilteringTable))
+ {
+ IPACMERR("Error Adding RuleTable(0) to Filtering, aborting...\n");
+ free(m_pFilteringTable);
+ return IPACM_FAILURE;
+ }
+ else
+ {
+ IPACMDBG("flt rule hdl0=0x%x, status=0x%x\n", m_pFilteringTable->rules[0].flt_rule_hdl, m_pFilteringTable->rules[0].status);
+ }
+
+ /* copy filter hdls */
+ dft_wan_fl_hdl[0] = m_pFilteringTable->rules[0].flt_rule_hdl;
+ free(m_pFilteringTable);
+ }
+ else
+ {
+ m_pFilteringTable = (struct ipa_ioc_add_flt_rule *)
+ calloc(1,
+ sizeof(struct ipa_ioc_add_flt_rule) +
+ 1 * sizeof(struct ipa_flt_rule_add)
+ );
+
+ if (m_pFilteringTable == NULL)
+ {
+ IPACMERR("Error Locate ipa_flt_rule_add memory...\n");
+ return IPACM_FAILURE;
+ }
+
+ m_pFilteringTable->commit = 1;
+ m_pFilteringTable->ep = rx_prop->rx[0].src_pipe;
+ m_pFilteringTable->global = false;
+ m_pFilteringTable->ip = IPA_IP_v4;
+ m_pFilteringTable->num_rules = (uint8_t)1;
+
+ IPACMDBG("Retreiving Routing handle for routing table name:%s\n",
+ IPACM_Iface::ipacmcfg->rt_tbl_lan_v4.name);
+ if (false == m_routing.GetRoutingTable(&IPACM_Iface::ipacmcfg->rt_tbl_lan_v4))
+ {
+ IPACMERR("m_routing.GetRoutingTable(&rt_tbl_lan_v4=0x%p) Failed.\n", &IPACM_Iface::ipacmcfg->rt_tbl_lan_v4);
+ free(m_pFilteringTable);
+ return IPACM_FAILURE;
+ }
+ IPACMDBG("Routing handle for wan routing table:0x%x\n", IPACM_Iface::ipacmcfg->rt_tbl_lan_v4.hdl);
+
+ rule_v4 = 0;
+ for (i = 0; i < firewall_config.num_extd_firewall_entries; i++)
+ {
+ if (firewall_config.extd_firewall_entries[i].ip_vsn == 4)
+ {
+ memset(&flt_rule_entry, 0, sizeof(struct ipa_flt_rule_add));
+
+ flt_rule_entry.at_rear = true;
+ flt_rule_entry.flt_rule_hdl = -1;
+ flt_rule_entry.status = -1;
+ flt_rule_entry.rule.action = IPA_PASS_TO_EXCEPTION; //Matched the firewall rule, go exception
+ flt_rule_entry.rule.rt_tbl_hdl = IPACM_Iface::ipacmcfg->rt_tbl_lan_v4.hdl;
+
+ memcpy(&flt_rule_entry.rule.attrib,
+ &firewall_config.extd_firewall_entries[i].attrib,
+ sizeof(struct ipa_rule_attrib));
+
+ IPACMDBG("rx property attrib mask: 0x%x\n", rx_prop->rx[0].attrib.attrib_mask);
+ flt_rule_entry.rule.attrib.attrib_mask |= rx_prop->rx[0].attrib.attrib_mask;
+ flt_rule_entry.rule.attrib.meta_data_mask = rx_prop->rx[0].attrib.meta_data_mask;
+ flt_rule_entry.rule.attrib.meta_data = rx_prop->rx[0].attrib.meta_data;
+
+ /* check if the rule is define as TCP_UDP, split into 2 rules, 1 for TCP and 1 UDP */
+ if (firewall_config.extd_firewall_entries[i].attrib.u.v4.protocol
+ == IPACM_FIREWALL_IPPROTO_TCP_UDP)
+ {
+ /* insert TCP rule*/
+ flt_rule_entry.rule.attrib.u.v4.protocol = IPACM_FIREWALL_IPPROTO_TCP;
+ memcpy(&(m_pFilteringTable->rules[0]), &flt_rule_entry, sizeof(struct ipa_flt_rule_add));
+
+ IPACMDBG("Filter rule attrib mask: 0x%x\n",
+ m_pFilteringTable->rules[0].rule.attrib.attrib_mask);
+ if (false == m_filtering.AddFilteringRule(m_pFilteringTable))
+ {
+ IPACMERR("Error Adding RuleTable(0) to Filtering, aborting...\n");
+ free(m_pFilteringTable);
+ return IPACM_FAILURE;
+ }
+ else
+ {
+ /* save v4 firewall filter rule handler */
+ IPACMDBG("flt rule hdl0=0x%x, status=0x%x\n",
+ m_pFilteringTable->rules[rule_v4].flt_rule_hdl,
+ m_pFilteringTable->rules[rule_v4].status);
+ firewall_hdl_v4[rule_v4] = m_pFilteringTable->rules[0].flt_rule_hdl;
+ num_firewall_v4++;
+ rule_v4++;
+ }
+
+ /* insert UDP rule*/
+ flt_rule_entry.rule.attrib.u.v4.protocol = IPACM_FIREWALL_IPPROTO_UDP;
+ memcpy(&(m_pFilteringTable->rules[0]), &flt_rule_entry, sizeof(struct ipa_flt_rule_add));
+
+ IPACMDBG("Filter rule attrib mask: 0x%x\n",
+ m_pFilteringTable->rules[0].rule.attrib.attrib_mask);
+ if (false == m_filtering.AddFilteringRule(m_pFilteringTable))
+ {
+ IPACMERR("Error Adding RuleTable(0) to Filtering, aborting...\n");
+ free(m_pFilteringTable);
+ return IPACM_FAILURE;
+ }
+ else
+ {
+ /* save v4 firewall filter rule handler */
+ IPACMDBG("flt rule hdl0=0x%x, status=0x%x\n",
+ m_pFilteringTable->rules[rule_v4].flt_rule_hdl,
+ m_pFilteringTable->rules[rule_v4].status);
+ firewall_hdl_v4[rule_v4] = m_pFilteringTable->rules[0].flt_rule_hdl;
+ num_firewall_v4++;
+ rule_v4++;
+ }
+ }
+ else
+ {
+ memcpy(&(m_pFilteringTable->rules[0]), &flt_rule_entry, sizeof(struct ipa_flt_rule_add));
+
+ IPACMDBG("Filter rule attrib mask: 0x%x\n",
+ m_pFilteringTable->rules[0].rule.attrib.attrib_mask);
+ if (false == m_filtering.AddFilteringRule(m_pFilteringTable))
+ {
+ IPACMERR("Error Adding RuleTable(0) to Filtering, aborting...\n");
+ free(m_pFilteringTable);
+ return IPACM_FAILURE;
+ }
+ else
+ {
+ /* save v4 firewall filter rule handler */
+ IPACMDBG("flt rule hdl0=0x%x, status=0x%x\n",
+ m_pFilteringTable->rules[rule_v4].flt_rule_hdl,
+ m_pFilteringTable->rules[rule_v4].status);
+ firewall_hdl_v4[rule_v4] = m_pFilteringTable->rules[0].flt_rule_hdl;
+ num_firewall_v4++;
+ rule_v4++;
+ }
+ }
+ }
+ } /* end of firewall ipv4 filter rule add for loop*/
+
+ /* configure default filter rule */
+ memset(&flt_rule_entry, 0, sizeof(struct ipa_flt_rule_add));
+
+ flt_rule_entry.at_rear = true;
+ flt_rule_entry.flt_rule_hdl = -1;
+ flt_rule_entry.status = -1;
+
+ flt_rule_entry.rule.action = IPA_PASS_TO_DST_NAT;
+ flt_rule_entry.rule.rt_tbl_hdl = IPACM_Iface::ipacmcfg->rt_tbl_lan_v4.hdl;
+ memcpy(&flt_rule_entry.rule.attrib,
+ &rx_prop->rx[0].attrib,
+ sizeof(struct ipa_rule_attrib));
+ flt_rule_entry.rule.attrib.attrib_mask |= IPA_FLT_DST_ADDR;
+ flt_rule_entry.rule.attrib.u.v4.dst_addr_mask = 0x00000000;
+ flt_rule_entry.rule.attrib.u.v4.dst_addr = 0x00000000;
+
+ memcpy(&(m_pFilteringTable->rules[0]), &flt_rule_entry, sizeof(struct ipa_flt_rule_add));
+
+ IPACMDBG("Filter rule attrib mask: 0x%x\n",
+ m_pFilteringTable->rules[0].rule.attrib.attrib_mask);
+ if (false == m_filtering.AddFilteringRule(m_pFilteringTable))
+ {
+ IPACMERR("Error Adding RuleTable(0) to Filtering, aborting...\n");
+ free(m_pFilteringTable);
+ return IPACM_FAILURE;
+ }
+ else
+ {
+ IPACMDBG("flt rule hdl0=0x%x, status=0x%x\n", m_pFilteringTable->rules[0].flt_rule_hdl, m_pFilteringTable->rules[0].status);
+ }
+
+ /* copy filter hdls */
+ dft_wan_fl_hdl[0] = m_pFilteringTable->rules[0].flt_rule_hdl;
+ free(m_pFilteringTable);
+ }
+
+ }
+ else
+ {
+ if (rule_v6 == 0)
+ {
+ m_pFilteringTable = (struct ipa_ioc_add_flt_rule *)
+ calloc(1,
+ sizeof(struct ipa_ioc_add_flt_rule) +
+ 1 * sizeof(struct ipa_flt_rule_add));
+
+
+ if (!m_pFilteringTable)
+ {
+ IPACMERR("Error Locate ipa_flt_rule_add memory...\n");
+ return IPACM_FAILURE;
+ }
+ m_pFilteringTable->commit = 1;
+ m_pFilteringTable->ep = rx_prop->rx[0].src_pipe;
+ m_pFilteringTable->global = false;
+ m_pFilteringTable->ip = IPA_IP_v6;
+ m_pFilteringTable->num_rules = (uint8_t)1;
+
+ memset(&flt_rule_entry, 0, sizeof(struct ipa_flt_rule_add));
+
+ if (false == m_routing.GetRoutingTable(&IPACM_Iface::ipacmcfg->rt_tbl_v6))
+ {
+ IPACMERR("m_routing.GetRoutingTable(rt_tbl_v6) Failed.\n");
+ free(m_pFilteringTable);
+ return IPACM_FAILURE;
+ }
+
+ flt_rule_entry.at_rear = true;
+ flt_rule_entry.flt_rule_hdl = -1;
+ flt_rule_entry.status = -1;
+ flt_rule_entry.rule.action = IPA_PASS_TO_ROUTING;
+ flt_rule_entry.rule.rt_tbl_hdl = IPACM_Iface::ipacmcfg->rt_tbl_v6.hdl;
+ memcpy(&flt_rule_entry.rule.attrib,
+ &rx_prop->rx[0].attrib,
+ sizeof(struct ipa_rule_attrib));
+ flt_rule_entry.rule.attrib.attrib_mask |= IPA_FLT_DST_ADDR;
+ flt_rule_entry.rule.attrib.u.v6.dst_addr_mask[0] = 0x00000000;
+ flt_rule_entry.rule.attrib.u.v6.dst_addr_mask[1] = 0x00000000;
+ flt_rule_entry.rule.attrib.u.v6.dst_addr_mask[2] = 0x00000000;
+ flt_rule_entry.rule.attrib.u.v6.dst_addr_mask[3] = 0x00000000;
+ flt_rule_entry.rule.attrib.u.v6.dst_addr[0] = 0X00000000;
+ flt_rule_entry.rule.attrib.u.v6.dst_addr[1] = 0x00000000;
+ flt_rule_entry.rule.attrib.u.v6.dst_addr[2] = 0x00000000;
+ flt_rule_entry.rule.attrib.u.v6.dst_addr[3] = 0X00000000;
+
+ memcpy(&(m_pFilteringTable->rules[0]), &flt_rule_entry, sizeof(struct ipa_flt_rule_add));
+
+ if (false == m_filtering.AddFilteringRule(m_pFilteringTable))
+ {
+ IPACMERR("Error Adding Filtering rules, aborting...\n");
+ free(m_pFilteringTable);
+ return IPACM_FAILURE;
+ }
+ else
+ {
+ IPACMDBG("flt rule hdl0=0x%x, status=0x%x\n", m_pFilteringTable->rules[0].flt_rule_hdl, m_pFilteringTable->rules[0].status);
+ }
+
+ /* copy filter hdls */
+ dft_wan_fl_hdl[1] = m_pFilteringTable->rules[0].flt_rule_hdl;
+ free(m_pFilteringTable);
+ }
+ else
+ {
+ m_pFilteringTable = (struct ipa_ioc_add_flt_rule *)
+ calloc(1,
+ sizeof(struct ipa_ioc_add_flt_rule) +
+ 1 * sizeof(struct ipa_flt_rule_add)
+ );
+
+ if (!m_pFilteringTable)
+ {
+ IPACMDBG("Error Locate ipa_flt_rule_add memory...\n");
+ return IPACM_FAILURE;
+ }
+ m_pFilteringTable->commit = 1;
+ m_pFilteringTable->ep = rx_prop->rx[0].src_pipe;
+ m_pFilteringTable->global = false;
+ m_pFilteringTable->ip = IPA_IP_v4;
+ m_pFilteringTable->num_rules = (uint8_t)1;
+
+ if (false == m_routing.GetRoutingTable(&IPACM_Iface::ipacmcfg->rt_tbl_v6))
+ {
+ IPACMERR("m_routing.GetRoutingTable(rt_tbl_v6) Failed.\n");
+ free(m_pFilteringTable);
+ return IPACM_FAILURE;
+ }
+
+ rule_v6 = 0;
+ for (i = 0; i < firewall_config.num_extd_firewall_entries; i++)
+ {
+ if (firewall_config.extd_firewall_entries[i].ip_vsn == 6)
+ {
+ memset(&flt_rule_entry, 0, sizeof(struct ipa_flt_rule_add));
+
+ flt_rule_entry.at_rear = true;
+ flt_rule_entry.flt_rule_hdl = -1;
+ flt_rule_entry.status = -1;
+
+ flt_rule_entry.rule.action = IPA_PASS_TO_DST_NAT;
+ flt_rule_entry.rule.rt_tbl_hdl = IPACM_Iface::ipacmcfg->rt_tbl_v6.hdl;
+ memcpy(&flt_rule_entry.rule.attrib,
+ &firewall_config.extd_firewall_entries[i].attrib,
+ sizeof(struct ipa_rule_attrib));
+ flt_rule_entry.rule.attrib.attrib_mask |= rx_prop->rx[0].attrib.attrib_mask;
+ flt_rule_entry.rule.attrib.meta_data_mask = rx_prop->rx[0].attrib.meta_data_mask;
+ flt_rule_entry.rule.attrib.meta_data = rx_prop->rx[0].attrib.meta_data;
+
+ /* check if the rule is define as TCP/UDP */
+ if (firewall_config.extd_firewall_entries[i].attrib.u.v6.next_hdr == IPACM_FIREWALL_IPPROTO_TCP_UDP)
+ {
+ /* insert TCP rule*/
+ flt_rule_entry.rule.attrib.u.v6.next_hdr = IPACM_FIREWALL_IPPROTO_TCP;
+ memcpy(&(m_pFilteringTable->rules[0]), &flt_rule_entry, sizeof(struct ipa_flt_rule_add));
+ if (false == m_filtering.AddFilteringRule(m_pFilteringTable))
+ {
+ IPACMERR("Error Adding Filtering rules, aborting...\n");
+ free(m_pFilteringTable);
+ return IPACM_FAILURE;
+ }
+ else
+ {
+ /* save v4 firewall filter rule handler */
+ IPACMDBG("flt rule hdl0=0x%x, status=0x%x\n", m_pFilteringTable->rules[0].flt_rule_hdl, m_pFilteringTable->rules[0].status);
+ firewall_hdl_v6[rule_v6] = m_pFilteringTable->rules[0].flt_rule_hdl;
+ num_firewall_v6++;
+ rule_v6++;
+ }
+
+ /* insert UDP rule*/
+ flt_rule_entry.rule.attrib.u.v6.next_hdr = IPACM_FIREWALL_IPPROTO_UDP;
+ memcpy(&(m_pFilteringTable->rules[0]), &flt_rule_entry, sizeof(struct ipa_flt_rule_add));
+ if (false == m_filtering.AddFilteringRule(m_pFilteringTable))
+ {
+ IPACMERR("Error Adding Filtering rules, aborting...\n");
+ free(m_pFilteringTable);
+ return IPACM_FAILURE;
+ }
+ else
+ {
+ /* save v6 firewall filter rule handler */
+ IPACMDBG("flt rule hdl0=0x%x, status=0x%x\n", m_pFilteringTable->rules[0].flt_rule_hdl, m_pFilteringTable->rules[0].status);
+ firewall_hdl_v6[rule_v6] = m_pFilteringTable->rules[0].flt_rule_hdl;
+ num_firewall_v6++;
+ rule_v6++;
+ }
+ }
+ else
+ {
+
+ memcpy(&(m_pFilteringTable->rules[0]), &flt_rule_entry, sizeof(struct ipa_flt_rule_add));
+ if (false == m_filtering.AddFilteringRule(m_pFilteringTable))
+ {
+ IPACMERR("Error Adding Filtering rules, aborting...\n");
+ free(m_pFilteringTable);
+ return IPACM_FAILURE;
+ }
+ else
+ {
+ /* save v6 firewall filter rule handler */
+ IPACMDBG("flt rule hdl0=0x%x, status=0x%x\n", m_pFilteringTable->rules[0].flt_rule_hdl, m_pFilteringTable->rules[0].status);
+ firewall_hdl_v6[rule_v6] = m_pFilteringTable->rules[0].flt_rule_hdl;
+ num_firewall_v6++;
+ rule_v6++;
+ }
+ }
+ }
+ } /* end of firewall ipv6 filter rule add for loop*/
+
+ /* setup default wan filter rule */
+ memset(&flt_rule_entry, 0, sizeof(struct ipa_flt_rule_add));
+
+ flt_rule_entry.at_rear = true;
+ flt_rule_entry.flt_rule_hdl = -1;
+ flt_rule_entry.status = -1;
+ flt_rule_entry.rule.action = IPA_PASS_TO_EXCEPTION;
+ memcpy(&flt_rule_entry.rule.attrib,
+ &rx_prop->rx[0].attrib,
+ sizeof(struct ipa_rule_attrib));
+ flt_rule_entry.rule.attrib.attrib_mask |= IPA_FLT_DST_ADDR;
+ flt_rule_entry.rule.attrib.u.v6.dst_addr_mask[0] = 0x00000000;
+ flt_rule_entry.rule.attrib.u.v6.dst_addr_mask[1] = 0x00000000;
+ flt_rule_entry.rule.attrib.u.v6.dst_addr_mask[2] = 0x00000000;
+ flt_rule_entry.rule.attrib.u.v6.dst_addr_mask[3] = 0x00000000;
+ flt_rule_entry.rule.attrib.u.v6.dst_addr[0] = 0X00000000;
+ flt_rule_entry.rule.attrib.u.v6.dst_addr[1] = 0x00000000;
+ flt_rule_entry.rule.attrib.u.v6.dst_addr[2] = 0x00000000;
+ flt_rule_entry.rule.attrib.u.v6.dst_addr[3] = 0X00000000;
+
+ memcpy(&(m_pFilteringTable->rules[0]), &flt_rule_entry, sizeof(struct ipa_flt_rule_add));
+
+ if (false == m_filtering.AddFilteringRule(m_pFilteringTable))
+ {
+ IPACMERR("Error Adding Filtering rules, aborting...\n");
+ free(m_pFilteringTable);
+ return IPACM_FAILURE;
+ }
+ else
+ {
+ IPACMDBG("flt rule hdl0=0x%x, status=0x%x\n", m_pFilteringTable->rules[0].flt_rule_hdl, m_pFilteringTable->rules[0].status);
+ }
+ /* copy filter hdls*/
+ dft_wan_fl_hdl[1] = m_pFilteringTable->rules[0].flt_rule_hdl;
+ free(m_pFilteringTable);
+ }
+ }
+ return IPACM_SUCCESS;
+}
+
+
+
+/*handle wan-iface down event */
+int IPACM_Wan::handle_down_evt()
+{
+ int res = IPACM_SUCCESS;
+ int i;
+
+ IPACMDBG(" wan handle_down_evt \n");
+
+ /* no iface address up, directly close iface*/
+ if (ip_type == IPACM_IP_NULL)
+ {
+ goto fail;
+ }
+
+ /* make sure default routing rules and firewall rules are deleted*/
+ if (ip_type != IPA_IP_v6)
+ {
+ del_dft_firewall_rules(IPA_IP_v4);
+ handle_route_del_evt(IPA_IP_v4);
+ }
+
+ if (ip_type != IPA_IP_v4)
+ {
+ del_dft_firewall_rules(IPA_IP_v6);
+ handle_route_del_evt(IPA_IP_v6);
+ }
+
+ /* Delete default v4 RT rule */
+ if (ip_type != IPA_IP_v6)
+ {
+ IPACMDBG("Delete default v4 routing rules\n");
+ if (m_routing.DeleteRoutingHdl(dft_rt_rule_hdl[0], IPA_IP_v4)
+ == false)
+ {
+ IPACMDBG("Routing rule deletion failed!\n");
+ res = IPACM_FAILURE;
+ goto fail;
+ }
+ }
+
+ /* delete default v6 RT rule */
+ if (ip_type != IPA_IP_v4)
+ {
+ IPACMDBG("Delete default v6 routing rules\n");
+ /* May have multiple ipv6 iface-routing rules*/
+ for (i = 0; i < num_dft_rt; i++)
+ {
+ if (m_routing.DeleteRoutingHdl(dft_rt_rule_hdl[1 + i], IPA_IP_v6)
+ == false)
+ {
+ IPACMERR("Routing rule deletion failed!\n");
+ res = IPACM_FAILURE;
+ goto fail;
+ }
+ }
+
+ IPACMDBG("finished delete default v6 RT rules\n ");
+ }
+
+ /* check software routing fl rule hdl */
+ if (softwarerouting_act == true)
+ {
+ IPACM_Iface::handle_software_routing_disable();
+ handle_software_routing_disable();
+ }
+
+ /* free filter rule handlers */
+ if (ip_type != IPA_IP_v6)
+ {
+ if (m_filtering.DeleteFilteringHdls(dft_v4fl_rule_hdl,
+ IPA_IP_v4,
+ IPV4_DEFAULT_FILTERTING_RULES) == false)
+ {
+ IPACMERR("Error Delete Filtering rules, aborting...\n");
+ res = IPACM_FAILURE;
+ goto fail;
+ }
+
+ IPACMDBG("finished delete default v4 filtering rules\n ");
+ }
+
+
+ if (ip_type != IPA_IP_v4)
+ {
+ if (m_filtering.DeleteFilteringHdls(dft_v6fl_rule_hdl,
+ IPA_IP_v6,
+ IPV6_DEFAULT_FILTERTING_RULES) == false)
+ {
+ IPACMERR("ErrorDeleting Filtering rule, aborting...\n");
+ res = IPACM_FAILURE;
+ goto fail;
+ }
+
+ IPACMDBG("finished delete default v6 filtering rules\n ");
+ }
+
+fail:
+ free(tx_prop);
+ free(rx_prop);
+ free(iface_query);
+
+ return res;
+}
+
+/*clean firewall filter rules */
+int IPACM_Wan::del_dft_firewall_rules(ipa_ip_type iptype)
+{
+ /* free v4 firewall filter rule */
+ if ((iptype == IPA_IP_v4) && (active_v4 == true))
+ {
+ if (num_firewall_v4 != 0)
+ {
+ if (m_filtering.DeleteFilteringHdls(firewall_hdl_v4,
+ IPA_IP_v4, num_firewall_v4) == false)
+ {
+ IPACMERR("Error Deleting Filtering rules, aborting...\n");
+ return IPACM_FAILURE;
+ }
+ }
+ else
+ {
+ IPACMDBG("No ipv4 firewall rules, no need deleted\n");
+ }
+
+ if (m_filtering.DeleteFilteringHdls(dft_wan_fl_hdl,
+ IPA_IP_v4, 1) == false)
+ {
+ IPACMERR("Error Deleting Filtering rules, aborting...\n");
+ return IPACM_FAILURE;
+ }
+
+ num_firewall_v4 = 0;
+ }
+
+ /* free v6 firewall filter rule */
+ if ((iptype == IPA_IP_v6) && (active_v6 == true))
+ {
+ if (num_firewall_v6 != 0)
+ {
+ if (m_filtering.DeleteFilteringHdls(firewall_hdl_v6,
+ IPA_IP_v6, num_firewall_v6) == false)
+ {
+ IPACMERR("Error Deleting Filtering rules, aborting...\n");
+ return IPACM_FAILURE;
+ }
+ }
+ else
+ {
+ IPACMDBG("No ipv6 firewall rules, no need deleted\n");
+ }
+
+ if (m_filtering.DeleteFilteringHdls(&dft_wan_fl_hdl[1],
+ IPA_IP_v6, 1) == false)
+ {
+ IPACMERR("Error Deleting Filtering rules, aborting...\n");
+ return IPACM_FAILURE;
+ }
+ num_firewall_v6 = 0;
+ }
+
+ return IPACM_SUCCESS;
+}
diff --git a/ipacm/src/IPACM_Wlan.cpp b/ipacm/src/IPACM_Wlan.cpp
new file mode 100644
index 0000000..0160406
--- /dev/null
+++ b/ipacm/src/IPACM_Wlan.cpp
@@ -0,0 +1,1421 @@
+/*
+Copyright (c) 2013, The Linux Foundation. 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 name of The Linux 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 "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+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.
+*/
+/*!
+@file
+IPACM_Wlan.cpp
+
+@brief
+This file implements the WLAN iface functionality.
+
+@Author
+Skylar Chang
+
+*/
+
+#include <string.h>
+#include <unistd.h>
+#include <sys/ioctl.h>
+#include <IPACM_Wlan.h>
+#include <IPACM_Netlink.h>
+#include <fcntl.h>
+#include <sys/inotify.h>
+#include <IPACM_Wan.h>
+#include <IPACM_Lan.h>
+#include <IPACM_IfaceManager.h>
+
+/* static member to store the number of total wifi clients within all APs*/
+int IPACM_Wlan::total_num_wifi_clients = 0;
+
+IPACM_Wlan::IPACM_Wlan(int iface_index) : IPACM_Lan(iface_index)
+{
+#define WLAN_AMPDU_DEFAULT_FILTER_RULES 3
+
+ num_wifi_client = 0;
+ header_name_count = 0;
+
+ /* one for WAN and two for Soft-routing */
+ wlan_ampdu_flt_rule.num_rules = WLAN_AMPDU_DEFAULT_FILTER_RULES;
+
+ wlan_ampdu_flt_rule.hdl[0] = 0; /* for WAN */
+ wlan_ampdu_flt_rule.ip[0] = IPA_IP_v4; /* for WAN */
+
+ wlan_ampdu_flt_rule.hdl[1] = 0; /* for Soft-routing */
+ wlan_ampdu_flt_rule.ip[1] = IPA_IP_v4; /* for Soft-routing */
+
+ wlan_ampdu_flt_rule.hdl[2] = 0; /* for Soft-routing */
+ wlan_ampdu_flt_rule.ip[2] = IPA_IP_v6; /* for Soft-routing */
+
+ wlan_client_len = (sizeof(ipa_wlan_client)) + (iface_query->num_tx_props * sizeof(wlan_client_rt_hdl));
+ wlan_client = (ipa_wlan_client *)calloc(IPA_MAX_NUM_WIFI_CLIENTS, wlan_client_len);
+ if (wlan_client == NULL)
+ {
+ IPACMERR("unable to allocate memory\n");
+ return;
+ }
+
+ IPACMDBG("index:%d constructor: Tx properties:%d\n", iface_index, iface_query->num_tx_props);
+ return;
+}
+
+
+IPACM_Wlan::~IPACM_Wlan()
+{
+ IPACM_EvtDispatcher::deregistr(this);
+ IPACM_IfaceManager::deregistr(this);
+ return;
+}
+
+void IPACM_Wlan::event_callback(ipa_cm_event_id event, void *param)
+{
+ int ipa_interface_index;
+
+ switch (event)
+ {
+
+ case IPA_LINK_DOWN_EVENT:
+ {
+ ipacm_event_data_fid *data = (ipacm_event_data_fid *)param;
+ ipa_interface_index = iface_ipa_index_query(data->if_index);
+ if (ipa_interface_index == ipa_if_num)
+ {
+ IPACMDBG("Received IPA_LINK_DOWN_EVENT\n");
+ handle_down_evt();
+ IPACMDBG("ipa_WLAN (%s):ipa_index (%d) instance close \n",
+ IPACM_Iface::ipacmcfg->iface_table[ipa_if_num].iface_name, ipa_if_num);
+ delete this;
+ return;
+ }
+ }
+ break;
+
+ case IPA_ADDR_ADD_EVENT:
+ {
+ ipacm_event_data_addr *data = (ipacm_event_data_addr *)param;
+ ipa_interface_index = iface_ipa_index_query(data->if_index);
+
+ if (ipa_interface_index == ipa_if_num)
+ {
+ if ((data->iptype != ip_type) && (ip_type != IPA_IP_MAX)) // check not setup before
+ {
+ /* Post event to NAT */
+ if (data->iptype == IPA_IP_v4)
+ {
+ ipacm_cmd_q_data evt_data;
+ ipacm_event_iface_up *info;
+
+ info = (ipacm_event_iface_up *)
+ malloc(sizeof(ipacm_event_iface_up));
+ if (info == NULL)
+ {
+ IPACMERR("Unable to allocate memory\n");
+ return;
+ }
+
+ memcpy(info->ifname, dev_name, IF_NAME_LEN);
+ info->ipv4_addr = data->ipv4_addr;
+ info->addr_mask = IPACM_Iface::ipacmcfg->private_subnet_table[0].subnet_mask;
+
+ evt_data.event = IPA_HANDLE_WLAN_UP;
+ evt_data.evt_data = (void *)info;
+
+ /* Insert IPA_HANDLE_WLAN_UP to command queue */
+ IPACMDBG("posting IPA_HANDLE_WLAN_UP for IPv4 with below information\n");
+ IPACMDBG("IPv4 address:0x%x, IPv4 address mask:0x%x\n",
+ info->ipv4_addr, info->addr_mask);
+ IPACM_EvtDispatcher::PostEvt(&evt_data);
+ }
+
+ IPACM_Lan::handle_addr_evt(data);
+ handle_addr_evt(data);
+
+ IPACM_Lan::handle_private_subnet(data->iptype);
+ handle_private_subnet(data->iptype);
+
+ if (IPACM_Wan::isWanUP() && (data->iptype == IPA_IP_v4))
+ {
+ IPACM_Lan::handle_wan_up();
+ handle_wan_up();
+ }
+
+ IPACMDBG("posting IPA_HANDLE_WLAN_UP:Finished checking wan_up\n");
+ }
+ }
+ }
+ break;
+
+ case IPA_HANDLE_WAN_UP:
+ IPACMDBG("Received IPA_HANDLE_WAN_UP event\n");
+ IPACM_Lan::handle_wan_up();
+ handle_wan_up();
+ break;
+
+ case IPA_HANDLE_WAN_DOWN:
+ IPACMDBG("Received IPA_HANDLE_WAN_DOWN event\n");
+ IPACM_Lan::handle_wan_down();
+ handle_wan_down();
+ break;
+
+ case IPA_WLAN_CLIENT_ADD_EVENT:
+ {
+ ipacm_event_data_mac *data = (ipacm_event_data_mac *)param;
+ ipa_interface_index = iface_ipa_index_query(data->if_index);
+ if (ipa_interface_index == ipa_if_num)
+ {
+ IPACMDBG("Received IPA_WLAN_CLIENT_ADD_EVENT\n");
+ handle_wlan_client_init(data->mac_addr);
+ }
+ }
+ break;
+
+ case IPA_WLAN_CLIENT_DEL_EVENT:
+ {
+ ipacm_event_data_mac *data = (ipacm_event_data_mac *)param;
+ ipa_interface_index = iface_ipa_index_query(data->if_index);
+ if (ipa_interface_index == ipa_if_num)
+ {
+ IPACMDBG("Received IPA_WLAN_CLIENT_DEL_EVENT\n");
+ handle_wlan_client_down_evt(data->mac_addr);
+ }
+ }
+ break;
+
+ case IPA_WLAN_CLIENT_POWER_SAVE_EVENT:
+ {
+ ipacm_event_data_mac *data = (ipacm_event_data_mac *)param;
+ ipa_interface_index = iface_ipa_index_query(data->if_index);
+ if (ipa_interface_index == ipa_if_num)
+ {
+ IPACMDBG("Received IPA_WLAN_CLIENT_POWER_SAVE_EVENT\n");
+ handle_wlan_client_pwrsave(data->mac_addr);
+ }
+ }
+ break;
+
+ case IPA_WLAN_CLIENT_RECOVER_EVENT:
+ {
+ ipacm_event_data_mac *data = (ipacm_event_data_mac *)param;
+ ipa_interface_index = iface_ipa_index_query(data->if_index);
+ if (ipa_interface_index == ipa_if_num)
+ {
+ IPACMDBG("Received IPA_WLAN_CLIENT_RECOVER_EVENT\n");
+ if (ip_type != IPA_IP_v6) /* for ipv4 */
+ {
+ handle_wlan_client_route_rule(data->mac_addr, IPA_IP_v4);
+ }
+
+ if (ip_type != IPA_IP_v4) /* for ipv6 */
+ {
+ handle_wlan_client_route_rule(data->mac_addr, IPA_IP_v6);
+ }
+ }
+ }
+ break;
+
+ case IPA_NEIGH_CLIENT_IP_ADDR_ADD_EVENT:
+ {
+ ipacm_event_data_all *data = (ipacm_event_data_all *)param;
+ ipa_interface_index = iface_ipa_index_query(data->if_index);
+ if (ipa_interface_index == ipa_if_num)
+ {
+ IPACMDBG("Received IPA_NEIGH_CLIENT_IP_ADDR_ADD_EVENT\n");
+ if (handle_wlan_client_ipaddr(data) == IPACM_FAILURE)
+ {
+ return;
+ }
+ handle_wlan_client_route_rule(data->mac_addr, data->iptype);
+ }
+ }
+ break;
+
+ /* handle software routing enable event*/
+ case IPA_SW_ROUTING_ENABLE:
+ IPACMDBG("Received IPA_SW_ROUTING_ENABLE\n");
+ IPACM_Iface::handle_software_routing_enable();
+ handle_software_routing_enable();
+ break;
+
+ /* handle software routing disable event*/
+ case IPA_SW_ROUTING_DISABLE:
+ IPACMDBG("Received IPA_SW_ROUTING_DISABLE\n");
+ IPACM_Iface::handle_software_routing_disable();
+ handle_software_routing_disable();
+ break;
+
+ default:
+ break;
+ }
+ return;
+}
+
+/* handle wifi client initial,copy all partial headers (tx property) */
+int IPACM_Wlan::handle_wlan_client_init(uint8_t *mac_addr)
+{
+
+#define WLAN_IFACE_INDEX_LEN 2
+
+ int res = IPACM_SUCCESS, len = 0;
+ char index[WLAN_IFACE_INDEX_LEN];
+ struct ipa_ioc_copy_hdr sCopyHeader;
+ struct ipa_ioc_add_hdr *pHeaderDescriptor = NULL;
+
+ /* start of adding header */
+ if ((num_wifi_client >= IPA_MAX_NUM_WIFI_CLIENTS) ||
+ (IPACM_Wlan::total_num_wifi_clients >= IPA_MAX_NUM_WIFI_CLIENTS))
+ {
+ IPACMERR("Reached maximum number of wlan clients\n");
+ return IPACM_FAILURE;
+ }
+
+ IPACMDBG("Wifi client number: %d\n", num_wifi_client);
+
+ IPACMDBG("Received Client MAC %02x:%02x:%02x:%02x:%02x:%02x\n",
+ mac_addr[0], mac_addr[1], mac_addr[2],
+ mac_addr[3], mac_addr[4], mac_addr[5]);
+
+ memcpy(get_client_memptr(wlan_client, num_wifi_client)->mac,
+ mac_addr,
+ sizeof(get_client_memptr(wlan_client, num_wifi_client)->mac));
+
+ IPACMDBG("stored MAC %02x:%02x:%02x:%02x:%02x:%02x\n",
+ get_client_memptr(wlan_client, num_wifi_client)->mac[0],
+ get_client_memptr(wlan_client, num_wifi_client)->mac[1],
+ get_client_memptr(wlan_client, num_wifi_client)->mac[2],
+ get_client_memptr(wlan_client, num_wifi_client)->mac[3],
+ get_client_memptr(wlan_client, num_wifi_client)->mac[4],
+ get_client_memptr(wlan_client, num_wifi_client)->mac[5]);
+
+ /* add header to IPA */
+ len = sizeof(struct ipa_ioc_add_hdr) + (1 * sizeof(struct ipa_hdr_add));
+ pHeaderDescriptor = (struct ipa_ioc_add_hdr *)calloc(1, len);
+ if (pHeaderDescriptor == NULL)
+ {
+ IPACMERR("calloc failed to allocate pHeaderDescriptor\n");
+ return IPACM_FAILURE;
+ }
+
+ /* copy partial header */
+ memset(&sCopyHeader, 0, sizeof(sCopyHeader));
+ memcpy(sCopyHeader.name,
+ tx_prop->tx[0].hdr_name,
+ sizeof(sCopyHeader.name));
+
+ IPACMDBG("header name: %s\n", sCopyHeader.name);
+ if (m_header.CopyHeader(&sCopyHeader) == false)
+ {
+ PERROR("ioctl copy header failed");
+ res = IPACM_FAILURE;
+ goto fail;
+ }
+
+ IPACMDBG("header length: %d, paritial: %d\n", sCopyHeader.hdr_len, sCopyHeader.is_partial);
+ if (sCopyHeader.hdr_len > IPA_HDR_MAX_SIZE)
+ {
+ IPACMERR("header oversize\n");
+ res = IPACM_FAILURE;
+ goto fail;
+ }
+ else
+ {
+ memcpy(pHeaderDescriptor->hdr[0].hdr,
+ sCopyHeader.hdr,
+ sCopyHeader.hdr_len);
+ }
+
+ /* copy client mac_addr to partial header */
+ memcpy(&pHeaderDescriptor->hdr[0].hdr[IPA_WLAN_PARTIAL_HDR_OFFSET],
+ get_client_memptr(wlan_client, num_wifi_client)->mac,
+ IPA_MAC_ADDR_SIZE);
+
+ pHeaderDescriptor->commit = true;
+ pHeaderDescriptor->num_hdrs = 1;
+
+ memset(pHeaderDescriptor->hdr[0].name, 0,
+ sizeof(pHeaderDescriptor->hdr[0].name));
+
+ sprintf(index, "%d", ipa_if_num);
+ strncpy(pHeaderDescriptor->hdr[0].name, index, sizeof(index));
+
+ strncat(pHeaderDescriptor->hdr[0].name,
+ IPA_WLAN_PARTIAL_HDR_NAME,
+ sizeof(IPA_WLAN_PARTIAL_HDR_NAME));
+
+ sprintf(index, "%d", header_name_count);
+ strncat(pHeaderDescriptor->hdr[0].name, index, sizeof(index));
+
+ pHeaderDescriptor->hdr[0].hdr_len = sCopyHeader.hdr_len;
+ pHeaderDescriptor->hdr[0].hdr_hdl = -1;
+ pHeaderDescriptor->hdr[0].is_partial = 0;
+ pHeaderDescriptor->hdr[0].status = -1;
+
+ if (m_header.AddHeader(pHeaderDescriptor) == false ||
+ pHeaderDescriptor->hdr[0].status != 0)
+ {
+ IPACMERR("ioctl IPA_IOC_ADD_HDR failed: %d\n", pHeaderDescriptor->hdr[0].status);
+ res = IPACM_FAILURE;
+ goto fail;
+ }
+
+ get_client_memptr(wlan_client, num_wifi_client)->hdr_hdl = pHeaderDescriptor->hdr[0].hdr_hdl;
+ IPACMDBG("client(%d) full header name:%s header handle:(0x%x)\n",
+ num_wifi_client,
+ pHeaderDescriptor->hdr[0].name,
+ get_client_memptr(wlan_client, num_wifi_client)->hdr_hdl);
+ /* initialize wifi client*/
+ get_client_memptr(wlan_client, num_wifi_client)->route_rule_set_v4 = false;
+ get_client_memptr(wlan_client, num_wifi_client)->route_rule_set_v6 = false;
+ get_client_memptr(wlan_client, num_wifi_client)->ipv4_set = false;
+ get_client_memptr(wlan_client, num_wifi_client)->ipv6_set = false;
+
+ num_wifi_client++;
+ header_name_count++; //keep increasing header_name_count
+ IPACM_Wlan::total_num_wifi_clients++;
+ res = IPACM_SUCCESS;
+
+ IPACMDBG("Wifi client number: %d\n", num_wifi_client);
+
+fail:
+ free(pHeaderDescriptor);
+
+ return res;
+}
+
+/*handle wifi client */
+int IPACM_Wlan::handle_wlan_client_ipaddr(ipacm_event_data_all *data)
+{
+ int clnt_indx;
+
+ IPACMDBG("number of wifi clients: %d\n", num_wifi_client);
+ IPACMDBG(" event MAC %02x:%02x:%02x:%02x:%02x:%02x\n",
+ data->mac_addr[0],
+ data->mac_addr[1],
+ data->mac_addr[2],
+ data->mac_addr[3],
+ data->mac_addr[4],
+ data->mac_addr[5]);
+
+ clnt_indx = get_wlan_client_index(data->mac_addr);
+ if (clnt_indx == IPACM_INVALID_INDEX)
+ {
+ if (clnt_indx == IPACM_INVALID_INDEX)
+ {
+ IPACMDBG("wlan client not found/attached \n");
+ return IPACM_FAILURE;
+ }
+ }
+
+ IPACMDBG("Ip type received %d\n", data->iptype);
+ if (data->iptype == IPA_IP_v4)
+ {
+ IPACMDBG("Ipv4 with ipv4 address: 0x%x\n", data->ipv4_addr);
+ if (data->ipv4_addr != 0) /* not 0.0.0.0 */
+ {
+ if (get_client_memptr(wlan_client, clnt_indx)->ipv4_set == false)
+ {
+ get_client_memptr(wlan_client, clnt_indx)->v4_addr = data->ipv4_addr;
+ get_client_memptr(wlan_client, clnt_indx)->ipv4_set = true;
+ }
+ else
+ {
+ IPACMDBG("Already setup ipv4 addr for client:%d\n", clnt_indx);
+ }
+ }
+ }
+ else
+ {
+ if ((data->ipv6_addr[0] != 0) || (data->ipv6_addr[1] != 0) ||
+ (data->ipv6_addr[2] != 0) || (data->ipv6_addr[3] || 0)) /* check if all 0 not valid ipv6 address */
+ {
+ if (get_client_memptr(wlan_client, clnt_indx)->ipv6_set == false)
+ {
+ get_client_memptr(wlan_client, clnt_indx)->v6_addr[0] = data->ipv6_addr[0];
+ get_client_memptr(wlan_client, clnt_indx)->v6_addr[1] = data->ipv6_addr[1];
+ get_client_memptr(wlan_client, clnt_indx)->v6_addr[2] = data->ipv6_addr[2];
+ get_client_memptr(wlan_client, clnt_indx)->v6_addr[3] = data->ipv6_addr[3];
+ get_client_memptr(wlan_client, clnt_indx)->ipv6_set = true;
+ }
+ else
+ {
+ IPACMDBG("Already setup ipv6 addr for client:%d\n", clnt_indx);
+ }
+ }
+ }
+
+ return IPACM_SUCCESS;
+}
+
+/*handle wifi client routing rule*/
+int IPACM_Wlan::handle_wlan_client_route_rule(uint8_t *mac_addr, ipa_ip_type iptype)
+{
+ struct ipa_ioc_add_rt_rule *rt_rule;
+ struct ipa_rt_rule_add *rt_rule_entry;
+ uint32_t tx_index;
+ int wlan_index;
+
+ IPACMDBG("Received mac_addr MAC %02x:%02x:%02x:%02x:%02x:%02x\n",
+ mac_addr[0], mac_addr[1], mac_addr[2],
+ mac_addr[3], mac_addr[4], mac_addr[5]);
+
+ wlan_index = get_wlan_client_index(mac_addr);
+ if (wlan_index == IPACM_INVALID_INDEX)
+ {
+ IPACMDBG("wlan client not found/attached \n");
+ return IPACM_SUCCESS;
+ }
+
+ IPACMDBG("wlan client index: %d, ip-type: %d, ipv4_set:%d, ipv4_rule_set:%d \n", wlan_index, iptype,
+ get_client_memptr(wlan_client, wlan_index)->ipv4_set,
+ get_client_memptr(wlan_client, wlan_index)->route_rule_set_v4);
+ /* Add default 4 Qos routing rules if not set yet */
+ if ((iptype == IPA_IP_v4
+ && get_client_memptr(wlan_client, wlan_index)->route_rule_set_v4 == false
+ && get_client_memptr(wlan_client, wlan_index)->ipv4_set == true)
+ || (iptype == IPA_IP_v6
+ && get_client_memptr(wlan_client, wlan_index)->route_rule_set_v6 == false
+ && get_client_memptr(wlan_client, wlan_index)->ipv6_set == true))
+ {
+ IPACMDBG("client index(%d):ipv4 address: 0x%x\n", wlan_index,
+ get_client_memptr(wlan_client, wlan_index)->v4_addr);
+
+ IPACMDBG("client(%d): header handle:(0x%x), num of rules: %d\n",
+ wlan_index,
+ get_client_memptr(wlan_client, wlan_index)->hdr_hdl,
+ iface_query->num_tx_props);
+
+
+ rt_rule = (struct ipa_ioc_add_rt_rule *)
+ calloc(1, sizeof(struct ipa_ioc_add_rt_rule) +
+ (iface_query->num_tx_props * sizeof(struct ipa_rt_rule_add)));
+
+ if (rt_rule == NULL)
+ {
+ PERROR("Error Locate ipa_ioc_add_rt_rule memory...\n");
+ return IPACM_FAILURE;
+ }
+
+ rt_rule->commit = 1;
+ rt_rule->num_rules = iface_query->num_tx_props;
+ rt_rule->ip = iptype;
+
+ for (tx_index = 0; tx_index < iface_query->num_tx_props; tx_index++)
+ {
+ if (iptype == IPA_IP_v4)
+ {
+ strncpy(rt_rule->rt_tbl_name,
+ IPACM_Iface::ipacmcfg->rt_tbl_lan_v4.name,
+ sizeof(rt_rule->rt_tbl_name));
+ }
+ else
+ {
+ strncpy(rt_rule->rt_tbl_name,
+ IPACM_Iface::ipacmcfg->rt_tbl_v6.name,
+ sizeof(rt_rule->rt_tbl_name));
+ }
+
+ rt_rule_entry = &rt_rule->rules[tx_index];
+ rt_rule_entry->at_rear = 0;
+ rt_rule_entry->rule.dst = tx_prop->tx[tx_index].dst_pipe;
+ rt_rule_entry->rule.hdr_hdl = get_client_memptr(wlan_client, wlan_index)->hdr_hdl;
+
+ memcpy(&rt_rule_entry->rule.attrib,
+ &tx_prop->tx[tx_index].attrib,
+ sizeof(rt_rule_entry->rule.attrib));
+ rt_rule_entry->rule.attrib.attrib_mask |= IPA_FLT_DST_ADDR;
+
+ if (iptype == IPA_IP_v4)
+ {
+ rt_rule_entry->rule.attrib.u.v4.dst_addr = get_client_memptr(wlan_client, wlan_index)->v4_addr;
+ rt_rule_entry->rule.attrib.u.v4.dst_addr_mask = 0xFFFFFFFF;
+ }
+ else if (iptype == IPA_IP_v6)
+ {
+ rt_rule_entry->rule.attrib.u.v6.dst_addr[0] = get_client_memptr(wlan_client, wlan_index)->v6_addr[0];
+ rt_rule_entry->rule.attrib.u.v6.dst_addr[1] = get_client_memptr(wlan_client, wlan_index)->v6_addr[1];
+ rt_rule_entry->rule.attrib.u.v6.dst_addr[2] = get_client_memptr(wlan_client, wlan_index)->v6_addr[2];
+ rt_rule_entry->rule.attrib.u.v6.dst_addr[3] = get_client_memptr(wlan_client, wlan_index)->v6_addr[3];
+ rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[0] = 0xFFFFFFFF;
+ rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[1] = 0xFFFFFFFF;
+ rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[2] = 0xFFFFFFFF;
+ rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[3] = 0xFFFFFFFF;
+ }
+ } /* end of for loop */
+
+ if (false == m_routing.AddRoutingRule(rt_rule))
+ {
+ IPACMERR("Routing rule addition failed!\n");
+ free(rt_rule);
+ return IPACM_FAILURE;
+ }
+
+ for (tx_index = 0; tx_index < iface_query->num_tx_props; tx_index++)
+ {
+ if (iptype == IPA_IP_v4)
+ {
+ get_client_memptr(wlan_client, wlan_index)->wifi_rt_hdl[tx_index].wifi_rt_rule_hdl_v4 =
+ rt_rule->rules[tx_index].rt_rule_hdl;
+ IPACMDBG("tx:%d, rt rule hdl=%x ip-type: %d\n", tx_index,
+ get_client_memptr(wlan_client, wlan_index)->wifi_rt_hdl[tx_index].wifi_rt_rule_hdl_v4, iptype);
+ }
+ else if (iptype == IPA_IP_v6)
+ {
+ get_client_memptr(wlan_client, wlan_index)->wifi_rt_hdl[tx_index].wifi_rt_rule_hdl_v6 =
+ rt_rule->rules[tx_index].rt_rule_hdl;
+ IPACMDBG("tx:%d, rt rule hdl=%x ip-type: %d\n", tx_index,
+ get_client_memptr(wlan_client, wlan_index)->wifi_rt_hdl[tx_index].wifi_rt_rule_hdl_v6, iptype);
+ }
+ }
+
+ free(rt_rule);
+
+ if (iptype == IPA_IP_v4)
+ {
+ get_client_memptr(wlan_client, wlan_index)->route_rule_set_v4 = true;
+ }
+ else
+ {
+ get_client_memptr(wlan_client, wlan_index)->route_rule_set_v6 = true;
+ }
+ }
+
+ return IPACM_SUCCESS;
+}
+
+/*handle wifi client power-save mode*/
+int IPACM_Wlan::handle_wlan_client_pwrsave(uint8_t *mac_addr)
+{
+ int clt_indx;
+ IPACMDBG("wlan->handle_wlan_client_pwrsave();\n");
+
+ clt_indx = get_wlan_client_index(mac_addr);
+ if (clt_indx == IPACM_INVALID_INDEX)
+ {
+ IPACMDBG("wlan client not attached\n");
+ return IPACM_SUCCESS;
+ }
+
+ /*check if got duplicate power-save mode*/
+ if ((ip_type != IPA_IP_v6 && get_client_memptr(wlan_client, clt_indx)->route_rule_set_v4 == true)
+ || (ip_type != IPA_IP_v4 && get_client_memptr(wlan_client, clt_indx)->route_rule_set_v6 == true))
+ {
+ return delete_default_qos_rtrules(clt_indx);
+ }
+ else
+ {
+ IPACMDBG("wlan client already in power-save mode\n");
+ return IPACM_SUCCESS;
+ }
+}
+
+/*handle wifi client del mode*/
+int IPACM_Wlan::handle_wlan_client_down_evt(uint8_t *mac_addr)
+{
+ int clt_indx;
+ uint32_t tx_index;
+ int num_wifi_client_tmp = num_wifi_client;
+
+ IPACMDBG("total client: %d\n", num_wifi_client_tmp);
+
+ clt_indx = get_wlan_client_index(mac_addr);
+ if (clt_indx == IPACM_INVALID_INDEX)
+ {
+ IPACMDBG("wlan client not attached\n");
+ return IPACM_SUCCESS;
+ }
+
+ if (delete_default_qos_rtrules(clt_indx))
+ {
+ IPACMDBG("unbale to delete default qos route rules\n");
+ return IPACM_FAILURE;
+ }
+
+ /* Delete wlan client header */
+ if (m_header.DeleteHeaderHdl(get_client_memptr(wlan_client, clt_indx)->hdr_hdl)
+ == false)
+ {
+ return IPACM_FAILURE;
+ }
+
+ /* Reset ip_set to 0*/
+ get_client_memptr(wlan_client, clt_indx)->ipv4_set = false;
+ get_client_memptr(wlan_client, clt_indx)->ipv6_set = false;
+ get_client_memptr(wlan_client, clt_indx)->route_rule_set_v4 = false;
+ get_client_memptr(wlan_client, clt_indx)->route_rule_set_v6 = false;
+
+ for (; clt_indx < num_wifi_client_tmp - 1; clt_indx++)
+ {
+ memcpy(get_client_memptr(wlan_client, clt_indx)->mac,
+ get_client_memptr(wlan_client, (clt_indx + 1))->mac,
+ sizeof(get_client_memptr(wlan_client, clt_indx)->mac));
+
+ get_client_memptr(wlan_client, clt_indx)->hdr_hdl = get_client_memptr(wlan_client, (clt_indx + 1))->hdr_hdl;
+ get_client_memptr(wlan_client, clt_indx)->v4_addr = get_client_memptr(wlan_client, (clt_indx + 1))->v4_addr;
+
+ get_client_memptr(wlan_client, clt_indx)->ipv4_set = get_client_memptr(wlan_client, (clt_indx + 1))->ipv4_set;
+ get_client_memptr(wlan_client, clt_indx)->ipv6_set = get_client_memptr(wlan_client, (clt_indx + 1))->ipv6_set;
+ get_client_memptr(wlan_client, clt_indx)->route_rule_set_v4 = get_client_memptr(wlan_client, (clt_indx + 1))->route_rule_set_v4;
+ get_client_memptr(wlan_client, clt_indx)->route_rule_set_v6 = get_client_memptr(wlan_client, (clt_indx + 1))->route_rule_set_v6;
+
+ get_client_memptr(wlan_client, clt_indx)->v6_addr[0] = get_client_memptr(wlan_client, (clt_indx + 1))->v6_addr[0];
+ get_client_memptr(wlan_client, clt_indx)->v6_addr[1] = get_client_memptr(wlan_client, (clt_indx + 1))->v6_addr[1];
+ get_client_memptr(wlan_client, clt_indx)->v6_addr[2] = get_client_memptr(wlan_client, (clt_indx + 1))->v6_addr[2];
+ get_client_memptr(wlan_client, clt_indx)->v6_addr[3] = get_client_memptr(wlan_client, (clt_indx + 1))->v6_addr[3];
+
+ for (tx_index = 0; tx_index < iface_query->num_tx_props; tx_index++)
+ {
+ get_client_memptr(wlan_client, clt_indx)->wifi_rt_hdl[tx_index].wifi_rt_rule_hdl_v4 =
+ get_client_memptr(wlan_client, (clt_indx + 1))->wifi_rt_hdl[tx_index].wifi_rt_rule_hdl_v4;
+
+ get_client_memptr(wlan_client, clt_indx)->wifi_rt_hdl[tx_index].wifi_rt_rule_hdl_v6 =
+ get_client_memptr(wlan_client, (clt_indx + 1))->wifi_rt_hdl[tx_index].wifi_rt_rule_hdl_v6;
+ }
+ }
+
+ IPACMDBG(" %d wifi client deleted successfully \n", num_wifi_client);
+ num_wifi_client = num_wifi_client - 1;
+ IPACM_Wlan::total_num_wifi_clients = IPACM_Wlan::total_num_wifi_clients - 1;
+ IPACMDBG(" Number of wifi client: %d\n", num_wifi_client);
+
+ return IPACM_SUCCESS;
+}
+
+/* duplicate ampdu filter rules for wan_up event */
+int IPACM_Wlan::handle_wan_up(void)
+{
+ struct ipa_flt_rule_add flt_rule_entry;
+ IPACMDBG("Wlan->handle_wan_up(); \n");
+
+ ipa_ioc_add_flt_rule *m_pFilteringTable;
+ m_pFilteringTable = (struct ipa_ioc_add_flt_rule *)
+ calloc(1,
+ sizeof(struct ipa_ioc_add_flt_rule) +
+ 1 * sizeof(struct ipa_flt_rule_add)
+ );
+ if (!m_pFilteringTable)
+ {
+ PERROR("Error Locate ipa_flt_rule_add memory...\n");
+ return IPACM_FAILURE;
+ }
+
+ m_pFilteringTable->commit = 1;
+ m_pFilteringTable->ep = IPA_CLIENT_A5_WLAN_AMPDU_PROD;
+ m_pFilteringTable->global = false;
+ m_pFilteringTable->ip = IPA_IP_v4;
+ m_pFilteringTable->num_rules = (uint8_t)1;
+
+ if (false == m_routing.GetRoutingTable(&IPACM_Iface::ipacmcfg->rt_tbl_wan_v4))
+ {
+ IPACMDBG("m_routing.GetRoutingTable(&IPACM_Iface::ipacmcfg->rt_tbl_wan_v4=0x%p) Failed.\n", &IPACM_Iface::ipacmcfg->rt_tbl_wan_v4);
+ return IPACM_FAILURE;
+ }
+
+ memset(&flt_rule_entry, 0, sizeof(ipa_flt_rule_add));
+ flt_rule_entry.at_rear = true;
+ flt_rule_entry.flt_rule_hdl = -1;
+ flt_rule_entry.status = -1;
+ flt_rule_entry.rule.action = IPA_PASS_TO_SRC_NAT; //IPA_PASS_TO_ROUTING
+ flt_rule_entry.rule.rt_tbl_hdl = IPACM_Iface::ipacmcfg->rt_tbl_wan_v4.hdl;
+ memcpy(&flt_rule_entry.rule.attrib,
+ &rx_prop->rx[0].attrib,
+ sizeof(flt_rule_entry.rule.attrib));
+
+ /* Match-all rule */
+ flt_rule_entry.rule.attrib.attrib_mask |= IPA_FLT_DST_ADDR;
+ flt_rule_entry.rule.attrib.u.v4.dst_addr_mask = 0x00000000;
+ flt_rule_entry.rule.attrib.u.v4.dst_addr = 0x00000000;
+
+ memcpy(&m_pFilteringTable->rules[0], &flt_rule_entry, sizeof(flt_rule_entry));
+ if (m_filtering.AddFilteringRule(m_pFilteringTable) == false)
+ {
+ IPACMDBG("Error Adding Filtering Rule, aborting...\n");
+ perror("Wlan: Unable to add filtering table");
+ free(m_pFilteringTable);
+ return IPACM_FAILURE;
+ }
+ else
+ {
+ IPACMDBG("flt rule hdl0=0x%x, status=0x%x\n", m_pFilteringTable->rules[0].flt_rule_hdl, m_pFilteringTable->rules[0].status);
+ }
+
+ /* copy filter hdls */
+ wlan_ampdu_flt_rule.hdl[0] = m_pFilteringTable->rules[0].flt_rule_hdl;
+ free(m_pFilteringTable);
+
+ return IPACM_SUCCESS;
+}
+
+
+/*delete ampdu filter rules for wan_down event*/
+int IPACM_Wlan::handle_wan_down(void)
+{
+ IPACMDBG("\n");
+
+ if (m_filtering.DeleteFilteringHdls(&wlan_ampdu_flt_rule.hdl[0],
+ IPA_IP_v4, 1) == false)
+ {
+ return IPACM_FAILURE;
+ }
+ wlan_ampdu_flt_rule.hdl[0] = 0;
+
+ return IPACM_SUCCESS;
+}
+
+/*duplicate ampdu filter rules for software_routing event*/
+int IPACM_Wlan::handle_software_routing_enable(void)
+{
+
+ struct ipa_flt_rule_add flt_rule_entry;
+ ipa_ioc_add_flt_rule *m_pFilteringTable;
+ int res = IPACM_SUCCESS;
+
+ IPACMDBG("\n");
+
+ m_pFilteringTable = (struct ipa_ioc_add_flt_rule *)
+ calloc(1,
+ sizeof(struct ipa_ioc_add_flt_rule) +
+ 1 * sizeof(struct ipa_flt_rule_add)
+ );
+
+ if (!m_pFilteringTable)
+ {
+ PERROR("Error Locate ipa_ioc_add_flt_rule memory...\n");
+ return IPACM_FAILURE;
+ }
+
+ m_pFilteringTable->commit = 1;
+ m_pFilteringTable->ep = IPA_CLIENT_A5_WLAN_AMPDU_PROD;
+ m_pFilteringTable->global = false;
+ m_pFilteringTable->num_rules = (uint8_t)1;
+
+
+ /* Configuring Software_routing Filtering Rule */
+ memset(&flt_rule_entry, 0, sizeof(struct ipa_flt_rule_add));
+
+ flt_rule_entry.at_rear = false;
+ flt_rule_entry.flt_rule_hdl = -1;
+ flt_rule_entry.status = -1;
+ flt_rule_entry.rule.action = IPA_PASS_TO_EXCEPTION;
+ memcpy(&flt_rule_entry.rule.attrib,
+ &rx_prop->rx[0].attrib,
+ sizeof(flt_rule_entry.rule.attrib));
+
+ memcpy(&(m_pFilteringTable->rules[0]), &flt_rule_entry, sizeof(struct ipa_flt_rule_add));
+
+
+/* check iface is v4 or v6 or both*/
+ if (ip_type == IPA_IP_MAX)
+ {
+ /* handle v4 */
+ m_pFilteringTable->ip = IPA_IP_v4;
+ if (false == m_filtering.AddFilteringRule(m_pFilteringTable))
+ {
+ PERROR("Error Adding Filtering rule, aborting...\n");
+ res = IPACM_FAILURE;
+ goto fail;
+ }
+ else if (m_pFilteringTable->rules[0].status)
+ {
+ IPACMDBG("adding flt rule failed status=0x%x\n", m_pFilteringTable->rules[0].status);
+ res = IPACM_FAILURE;
+ goto fail;
+ }
+
+ IPACMDBG("soft-routing flt rule hdl0=0x%x\n", m_pFilteringTable->rules[0].flt_rule_hdl);
+ /* copy filter hdls */
+ wlan_ampdu_flt_rule.hdl[1] = m_pFilteringTable->rules[0].flt_rule_hdl;
+
+
+
+ /* handle v6*/
+ m_pFilteringTable->ip = IPA_IP_v6;
+ if (false == m_filtering.AddFilteringRule(m_pFilteringTable))
+ {
+ PERROR("Error Adding Filtering rule, aborting...\n");
+ res = IPACM_FAILURE;
+ goto fail;
+ }
+ else if (m_pFilteringTable->rules[0].status)
+ {
+ IPACMDBG("adding flt rule failed status=0x%x\n", m_pFilteringTable->rules[0].status);
+ res = IPACM_FAILURE;
+ goto fail;
+ }
+
+ IPACMDBG("soft-routing flt rule hdl0=0x%x\n", m_pFilteringTable->rules[0].flt_rule_hdl);
+ /* copy filter hdls */
+ wlan_ampdu_flt_rule.hdl[2] = m_pFilteringTable->rules[0].flt_rule_hdl;
+
+ }
+ else
+ {
+ if (ip_type == IPA_IP_v4) m_pFilteringTable->ip = IPA_IP_v4;
+ else m_pFilteringTable->ip = IPA_IP_v6;
+
+ if (false == m_filtering.AddFilteringRule(m_pFilteringTable))
+ {
+ PERROR("Error Adding Filtering rule, aborting...\n");
+ res = IPACM_FAILURE;
+ goto fail;
+ }
+ else if (m_pFilteringTable->rules[0].status)
+ {
+ IPACMDBG("adding flt rule failed status=0x%x\n", m_pFilteringTable->rules[0].status);
+ res = IPACM_FAILURE;
+ goto fail;
+ }
+
+ IPACMDBG("soft-routing flt rule hdl0=0x%x\n", m_pFilteringTable->rules[0].flt_rule_hdl);
+ /* copy filter hdls */
+ if (ip_type == IPA_IP_v4) wlan_ampdu_flt_rule.hdl[1] = m_pFilteringTable->rules[0].flt_rule_hdl;
+ else wlan_ampdu_flt_rule.hdl[2] = m_pFilteringTable->rules[0].flt_rule_hdl;
+ }
+
+fail:
+ free(m_pFilteringTable);
+
+ return res;
+
+}
+
+/*delete ampdu filter rules for disabling software_routing event*/
+int IPACM_Wlan::handle_software_routing_disable(void)
+{
+
+ if (ip_type == IPA_IP_MAX)
+ {
+ /* ipv4 case */
+ if (m_filtering.DeleteFilteringHdls(&wlan_ampdu_flt_rule.hdl[1],
+ IPA_IP_v4, 1) == false)
+ {
+ return IPACM_FAILURE;
+ }
+
+ /* ipv6 case */
+ if (m_filtering.DeleteFilteringHdls(&wlan_ampdu_flt_rule.hdl[2],
+ IPA_IP_v6, 1) == false)
+ {
+ return IPACM_FAILURE;
+ }
+
+ }
+ else
+ {
+ if (ip_type == IPA_IP_v4)
+ {
+ if (m_filtering.DeleteFilteringHdls(&wlan_ampdu_flt_rule.hdl[1],
+ IPA_IP_v4, 1) == false)
+ {
+ return IPACM_FAILURE;
+ }
+ }
+ else if (ip_type == IPA_IP_v6)
+ {
+ if (m_filtering.DeleteFilteringHdls(&wlan_ampdu_flt_rule.hdl[2],
+ IPA_IP_v6, 1) == false)
+ {
+ return IPACM_FAILURE;
+ }
+ }
+ }
+
+ return IPACM_SUCCESS;
+}
+
+
+/*duplicate ampdu filter rules for initial iface configuration*/
+int IPACM_Wlan::init_fl_rule(ipa_ip_type iptype)
+{
+ int res = IPACM_SUCCESS;
+ struct ipa_flt_rule_add flt_rule_entry;
+ ipa_ioc_add_flt_rule *m_pFilteringTable;
+
+ IPACMDBG("ip-type: %d\n", iptype);
+
+ if (iptype == IPA_IP_v4)
+ {
+ m_pFilteringTable = (struct ipa_ioc_add_flt_rule *)
+ calloc(1,
+ sizeof(struct ipa_ioc_add_flt_rule) +
+ IPV4_DEFAULT_FILTERTING_RULES * sizeof(struct ipa_flt_rule_add)
+ );
+
+ if (!m_pFilteringTable)
+ {
+ PERROR("Error Locate ipa_flt_rule_add memory...\n");
+ return IPACM_FAILURE;
+ }
+
+
+ m_pFilteringTable->commit = 1;
+ m_pFilteringTable->ep = IPA_CLIENT_A5_WLAN_AMPDU_PROD;
+ m_pFilteringTable->global = false;
+ m_pFilteringTable->ip = iptype;
+ m_pFilteringTable->num_rules = (uint8_t)IPV4_DEFAULT_FILTERTING_RULES;
+
+ /* Configuring Fragment Rule */
+ memset(&flt_rule_entry, 0, sizeof(struct ipa_flt_rule_add));
+
+ flt_rule_entry.at_rear = true;
+ flt_rule_entry.flt_rule_hdl = -1;
+ flt_rule_entry.status = -1;
+ flt_rule_entry.rule.action = IPA_PASS_TO_EXCEPTION;
+ memcpy(&flt_rule_entry.rule.attrib,
+ &rx_prop->rx[0].attrib,
+ sizeof(flt_rule_entry.rule.attrib));
+ flt_rule_entry.rule.attrib.attrib_mask |= IPA_FLT_FRAGMENT;
+ memcpy(&(m_pFilteringTable->rules[0]), &flt_rule_entry, sizeof(struct ipa_flt_rule_add));
+
+ /* Configuring Multicast Filtering Rule */
+ memcpy(&flt_rule_entry.rule.attrib,
+ &rx_prop->rx[0].attrib,
+ sizeof(flt_rule_entry.rule.attrib));
+ flt_rule_entry.rule.attrib.attrib_mask |= IPA_FLT_DST_ADDR;
+ flt_rule_entry.rule.attrib.u.v4.dst_addr_mask = 0xF0000000;
+ flt_rule_entry.rule.attrib.u.v4.dst_addr = 0xE0000000; /* DST_IP == 224.0.0.0 */
+ memcpy(&(m_pFilteringTable->rules[1]), &flt_rule_entry, sizeof(struct ipa_flt_rule_add));
+
+ /* Configuring Broadcast Filtering Rule */
+ flt_rule_entry.rule.attrib.u.v4.dst_addr_mask = 0xFFFFFFFF;
+ flt_rule_entry.rule.attrib.u.v4.dst_addr = 0xFFFFFFFF; /* Filter DST_IP == 127.0.0.1 */
+ memcpy(&(m_pFilteringTable->rules[2]), &flt_rule_entry, sizeof(struct ipa_flt_rule_add));
+
+ if (false == m_filtering.AddFilteringRule(m_pFilteringTable))
+ {
+ PERROR("Error Adding RuleTable(2) to Filtering, aborting...\n");
+ res = IPACM_FAILURE;
+ }
+ else
+ {
+ /* copy filter hdls */
+ wlan_ampdu_flt_rule.hdl[wlan_ampdu_flt_rule.num_rules] = m_pFilteringTable->rules[0].flt_rule_hdl;
+ wlan_ampdu_flt_rule.hdl[wlan_ampdu_flt_rule.num_rules + 1] = m_pFilteringTable->rules[1].flt_rule_hdl;
+ wlan_ampdu_flt_rule.hdl[wlan_ampdu_flt_rule.num_rules + 2] = m_pFilteringTable->rules[2].flt_rule_hdl;
+ wlan_ampdu_flt_rule.ip[wlan_ampdu_flt_rule.num_rules] = IPA_IP_v4;
+ wlan_ampdu_flt_rule.ip[wlan_ampdu_flt_rule.num_rules + 1] = IPA_IP_v4;
+ wlan_ampdu_flt_rule.ip[wlan_ampdu_flt_rule.num_rules + 2] = IPA_IP_v4;
+ wlan_ampdu_flt_rule.num_rules += IPV4_DEFAULT_FILTERTING_RULES;
+ }
+ }
+ else
+ {
+ /* IPv6 filter rule configuration */
+ m_pFilteringTable = (struct ipa_ioc_add_flt_rule *)
+ calloc(1,
+ sizeof(struct ipa_ioc_add_flt_rule) +
+ IPV6_DEFAULT_FILTERTING_RULES * sizeof(struct ipa_flt_rule_add)
+ );
+
+ if (!m_pFilteringTable)
+ {
+ PERROR("Error Locate ipa_flt_rule_add memory...\n");
+ return IPACM_FAILURE;
+ }
+ m_pFilteringTable->commit = 1;
+ m_pFilteringTable->ep = IPA_CLIENT_A5_WLAN_AMPDU_PROD;
+ m_pFilteringTable->global = false;
+ m_pFilteringTable->ip = iptype;
+ m_pFilteringTable->num_rules = (uint8_t)IPV6_DEFAULT_FILTERTING_RULES;
+
+ /* Configuring Fragment Filtering Rule */
+ memset(&flt_rule_entry, 0, sizeof(struct ipa_flt_rule_add));
+
+ flt_rule_entry.at_rear = true;
+ flt_rule_entry.flt_rule_hdl = -1;
+ flt_rule_entry.status = -1;
+ flt_rule_entry.rule.action = IPA_PASS_TO_EXCEPTION;
+
+ /* Configuring Multicast Filtering Rule */
+ memcpy(&flt_rule_entry.rule.attrib,
+ &rx_prop->rx[0].attrib,
+ sizeof(flt_rule_entry.rule.attrib));
+ flt_rule_entry.rule.attrib.attrib_mask |= IPA_FLT_DST_ADDR;
+ flt_rule_entry.rule.attrib.u.v6.dst_addr_mask[0] = 0xFF000000;
+ flt_rule_entry.rule.attrib.u.v6.dst_addr_mask[1] = 0x00000000;
+ flt_rule_entry.rule.attrib.u.v6.dst_addr_mask[2] = 0x00000000;
+ flt_rule_entry.rule.attrib.u.v6.dst_addr_mask[3] = 0x00000000;
+ flt_rule_entry.rule.attrib.u.v6.dst_addr[0] = 0XFF000000;
+ flt_rule_entry.rule.attrib.u.v6.dst_addr[1] = 0x00000000;
+ flt_rule_entry.rule.attrib.u.v6.dst_addr[2] = 0x00000000;
+ flt_rule_entry.rule.attrib.u.v6.dst_addr[3] = 0X00000000;
+ memcpy(&(m_pFilteringTable->rules[0]), &flt_rule_entry, sizeof(struct ipa_flt_rule_add));
+ if (false == m_filtering.AddFilteringRule(m_pFilteringTable))
+ {
+ PERROR("Error Adding Filtering Rule, aborting...\n");
+ res = IPACM_FAILURE;
+ }
+ else
+ {
+ /* copy filter hdls */
+ wlan_ampdu_flt_rule.hdl[wlan_ampdu_flt_rule.num_rules] = m_pFilteringTable->rules[0].flt_rule_hdl;
+ //wlan_ampdu_flt_rule.hdl[wlan_ampdu_flt_rule.num_rules + 1] = m_pFilteringTable->rules[1].flt_rule_hdl;
+ wlan_ampdu_flt_rule.ip[wlan_ampdu_flt_rule.num_rules] = IPA_IP_v6;
+ //wlan_ampdu_flt_rule.ip[wlan_ampdu_flt_rule.num_rules + 1] = IPA_IP_v6;
+ wlan_ampdu_flt_rule.num_rules += IPV6_DEFAULT_FILTERTING_RULES;
+ }
+ }
+
+ free(m_pFilteringTable);
+ return res;
+}
+
+
+/*duplicate ampdu filter rules for new_address event*/
+int IPACM_Wlan::handle_addr_evt(ipacm_event_data_addr *data)
+{
+ ipa_ioc_add_flt_rule *m_pFilteringTable;
+ struct ipa_flt_rule_add flt_rule_entry;
+ int NUM_RULES = 1;
+
+ IPACMDBG(" set route/filter rule ip-type: %d \n", data->iptype);
+ if (data->iptype == IPA_IP_v6)
+ {
+ if (num_dft_rt == 1) /*LAN handle_addr_evt will update this to 1*/
+ {
+ /* configure ampdu multicast/broadcast/fragment filter rule */
+ init_fl_rule(data->iptype);
+
+ /* add default v6 filter rule */
+ m_pFilteringTable = (struct ipa_ioc_add_flt_rule *)
+ calloc(1,
+ sizeof(struct ipa_ioc_add_flt_rule) +
+ NUM_RULES * sizeof(struct ipa_flt_rule_add)
+ );
+
+ if (!m_pFilteringTable)
+ {
+ PERROR("Error Locate ipa_ioc_add_flt_rule memory...\n");
+ return IPACM_FAILURE;
+ }
+
+ m_pFilteringTable->commit = 1;
+ m_pFilteringTable->ep = IPA_CLIENT_A5_WLAN_AMPDU_PROD;
+ m_pFilteringTable->global = false;
+ m_pFilteringTable->ip = IPA_IP_v6;
+ m_pFilteringTable->num_rules = (uint8_t)NUM_RULES;
+
+ if (false == m_routing.GetRoutingTable(&IPACM_Iface::ipacmcfg->rt_tbl_v6))
+ {
+ PERROR("m_routing.GetRoutingTable() Failed.\n");
+ return IPACM_FAILURE;
+ }
+
+ memset(&flt_rule_entry, 0, sizeof(struct ipa_flt_rule_add));
+
+ flt_rule_entry.at_rear = true;
+ flt_rule_entry.flt_rule_hdl = -1;
+ flt_rule_entry.status = -1;
+ flt_rule_entry.rule.action = IPA_PASS_TO_ROUTING;
+ flt_rule_entry.rule.rt_tbl_hdl = IPACM_Iface::ipacmcfg->rt_tbl_v6.hdl;
+ memcpy(&flt_rule_entry.rule.attrib,
+ &rx_prop->rx[0].attrib,
+ sizeof(flt_rule_entry.rule.attrib));
+ flt_rule_entry.rule.attrib.attrib_mask |= IPA_FLT_DST_ADDR;
+ flt_rule_entry.rule.attrib.u.v6.dst_addr_mask[0] = 0x00000000;
+ flt_rule_entry.rule.attrib.u.v6.dst_addr_mask[1] = 0x00000000;
+ flt_rule_entry.rule.attrib.u.v6.dst_addr_mask[2] = 0x00000000;
+ flt_rule_entry.rule.attrib.u.v6.dst_addr_mask[3] = 0x00000000;
+ flt_rule_entry.rule.attrib.u.v6.dst_addr[0] = 0X00000000;
+ flt_rule_entry.rule.attrib.u.v6.dst_addr[1] = 0x00000000;
+ flt_rule_entry.rule.attrib.u.v6.dst_addr[2] = 0x00000000;
+ flt_rule_entry.rule.attrib.u.v6.dst_addr[3] = 0X00000000;
+
+ memcpy(&(m_pFilteringTable->rules[0]), &flt_rule_entry, sizeof(struct ipa_flt_rule_add));
+ if (false == m_filtering.AddFilteringRule(m_pFilteringTable))
+ {
+ PERROR("Error Adding RuleTable(0) to Filtering, aborting...\n");
+ free(m_pFilteringTable);
+ return IPACM_FAILURE;
+
+ }
+ else
+ {
+ IPACMDBG("flt rule hdl0=0x%x, status=0x%x\n", m_pFilteringTable->rules[0].flt_rule_hdl, m_pFilteringTable->rules[0].status);
+ }
+
+ /* copy filter hdls */
+ wlan_ampdu_flt_rule.hdl[wlan_ampdu_flt_rule.num_rules] = m_pFilteringTable->rules[0].flt_rule_hdl;
+ wlan_ampdu_flt_rule.ip[wlan_ampdu_flt_rule.num_rules] = IPA_IP_v6;
+ wlan_ampdu_flt_rule.num_rules++;
+ free(m_pFilteringTable);
+ }
+ }
+ else
+ {
+ init_fl_rule(data->iptype);
+ }
+ return IPACM_SUCCESS;
+}
+
+/*duplicate ampdu filter rules for private subnet configuration*/
+int IPACM_Wlan::handle_private_subnet(ipa_ip_type iptype)
+{
+ struct ipa_flt_rule_add flt_rule_entry;
+ int i;
+
+ IPACMDBG("wlan->handle_private_subnet(); set route/filter rule \n");
+
+ if (iptype == IPA_IP_v4)
+ {
+ /* construct ipa_ioc_add_flt_rule with 1 rules */
+ ipa_ioc_add_flt_rule *m_pFilteringTable;
+
+ m_pFilteringTable = (struct ipa_ioc_add_flt_rule *)
+ calloc(1,
+ sizeof(struct ipa_ioc_add_flt_rule) +
+ (IPACM_Iface::ipacmcfg->ipa_num_private_subnet) * sizeof(struct ipa_flt_rule_add)
+ );
+
+ if (!m_pFilteringTable)
+ {
+ PERROR("Error Locate ipa_ioc_add_flt_rule memory...\n");
+ return IPACM_FAILURE;
+ }
+
+ m_pFilteringTable->commit = 1;
+ m_pFilteringTable->ep = IPA_CLIENT_A5_WLAN_AMPDU_PROD;
+ m_pFilteringTable->global = false;
+ m_pFilteringTable->ip = IPA_IP_v4;
+ m_pFilteringTable->num_rules = (uint8_t)IPACM_Iface::ipacmcfg->ipa_num_private_subnet;
+
+ if (false == m_routing.GetRoutingTable(&IPACM_Iface::ipacmcfg->rt_tbl_lan_v4))
+ {
+ PERROR("WLAN m_routing.GetRoutingTable(IPACM_Iface::ipacmcfg->rt_tbl_lan_v4) Failed.\n");
+ free(m_pFilteringTable);
+ return IPACM_FAILURE;
+ }
+
+ for (i = 0; i < IPACM_Iface::ipacmcfg->ipa_num_private_subnet; i++)
+ {
+ memset(&flt_rule_entry, 0, sizeof(struct ipa_flt_rule_add));
+ flt_rule_entry.at_rear = true;
+ flt_rule_entry.flt_rule_hdl = -1;
+ flt_rule_entry.status = -1;
+ flt_rule_entry.rule.action = IPA_PASS_TO_ROUTING;
+ flt_rule_entry.rule.rt_tbl_hdl = IPACM_Iface::ipacmcfg->rt_tbl_lan_v4.hdl;
+ memcpy(&flt_rule_entry.rule.attrib,
+ &rx_prop->rx[0].attrib,
+ sizeof(flt_rule_entry.rule.attrib));
+ flt_rule_entry.rule.attrib.attrib_mask |= IPA_FLT_DST_ADDR;
+ flt_rule_entry.rule.attrib.u.v4.dst_addr_mask = IPACM_Iface::ipacmcfg->private_subnet_table[i].subnet_mask;
+ flt_rule_entry.rule.attrib.u.v4.dst_addr = IPACM_Iface::ipacmcfg->private_subnet_table[i].subnet_addr;
+ memcpy(&(m_pFilteringTable->rules[i]), &flt_rule_entry, sizeof(struct ipa_flt_rule_add));
+ }
+
+ if (false == m_filtering.AddFilteringRule(m_pFilteringTable))
+ {
+ PERROR("Error Adding RuleTable(0) to Filtering, aborting...\n");
+ free(m_pFilteringTable);
+ return IPACM_FAILURE;
+ };
+
+
+ /* copy filter hdls */
+ for (i = 0; i < (IPACM_Iface::ipacmcfg->ipa_num_private_subnet); i++)
+ {
+ wlan_ampdu_flt_rule.hdl[wlan_ampdu_flt_rule.num_rules + i] = m_pFilteringTable->rules[i].flt_rule_hdl;
+ wlan_ampdu_flt_rule.ip[wlan_ampdu_flt_rule.num_rules + i] = IPA_IP_v4;
+ }
+ wlan_ampdu_flt_rule.num_rules += IPACM_Iface::ipacmcfg->ipa_num_private_subnet;
+
+ IPACMDBG("wlan handle private ok~\n");
+ free(m_pFilteringTable);
+ }
+ return IPACM_SUCCESS;
+}
+
+
+/*handle wlan iface down event*/
+int IPACM_Wlan::handle_down_evt()
+{
+ IPACMDBG("ip-type: %d \n", ip_type);
+ uint32_t tx_index, rt_hdl;
+ ipa_ip_type ip;
+ int res = IPACM_SUCCESS, i;
+
+ /* no iface address up, directly close iface*/
+ if (ip_type == IPACM_IP_NULL)
+ {
+ IPACMERR("Invalid iptype: 0x%x\n", ip_type);
+ return IPACM_FAILURE;
+ }
+
+ /* Delete v6 filtering rules */
+ if (ip_type != IPA_IP_v6)
+ {
+ IPACMDBG("Delete default v4 filter rules\n");
+ /* delete default filter rules */
+ if (m_filtering.DeleteFilteringHdls(dft_v4fl_rule_hdl,
+ IPA_IP_v4,
+ IPV4_DEFAULT_FILTERTING_RULES) == false)
+ {
+ res = IPACM_FAILURE;
+ goto fail;
+ }
+
+ IPACMDBG("Delete private v4 filter rules\n");
+ /* free private-ipv4 filter rules */
+ if (m_filtering.DeleteFilteringHdls(
+ private_fl_rule_hdl,
+ IPA_IP_v4,
+ IPACM_Iface::ipacmcfg->ipa_num_private_subnet) == false)
+ {
+ res = IPACM_FAILURE;
+ goto fail;
+ }
+ }
+
+ /* Delete v4 filtering rules */
+ if (ip_type != IPA_IP_v4)
+ {
+ IPACMDBG("Delete default %d v6 filter rules\n", IPV6_DEFAULT_FILTERTING_RULES);
+ /* delete default filter rules */
+ if (m_filtering.DeleteFilteringHdls(dft_v6fl_rule_hdl,
+ IPA_IP_v6,
+ IPV6_DEFAULT_FILTERTING_RULES) == false)
+ {
+ res = IPACM_FAILURE;
+ goto fail;
+ }
+ }
+ IPACMDBG("finished delte default filtering rules\n ");
+
+ /* delete WLAN IPA_CLIENT_A5_WLAN_AMPDU_PROD filter rules*/
+ for (i = 3; i < wlan_ampdu_flt_rule.num_rules; i++)
+ {
+ IPACMDBG("Delete WLAN IPA_CLIENT_A5_WLAN_AMPDU_PROD filter rules\n");
+ if (m_filtering.DeleteFilteringHdls(&wlan_ampdu_flt_rule.hdl[i],
+ wlan_ampdu_flt_rule.ip[i], 1) == false)
+ {
+ res = IPACM_FAILURE;
+ goto fail;
+ }
+ }
+ IPACMDBG("finished delte AMPDU filtering rules\n ");
+
+
+ /* Delete default v4 RT rule */
+ if (ip_type != IPA_IP_v6)
+ {
+ IPACMDBG("Delete default v4 routing rules\n");
+ if (m_routing.DeleteRoutingHdl(dft_rt_rule_hdl[0], IPA_IP_v4)
+ == false)
+ {
+ IPACMERR("Routing rule deletion failed!\n");
+ res = IPACM_FAILURE;
+ goto fail;
+ }
+ }
+
+ /* Delete default v6 RT rule */
+ if (ip_type != IPA_IP_v4)
+ {
+ IPACMDBG("Delete default v6 routing rules\n");
+ /* May have multiple ipv6 iface-RT rules */
+ for (i = 0; i < num_dft_rt; i++)
+ {
+ if (m_routing.DeleteRoutingHdl(dft_rt_rule_hdl[i + 1], IPA_IP_v6)
+ == false)
+ {
+ IPACMERR("Routing rule deletion failed!\n");
+ res = IPACM_FAILURE;
+ goto fail;
+ }
+ }
+ }
+ IPACMDBG("finished deleting default RT rules\n ");
+
+
+ /* delete wan filter rule */
+ if (IPACM_Wan::isWanUP())
+ {
+ IPACMDBG("Delete wan filtering rules\n");
+
+ IPACM_Lan::handle_wan_down();
+ handle_wan_down();
+ }
+ IPACMDBG("finished deleting wan filtering rules\n ");
+
+
+ /* check software routing fl rule hdl */
+ if (softwarerouting_act == true)
+ {
+ IPACMDBG("Delete sw routing filtering rules\n");
+ IPACM_Iface::handle_software_routing_disable();
+ handle_software_routing_disable();
+ }
+ IPACMDBG("finished delete software-routing filtering rules\n ");
+
+
+ /* clean wifi-client header, routing rules */
+ /* clean wifi client rule*/
+ IPACMDBG("left %d wifi clients need to be deleted \n ", num_wifi_client);
+ for (i = 0; i < num_wifi_client; i++)
+ {
+
+ for (tx_index = 0; tx_index < iface_query->num_tx_props; tx_index++)
+ {
+ if (ip_type != IPA_IP_v6) /* for ipv4 */
+ {
+ rt_hdl = get_client_memptr(wlan_client, i)->wifi_rt_hdl[tx_index].wifi_rt_rule_hdl_v4;
+ ip = IPA_IP_v4;
+ }
+ else if (ip_type != IPA_IP_v4) /* for ipv6 */
+ {
+ rt_hdl = get_client_memptr(wlan_client, i)->wifi_rt_hdl[tx_index].wifi_rt_rule_hdl_v6;
+ ip = IPA_IP_v6;
+ }
+
+ IPACMDBG("Delete %d client route rule %d\n", num_wifi_client, tx_index);
+ if (m_routing.DeleteRoutingHdl(rt_hdl, ip) == false)
+ {
+ res = IPACM_FAILURE;
+ goto fail;
+ }
+
+ } /* end of tx-index for loop*/
+
+ IPACMDBG("Delete %d client header\n", num_wifi_client);
+ if (m_header.DeleteHeaderHdl(get_client_memptr(wlan_client, i)->hdr_hdl)
+ == false)
+ {
+ res = IPACM_FAILURE;
+ goto fail;
+ }
+
+ } /* end of for loop */
+
+ /* free the wlan clients cache */
+ IPACMDBG("Free wlan clients cache\n");
+
+fail:
+ free(wlan_client);
+ free(tx_prop);
+ free(rx_prop);
+ free(iface_query);
+
+ return res;
+}
diff --git a/ipacm/src/IPACM_Xml.cpp b/ipacm/src/IPACM_Xml.cpp
new file mode 100644
index 0000000..8871b1d
--- /dev/null
+++ b/ipacm/src/IPACM_Xml.cpp
@@ -0,0 +1,1090 @@
+/*
+Copyright (c) 2013, The Linux Foundation. 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 name of The Linux 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 "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+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.
+*/
+/*!
+ @file
+ IPACM_Xml.cpp
+
+ @brief
+ This file implements the XML specific parsing functionality.
+
+ @Author
+ Skylar Chang/Shihuan Liu
+*/
+
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+#include "IPACM_Xml.h"
+#include "IPACM_Log.h"
+#include "IPACM_Netlink.h"
+
+static char* IPACM_read_content_element
+(
+ xmlNode* element
+);
+
+static int32_t IPACM_util_icmp_string
+(
+ const char* xml_str,
+ const char* str
+);
+
+static int ipacm_cfg_xml_parse_tree
+(
+ xmlNode* xml_node,
+ IPACM_conf_t *config
+);
+
+static int IPACM_firewall_xml_parse_tree
+(
+ xmlNode* xml_node,
+ IPACM_firewall_conf_t *config
+);
+
+/*Reads content (stored as child) of the element */
+static char* IPACM_read_content_element
+(
+ xmlNode* element
+)
+{
+ xmlNode* child_ptr;
+
+ for (child_ptr = element->children;
+ child_ptr != NULL;
+ child_ptr = child_ptr->next)
+ {
+ if (child_ptr->type == XML_TEXT_NODE)
+ {
+ return (char*)child_ptr->content;
+ }
+ }
+ return NULL;
+}
+
+/* insensitive comparison of a libxml's string (xml_str) and a regular string (str)*/
+static int32_t IPACM_util_icmp_string
+(
+ const char* xml_str,
+ const char* str
+)
+{
+ int32_t ret = -1;
+
+ if (NULL != xml_str && NULL != str)
+ {
+ uint32_t len1 = strlen(str);
+ uint32_t len2 = strlen(xml_str);
+ /* If the lengths match, do the string comparison */
+ if (len1 == len2)
+ {
+ ret = strncasecmp(xml_str, str, len1);
+ }
+ }
+
+ return ret;
+}
+
+/* This function read IPACM XML and populate the IPA CM Cfg */
+int ipacm_read_cfg_xml(char *xml_file, IPACM_conf_t *config)
+{
+ xmlDocPtr doc = NULL;
+ xmlNode* root = NULL;
+ int ret_val;
+
+ /* Invoke the XML parser and obtain the parse tree */
+ doc = xmlReadFile(xml_file, "UTF-8", XML_PARSE_NOBLANKS);
+ if (doc == NULL) {
+ IPACMDBG("IPACM_xml_parse: libxml returned parse error!\n");
+ return IPACM_FAILURE;
+ }
+
+ /*Get the root of the tree*/
+ root = xmlDocGetRootElement(doc);
+
+ memset(config, 0, sizeof(IPACM_conf_t));
+
+ /* parse the xml tree returned by libxml */
+ ret_val = ipacm_cfg_xml_parse_tree(root, config);
+
+ if (ret_val != IPACM_SUCCESS)
+ IPACMDBG("IPACM_xml_parse: ipacm_cfg_xml_parse_tree returned parse error!\n");
+
+ /* Free up the libxml's parse tree */
+ xmlFreeDoc(doc);
+ //xmlCleanupParser();
+
+ return ret_val;
+}
+
+/* This function traverses the xml tree*/
+static int ipacm_cfg_xml_parse_tree
+(
+ xmlNode* xml_node,
+ IPACM_conf_t *config
+)
+{
+ int32_t ret_val = IPACM_SUCCESS;
+ int str_size;
+ char* content;
+ char content_buf[MAX_XML_STR_LEN];
+
+ if (NULL == xml_node)
+ return ret_val;
+
+ while ( xml_node != NULL &&
+ ret_val == IPACM_SUCCESS)
+ {
+ switch (xml_node->type)
+ {
+ case XML_ELEMENT_NODE:
+ {
+ if (IPACM_util_icmp_string((char*)xml_node->name,
+ system_TAG) == 0 ||
+ IPACM_util_icmp_string((char*)xml_node->name,
+ IPACMCFG_TAG) == 0 ||
+ IPACM_util_icmp_string((char*)xml_node->name,
+ IPACMIFACECFG_TAG) == 0 ||
+ IPACM_util_icmp_string((char*)xml_node->name,
+ IFACE_TAG) == 0 ||
+ IPACM_util_icmp_string((char*)xml_node->name,
+ IPACMPRIVATESUBNETCFG_TAG) == 0 ||
+ IPACM_util_icmp_string((char*)xml_node->name,
+ SUBNET_TAG) == 0 ||
+ IPACM_util_icmp_string((char*)xml_node->name,
+ IPACMALG_TAG) == 0 ||
+ IPACM_util_icmp_string((char*)xml_node->name,
+ ALG_TAG) == 0 ||
+ IPACM_util_icmp_string((char*)xml_node->name,
+ IPACMNat_TAG) == 0)
+ {
+ if (0 == IPACM_util_icmp_string((char*)xml_node->name,
+ IFACE_TAG))
+ {
+ /* increase iface entry number */
+ config->iface_config.num_iface_entries++;
+ }
+
+ if (0 == IPACM_util_icmp_string((char*)xml_node->name,
+ SUBNET_TAG))
+ {
+ /* increase iface entry number */
+ config->private_subnet_config.num_subnet_entries++;
+ }
+
+ if (0 == IPACM_util_icmp_string((char*)xml_node->name,
+ ALG_TAG))
+ {
+ /* increase iface entry number */
+ config->alg_config.num_alg_entries++;
+ }
+ /* go to child */
+ ret_val = ipacm_cfg_xml_parse_tree(xml_node->children,
+ config);
+ }
+ else if (IPACM_util_icmp_string((char*)xml_node->name,
+ NAME_TAG) == 0)
+ {
+ content = IPACM_read_content_element(xml_node);
+ if (content)
+ {
+ str_size = strlen(content);
+ memset(content_buf, 0, sizeof(content_buf));
+ memcpy(content_buf, (void *)content, str_size);
+ strncpy(config->iface_config.iface_entries[config->iface_config.num_iface_entries - 1].iface_name, content_buf, str_size);
+ IPACMDBG("Name %s\n", config->iface_config.iface_entries[config->iface_config.num_iface_entries - 1].iface_name);
+ }
+ }
+ else if (IPACM_util_icmp_string((char*)xml_node->name,
+ CATEGORY_TAG) == 0)
+ {
+ content = IPACM_read_content_element(xml_node);
+ if (content)
+ {
+ str_size = strlen(content);
+ memset(content_buf, 0, sizeof(content_buf));
+ memcpy(content_buf, (void *)content, str_size);
+ if (0 == strncasecmp(content_buf, WANIF_TAG, str_size))
+ {
+ config->iface_config.iface_entries[config->iface_config.num_iface_entries - 1].if_cat = WAN_IF;
+ IPACMDBG("Category %d\n", config->iface_config.iface_entries[config->iface_config.num_iface_entries - 1].if_cat);
+ }
+ else if (0 == strncasecmp(content_buf, LANIF_TAG, str_size))
+ {
+ config->iface_config.iface_entries[config->iface_config.num_iface_entries - 1].if_cat = LAN_IF;
+ IPACMDBG("Category %d\n", config->iface_config.iface_entries[config->iface_config.num_iface_entries - 1].if_cat);
+ }
+ else if (0 == strncasecmp(content_buf, WLANIF_TAG, str_size))
+ {
+ config->iface_config.iface_entries[config->iface_config.num_iface_entries - 1].if_cat = WLAN_IF;
+ IPACMDBG("Category %d\n", config->iface_config.iface_entries[config->iface_config.num_iface_entries - 1].if_cat);
+ }
+ else if (0 == strncasecmp(content_buf, VIRTUALIF_TAG, str_size))
+ {
+ config->iface_config.iface_entries[config->iface_config.num_iface_entries - 1].if_cat = VIRTUAL_IF;
+ IPACMDBG("Category %d\n", config->iface_config.iface_entries[config->iface_config.num_iface_entries - 1].if_cat);
+ }
+ }
+ }
+ else if (IPACM_util_icmp_string((char*)xml_node->name,
+ SUBNETADDRESS_TAG) == 0)
+ {
+ content = IPACM_read_content_element(xml_node);
+ if (content)
+ {
+ str_size = strlen(content);
+ memset(content_buf, 0, sizeof(content_buf));
+ memcpy(content_buf, (void *)content, str_size);
+ config->private_subnet_config.private_subnet_entries[config->private_subnet_config.num_subnet_entries - 1].subnet_addr
+ = ntohl(inet_addr(content_buf));
+ IPACMDBG("subnet_addr: %s \n", content_buf);
+ }
+ }
+ else if (IPACM_util_icmp_string((char*)xml_node->name,
+ SUBNETMASK_TAG) == 0)
+ {
+ content = IPACM_read_content_element(xml_node);
+ if (content)
+ {
+ str_size = strlen(content);
+ memset(content_buf, 0, sizeof(content_buf));
+ memcpy(content_buf, (void *)content, str_size);
+ config->private_subnet_config.private_subnet_entries[config->private_subnet_config.num_subnet_entries - 1].subnet_mask
+ = ntohl(inet_addr(content_buf));
+ IPACMDBG("subnet_mask: %s \n", content_buf);
+ }
+ }
+ else if (IPACM_util_icmp_string((char*)xml_node->name,
+ Protocol_TAG) == 0)
+ {
+ content = IPACM_read_content_element(xml_node);
+ if (content)
+ {
+ str_size = strlen(content);
+ memset(content_buf, 0, sizeof(content_buf));
+ memcpy(content_buf, (void *)content, str_size);
+
+ if (0 == strncasecmp(content_buf, TCP_PROTOCOL_TAG, str_size))
+ {
+ config->alg_config.alg_entries[config->alg_config.num_alg_entries - 1].protocol = IPPROTO_TCP;
+ IPACMDBG("Protocol %s: %d\n", content_buf, config->alg_config.alg_entries[config->alg_config.num_alg_entries - 1].protocol);
+ }
+ else if (0 == strncasecmp(content_buf, UDP_PROTOCOL_TAG, str_size))
+ {
+ config->alg_config.alg_entries[config->alg_config.num_alg_entries - 1].protocol = IPPROTO_UDP;
+ IPACMDBG("Protocol %s: %d\n", content_buf, config->alg_config.alg_entries[config->alg_config.num_alg_entries - 1].protocol);
+ }
+ }
+ }
+ else if (IPACM_util_icmp_string((char*)xml_node->name,
+ Port_TAG) == 0)
+ {
+ content = IPACM_read_content_element(xml_node);
+ if (content)
+ {
+ str_size = strlen(content);
+ memset(content_buf, 0, sizeof(content_buf));
+ memcpy(content_buf, (void *)content, str_size);
+ config->alg_config.alg_entries[config->alg_config.num_alg_entries - 1].port
+ = atoi(content_buf);
+ IPACMDBG("port %d\n", config->alg_config.alg_entries[config->alg_config.num_alg_entries - 1].port);
+ }
+ }
+ else if (IPACM_util_icmp_string((char*)xml_node->name,
+ NAT_MaxEntries_TAG) == 0)
+ {
+ content = IPACM_read_content_element(xml_node);
+ if (content)
+ {
+ str_size = strlen(content);
+ memset(content_buf, 0, sizeof(content_buf));
+ memcpy(content_buf, (void *)content, str_size);
+ config->nat_max_entries = atoi(content_buf);
+ IPACMDBG("Nat Table Max Entries %d\n", config->nat_max_entries);
+ }
+ }
+ }
+ break;
+ default:
+ break;
+ }
+ /* go to sibling */
+ xml_node = xml_node->next;
+ } /* end while */
+ return ret_val;
+}
+
+/* This function read QCMAP CM Firewall XML and populate the QCMAP CM Cfg */
+int IPACM_read_firewall_xml(char *xml_file, IPACM_firewall_conf_t *config)
+{
+ xmlDocPtr doc = NULL;
+ xmlNode* root = NULL;
+ int ret_val;
+
+ IPACM_ASSERT(xml_file != NULL);
+ IPACM_ASSERT(config != NULL);
+
+ /* invoke the XML parser and obtain the parse tree */
+ doc = xmlReadFile(xml_file, "UTF-8", XML_PARSE_NOBLANKS);
+ if (doc == NULL) {
+ IPACMDBG("IPACM_xml_parse: libxml returned parse error\n");
+ return IPACM_FAILURE;
+ }
+ /*get the root of the tree*/
+ root = xmlDocGetRootElement(doc);
+
+ /* parse the xml tree returned by libxml*/
+ ret_val = IPACM_firewall_xml_parse_tree(root, config);
+
+ if (ret_val != IPACM_SUCCESS)
+ IPACMDBG("IPACM_xml_parse: ipacm_firewall_xml_parse_tree returned parse error!\n");
+
+ /* free the tree */
+ xmlFreeDoc(doc);
+
+ return ret_val;
+}
+
+
+/* This function traverses the firewall xml tree */
+static int IPACM_firewall_xml_parse_tree
+(
+ xmlNode* xml_node,
+ IPACM_firewall_conf_t *config
+)
+{
+ int mask_value_v6, mask_index;
+ int32_t ret_val = IPACM_SUCCESS;
+ char *content;
+ int str_size;
+ char content_buf[MAX_XML_STR_LEN];
+ struct in6_addr ip6_addr;
+
+ IPACM_ASSERT(config != NULL);
+
+ if (NULL == xml_node)
+ return ret_val;
+
+ while ( xml_node != NULL &&
+ ret_val == IPACM_SUCCESS)
+ {
+ switch (xml_node->type)
+ {
+
+ case XML_ELEMENT_NODE:
+ {
+ if (0 == IPACM_util_icmp_string((char*)xml_node->name,
+ system_TAG) ||
+ 0 == IPACM_util_icmp_string((char*)xml_node->name,
+ MobileAPFirewallCfg_TAG) ||
+ 0 == IPACM_util_icmp_string((char*)xml_node->name,
+ Firewall_TAG)
+ )
+ {
+ if (0 == IPACM_util_icmp_string((char*)xml_node->name,
+ Firewall_TAG))
+ {
+ /* increase firewall entry num */
+ config->num_extd_firewall_entries++;
+ }
+ /* go to child */
+ ret_val = IPACM_firewall_xml_parse_tree(xml_node->children,
+ config);
+ }
+ else if (0 == IPACM_util_icmp_string((char*)xml_node->name,
+ IPFamily_TAG))
+ {
+ content = IPACM_read_content_element(xml_node);
+ if (content)
+ {
+ str_size = strlen(content);
+ memset(content_buf, 0, sizeof(content_buf));
+ memcpy(content_buf, (void *)content, str_size);
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].ip_vsn
+ = (firewall_ip_version_enum)atoi(content_buf);
+ IPACMDBG("\n IP family type is %d \n",
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].ip_vsn);
+
+ }
+ }
+ else if (0 == IPACM_util_icmp_string((char*)xml_node->name,
+ IPV4SourceAddress_TAG))
+ {
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.attrib_mask |= IPA_FLT_SRC_ADDR;
+ /* go to child */
+ ret_val = IPACM_firewall_xml_parse_tree(xml_node->children,
+ config);
+ }
+ else if (0 == IPACM_util_icmp_string((char*)xml_node->name,
+ IPV4SourceIPAddress_TAG))
+ {
+ content = IPACM_read_content_element(xml_node);
+ if (content)
+ {
+ str_size = strlen(content);
+ memset(content_buf, 0, sizeof(content_buf));
+ memcpy(content_buf, (void *)content, str_size);
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.u.v4.src_addr
+ = ntohl(inet_addr(content_buf));
+ IPACMDBG("IPv4 source address is: %s \n", content_buf);
+ }
+ }
+ else if (0 == IPACM_util_icmp_string((char*)xml_node->name,
+ IPV4SourceSubnetMask_TAG))
+ {
+ content = IPACM_read_content_element(xml_node);
+ if (content)
+ {
+ str_size = strlen(content);
+ memset(content_buf, 0, sizeof(content_buf));
+ memcpy(content_buf, (void *)content, str_size);
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.u.v4.src_addr_mask
+ = ntohl(inet_addr(content_buf));
+ IPACMDBG("IPv4 source subnet mask is: %s \n", content_buf);
+ }
+ }
+ else if (0 == IPACM_util_icmp_string((char*)xml_node->name,
+ IPV4DestinationAddress_TAG))
+ {
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.attrib_mask |= IPA_FLT_DST_ADDR;
+ /* go to child */
+ ret_val = IPACM_firewall_xml_parse_tree(xml_node->children,
+ config);
+ }
+ else if (0 == IPACM_util_icmp_string((char*)xml_node->name,
+ IPV4DestinationIPAddress_TAG))
+ {
+ content = IPACM_read_content_element(xml_node);
+ if (content)
+ {
+ str_size = strlen(content);
+ memset(content_buf, 0, sizeof(content_buf));
+ memcpy(content_buf, (void *)content, str_size);
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.u.v4.dst_addr
+ = ntohl(inet_addr(content_buf));
+ IPACMDBG("IPv4 destination address is: %s \n", content_buf);
+ }
+ }
+ else if (0 == IPACM_util_icmp_string((char*)xml_node->name,
+ IPV4DestinationSubnetMask_TAG))
+ {
+ content = IPACM_read_content_element(xml_node);
+ if (content)
+ {
+ str_size = strlen(content);
+ memset(content_buf, 0, sizeof(content_buf));
+ memcpy(content_buf, (void *)content, str_size);
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.u.v4.dst_addr_mask
+ = ntohl(inet_addr(content_buf));
+ IPACMDBG("IPv4 destination subnet mask is: %s \n", content_buf);
+ }
+ }
+ else if (0 == IPACM_util_icmp_string((char*)xml_node->name,
+ IPV4TypeOfService_TAG))
+ {
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.attrib_mask |= IPA_FLT_TOS;
+ /* go to child */
+ ret_val = IPACM_firewall_xml_parse_tree(xml_node->children,
+ config);
+ }
+ else if (0 == IPACM_util_icmp_string((char*)xml_node->name,
+ TOSValue_TAG))
+ {
+ content = IPACM_read_content_element(xml_node);
+ if (content)
+ {
+ str_size = strlen(content);
+ memset(content_buf, 0, sizeof(content_buf));
+ memcpy(content_buf, (void *)content, str_size);
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.u.v4.tos
+ = atoi(content_buf);
+
+ IPACMDBG("\n IPV4 TOS val is %d \n",
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.u.v4.tos);
+ }
+ }
+ else if (0 == IPACM_util_icmp_string((char*)xml_node->name,
+ TOSMask_TAG))
+ {
+ content = IPACM_read_content_element(xml_node);
+ if (content)
+ {
+ str_size = strlen(content);
+ memset(content_buf, 0, sizeof(content_buf));
+ memcpy(content_buf, (void *)content, str_size);
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.u.v4.tos
+ &= atoi(content_buf);
+
+ IPACMDBG("\n IPv4 TOS mask is %d \n",
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.u.v4.tos);
+ }
+ }
+ else if (0 == IPACM_util_icmp_string((char*)xml_node->name,
+ IPV4NextHeaderProtocol_TAG))
+ {
+ content = IPACM_read_content_element(xml_node);
+ if (content)
+ {
+ str_size = strlen(content);
+ memset(content_buf, 0, sizeof(content_buf));
+ memcpy(content_buf, (void *)content, str_size);
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.attrib_mask |= IPA_FLT_PROTOCOL;
+
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.u.v4.protocol = atoi(content_buf);
+
+ IPACMDBG("\n IPv4 next header prot is %d \n",
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.u.v4.protocol);
+ }
+ }
+ else if (0 == IPACM_util_icmp_string((char*)xml_node->name,
+ IPV6SourceAddress_TAG))
+ {
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.attrib_mask |=
+ IPA_FLT_SRC_ADDR;
+ /* go to child */
+ ret_val = IPACM_firewall_xml_parse_tree(xml_node->children,
+ config);
+ }
+ else if (0 == IPACM_util_icmp_string((char*)xml_node->name,
+ IPV6SourceIPAddress_TAG))
+ {
+ content = IPACM_read_content_element(xml_node);
+ if (content)
+ {
+ str_size = strlen(content);
+ memset(content_buf, 0, sizeof(content_buf));
+ memcpy(content_buf, (void *)content, str_size);
+ inet_pton(AF_INET6, content_buf, &ip6_addr);
+ memcpy(config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.u.v6.src_addr,
+ ip6_addr.s6_addr, IPACM_IPV6_ADDR_LEN * sizeof(uint8_t));
+
+ IPACMDBG("\n ipv6 source addr is %d \n ",
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.u.v6.src_addr[0]);
+ }
+ }
+ else if (0 == IPACM_util_icmp_string((char*)xml_node->name,
+ IPV6SourcePrefix_TAG))
+ {
+ content = IPACM_read_content_element(xml_node);
+ if (content)
+ {
+ str_size = strlen(content);
+ memset(content_buf, 0, sizeof(content_buf));
+ memcpy(content_buf, (void *)content, str_size);
+ mask_value_v6 = atoi(content_buf);
+ for (mask_index = 0; mask_index < 4; mask_index++)
+ {
+ if (mask_value_v6 >= 32)
+ {
+ mask_v6(32, &(config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.u.v6.src_addr_mask[mask_index]));
+ mask_value_v6 -= 32;
+ }
+ else
+ {
+ mask_v6(mask_value_v6, &(config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.u.v6.src_addr_mask[mask_index]));
+ mask_value_v6 = 0;
+ }
+ }
+ IPACMDBG("\n ipv6 source prefix is %d \n",
+ atoi(content_buf));
+ }
+ }
+ else if (0 == IPACM_util_icmp_string((char*)xml_node->name,
+ IPV6DestinationAddress_TAG))
+ {
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.attrib_mask |=
+ IPA_FLT_DST_ADDR;
+ /* go to child */
+ ret_val = IPACM_firewall_xml_parse_tree(xml_node->children,
+ config);
+ }
+ else if (0 == IPACM_util_icmp_string((char*)xml_node->name,
+ IPV6DestinationIPAddress_TAG))
+ {
+ content = IPACM_read_content_element(xml_node);
+ if (content)
+ {
+ str_size = strlen(content);
+ memset(content_buf, 0, sizeof(content_buf));
+ memcpy(content_buf, (void *)content, str_size);
+ inet_pton(AF_INET6, content_buf, &ip6_addr);
+
+ memcpy(config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.u.v6.dst_addr,
+ ip6_addr.s6_addr, IPACM_IPV6_ADDR_LEN * sizeof(uint8_t));
+ IPACMDBG("\n ipv6 dest addr is %d \n",
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.u.v6.dst_addr[0]);
+ }
+ }
+ else if (0 == IPACM_util_icmp_string((char*)xml_node->name,
+ IPV6DestinationPrefix_TAG))
+ {
+ content = IPACM_read_content_element(xml_node);
+ if (content)
+ {
+ str_size = strlen(content);
+ memset(content_buf, 0, sizeof(content_buf));
+ memcpy(content_buf, (void *)content, str_size);
+ mask_value_v6 = atoi(content_buf);
+ for (mask_index = 0; mask_index < 4; mask_index++)
+ {
+ if (mask_value_v6 >= 32)
+ {
+ mask_v6(32, &(config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.u.v6.dst_addr_mask[mask_index]));
+ mask_value_v6 -= 32;
+ }
+ else
+ {
+ mask_v6(mask_value_v6, &(config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.u.v6.dst_addr_mask[mask_index]));
+ mask_value_v6 = 0;
+ }
+ }
+ IPACMDBG("\n ipv6 dest prefix is %d \n",
+ atoi(content_buf));
+ }
+ }
+ else if (0 == IPACM_util_icmp_string((char*)xml_node->name,
+ IPV6TrafficClass_TAG))
+ {
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.attrib_mask |= IPA_FLT_TC;
+ /* go to child */
+ ret_val = IPACM_firewall_xml_parse_tree(xml_node->children,
+ config);
+ }
+ else if (0 == IPACM_util_icmp_string((char*)xml_node->name,
+ TrfClsValue_TAG))
+ {
+ content = IPACM_read_content_element(xml_node);
+ if (content)
+ {
+ str_size = strlen(content);
+ memset(content_buf, 0, sizeof(content_buf));
+ memcpy(content_buf, (void *)content, str_size);
+
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.u.v6.tc
+ = atoi(content_buf);
+ IPACMDBG("\n ipv6 trf class val is %d \n",
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.u.v6.tc);
+ }
+ }
+ else if (0 == IPACM_util_icmp_string((char*)xml_node->name,
+ TrfClsMask_TAG))
+ {
+ content = IPACM_read_content_element(xml_node);
+ if (content)
+ {
+ str_size = strlen(content);
+ memset(content_buf, 0, sizeof(content_buf));
+ memcpy(content_buf, (void *)content, str_size);
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.u.v6.tc
+ &= atoi(content_buf);
+
+ IPACMDBG("\n ipv6 trf class mask is %d \n",
+ atoi(content_buf));
+ }
+ }
+ else if (0 == IPACM_util_icmp_string((char*)xml_node->name,
+ IPV6NextHeaderProtocol_TAG))
+ {
+ content = IPACM_read_content_element(xml_node);
+ if (content)
+ {
+ str_size = strlen(content);
+ memset(content_buf, 0, sizeof(content_buf));
+ memcpy(content_buf, (void *)content, str_size);
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.attrib_mask |= IPA_FLT_NEXT_HDR;
+
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.u.v6.next_hdr
+ = atoi(content_buf);
+ IPACMDBG("\n ipv6 next header protocol is %d \n",
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.u.v6.next_hdr);
+ }
+ }
+ else if (0 == IPACM_util_icmp_string((char*)xml_node->name,
+ TCPSource_TAG))
+ {
+ /* go to child */
+ ret_val = IPACM_firewall_xml_parse_tree(xml_node->children,
+ config);
+ }
+ else if (0 == IPACM_util_icmp_string((char*)xml_node->name,
+ TCPSourcePort_TAG))
+ {
+ content = IPACM_read_content_element(xml_node);
+ if (content)
+ {
+ str_size = strlen(content);
+ memset(content_buf, 0, sizeof(content_buf));
+ memcpy(content_buf, (void *)content, str_size);
+
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.src_port
+ = atoi(content_buf);
+ }
+ }
+ else if (0 == IPACM_util_icmp_string((char*)xml_node->name,
+ TCPSourceRange_TAG))
+ {
+ content = IPACM_read_content_element(xml_node);
+ if (content)
+ {
+ str_size = strlen(content);
+ memset(content_buf, 0, sizeof(content_buf));
+ memcpy(content_buf, (void *)content, str_size);
+ if (atoi(content_buf) != 0)
+ {
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.attrib_mask |= IPA_FLT_SRC_PORT_RANGE;
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.src_port_lo
+ = config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.src_port;
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.src_port_hi
+ = config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.src_port + atoi(content_buf);
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.src_port
+ = 0;
+ IPACMDBG("\n tcp source port from %d to %d \n",
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.src_port_lo,
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.src_port_hi);
+ }
+ else
+ {
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.attrib_mask |= IPA_FLT_SRC_PORT;
+ IPACMDBG("\n tcp source port= %d \n",
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.src_port);
+
+ }
+ }
+ }
+ else if (0 == IPACM_util_icmp_string((char*)xml_node->name,
+ TCPDestination_TAG))
+ {
+ /* go to child */
+ ret_val = IPACM_firewall_xml_parse_tree(xml_node->children,
+ config);
+ }
+ else if (0 == IPACM_util_icmp_string((char*)xml_node->name,
+ TCPDestinationPort_TAG))
+ {
+ content = IPACM_read_content_element(xml_node);
+ if (content)
+ {
+ str_size = strlen(content);
+ memset(content_buf, 0, sizeof(content_buf));
+ memcpy(content_buf, (void *)content, str_size);
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.dst_port
+ = atoi(content_buf);
+ }
+ }
+ else if (0 == IPACM_util_icmp_string((char*)xml_node->name,
+ TCPDestinationRange_TAG))
+ {
+ content = IPACM_read_content_element(xml_node);
+ if (content)
+ {
+ str_size = strlen(content);
+ memset(content_buf, 0, sizeof(content_buf));
+ memcpy(content_buf, (void *)content, str_size);
+ if(atoi(content_buf)!=0)
+ {
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.attrib_mask |= IPA_FLT_DST_PORT_RANGE;
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.dst_port_lo
+ = config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.dst_port;
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.dst_port_hi
+ = config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.dst_port + atoi(content_buf);
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.dst_port
+ = 0;
+ IPACMDBG("\n tcp dest port from %d to %d \n",
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.dst_port_lo,
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.dst_port_hi);
+ }
+ else
+ {
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.attrib_mask |= IPA_FLT_DST_PORT;
+ IPACMDBG("\n tcp dest port= %d \n",
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.dst_port);
+ }
+ }
+ }
+ else if (0 == IPACM_util_icmp_string((char*)xml_node->name,
+ UDPSource_TAG))
+ {
+ /* go to child */
+ ret_val = IPACM_firewall_xml_parse_tree(xml_node->children,
+ config);
+ }
+ else if (0 == IPACM_util_icmp_string((char*)xml_node->name,
+ UDPSourcePort_TAG))
+ {
+ content = IPACM_read_content_element(xml_node);
+ if (content)
+ {
+ str_size = strlen(content);
+ memset(content_buf, 0, sizeof(content_buf));
+ memcpy(content_buf, (void *)content, str_size);
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.src_port
+ = atoi(content_buf);
+ }
+ }
+ else if (0 == IPACM_util_icmp_string((char*)xml_node->name,
+ UDPSourceRange_TAG))
+ {
+ content = IPACM_read_content_element(xml_node);
+ if (content)
+ {
+ str_size = strlen(content);
+ memset(content_buf, 0, sizeof(content_buf));
+ memcpy(content_buf, (void *)content, str_size);
+ if(atoi(content_buf)!=0)
+ {
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.attrib_mask |= IPA_FLT_SRC_PORT_RANGE;
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.src_port_lo
+ = config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.src_port;
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.src_port_hi
+ = config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.src_port + atoi(content_buf);
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.src_port
+ = 0;
+ IPACMDBG("\n udp source port from %d to %d \n",
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.src_port_lo,
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.src_port_hi);
+ }
+ else
+ {
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.attrib_mask |= IPA_FLT_SRC_PORT;
+ IPACMDBG("\n udp source port= %d \n",
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.src_port);
+
+ }
+ }
+ }
+ else if (0 == IPACM_util_icmp_string((char*)xml_node->name,
+ UDPDestination_TAG))
+ {
+ /* go to child */
+ ret_val = IPACM_firewall_xml_parse_tree(xml_node->children,
+ config);
+ }
+ else if (0 == IPACM_util_icmp_string((char*)xml_node->name,
+ UDPDestinationPort_TAG))
+ {
+ content = IPACM_read_content_element(xml_node);
+ if (content)
+ {
+ str_size = strlen(content);
+ memset(content_buf, 0, sizeof(content_buf));
+ memcpy(content_buf, (void *)content, str_size);
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.dst_port
+ = atoi(content_buf);
+ }
+ }
+ else if (0 == IPACM_util_icmp_string((char*)xml_node->name,
+ UDPDestinationRange_TAG))
+ {
+ content = IPACM_read_content_element(xml_node);
+ if (content)
+ {
+ str_size = strlen(content);
+ memset(content_buf, 0, sizeof(content_buf));
+ memcpy(content_buf, (void *)content, str_size);
+ if(atoi(content_buf)!=0)
+ {
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.attrib_mask |= IPA_FLT_DST_PORT_RANGE;
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.dst_port_lo
+ = config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.dst_port;
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.dst_port_hi
+ = config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.dst_port + atoi(content_buf);
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.dst_port
+ = 0;
+ IPACMDBG("\n UDP dest port from %d to %d \n",
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.dst_port_lo,
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.dst_port_hi);
+ }
+ else
+ {
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.attrib_mask |= IPA_FLT_DST_PORT;
+ IPACMDBG("\n UDP dest port= %d \n",
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.dst_port);
+
+ }
+ }
+ }
+ else if (0 == IPACM_util_icmp_string((char*)xml_node->name,
+ ICMPType_TAG))
+ {
+ content = IPACM_read_content_element(xml_node);
+ if (content)
+ {
+ str_size = strlen(content);
+ memset(content_buf, 0, sizeof(content_buf));
+ memcpy(content_buf, (void *)content, str_size);
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.type = atoi(content_buf);
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.attrib_mask |= IPA_FLT_TYPE;
+ IPACMDBG("\n icmp type is %d \n",
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.type);
+ }
+ }
+ else if (0 == IPACM_util_icmp_string((char*)xml_node->name,
+ ICMPCode_TAG))
+ {
+ content = IPACM_read_content_element(xml_node);
+ if (content)
+ {
+ str_size = strlen(content);
+ memset(content_buf, 0, sizeof(content_buf));
+ memcpy(content_buf, (void *)content, str_size);
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.code = atoi(content_buf);
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.attrib_mask |= IPA_FLT_CODE;
+ IPACMDBG("\n icmp code is %d \n",
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.code);
+ }
+ }
+ else if (0 == IPACM_util_icmp_string((char*)xml_node->name,
+ ESPSPI_TAG))
+ {
+ content = IPACM_read_content_element(xml_node);
+ if (content)
+ {
+ str_size = strlen(content);
+ memset(content_buf, 0, sizeof(content_buf));
+ memcpy(content_buf, (void *)content, str_size);
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.spi = atoi(content_buf);
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.attrib_mask |= IPA_FLT_SPI;
+ IPACMDBG("\n esp spi is %d \n",
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.spi);
+ }
+ }
+ else if (0 == IPACM_util_icmp_string((char*)xml_node->name,
+ TCP_UDPSource_TAG))
+ {
+ /* go to child */
+ ret_val = IPACM_firewall_xml_parse_tree(xml_node->children,
+ config);
+ }
+ else if (0 == IPACM_util_icmp_string((char*)xml_node->name,
+ TCP_UDPSourcePort_TAG))
+ {
+ content = IPACM_read_content_element(xml_node);
+ if (content)
+ {
+ str_size = strlen(content);
+ memset(content_buf, 0, sizeof(content_buf));
+ memcpy(content_buf, (void *)content,str_size);
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.src_port
+ = atoi(content_buf);
+ }
+ }
+ else if (0 == IPACM_util_icmp_string((char*)xml_node->name,
+ TCP_UDPSourceRange_TAG))
+ {
+ content = IPACM_read_content_element(xml_node);
+ if (content)
+ {
+ str_size = strlen(content);
+ memset(content_buf, 0, sizeof(content_buf));
+ memcpy(content_buf, (void *)content, str_size);
+ if(atoi(content_buf)!=0)
+ {
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.attrib_mask |= IPA_FLT_SRC_PORT_RANGE;
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.src_port_lo
+ = config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.src_port;
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.src_port_hi
+ = config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.src_port + atoi(content_buf);
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.src_port
+ = 0;
+ IPACMDBG("\n tcp_udp source port from %d to %d \n",
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.src_port_lo,
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.src_port_hi);
+ }
+ else
+ {
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.attrib_mask |= IPA_FLT_SRC_PORT;
+ IPACMDBG("\n tcp_udp source port= %d \n",
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.src_port);
+
+ }
+ }
+ }
+ else if (0 == IPACM_util_icmp_string((char*)xml_node->name,
+ TCP_UDPDestination_TAG))
+ {
+ ret_val = IPACM_firewall_xml_parse_tree(xml_node->children,
+ config);
+ }
+ else if (0 == IPACM_util_icmp_string((char*)xml_node->name,
+ TCP_UDPDestinationPort_TAG))
+ {
+ content = IPACM_read_content_element(xml_node);
+ if (content)
+ {
+ str_size = strlen(content);
+ memset(content_buf, 0, sizeof(content_buf));
+ memcpy(content_buf, (void *)content, str_size);
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.dst_port
+ = atoi(content_buf);
+ }
+ }
+ else if (0 == IPACM_util_icmp_string((char*)xml_node->name,
+ TCP_UDPDestinationRange_TAG))
+ {
+ content = IPACM_read_content_element(xml_node);
+ if (content)
+ {
+ str_size = strlen(content);
+ memset(content_buf, 0, sizeof(content_buf));
+ memcpy(content_buf, (void *)content, str_size);
+ if(atoi(content_buf)!=0)
+ {
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.attrib_mask |= IPA_FLT_DST_PORT_RANGE;
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.dst_port_lo
+ = config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.dst_port;
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.dst_port_hi
+ = config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.dst_port + atoi(content_buf);
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.dst_port
+ = 0;
+ IPACMDBG("\n tcp_udp dest port from %d to %d \n",
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.dst_port_lo,
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.dst_port_hi);
+ }
+ else
+ {
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.attrib_mask |= IPA_FLT_DST_PORT;
+ IPACMDBG("\n tcp_udp dest port= %d \n",
+ config->extd_firewall_entries[config->num_extd_firewall_entries - 1].attrib.dst_port);
+
+ }
+ }
+ }
+ }
+ break;
+
+ default:
+ break;
+ }
+ /* go to sibling */
+ xml_node = xml_node->next;
+ } /* end while */
+ return ret_val;
+}
+
+
diff --git a/ipacm/src/IPACM_cfg.xml b/ipacm/src/IPACM_cfg.xml
new file mode 100644
index 0000000..06f20b6
--- /dev/null
+++ b/ipacm/src/IPACM_cfg.xml
@@ -0,0 +1,42 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<system xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="ipacm_cfg.xsd">
+ <IPACM>
+ <IPACMIface>
+ <Iface>
+ <Name>rmnet0</Name>
+ <Category>WAN</Category>
+ </Iface>
+ <Iface>
+ <Name>rmnet1</Name>
+ <Category>LAN</Category>
+ </Iface>
+ <Iface>
+ <Name>wlan0</Name>
+ <Category>WLAN</Category>
+ </Iface>
+ <Iface>
+ <Name>bridge0</Name>
+ <Category>VIRTUAL</Category>
+ </Iface>
+ </IPACMIface>
+ <IPACMPrivateSubnet>
+ <Subnet>
+ <SubnetAddress>192.168.1.0</SubnetAddress>
+ <SubnetMask>255.255.255.0</SubnetMask>
+ </Subnet>
+ </IPACMPrivateSubnet>
+ <IPACMALG>
+ <ALG>
+ <Protocol>TCP</Protocol>
+ <Port>23</Port>
+ </ALG>
+ <ALG>
+ <Protocol>UDP</Protocol>
+ <Port>250</Port>
+ </ALG>
+ </IPACMALG>
+ <IPACMNAT>
+ <MaxNatEntries>100</MaxNatEntries>
+ </IPACMNAT>
+ </IPACM>
+</system>
diff --git a/ipacm/src/Makefile.am b/ipacm/src/Makefile.am
new file mode 100644
index 0000000..22fa657
--- /dev/null
+++ b/ipacm/src/Makefile.am
@@ -0,0 +1,41 @@
+EXTRA_CPPFLAGS = -DDEBUG
+
+AM_CPPFLAGS = -I./../inc -I$(WORKSPACE)/data-ipa/ipanat/inc -I$(WORKSPACE)/kernel/include -I/usr/include/libxml2
+AM_CPPFLAGS += -Wall -Wundef -Wno-trigraphs
+
+ipacm_SOURCES = IPACM_Main.cpp \
+ IPACM_Conntrack_NATApp.cpp\
+ IPACM_ConntrackClient.cpp \
+ IPACM_ConntrackListener.cpp \
+ IPACM_EvtDispatcher.cpp \
+ IPACM_Config.cpp \
+ IPACM_CmdQueue.cpp \
+ IPACM_Log.cpp \
+ IPACM_Filtering.cpp \
+ IPACM_Routing.cpp \
+ IPACM_Header.cpp \
+ IPACM_Lan.cpp \
+ IPACM_Iface.cpp \
+ IPACM_Wlan.cpp \
+ IPACM_Wan.cpp \
+ IPACM_IfaceManager.cpp \
+ IPACM_Neighbor.cpp \
+ IPACM_Netlink.cpp \
+ IPACM_Xml.cpp
+
+bin_PROGRAMS = ipacm
+
+requiredlibs = -lxml2 -lpthread -lnetfilter_conntrack -lnfnetlink\
+ ../../ipanat/src/libipanat.la
+
+ipacm_LDADD = $(requiredlibs)
+
+LOCAL_MODULE := libipanat
+LOCAL_PRELINK_MODULE := false
+include $(BUILD_SHARED_LIBRARY)
+
+etcdir = ${sysconfdir}
+etc_SCRIPTS = IPACM_cfg.xml mobileap_firewall.xml
+
+init_ddir = ${sysconfdir}/init.d
+init_d_SCRIPTS = start_ipacm_le
diff --git a/ipacm/src/mobileap_firewall.xml b/ipacm/src/mobileap_firewall.xml
new file mode 100644
index 0000000..c722511
--- /dev/null
+++ b/ipacm/src/mobileap_firewall.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<system xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="mobileap_firewall_cfg.xsd">
+ <MobileAPFirewallCfg>
+ </MobileAPFirewallCfg>
+</system>
diff --git a/ipacm/src/start_ipacm_le b/ipacm/src/start_ipacm_le
new file mode 100755
index 0000000..3541a0b
--- /dev/null
+++ b/ipacm/src/start_ipacm_le
@@ -0,0 +1,57 @@
+#! /bin/sh
+#
+################################
+# Copyright (c) 2013, The Linux Foundation. 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 name of The Linux 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 "AS IS" AND ANY EXPRESS OR IMPLIED
+# WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+# 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.
+################################
+
+# ipacm init.d script to start the data-ipa Software's ipacm daemon
+
+set -e
+
+case "$1" in
+ start)
+ echo -n "Starting ipacm: "
+ start-stop-daemon -S -b -a ipacm
+ echo "done"
+ ;;
+ stop)
+ echo -n "Stopping ipacm: "
+ start-stop-daemon -K -n ipacm
+ echo "done"
+ ;;
+ restart)
+ $0 stop
+ $0 start
+ ;;
+ *)
+ echo "Usage ipacm { start | stop | restart}" >&2
+ exit 1
+ ;;
+esac
+
+exit 0
diff --git a/ipanat/inc/ipa_nat_drv.h b/ipanat/inc/ipa_nat_drv.h
new file mode 100644
index 0000000..cda63f1
--- /dev/null
+++ b/ipanat/inc/ipa_nat_drv.h
@@ -0,0 +1,118 @@
+/*
+Copyright (c) 2013, The Linux Foundation. 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 name of The Linux 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 "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+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 "string.h" /* memset */
+#include "stdlib.h" /* free, malloc */
+#include "stdint.h" /* uint32_t */
+
+/**
+ * struct ipa_nat_ipv4_rule - To hold ipv4 nat rule
+ * @target_ip: destination ip address
+ * @private_ip: private ip address
+ * @target_port: destination port
+ * @private_port: private port
+ * @protocol: protocol of rule (tcp/udp)
+ */
+typedef struct
+{
+ uint32_t target_ip;
+ uint32_t private_ip;
+ uint16_t target_port;
+ uint16_t private_port;
+ uint16_t public_port;
+ uint8_t protocol;
+
+}ipa_nat_ipv4_rule;
+
+/**
+ * ipa_nat_add_ipv4_tbl() - create ipv4 nat table
+ * @public_ip_addr: [in] public ipv4 address
+ * @number_of_entries: [in] number of nat entries
+ * @table_handle: [out] Handle of new ipv4 nat table
+ *
+ * To create new ipv4 nat table
+ *
+ * Returns: 0 On Success, negative on failure
+ */
+int ipa_nat_add_ipv4_tbl(uint32_t public_ip_addr,
+ uint16_t number_of_entries,
+ uint32_t *table_handle);
+
+/**
+ * ipa_nat_del_ipv4_tbl() - delete ipv4 table
+ * @table_handle: [in] Handle of ipv4 nat table
+ *
+ * To delete given ipv4 nat table
+ *
+ * Returns: 0 On Success, negative on failure
+ */
+int ipa_nat_del_ipv4_tbl(uint32_t table_handle);
+
+/**
+ * ipa_nat_add_ipv4_rule() - to insert new ipv4 rule
+ * @table_handle: [in] handle of ipv4 nat table
+ * @rule: [in] Pointer to new rule
+ * @rule_handle: [out] Return the handle to rule
+ *
+ * To insert new ipv4 nat rule into ipv4 nat table
+ *
+ * Returns: 0 On Success, negative on failure
+ */
+int ipa_nat_add_ipv4_rule(uint32_t table_handle,
+ const ipa_nat_ipv4_rule *rule,
+ uint32_t *rule_handle);
+
+/**
+ * ipa_nat_del_ipv4_rule() - to delete ipv4 nat rule
+ * @table_handle: [in] handle of ipv4 nat table
+ * @rule_handle: [in] ipv4 nat rule handle
+ *
+ * To insert new ipv4 nat rule into ipv4 nat table
+ *
+ * Returns: 0 On Success, negative on failure
+ */
+int ipa_nat_del_ipv4_rule(uint32_t table_handle,
+ uint32_t rule_handle);
+
+
+/**
+ * ipa_nat_query_timestamp() - to query timestamp
+ * @table_handle: [in] handle of ipv4 nat table
+ * @rule_handle: [in] ipv4 nat rule handle
+ * @time_stamp: [out] time stamp of rule
+ *
+ * To retrieve the timestamp that lastly the
+ * nat rule was accessed
+ *
+ * Returns: 0 On Success, negative on failure
+ */
+int ipa_nat_query_timestamp(uint32_t table_handle,
+ uint32_t rule_handle,
+ uint32_t *time_stamp);
+
diff --git a/ipanat/inc/ipa_nat_drvi.h b/ipanat/inc/ipa_nat_drvi.h
new file mode 100644
index 0000000..9b56cf1
--- /dev/null
+++ b/ipanat/inc/ipa_nat_drvi.h
@@ -0,0 +1,474 @@
+/*
+Copyright (c) 2013, The Linux Foundation. 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 name of The Linux 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 "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+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 IPA_NAT_DRVI_H
+#define IPA_NAT_DRVI_H
+
+#include <unistd.h>
+#include <stdio.h>
+#include <sys/ioctl.h>
+#include <fcntl.h>
+#include <sys/mman.h>
+#include <linux/msm_ipa.h>
+#include <netinet/in.h>
+#include <sys/inotify.h>
+
+#include "ipa_nat_logi.h"
+
+#define NAT_DUMP
+//#define IPADBG(fmt, args...) printf(" %s:%d " fmt, __FUNCTION__, __LINE__, ## args)
+//#define IPAERR(fmt, args...) printf(" %s:%d " fmt, __FUNCTION__, __LINE__, ## args)
+
+
+/*======= IMPLEMENTATION related data structures and functions ======= */
+#ifdef IPA_ON_R3PC
+#define NAT_MMAP_MEM_SIZE (2 * 1024UL * 1024UL - 1)
+#endif
+
+#define IPA_DEV_NAME "/dev/ipa"
+#define NAT_DEV_DIR "/dev"
+#define NAT_DEV_NAME "ipaNatTable"
+#define NAT_DEV_FULL_NAME "/dev/ipaNatTable"
+
+#define IPA_NAT_TABLE_VALID 1
+#define IPA_NAT_MAX_IP4_TBLS 1
+#define IPA_NAT_BASE_TABLE_PERCENTAGE .8
+#define IPA_NAT_EXPANSION_TABLE_PERCENTAGE .2
+
+#define IPA_NAT_NUM_OF_BASE_TABLES 2
+#define IPA_NAT_UNUSED_BASE_ENTRIES 2
+
+#define IPA_NAT_RULE_FLAG_FIELD_OFFSET 18
+#define IPA_NAT_RULE_NEXT_FIELD_OFFSET 8
+#define IPA_NAT_RULE_PROTO_FIELD_OFFSET 22
+
+#define IPA_NAT_INDEX_RULE_NEXT_FIELD_OFFSET 2
+#define IPA_NAT_INDEX_RULE_NAT_INDEX_FIELD_OFFSET 0
+
+#define IPA_NAT_RULE_FLAG_FIELD_SIZE 2
+#define IPA_NAT_RULE_NEXTFIELD_FIELD_SIZE 2
+
+#define IPA_NAT_FLAG_ENABLE_BIT_MASK 0x8000
+#define IPA_NAT_FLAG_DISABLE_BIT_MASK 0x0000
+
+#define IPA_NAT_FLAG_ENABLE_BIT 1
+#define IPA_NAT_FLAG_DISABLE_BIT 0
+
+#define IPA_NAT_INVALID_PROTO_FIELD_VALUE 0xFF00
+#define IPA_NAT_INVALID_PROTO_FIELD_CMP 0xFF
+
+#define IPA_NAT_INVALID_INDEX 0xFF
+#define IPA_NAT_INVALID_NAT_ENTRY 0x0
+
+#define INDX_TBL_ENTRY_SIZE_IN_BITS 16
+
+/* ----------- Rule id -----------------------
+
+ ------------------------------------------------
+ | 3bits | 12 bits | 1 bit |
+ ------------------------------------------------
+ | reserved | index into table | 0 - base |
+ | | | 1 - expansion |
+ ------------------------------------------------
+
+*/
+#define IPA_NAT_RULE_HDL_TBL_TYPE_BITS 0x1
+#define IPA_NAT_RULE_HDL_TBL_TYPE_MASK 0x1
+
+/* ----------- sw specif parameter -----
+ ------------------------------------
+ | 16 bits | 16 bits |
+ ------------------------------------
+ | index table | prev index |
+ | entry | |
+ ------------------------------------
+-----------------------------------------*/
+#define IPA_NAT_SW_PARAM_PREV_INDX_BYTE 0
+#define IPA_NAT_SW_PARAM_INDX_TBL_ENTRY_BYTE 1
+
+typedef enum
+{
+ IPA_NAT_BASE_TBL = 0,
+ IPA_NAT_EXPN_TBL = 1,
+ IPA_NAT_INDX_TBL = 2,
+ IPA_NAT_INDEX_EXPN_TBL = 3,
+}nat_table_type;
+
+typedef enum
+{
+ NEXT_INDEX_FIELD,
+ PUBLIC_PORT_FILED,
+ PRIVATE_PORT_FIELD,
+ TARGET_PORT_FIELD,
+ IP_CHKSUM_FIELD,
+ ENABLE_FIELD,
+ TIME_STAMP_FIELD,
+ PROTOCOL_FIELD,
+ TCP_UDP_CHKSUM_FIELD,
+ SW_SPEC_PARAM_PREV_INDEX_FIELD,
+ SW_SPEC_PARAM_INDX_TBL_ENTRY_FIELD,
+ INDX_TBL_TBL_ENTRY_FIELD,
+ INDX_TBL_NEXT_INDEX_FILED
+
+}ipa_nat_rule_field_type;
+
+/*
+ ---------------------------------------------
+ | 3 | 2 | 1 | 0 |
+ ---------------------------------------------
+ | Public Port(2B) | Next Index(2B) |
+ ---------------------------------------------
+*/
+typedef struct
+{
+ uint32_t next_index:16;
+ uint32_t public_port:16;
+}next_index_pub_port;
+
+
+/*
+ ---------------------------------------------
+ | 3 | 2 | 1 | 0 |
+ ---------------------------------------------
+ | Flags(2B) | IP check sum Diff(2B)|
+ |EN|FIN|Resv | | |
+ ---------------------------------------------
+*/
+typedef struct
+{
+ uint32_t ip_chksum:16;
+ uint32_t rsvd1:14;
+ uint32_t redirect:1;
+ uint32_t enable:1;
+}ipcksum_enbl;
+
+
+/*
+ ---------------------------------------
+ | 7 | 6 | 5 | 4 |
+ ---------------------------------------
+ | Proto | TimeStamp(3B) |
+ | (1B) | |
+ ---------------------------------------
+*/
+typedef struct
+{
+ uint32_t time_stamp:24;
+ uint32_t protocol:8;
+}time_stamp_proto;
+
+
+/*
+ ---------------------------------------------
+ | 3 | 2 | 1 | 0 |
+ ---------------------------------------------
+ | next_index | Table entry |
+ ----------------------------------------------
+*/
+typedef struct {
+ uint16_t tbl_entry;
+ uint16_t next_index;
+}tbl_ent_nxt_indx;
+
+/*--------------------------------------------------
+ 32 bit sw_spec_params is interpreted as follows
+ ------------------------------------
+ | 16 bits | 16 bits |
+ ------------------------------------
+ | index table | prev index |
+ | entry | |
+ ------------------------------------
+--------------------------------------------------*/
+typedef struct {
+ uint16_t prev_index;
+ uint16_t index_table_entry;
+}sw_spec_params;
+
+/*------------------------ NAT Table Entry ---------------------------------------
+
+ -----------------------------------------------------------------------------------
+ | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
+ -----------------------------------------------------------------------------------
+ | Target IP(4B) | Private IP(4B) |
+ -----------------------------------------------------------------------------------
+ |Target Port(2B) | Private Port(2B) | Public Port(2B) | Next Index(2B) |
+ -----------------------------------------------------------------------------------
+ | Proto | TimeStamp(3B) | Flags(2B) | IP check sum Diff(2B)|
+ | (1B) | |EN|FIN|Resv | | |
+ -----------------------------------------------------------------------------------
+ | TCP/UDP checksum | Reserved(2B) | SW Specific Parameters(4B) |
+ | diff (2B) | |
+ -----------------------------------------------------------------------------------
+
+ Dont change below structure definition.
+ It should be same as above(little endian order)
+ -------------------------------------------------------------------------------*/
+struct ipa_nat_rule {
+ uint64_t private_ip:32;
+ uint64_t target_ip:32;
+
+ uint64_t nxt_indx_pub_port:32;
+ uint64_t private_port:16;
+ uint64_t target_port:16;
+
+ uint64_t ip_cksm_enbl:32;
+ uint64_t ts_proto:32;
+
+ /*--------------------------------------------------
+ 32 bit sw_spec_params is interpreted as follows
+ ------------------------------------
+ | 16 bits | 16 bits |
+ ------------------------------------
+ | index table | prev index |
+ | entry | |
+ ------------------------------------
+ --------------------------------------------------*/
+ uint64_t sw_spec_params:32;
+
+ uint64_t rsvd2:16;
+ uint64_t tcp_udp_chksum:16;
+
+};
+
+struct ipa_nat_sw_rule {
+ uint64_t private_ip:32;
+ uint64_t target_ip:32;
+
+ uint64_t next_index:16;
+ uint64_t public_port:16;
+ uint64_t private_port:16;
+ uint64_t target_port:16;
+
+ uint64_t ip_chksum:16;
+ uint64_t rsvd1:14;
+ uint64_t redirect:1;
+ uint64_t enable:1;
+ uint64_t time_stamp:24;
+ uint64_t protocol:8;
+
+ /*--------------------------------------------------
+ 32 bit sw_spec_params is interpreted as follows
+ ------------------------------------
+ | 16 bits | 16 bits |
+ ------------------------------------
+ | index table | prev index |
+ | entry | |
+ ------------------------------------
+ --------------------------------------------------*/
+ uint64_t prev_index:16;
+ uint64_t indx_tbl_entry:16;
+ uint64_t rsvd2:16;
+ uint64_t tcp_udp_chksum:16;
+
+};
+#define IPA_NAT_TABLE_ENTRY_SIZE 32
+#define IPA_NAT_INDEX_TABLE_ENTRY_SIZE 4
+
+struct ipa_nat_indx_tbl_rule {
+ uint32_t tbl_entry_nxt_indx;
+};
+
+struct ipa_nat_sw_indx_tbl_rule {
+ uint16_t tbl_entry;
+ uint16_t next_index;
+};
+
+struct ipa_nat_indx_tbl_meta_info {
+ uint16_t prev_index;
+};
+
+struct ipa_nat_ip4_table_cache {
+ uint8_t valid;
+ uint32_t public_addr;
+
+ int nat_fd;
+ int size;
+ uint32_t tbl_addr_offset;
+ char table_name[IPA_RESOURCE_NAME_MAX];
+
+ char *ipv4_rules_addr;
+ char *index_table_addr;
+ uint16_t table_entries;
+
+ char *ipv4_expn_rules_addr;
+ char *index_table_expn_addr;
+ uint16_t expn_table_entries;
+
+ struct ipa_nat_indx_tbl_meta_info *index_expn_table_meta;
+
+ uint16_t *rule_id_array;
+#ifdef IPA_ON_R3PC
+ uint32_t mmap_offset;
+#endif
+};
+
+struct ipa_nat_cache {
+ struct ipa_nat_ip4_table_cache ip4_tbl[IPA_NAT_MAX_IP4_TBLS];
+ int ipa_fd;
+ uint8_t table_cnt;
+};
+
+struct ipa_nat_indx_tbl_sw_rule {
+ uint16_t tbl_entry;
+ uint16_t next_index;
+ uint16_t prev_index;
+};
+
+typedef enum
+{
+ IPA_NAT_DEL_TYPE_ONLY_ONE,
+ IPA_NAT_DEL_TYPE_HEAD,
+ IPA_NAT_DEL_TYPE_MIDDLE,
+ IPA_NAT_DEL_TYPE_LAST,
+}del_type;
+
+/**
+ * ipa_nati_parse_ipv4_rule_hdl() - prase rule handle
+ * @tbl_hdl: [in] nat table rule
+ * @rule_hdl: [in] nat rule handle
+ * @expn_tbl: [out] expansion table or not
+ * @tbl_entry: [out] index into table
+ *
+ * Parse the rule handle to retrieve the nat table
+ * type and entry of nat table
+ *
+ * Returns: None
+ */
+void ipa_nati_parse_ipv4_rule_hdl(uint8_t tbl_hdl,
+ uint16_t rule_hdl,
+ uint8_t *expn_tbl,
+ uint16_t *tbl_entry);
+
+/**
+ * ipa_nati_make_rule_hdl() - makes nat rule handle
+ * @tbl_hdl: [in] nat table handle
+ * @tbl_entry: [in] nat table entry
+ *
+ * Calculate the nat rule handle which from
+ * nat entry which will be returned to client of
+ * nat driver
+ *
+ * Returns: >0 nat rule handle
+ */
+uint16_t ipa_nati_make_rule_hdl(uint16_t tbl_hdl,
+ uint16_t tbl_entry);
+
+uint32_t ipa_nati_get_index_entry_offset(struct ipa_nat_ip4_table_cache *cache_ptr,
+ nat_table_type tbl_type,
+ uint16_t indx_tbl_entry);
+uint32_t ipa_nati_get_entry_offset(struct ipa_nat_ip4_table_cache *cache_ptr,
+ nat_table_type tbl_type,
+ uint16_t tbl_entry);
+
+int ipa_nati_add_ipv4_tbl(uint32_t public_ip_addr,
+ uint16_t number_of_entries,
+ uint32_t *table_hanle);
+
+int ipa_nati_alloc_table(uint16_t number_of_entries,
+ struct ipa_ioc_nat_alloc_mem *mem,
+ uint16_t *tbl_entries, uint16_t *expn_tbl_entries);
+
+int ipa_nati_update_cache(struct ipa_ioc_nat_alloc_mem *,
+ uint32_t public_ip_addr,
+ uint16_t tbl_entries,
+ uint16_t expn_tbl_entries);
+
+int ipa_nati_del_ipv4_table(uint32_t tbl_hdl);
+int ipa_nati_reset_ipv4_table(uint32_t tbl_hdl);
+int ipa_nati_post_ipv4_init_cmd(uint8_t tbl_index);
+
+int ipa_nati_query_timestamp(uint32_t tbl_hdl,
+ uint32_t rule_hdl,
+ uint32_t *time_stamp);
+
+uint32_t ipa_nati_add_ipv4_rule(uint32_t tbl_hdl,
+ const ipa_nat_ipv4_rule *clnt_rule);
+
+int ipa_nati_generate_rule(uint32_t tbl_hdl,
+ const ipa_nat_ipv4_rule *clnt_rule,
+ struct ipa_nat_sw_rule *rule,
+ struct ipa_nat_indx_tbl_sw_rule *index_sw_rule,
+ uint16_t *tbl_entry,
+ uint16_t *indx_tbl_entry);
+uint16_t ipa_nati_expn_tbl_free_entry(struct ipa_nat_rule *expn_tbl,
+ uint16_t size);
+uint16_t ipa_nati_generate_tbl_rule(const ipa_nat_ipv4_rule *clnt_rule,
+ struct ipa_nat_sw_rule *sw_rule,
+ struct ipa_nat_ip4_table_cache *tbl_ptr);
+uint16_t ipa_nati_generate_index_rule(const ipa_nat_ipv4_rule *clnt_rule,
+ struct ipa_nat_indx_tbl_sw_rule *sw_rule,
+ struct ipa_nat_ip4_table_cache *tbl_ptr);
+uint16_t ipa_nati_index_expn_get_free_entry(struct ipa_nat_indx_tbl_rule *tbl,
+ uint16_t size);
+
+void ipa_nati_copy_ipv4_rule_to_hw(
+ struct ipa_nat_ip4_table_cache *ipv4_cache,
+ struct ipa_nat_sw_rule *rule,
+ uint16_t entry, uint8_t tbl_index);
+void ipa_nati_copy_ipv4_index_rule_to_hw(
+ struct ipa_nat_ip4_table_cache *ipv4_cache,
+ struct ipa_nat_indx_tbl_sw_rule *indx_sw_rule,
+ uint16_t entry, uint8_t tbl_index);
+
+void ipa_nati_write_next_index(uint8_t tbl_indx,
+ nat_table_type tbl_type,
+ uint16_t value,
+ uint32_t offset);
+int ipa_nati_post_ipv4_dma_cmd(uint8_t tbl_indx,
+ uint16_t entry);
+
+int ipa_nati_del_ipv4_rule(uint32_t tbl_hdl,
+ uint32_t rule_hdl);
+int ipa_nati_post_del_dma_cmd(uint8_t tbl_indx,
+ uint16_t tbl_entry,
+ uint8_t expn_tbl,
+ del_type rule_pos);
+void ipa_nati_find_index_rule_pos(
+ struct ipa_nat_ip4_table_cache *cache_ptr,
+ uint16_t tbl_entry,
+ del_type *rule_pos);
+void ipa_nati_del_dead_ipv4_head_nodes(uint8_t tbl_indx);
+void ipa_nati_find_rule_pos(struct ipa_nat_ip4_table_cache *cache_ptr,
+ uint8_t expn_tbl,
+ uint16_t tbl_entry,
+ del_type *rule_pos);
+void ipa_nati_del_dead_ipv4_head_nodes(uint8_t tbl_indx);
+
+
+/* ========================================================
+ Debug functions
+ ========================================================*/
+#ifdef NAT_DUMP
+void ipa_nati_print_rule(struct ipa_nat_rule *rule, uint32_t rule_id);
+void ipa_nati_dump_rule_buf(void *param1, uint8_t size, uint32_t rule_id);
+void ipa_nat_dump_ipv4_table(uint32_t tbl_hdl);
+void ipa_nati_dump_index_rule_buf(void *param1, uint8_t size, uint32_t rule_id);
+#endif
+
+#endif /* #ifndef IPA_NAT_DRVI_H */
diff --git a/ipanat/inc/ipa_nat_logi.h b/ipanat/inc/ipa_nat_logi.h
new file mode 100644
index 0000000..0ffa672
--- /dev/null
+++ b/ipanat/inc/ipa_nat_logi.h
@@ -0,0 +1,79 @@
+/*
+Copyright (c) 2013, The Linux Foundation. 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 name of The Linux 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 "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+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.
+*/
+/*!
+ @file
+ ipa_nat_logi.h
+
+ @brief
+ This file implements the IPAM log functionality.
+
+ @Author
+
+
+*/
+
+#ifndef IPA_NAT_LOGI_H
+#define IPA_NAT_LOGI_H
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#include <stdio.h>
+#include <string.h>
+
+#define NAT_LOG_SIZE 200
+
+#define PERROR(fmt) printf("%s:%d %s()", __FILE__, __LINE__, __FUNCTION__);\
+ perror(fmt);
+
+#define IPADBG(fmt, ...) {\
+ int n =0; \
+ n = snprintf(nat_log_buf, sizeof(nat_log_buf), "%s:%d %s() ", __FILE__, __LINE__, __FUNCTION__);\
+ snprintf((nat_log_buf+n), (sizeof(nat_log_buf)-n-1), fmt, ##__VA_ARGS__);\
+ log_nat_message(nat_log_buf);\
+ }
+
+
+#define IPAERR(fmt, ...) {\
+ int n =0; \
+ n = snprintf(nat_log_buf, sizeof(nat_log_buf), "%s:%d %s() %s", __FILE__, __LINE__, __FUNCTION__, "Error:");\
+ snprintf((nat_log_buf+n), (sizeof(nat_log_buf)-n-1), fmt, ##__VA_ARGS__);\
+ log_nat_message(nat_log_buf);\
+ }
+
+extern void log_nat_message(char *msg);
+extern char nat_log_buf[NAT_LOG_SIZE];
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* IPA_NAT_LOGI_H */
diff --git a/ipanat/src/Makefile.am b/ipanat/src/Makefile.am
new file mode 100644
index 0000000..cf9fc3f
--- /dev/null
+++ b/ipanat/src/Makefile.am
@@ -0,0 +1,20 @@
+AM_CFLAGS = -Wall -Wundef -Wstrict-prototypes -Wno-trigraphs
+AM_CFLAGS += -I./../inc -I$(WORKSPACE)/kernel/include
+
+c_sources = ipa_nat_drv.c \
+ ipa_nat_drvi.c \
+ ipa_nat_logi.c
+
+library_includedir = $(pkgincludedir)
+library_include_HEADERS = ./../inc/ipa_nat_drvi.h \
+ ./../inc/ipa_nat_drv.h \
+ ./../inc/ipa_nat_logi.h
+
+lib_LTLIBRARIES = libipanat.la
+libipanat_la_C = @C@
+libipanat_la_SOURCES = $(c_sources)
+libipanat_la_CFLAGS = $(AM_CFLAGS)
+libipanat_la_LDFLAGS = -shared -version-info 1:0:0
+
+
+
diff --git a/ipanat/src/ipa_nat_drv.c b/ipanat/src/ipa_nat_drv.c
new file mode 100644
index 0000000..68e2de8
--- /dev/null
+++ b/ipanat/src/ipa_nat_drv.c
@@ -0,0 +1,177 @@
+/*
+Copyright (c) 2013, The Linux Foundation. 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 name of The Linux 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 "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+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 "ipa_nat_drv.h"
+#include "ipa_nat_drvi.h"
+
+/**
+ * ipa_nat_add_ipv4_tbl() - create ipv4 nat table
+ * @public_ip_addr: [in] public ipv4 address
+ * @number_of_entries: [in] number of nat entries
+ * @table_handle: [out] Handle of new ipv4 nat table
+ *
+ * To create new ipv4 nat table
+ *
+ * Returns: 0 On Success, negative on failure
+ */
+int ipa_nat_add_ipv4_tbl(uint32_t public_ip_addr,
+ uint16_t number_of_entries,
+ uint32_t *tbl_hdl)
+{
+ int ret;
+
+ if (NULL == tbl_hdl || 0 == number_of_entries)
+ {
+ IPAERR("Invalid parameters \n");
+ return -1;
+ }
+
+ ret = ipa_nati_add_ipv4_tbl(public_ip_addr,
+ number_of_entries,
+ tbl_hdl);
+ if (ret != 0)
+ {
+ IPAERR("unable to add table \n");
+ return -1;
+ }
+ IPADBG("Returning table handle 0x%x\n", *tbl_hdl);
+
+ return ret;
+} /* __ipa_nat_add_ipv4_tbl() */
+
+/**
+ * ipa_nat_del_ipv4_tbl() - delete ipv4 table
+ * @table_handle: [in] Handle of ipv4 nat table
+ *
+ * To delete given ipv4 nat table
+ *
+ * Returns: 0 On Success, negative on failure
+ */
+int ipa_nat_del_ipv4_tbl(uint32_t tbl_hdl)
+{
+ if (IPA_NAT_INVALID_NAT_ENTRY == tbl_hdl ||
+ tbl_hdl > IPA_NAT_MAX_IP4_TBLS)
+ {
+ IPAERR("invalid table handle passed \n");
+ return -1;
+ }
+ IPADBG("Passed Table Handle: 0x%x\n", tbl_hdl);
+
+ return ipa_nati_del_ipv4_table(tbl_hdl);
+}
+
+/**
+ * ipa_nat_add_ipv4_rule() - to insert new ipv4 rule
+ * @table_handle: [in] handle of ipv4 nat table
+ * @rule: [in] Pointer to new rule
+ * @rule_handle: [out] Return the handle to rule
+ *
+ * To insert new ipv4 nat rule into ipv4 nat table
+ *
+ * Returns: 0 On Success, negative on failure
+ */
+int ipa_nat_add_ipv4_rule(uint32_t tbl_hdl,
+ const ipa_nat_ipv4_rule *clnt_rule,
+ uint32_t *rule_hdl)
+{
+
+ if (IPA_NAT_INVALID_NAT_ENTRY == tbl_hdl ||
+ tbl_hdl > IPA_NAT_MAX_IP4_TBLS || NULL == rule_hdl ||
+ NULL == clnt_rule)
+ {
+ IPAERR("invalide table handle passed \n");
+ return -1;
+ }
+ IPADBG("Passed Table handle: 0x%x\n", tbl_hdl);
+
+ *rule_hdl = ipa_nati_add_ipv4_rule(tbl_hdl, clnt_rule);
+ IPADBG("returning rule handle 0x%x\n", *rule_hdl);
+
+ return 0;
+}
+
+
+/**
+ * ipa_nat_del_ipv4_rule() - to delete ipv4 nat rule
+ * @table_handle: [in] handle of ipv4 nat table
+ * @rule_handle: [in] ipv4 nat rule handle
+ *
+ * To insert new ipv4 nat rule into ipv4 nat table
+ *
+ * Returns: 0 On Success, negative on failure
+ */
+int ipa_nat_del_ipv4_rule(uint32_t tbl_hdl,
+ uint32_t rule_hdl)
+{
+
+ if (IPA_NAT_INVALID_NAT_ENTRY == tbl_hdl ||
+ IPA_NAT_INVALID_NAT_ENTRY == rule_hdl)
+ {
+ IPAERR("invalide parameters\n");
+ return -1;
+ }
+ IPADBG("Passed Table: 0x%x and rule handle 0x%x\n", tbl_hdl, rule_hdl);
+
+ if (-1 == ipa_nati_del_ipv4_rule(tbl_hdl, rule_hdl))
+ {
+ IPAERR("unable to delete rule from hw \n");
+ return -1;
+ }
+
+ return 0;
+}
+
+/**
+ * ipa_nat_query_timestamp() - to query timestamp
+ * @table_handle: [in] handle of ipv4 nat table
+ * @rule_handle: [in] ipv4 nat rule handle
+ * @time_stamp: [out] time stamp of rule
+ *
+ * To retrieve the timestamp that lastly the
+ * nat rule was accessed
+ *
+ * Returns: 0 On Success, negative on failure
+ */
+int ipa_nat_query_timestamp(uint32_t tbl_hdl,
+ uint32_t rule_hdl,
+ uint32_t *time_stamp)
+{
+
+ if (0 == tbl_hdl || tbl_hdl > IPA_NAT_MAX_IP4_TBLS ||
+ NULL == time_stamp)
+ {
+ IPAERR("invalid parameters passed \n");
+ return -1;
+ }
+ IPADBG("Passed Table: 0x%x and rule handle 0x%x\n", tbl_hdl, rule_hdl);
+
+ return ipa_nati_query_timestamp(tbl_hdl, rule_hdl, time_stamp);
+}
+
+
diff --git a/ipanat/src/ipa_nat_drvi.c b/ipanat/src/ipa_nat_drvi.c
new file mode 100644
index 0000000..d542a88
--- /dev/null
+++ b/ipanat/src/ipa_nat_drvi.c
@@ -0,0 +1,2387 @@
+/*
+Copyright (c) 2013, The Linux Foundation. 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 name of The Linux 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 "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+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 "ipa_nat_drv.h"
+#include "ipa_nat_drvi.h"
+
+struct ipa_nat_cache ipv4_nat_cache;
+
+/* ------------------------------------------
+ UTILITY FUNCTIONS START
+ --------------------------------------------*/
+
+/**
+ * UpdateSwSpecParams() - updates sw specific params
+ * @rule: [in/out] nat table rule
+ * @param_type: [in] which param need to update
+ * @value: [in] value of param
+ *
+ * Update SW specific params in the passed rule.
+ *
+ * Returns: None
+ */
+void UpdateSwSpecParams(struct ipa_nat_rule *rule,
+ uint8_t param_type,
+ uint32_t value)
+{
+
+ uint32_t temp = rule->sw_spec_params;
+
+ if(IPA_NAT_SW_PARAM_INDX_TBL_ENTRY_BYTE == param_type)
+ {
+ value = (value << INDX_TBL_ENTRY_SIZE_IN_BITS);
+ }
+
+ temp = (temp | value);
+ rule->sw_spec_params = temp;
+ return;
+}
+
+/**
+ * Read8BitFieldValue()
+ * @rule: [in/out]
+ * @param_type: [in]
+ * @value: [in]
+ *
+ *
+ *
+ * Returns: None
+ */
+
+uint8_t Read8BitFieldValue(uint32_t param,
+ ipa_nat_rule_field_type fld_type)
+{
+
+ void *temp = (void *)¶m;
+
+ switch (fld_type)
+ {
+
+ case PROTOCOL_FIELD:
+ return ((time_stamp_proto *)temp)->protocol;
+
+ default:
+ IPAERR("Invalid Field type passed\n");
+ return 0;
+ }
+
+}
+
+uint16_t Read16BitFieldValue(uint32_t param,
+ ipa_nat_rule_field_type fld_type)
+{
+
+ void *temp = (void *)¶m;
+
+ switch (fld_type)
+ {
+
+ case NEXT_INDEX_FIELD:
+ return ((next_index_pub_port *)temp)->next_index;
+
+ case PUBLIC_PORT_FILED:
+ return ((next_index_pub_port *)temp)->public_port;
+
+ case ENABLE_FIELD:
+ return ((ipcksum_enbl *)temp)->enable;
+
+ case SW_SPEC_PARAM_PREV_INDEX_FIELD:
+ return ((sw_spec_params *)temp)->prev_index;
+
+ case SW_SPEC_PARAM_INDX_TBL_ENTRY_FIELD:
+ return ((sw_spec_params *)temp)->index_table_entry;
+
+ case INDX_TBL_TBL_ENTRY_FIELD:
+ return ((tbl_ent_nxt_indx *)temp)->tbl_entry;
+
+ case INDX_TBL_NEXT_INDEX_FILED:
+ return ((tbl_ent_nxt_indx *)temp)->next_index;
+
+#ifdef NAT_DUMP
+ case IP_CHKSUM_FIELD:
+ return ((ipcksum_enbl *)temp)->ip_chksum;
+#endif
+
+ default:
+ IPAERR("Invalid Field type passed\n");
+ return 0;
+ }
+
+}
+
+uint32_t Read32BitFieldValue(uint32_t param,
+ ipa_nat_rule_field_type fld_type)
+{
+
+ void *temp = (void *)¶m;
+
+ switch (fld_type)
+ {
+
+ case TIME_STAMP_FIELD:
+ return ((time_stamp_proto *)temp)->time_stamp;
+
+ default:
+ IPAERR("Invalid Field type passed\n");
+ return 0;
+ }
+
+}
+
+
+/**
+ * CreateNatDevice() - Create nat devices
+ * @mem: [in] name of device that need to create
+ *
+ * Create Nat device and Register for file create
+ * notification in given directory and wait till
+ * receive notification
+ *
+ * Returns: 0 on success, negative on failure
+ */
+int CreateNatDevice(struct ipa_ioc_nat_alloc_mem *mem)
+{
+
+#define EVENT_SIZE (sizeof (struct inotify_event))
+#define FILE_NAME_LENGTH (sizeof(NAT_DEV_NAME)*2 + 1)
+#define BUF_LEN (EVENT_SIZE + FILE_NAME_LENGTH)
+
+ int length;
+ int wd;
+ char buffer[BUF_LEN];
+ int ret, inotify_fd;
+
+ inotify_fd = inotify_init();
+ if (inotify_fd < 0)
+ {
+ perror("inotify_init");
+ return -1;
+ }
+
+ IPADBG("Waiting for nofications in dir %s\n", NAT_DEV_DIR);
+ wd = inotify_add_watch(inotify_fd,
+ NAT_DEV_DIR,
+ IN_CREATE);
+
+ ret = ioctl(ipv4_nat_cache.ipa_fd, IPA_IOC_ALLOC_NAT_MEM, mem);
+ if (ret != 0)
+ {
+ perror("CreateNatDevice(): ioctl error value");
+ IPAERR("unable to post nat mem init. Error ;%d\n", ret);
+ IPADBG("ipa fd %d\n",ipv4_nat_cache.ipa_fd);
+ return -1;
+ }
+ IPADBG("posted IPA_IOC_ALLOC_NAT_MEM to kernel successfully \n");
+
+ length = read(inotify_fd, buffer, BUF_LEN );
+
+ if (length < 0)
+ {
+ perror("inotify read");
+ return -1;
+ }
+
+ struct inotify_event *event = (struct inotify_event *)buffer;
+ if(event->len)
+ {
+ if(event->mask & IN_CREATE)
+ {
+ if( event->mask & IN_ISDIR)
+ {
+ IPADBG("The directory %s was created.\n", event->name);
+ }
+ else
+ {
+ IPADBG("The file %s was created.\n", event->name);
+ }
+ }
+ }
+
+ (void) inotify_rm_watch(inotify_fd, wd);
+ (void) close(inotify_fd);
+ return 0;
+}
+
+/**
+ * GetNearest2Power() - Returns the nearest power of 2
+ * @num: [in] given number
+ * @ret: [out] nearest power of 2
+ *
+ * Returns the nearest power of 2 for a
+ * given number
+ *
+ * Returns: 0 on success, negative on failure
+ */
+int GetNearest2Power (uint16_t num, uint16_t *ret)
+{
+ uint16_t number = num;
+ uint16_t tmp = 1;
+ *ret = 0;
+
+ if(0 == num)
+ {
+ return -1;
+ }
+
+ if(1 == num)
+ {
+ *ret = 2;
+ return 0;
+ }
+
+ for(;;)
+ {
+ if(1 == num)
+ {
+ if(number != tmp)
+ {
+ tmp *= 2;
+ }
+
+ *ret = tmp;
+ return 0;
+ }
+
+ num >>= 1;
+ tmp *= 2;
+ }
+
+ return -1;
+}
+
+/**
+ * GetNearestEven() - Returns the nearest even number
+ * @num: [in] given number
+ * @ret: [out] nearest even number
+ *
+ * Returns the nearest even number for a given number
+ *
+ * Returns: 0 on success, negative on failure
+ */
+void GetNearestEven (uint16_t num, uint16_t *ret)
+{
+
+ if(num < 2)
+ {
+ *ret = 2;
+ return;
+ }
+
+ while ((num % 2) != 0)
+ {
+ num = num + 1;
+ }
+
+ *ret = num;
+ return;
+}
+
+/**
+ * dst_hash() - Find the index into ipv4 base table
+ * @trgt_ip: [in] Target IP address
+ * @trgt_port: [in] Target port
+ * @public_port: [in] Public port
+ * @proto: [in] Protocol (TCP/IP)
+ * @size: [in] size of the ipv4 base Table
+ *
+ * This hash method is used to find the hash index of new nat
+ * entry into ipv4 base table. In case of zero index, the
+ * new entry will be stored into N-1 index where N is size of
+ * ipv4 base table
+ *
+ * Returns: >0 index into ipv4 base table, negative on failure
+ */
+static uint16_t dst_hash(uint32_t trgt_ip, uint16_t trgt_port,
+ uint16_t public_port, uint8_t proto,
+ uint16_t size)
+{
+ uint16_t hash = ((uint16_t)(trgt_ip)) ^ ((uint16_t)(trgt_ip>>16)) ^
+ (trgt_port) ^ (public_port) ^ (proto);
+
+ IPADBG("trgt_ip: 0x%x trgt_port: 0x%x\n", trgt_ip, trgt_port);
+ IPADBG("public_port: 0x%x\n", public_port);
+ IPADBG("proto: 0x%x size: 0x%x\n", proto, size);
+
+ hash = (hash & size);
+
+ /* If the hash resulted to zero then set it to maximum value
+ as zero is unused entry in nat tables */
+ if (0 == hash)
+ {
+ return size;
+ }
+
+ IPADBG("dst_hash returning value: %d\n", hash);
+ return hash;
+}
+
+/**
+ * src_hash() - Find the index into ipv4 index base table
+ * @priv_ip: [in] Private IP address
+ * @priv_port: [in] Private port
+ * @trgt_ip: [in] Target IP address
+ * @trgt_port: [in] Target Port
+ * @proto: [in] Protocol (TCP/IP)
+ * @size: [in] size of the ipv4 index base Table
+ *
+ * This hash method is used to find the hash index of new nat
+ * entry into ipv4 index base table. In case of zero index, the
+ * new entry will be stored into N-1 index where N is size of
+ * ipv4 index base table
+ *
+ * Returns: >0 index into ipv4 index base table, negative on failure
+ */
+static uint16_t src_hash(uint32_t priv_ip, uint16_t priv_port, uint32_t trgt_ip, uint16_t trgt_port, uint8_t proto, uint16_t size)
+{
+ uint16_t hash = ((uint16_t)(priv_ip)) ^ ((uint16_t)(priv_ip>>16)) ^
+ (priv_port) ^
+ ((uint16_t)(trgt_ip)) ^ ((uint16_t)(trgt_ip>>16)) ^
+ (trgt_port) ^ (proto);
+
+ IPADBG("priv_ip: 0x%x priv_port: 0x%x\n", priv_ip, priv_port);
+ IPADBG("trgt_ip: 0x%x trgt_port: 0x%x\n", trgt_ip, trgt_port);
+ IPADBG("proto: 0x%x size: 0x%x\n", proto, size);
+
+ hash = (hash & size);
+
+ /* If the hash resulted to zero then set it to maximum value
+ as zero is unused entry in nat tables */
+ if (0 == hash)
+ {
+ return size;
+ }
+
+ IPADBG("src_hash returning value: %d\n", hash);
+ return hash;
+}
+
+/**
+ * ipa_nati_calc_ip_cksum() - Calculate the source nat
+ * IP checksum diff
+ * @pub_ip_addr: [in] public ip address
+ * @priv_ip_addr: [in] Private ip address
+ *
+ * source nat ip checksum different is calculated as
+ * public_ip_addr - private_ip_addr
+ * Here we are using 1's complement to represent -ve number.
+ * So take 1's complement of private ip addr and add it
+ * to public ip addr.
+ *
+ * Returns: >0 ip checksum diff
+ */
+static uint16_t ipa_nati_calc_ip_cksum(uint32_t pub_ip_addr,
+ uint32_t priv_ip_addr)
+{
+ uint16_t ret;
+ uint32_t cksum = 0;
+
+ /* Add LSB(2 bytes) of public ip address to cksum */
+ cksum += (pub_ip_addr & 0xFFFF);
+
+ /* Add MSB(2 bytes) of public ip address to cksum
+ and check for carry forward(CF), if any add it
+ */
+ cksum += (pub_ip_addr>>16);
+ if (cksum>>16)
+ {
+ cksum = (cksum & 0x0000FFFF);
+ cksum += 1;
+ }
+
+ /* Calculate the 1's complement of private ip address */
+ priv_ip_addr = (~priv_ip_addr);
+
+ /* Add LSB(2 bytes) of private ip address to cksum
+ and check for carry forward(CF), if any add it
+ */
+ cksum += (priv_ip_addr & 0xFFFF);
+ if (cksum>>16)
+ {
+ cksum = (cksum & 0x0000FFFF);
+ cksum += 1;
+ }
+
+ /* Add MSB(2 bytes) of private ip address to cksum
+ and check for carry forward(CF), if any add it
+ */
+ cksum += (priv_ip_addr>>16);
+ if (cksum>>16)
+ {
+ cksum = (cksum & 0x0000FFFF);
+ cksum += 1;
+ }
+
+ /* Return the LSB(2 bytes) of checksum */
+ ret = (uint16_t)cksum;
+ return ret;
+
+}
+
+/**
+ * ipa_nati_calc_tcp_udp_cksum() - Calculate the source nat
+ * TCP/UDP checksum diff
+ * @pub_ip_addr: [in] public ip address
+ * @pub_port: [in] public tcp/udp port
+ * @priv_ip_addr: [in] Private ip address
+ * @priv_port: [in] Private tcp/udp prot
+ *
+ * source nat tcp/udp checksum is calculated as
+ * (pub_ip_addr + pub_port) - (priv_ip_addr + priv_port)
+ * Here we are using 1's complement to represent -ve number.
+ * So take 1's complement of prviate ip addr &private port
+ * and add it public ip addr & public port.
+ *
+ * Returns: >0 tcp/udp checksum diff
+ */
+static uint16_t ipa_nati_calc_tcp_udp_cksum(uint32_t pub_ip_addr, uint16_t pub_port,
+ uint32_t priv_ip_addr, uint16_t priv_port)
+{
+ uint16_t ret=0;
+ uint32_t cksum =0;
+
+ /* Add LSB(2 bytes) of public ip address to cksum */
+ cksum += (pub_ip_addr & 0xFFFF);
+
+ /* Add MSB(2 bytes) of public ip address to cksum
+ and check for carry forward(CF), if any add it
+ */
+ cksum += (pub_ip_addr>>16);
+ if (cksum>>16)
+ {
+ cksum = (cksum & 0x0000FFFF);
+ cksum += 1;
+ }
+
+ /* Add public port to cksum and
+ check for carry forward(CF), if any add it */
+ cksum += pub_port;
+ if (cksum>>16)
+ {
+ cksum = (cksum & 0x0000FFFF);
+ cksum += 1;
+ }
+
+ /* Calculate the 1's complement of private ip address */
+ priv_ip_addr = (~priv_ip_addr);
+
+ /* Add LSB(2 bytes) of private ip address to cksum
+ and check for carry forward(CF), if any add it
+ */
+ cksum += (priv_ip_addr & 0xFFFF);
+ if (cksum>>16)
+ {
+ cksum = (cksum & 0x0000FFFF);
+ cksum += 1;
+ }
+
+ /* Add MSB(2 bytes) of private ip address to cksum
+ and check for carry forward(CF), if any add
+ */
+ cksum += (priv_ip_addr>>16);
+ if (cksum>>16)
+ {
+ cksum = (cksum & 0x0000FFFF);
+ cksum += 1;
+ }
+
+ /* Calculate the 1's complement of private port */
+ priv_port = (~priv_port);
+
+ /* Add public port to cksum and
+ check for carry forward(CF), if any add it */
+ cksum += priv_port;
+ if (cksum>>16)
+ {
+ cksum = (cksum & 0x0000FFFF);
+ cksum += 1;
+ }
+
+ /* return the LSB(2 bytes) of checksum */
+ ret = (uint16_t)cksum;
+ return ret;
+
+}
+
+/**
+ * ipa_nati_make_rule_hdl() - makes nat rule handle
+ * @tbl_hdl: [in] nat table handle
+ * @tbl_entry: [in] nat table entry
+ *
+ * Calculate the nat rule handle which from
+ * nat entry which will be returned to client of
+ * nat driver
+ *
+ * Returns: >0 nat rule handle
+ */
+uint16_t ipa_nati_make_rule_hdl(uint16_t tbl_hdl,
+ uint16_t tbl_entry)
+{
+ struct ipa_nat_ip4_table_cache *tbl_ptr;
+ uint16_t rule_hdl = 0;
+ uint16_t cnt = 0;
+
+ tbl_ptr = &ipv4_nat_cache.ip4_tbl[tbl_hdl-1];
+
+ if (tbl_entry >= tbl_ptr->table_entries)
+ {
+ /* Update the index into table */
+ rule_hdl = tbl_entry - tbl_ptr->table_entries;
+ rule_hdl = (rule_hdl << IPA_NAT_RULE_HDL_TBL_TYPE_BITS);
+ /* Update the table type mask */
+ rule_hdl = (rule_hdl | IPA_NAT_RULE_HDL_TBL_TYPE_MASK);
+ }
+ else
+ {
+ rule_hdl = tbl_entry;
+ rule_hdl = (rule_hdl << IPA_NAT_RULE_HDL_TBL_TYPE_BITS);
+ }
+
+ for(; cnt< (tbl_ptr->table_entries + tbl_ptr->expn_table_entries); cnt++)
+ {
+ if (IPA_NAT_INVALID_NAT_ENTRY == tbl_ptr->rule_id_array[cnt])
+ {
+ tbl_ptr->rule_id_array[cnt] = rule_hdl;
+ return (cnt+1);
+ }
+ }
+
+ return cnt;
+}
+
+/**
+ * ipa_nati_parse_ipv4_rule_hdl() - prase rule handle
+ * @tbl_hdl: [in] nat table rule
+ * @rule_hdl: [in] nat rule handle
+ * @expn_tbl: [out] expansion table or not
+ * @tbl_entry: [out] index into table
+ *
+ * Parse the rule handle to retrieve the nat table
+ * type and entry of nat table
+ *
+ * Returns: None
+ */
+void ipa_nati_parse_ipv4_rule_hdl(uint8_t tbl_index,
+ uint16_t rule_hdl,
+ uint8_t *expn_tbl,
+ uint16_t *tbl_entry)
+{
+ struct ipa_nat_ip4_table_cache *tbl_ptr;
+ uint16_t rule_id;
+
+ *expn_tbl = 0;
+ *tbl_entry = IPA_NAT_INVALID_NAT_ENTRY;
+ tbl_ptr = &ipv4_nat_cache.ip4_tbl[tbl_index];
+
+ if (rule_hdl >= (tbl_ptr->table_entries + tbl_ptr->expn_table_entries))
+ {
+ IPAERR("invalid rule handle\n");
+ return;
+ }
+
+ rule_id = tbl_ptr->rule_id_array[rule_hdl-1];
+
+ /* Retrieve the table type */
+ *expn_tbl = 0;
+ if(rule_id & IPA_NAT_RULE_HDL_TBL_TYPE_MASK)
+ {
+ *expn_tbl = 1;
+ }
+
+ /* Retrieve the table entry */
+ *tbl_entry = (rule_id >> IPA_NAT_RULE_HDL_TBL_TYPE_BITS);
+
+ return;
+}
+
+uint32_t ipa_nati_get_entry_offset(struct ipa_nat_ip4_table_cache *cache_ptr,
+ nat_table_type tbl_type,
+ uint16_t tbl_entry)
+{
+ struct ipa_nat_rule *tbl_ptr;
+ uint32_t ret = 0;
+
+ if (IPA_NAT_EXPN_TBL == tbl_type)
+ {
+ tbl_ptr = (struct ipa_nat_rule *)cache_ptr->ipv4_expn_rules_addr;
+ }
+ else
+ {
+ tbl_ptr = (struct ipa_nat_rule *)cache_ptr->ipv4_rules_addr;
+ }
+
+ ret = (char *)&tbl_ptr[tbl_entry] - (char *)tbl_ptr;
+ ret += cache_ptr->tbl_addr_offset;
+ return ret;
+}
+
+uint32_t ipa_nati_get_index_entry_offset(struct ipa_nat_ip4_table_cache *cache_ptr,
+ nat_table_type tbl_type,
+ uint16_t indx_tbl_entry)
+{
+ struct ipa_nat_indx_tbl_rule *indx_tbl_ptr;
+ uint32_t ret = 0;
+
+ if (IPA_NAT_INDEX_EXPN_TBL == tbl_type)
+ {
+ indx_tbl_ptr =
+ (struct ipa_nat_indx_tbl_rule *)cache_ptr->index_table_expn_addr;
+ }
+ else
+ {
+ indx_tbl_ptr =
+ (struct ipa_nat_indx_tbl_rule *)cache_ptr->index_table_addr;
+ }
+
+ ret = (char *)&indx_tbl_ptr[indx_tbl_entry] - (char *)indx_tbl_ptr;
+ ret += cache_ptr->tbl_addr_offset;
+ return ret;
+}
+
+/* ------------------------------------------
+ UTILITY FUNCTIONS END
+--------------------------------------------*/
+
+/* ------------------------------------------
+ Main Functions
+--------------------------------------------**/
+void ipa_nati_reset_tbl(uint8_t tbl_indx)
+{
+ uint16_t table_entries = ipv4_nat_cache.ip4_tbl[tbl_indx].table_entries;
+ uint16_t expn_table_entries = ipv4_nat_cache.ip4_tbl[tbl_indx].expn_table_entries;
+
+ /* Base table */
+ IPADBG("memset() base table to 0, %p\n",
+ ipv4_nat_cache.ip4_tbl[tbl_indx].ipv4_rules_addr);
+
+ memset(ipv4_nat_cache.ip4_tbl[tbl_indx].ipv4_rules_addr,
+ 0,
+ IPA_NAT_TABLE_ENTRY_SIZE * table_entries);
+
+ /* Base expansino table */
+ IPADBG("memset() expn base table to 0, %p\n",
+ ipv4_nat_cache.ip4_tbl[tbl_indx].ipv4_expn_rules_addr);
+
+ memset(ipv4_nat_cache.ip4_tbl[tbl_indx].ipv4_expn_rules_addr,
+ 0,
+ IPA_NAT_TABLE_ENTRY_SIZE * expn_table_entries);
+
+ /* Index table */
+ IPADBG("memset() index table to 0, %p\n",
+ ipv4_nat_cache.ip4_tbl[tbl_indx].index_table_addr);
+
+ memset(ipv4_nat_cache.ip4_tbl[tbl_indx].index_table_addr,
+ 0,
+ IPA_NAT_INDEX_TABLE_ENTRY_SIZE * table_entries);
+
+ /* Index expansion table */
+ IPADBG("memset() index expn table to 0, %p\n",
+ ipv4_nat_cache.ip4_tbl[tbl_indx].index_table_expn_addr);
+
+ memset(ipv4_nat_cache.ip4_tbl[tbl_indx].index_table_expn_addr,
+ 0,
+ IPA_NAT_INDEX_TABLE_ENTRY_SIZE * expn_table_entries);
+
+ IPADBG("returning from ipa_nati_reset_tbl()\n");
+ return;
+}
+
+int ipa_nati_add_ipv4_tbl(uint32_t public_ip_addr,
+ uint16_t number_of_entries,
+ uint32_t *tbl_hdl)
+{
+ struct ipa_ioc_nat_alloc_mem mem;
+ uint8_t tbl_indx = ipv4_nat_cache.table_cnt;
+ uint16_t table_entries, expn_table_entries;
+ int ret;
+
+ *tbl_hdl = 0;
+ /* Allocate table */
+ memset(&mem, 0, sizeof(mem));
+ ret = ipa_nati_alloc_table(number_of_entries,
+ &mem,
+ &table_entries,
+ &expn_table_entries);
+ if (0 != ret)
+ {
+ IPAERR("unable to allocate nat table\n");
+ return -1;
+ }
+
+ /* Update the cache
+ The (IPA_NAT_UNUSED_BASE_ENTRIES/2) indicates zero entry entries
+ for both base and expansion table
+ */
+ ret = ipa_nati_update_cache(&mem,
+ public_ip_addr,
+ table_entries,
+ expn_table_entries);
+ if (0 != ret)
+ {
+ IPAERR("unable to update cache Error: %d\n", ret);
+ return -1;
+ }
+
+ /* Initialize the ipa hw with nat table dimensions */
+ ret = ipa_nati_post_ipv4_init_cmd(tbl_indx);
+ if (0 != ret)
+ {
+ IPAERR("unable to post nat_init command Error %d\n", ret);
+ return -1;
+ }
+
+ ipa_nati_reset_tbl(tbl_indx);
+
+ /* Return table handle */
+ ipv4_nat_cache.table_cnt++;
+ *tbl_hdl = ipv4_nat_cache.table_cnt;
+
+#ifdef NAT_DUMP
+ ipa_nat_dump_ipv4_table(*tbl_hdl);
+#endif
+ return 0;
+}
+
+int ipa_nati_alloc_table(uint16_t number_of_entries,
+ struct ipa_ioc_nat_alloc_mem *mem,
+ uint16_t *table_entries,
+ uint16_t *expn_table_entries)
+{
+ int fd = 0, ret;
+ uint16_t total_entries;
+
+ /* Copy the table name */
+ strcpy(mem->dev_name, NAT_DEV_NAME);
+
+ /* Calculate the size for base table and expansion table */
+ *table_entries = (uint16_t)(number_of_entries * IPA_NAT_BASE_TABLE_PERCENTAGE);
+ if(*table_entries == 0)
+ {
+ *table_entries = 1;
+ }
+ if(-1 == GetNearest2Power(*table_entries, table_entries))
+ {
+ IPAERR("unable to calculate power of 2\n");
+ return -1;
+ }
+
+ *expn_table_entries = (uint16_t)(number_of_entries * IPA_NAT_EXPANSION_TABLE_PERCENTAGE);
+ GetNearestEven(*expn_table_entries, expn_table_entries);
+
+ total_entries = (*table_entries) + (*expn_table_entries);
+
+ /* Calclate the memory size for both table and index table entries */
+ mem->size = (IPA_NAT_TABLE_ENTRY_SIZE * total_entries);
+ mem->size += (IPA_NAT_INDEX_TABLE_ENTRY_SIZE * total_entries);
+
+ if (!ipv4_nat_cache.ipa_fd)
+ {
+ fd = open(IPA_DEV_NAME, O_RDONLY);
+ if (fd < 0)
+ {
+ perror("ipa_nati_alloc_table(): open error value:");
+ IPAERR("unable to open ipa device\n");
+ return -1;
+ }
+ ipv4_nat_cache.ipa_fd = fd;
+ }
+
+ ret = CreateNatDevice(mem);
+ return ret;
+}
+
+
+int ipa_nati_update_cache(struct ipa_ioc_nat_alloc_mem *mem,
+ uint32_t public_addr,
+ uint16_t tbl_entries,
+ uint16_t expn_tbl_entries)
+{
+ uint32_t index = ipv4_nat_cache.table_cnt;
+ char *ipv4_rules_addr = NULL;
+
+ int fd = 0;
+ int flags = MAP_SHARED;
+ int prot = PROT_READ | PROT_WRITE;
+ off_t offset = 0;
+#ifdef IPA_ON_R3PC
+ int ret = 0;
+ uint32_t nat_mem_offset = 0;
+#endif
+
+ ipv4_nat_cache.ip4_tbl[index].valid = IPA_NAT_TABLE_VALID;
+ ipv4_nat_cache.ip4_tbl[index].public_addr = public_addr;
+ ipv4_nat_cache.ip4_tbl[index].size = mem->size;
+ ipv4_nat_cache.ip4_tbl[index].tbl_addr_offset = mem->offset;
+
+ ipv4_nat_cache.ip4_tbl[index].table_entries = tbl_entries;
+ ipv4_nat_cache.ip4_tbl[index].expn_table_entries = expn_tbl_entries;
+
+ IPADBG("num of ipv4 rules:%d\n",tbl_entries);
+ IPADBG("num of ipv4 expn rules:%d\n",expn_tbl_entries);
+
+ /* allocate memory for nat index expansion table */
+ if (NULL == ipv4_nat_cache.ip4_tbl[index].index_expn_table_meta)
+ {
+ ipv4_nat_cache.ip4_tbl[index].index_expn_table_meta =
+ malloc(sizeof(struct ipa_nat_indx_tbl_meta_info) * expn_tbl_entries);
+
+ if (NULL == ipv4_nat_cache.ip4_tbl[index].index_expn_table_meta)
+ {
+ IPAERR("Fail to allocate ipv4 index expansion table meta\n");
+ return 0;
+ }
+
+ memset(ipv4_nat_cache.ip4_tbl[index].index_expn_table_meta,
+ 0,
+ sizeof(struct ipa_nat_indx_tbl_meta_info) * expn_tbl_entries);
+ }
+
+ /* Allocate memory for rule_id_array */
+ if (NULL == ipv4_nat_cache.ip4_tbl[index].rule_id_array)
+ {
+ ipv4_nat_cache.ip4_tbl[index].rule_id_array =
+ malloc(sizeof(uint16_t) * (tbl_entries + expn_tbl_entries));
+
+ if (NULL == ipv4_nat_cache.ip4_tbl[index].rule_id_array)
+ {
+ IPAERR("Fail to allocate rule id array\n");
+ return 0;
+ }
+
+ memset(ipv4_nat_cache.ip4_tbl[index].rule_id_array,
+ 0,
+ sizeof(uint16_t) * (tbl_entries + expn_tbl_entries) );
+ }
+
+
+ /* open the nat table */
+ strcpy(mem->dev_name, NAT_DEV_FULL_NAME);
+ fd = open(mem->dev_name, O_RDWR);
+ if(fd < 0)
+ {
+ perror("ipa_nati_update_cache(): open error value:");
+ IPAERR("unable to open nat device. Error:%d\n",fd);
+ return -1;
+ }
+
+ /* copy the nat table name */
+ strncpy(ipv4_nat_cache.ip4_tbl[index].table_name,
+ mem->dev_name,
+ IPA_RESOURCE_NAME_MAX);
+ ipv4_nat_cache.ip4_tbl[index].nat_fd = fd;
+
+ /* open the nat device Table */
+#ifndef IPA_ON_R3PC
+ ipv4_rules_addr = (void *)mmap(NULL, mem->size,
+ prot, flags,
+ fd, offset);
+#else
+ IPADBG("user space r3pc \n");
+ ipv4_rules_addr = (void *)mmap((caddr_t)0, NAT_MMAP_MEM_SIZE,
+ prot, flags,
+ fd, offset);
+#endif
+ if(NULL == ipv4_rules_addr)
+ {
+ perror("unable to mmap the memory\n");
+ return -1;
+ }
+
+#ifdef IPA_ON_R3PC
+ ret = ioctl(ipv4_nat_cache.ipa_fd, IPA_IOC_GET_NAT_OFFSET, &nat_mem_offset);
+ if (ret != 0)
+ {
+ perror("ipa_nati_post_ipv4_init_cmd(): ioctl error value");
+ IPAERR("unable to post ant offset cmd Error: %d\n",ret);
+ IPADBG("ipa fd %d\n",ipv4_nat_cache.ipa_fd);
+ return -1;
+ }
+ ipv4_rules_addr += nat_mem_offset;
+ ipv4_nat_cache.ip4_tbl[index].mmap_offset = nat_mem_offset;
+#endif
+
+ IPADBG("mmap return value 0x%lx\n", (long unsigned int)ipv4_rules_addr);
+
+ ipv4_nat_cache.ip4_tbl[index].ipv4_rules_addr = ipv4_rules_addr;
+
+ ipv4_nat_cache.ip4_tbl[index].ipv4_expn_rules_addr =
+ ipv4_rules_addr + (IPA_NAT_TABLE_ENTRY_SIZE * tbl_entries);
+
+ ipv4_nat_cache.ip4_tbl[index].index_table_addr =
+ ipv4_rules_addr + (IPA_NAT_TABLE_ENTRY_SIZE * (tbl_entries + expn_tbl_entries));
+
+ ipv4_nat_cache.ip4_tbl[index].index_table_expn_addr =
+ ipv4_rules_addr +
+ (IPA_NAT_TABLE_ENTRY_SIZE * (tbl_entries + expn_tbl_entries)) +
+ (IPA_NAT_INDEX_TABLE_ENTRY_SIZE * tbl_entries);
+
+ return 0;
+}
+
+/* comment: check the implementation once
+ offset should be in terms of byes */
+int ipa_nati_post_ipv4_init_cmd(uint8_t tbl_index)
+{
+ struct ipa_ioc_v4_nat_init cmd;
+ uint32_t offset = ipv4_nat_cache.ip4_tbl[tbl_index].tbl_addr_offset;
+ int ret;
+
+ cmd.tbl_index = tbl_index;
+
+ cmd.ipv4_rules_offset = offset;
+ cmd.expn_rules_offset = cmd.ipv4_rules_offset +
+ (ipv4_nat_cache.ip4_tbl[tbl_index].table_entries * IPA_NAT_TABLE_ENTRY_SIZE);
+
+ cmd.index_offset = cmd.expn_rules_offset +
+ (ipv4_nat_cache.ip4_tbl[tbl_index].expn_table_entries * IPA_NAT_TABLE_ENTRY_SIZE);
+
+ cmd.index_expn_offset = cmd.index_offset +
+ (ipv4_nat_cache.ip4_tbl[tbl_index].table_entries * IPA_NAT_INDEX_TABLE_ENTRY_SIZE);
+
+ cmd.table_entries = ipv4_nat_cache.ip4_tbl[tbl_index].table_entries - 1;
+ cmd.expn_table_entries = ipv4_nat_cache.ip4_tbl[tbl_index].expn_table_entries;
+
+ cmd.ip_addr = ipv4_nat_cache.ip4_tbl[tbl_index].public_addr;
+
+ ret = ioctl(ipv4_nat_cache.ipa_fd, IPA_IOC_V4_INIT_NAT, &cmd);
+ if (ret != 0)
+ {
+ perror("ipa_nati_post_ipv4_init_cmd(): ioctl error value");
+ IPAERR("unable to post init cmd Error: %d\n",ret);
+ IPADBG("ipa fd %d\n",ipv4_nat_cache.ipa_fd);
+ return -1;
+ }
+ IPADBG("Posted IPA_IOC_V4_INIT_NAT to kernel successfully \n");
+
+ return 0;
+}
+
+int ipa_nati_del_ipv4_table(uint32_t tbl_hdl)
+{
+ uint8_t index = (uint8_t)(tbl_hdl - 1);
+ void *addr = (void *)ipv4_nat_cache.ip4_tbl[index].ipv4_rules_addr;
+ struct ipa_ioc_v4_nat_del del_cmd;
+ int ret;
+
+ if (!ipv4_nat_cache.ip4_tbl[index].valid)
+ {
+ IPAERR("invalid table handle passed\n");
+ return -1;
+ }
+
+ /* unmap the device memory from user space */
+#ifndef IPA_ON_R3PC
+ munmap(addr, ipv4_nat_cache.ip4_tbl[index].size);
+#else
+ addr = (char *)addr - ipv4_nat_cache.ip4_tbl[index].mmap_offset;
+ munmap(addr, NAT_MMAP_MEM_SIZE);
+#endif
+
+ /* close the file descriptor of nat device */
+ if (close(ipv4_nat_cache.ip4_tbl[index].nat_fd))
+ {
+ IPAERR("unable to close the file descriptor\n");
+ return -1;
+ }
+
+ del_cmd.table_index = index;
+ del_cmd.public_ip_addr = ipv4_nat_cache.ip4_tbl[index].public_addr;
+ ret = ioctl(ipv4_nat_cache.ipa_fd, IPA_IOC_V4_DEL_NAT, &del_cmd);
+ if (ret != 0)
+ {
+ perror("ipa_nati_del_ipv4_table(): ioctl error value");
+ IPAERR("unable to post nat del command init Error: %d\n",ret);
+ IPADBG("ipa fd %d\n",ipv4_nat_cache.ipa_fd);
+ return -1;
+ }
+ IPADBG("posted IPA_IOC_V4_DEL_NAT to kernel successfully \n");
+
+ free(ipv4_nat_cache.ip4_tbl[index].index_expn_table_meta);
+ free(ipv4_nat_cache.ip4_tbl[index].rule_id_array);
+
+ memset(&ipv4_nat_cache.ip4_tbl[index],
+ 0,
+ sizeof(ipv4_nat_cache.ip4_tbl[index]));
+
+ /* Decrease the table count by 1*/
+ ipv4_nat_cache.table_cnt--;
+
+ return 0;
+}
+
+int ipa_nati_query_timestamp(uint32_t tbl_hdl,
+ uint32_t rule_hdl,
+ uint32_t *time_stamp)
+{
+ uint8_t tbl_index = (uint8_t)(tbl_hdl - 1);
+ uint8_t expn_tbl = 0;
+ uint16_t tbl_entry = 0;
+ struct ipa_nat_rule *tbl_ptr = NULL;
+
+ if (!ipv4_nat_cache.ip4_tbl[tbl_index].valid)
+ {
+ IPAERR("invalid table handle\n");
+ return -1;
+ }
+
+ ipa_nati_parse_ipv4_rule_hdl(tbl_index, (uint16_t)rule_hdl,
+ &expn_tbl, &tbl_entry);
+
+ tbl_ptr =
+ (struct ipa_nat_rule *)ipv4_nat_cache.ip4_tbl[tbl_index].ipv4_rules_addr;
+ if (expn_tbl)
+ {
+ tbl_ptr =
+ (struct ipa_nat_rule *)ipv4_nat_cache.ip4_tbl[tbl_index].ipv4_expn_rules_addr;
+ }
+
+ *time_stamp = Read32BitFieldValue(tbl_ptr[tbl_entry].ts_proto,
+ TIME_STAMP_FIELD);
+ return 0;
+}
+
+uint32_t ipa_nati_add_ipv4_rule(uint32_t tbl_hdl,
+ const ipa_nat_ipv4_rule *clnt_rule)
+{
+ struct ipa_nat_ip4_table_cache *tbl_ptr;
+ struct ipa_nat_sw_rule sw_rule;
+ struct ipa_nat_indx_tbl_sw_rule index_sw_rule;
+ uint16_t new_entry, new_index_tbl_entry;
+ uint32_t rule_hdl = 0;
+
+ memset(&sw_rule, 0, sizeof(sw_rule));
+ memset(&index_sw_rule, 0, sizeof(index_sw_rule));
+
+ /* Generate rule from client input */
+ if (-1 == ipa_nati_generate_rule(tbl_hdl, clnt_rule,
+ &sw_rule, &index_sw_rule,
+ &new_entry, &new_index_tbl_entry))
+ {
+ IPAERR("unable to generate rule\n");
+ return -1;
+ }
+
+ tbl_ptr = &ipv4_nat_cache.ip4_tbl[tbl_hdl-1];
+ ipa_nati_copy_ipv4_rule_to_hw(tbl_ptr, &sw_rule, new_entry, (uint8_t)(tbl_hdl-1));
+ ipa_nati_copy_ipv4_index_rule_to_hw(tbl_ptr,
+ &index_sw_rule,
+ new_index_tbl_entry,
+ (uint8_t)(tbl_hdl-1));
+
+ IPADBG("new entry:%d, new index entry: %d\n", new_entry, new_index_tbl_entry);
+ if( -1 == ipa_nati_post_ipv4_dma_cmd((uint8_t)(tbl_hdl-1), new_entry))
+ {
+ IPAERR("unable to post dma command\n");
+ return -1;
+ }
+
+ /* Generate rule handle */
+ rule_hdl = ipa_nati_make_rule_hdl((uint16_t)tbl_hdl, new_entry);
+ if (!rule_hdl)
+ {
+ IPAERR("unable to generate rule handle\n");
+ return -1;
+ }
+
+#ifdef NAT_DUMP
+ ipa_nat_dump_ipv4_table(tbl_hdl);
+#endif
+
+ return rule_hdl;
+}
+int ipa_nati_generate_rule(uint32_t tbl_hdl,
+ const ipa_nat_ipv4_rule *clnt_rule,
+ struct ipa_nat_sw_rule *rule,
+ struct ipa_nat_indx_tbl_sw_rule *index_sw_rule,
+ uint16_t *tbl_entry,
+ uint16_t *indx_tbl_entry)
+{
+
+ struct ipa_nat_ip4_table_cache *tbl_ptr;
+ uint16_t tmp;
+
+ if (NULL == clnt_rule || NULL == index_sw_rule ||
+ NULL == rule || NULL == tbl_entry ||
+ NULL == indx_tbl_entry)
+ {
+ IPAERR("invalid parameters\n");
+ return -1;
+ }
+
+ tbl_ptr = &ipv4_nat_cache.ip4_tbl[tbl_hdl-1];
+
+ *tbl_entry = ipa_nati_generate_tbl_rule(clnt_rule,
+ rule,
+ tbl_ptr);
+ if (IPA_NAT_INVALID_NAT_ENTRY == *tbl_entry)
+ {
+ IPAERR("unable to generate table entry\n");
+ return -1;
+ }
+
+ index_sw_rule->tbl_entry = *tbl_entry;
+ *indx_tbl_entry = ipa_nati_generate_index_rule(clnt_rule,
+ index_sw_rule,
+ tbl_ptr);
+ if (IPA_NAT_INVALID_NAT_ENTRY == *indx_tbl_entry)
+ {
+ IPAERR("unable to generate index table entry\n");
+ return -1;
+ }
+
+ rule->indx_tbl_entry = *indx_tbl_entry;
+ if (*indx_tbl_entry >= tbl_ptr->table_entries)
+ {
+ tmp = *indx_tbl_entry - tbl_ptr->table_entries;
+ tbl_ptr->index_expn_table_meta[tmp].prev_index = index_sw_rule->prev_index;
+ }
+
+ return 0;
+}
+
+uint16_t ipa_nati_generate_tbl_rule(const ipa_nat_ipv4_rule *clnt_rule,
+ struct ipa_nat_sw_rule *sw_rule,
+ struct ipa_nat_ip4_table_cache *tbl_ptr)
+{
+ uint32_t pub_ip_addr;
+ uint16_t prev=0, nxt_indx=0, new_entry;
+ struct ipa_nat_rule *tbl = NULL, *expn_tbl = NULL;
+
+ pub_ip_addr = tbl_ptr->public_addr;
+
+ tbl = (struct ipa_nat_rule *)tbl_ptr->ipv4_rules_addr;
+ expn_tbl = (struct ipa_nat_rule *)tbl_ptr->ipv4_expn_rules_addr;
+
+ /* copy the values from client rule to sw rule */
+ sw_rule->private_ip = clnt_rule->private_ip;
+ sw_rule->private_port = clnt_rule->private_port;
+ sw_rule->protocol = clnt_rule->protocol;
+ sw_rule->public_port = clnt_rule->public_port;
+ sw_rule->target_ip = clnt_rule->target_ip;
+ sw_rule->target_port = clnt_rule->target_port;
+
+ /* consider only public and private ip fields */
+ sw_rule->ip_chksum = ipa_nati_calc_ip_cksum(pub_ip_addr,
+ clnt_rule->private_ip);
+
+ if(IPPROTO_TCP == sw_rule->protocol ||
+ IPPROTO_UDP == sw_rule->protocol)
+ {
+ /* consider public and private ip & port fields */
+ sw_rule->tcp_udp_chksum = ipa_nati_calc_tcp_udp_cksum(
+ pub_ip_addr,
+ clnt_rule->public_port,
+ clnt_rule->private_ip,
+ clnt_rule->private_port);
+ }
+
+ sw_rule->rsvd1 = 0;
+ sw_rule->enable = IPA_NAT_FLAG_DISABLE_BIT;
+ sw_rule->next_index = 0;
+
+ /*
+ SW sets this timer to 0.
+ The assumption is that 0 is an invalid clock value and no clock
+ wraparounds are expected
+ */
+ sw_rule->time_stamp = 0;
+ sw_rule->rsvd2 = 0;
+ sw_rule->prev_index = 0;
+ sw_rule->indx_tbl_entry = 0;
+
+ new_entry = dst_hash(clnt_rule->target_ip,
+ clnt_rule->target_port,
+ clnt_rule->public_port,
+ clnt_rule->protocol,
+ tbl_ptr->table_entries-1 );
+
+ /* check whether there is any collision
+ if no collision return */
+ if (! Read16BitFieldValue(tbl[new_entry].ip_cksm_enbl,
+ ENABLE_FIELD))
+ {
+ sw_rule->prev_index = 0;
+ IPADBG("Destination Nat New Entry Index %d\n",new_entry);
+ return new_entry;
+ }
+
+ /* First collision */
+ if (Read16BitFieldValue(tbl[new_entry].nxt_indx_pub_port,
+ NEXT_INDEX_FIELD) == IPA_NAT_INVALID_NAT_ENTRY)
+ {
+ sw_rule->prev_index = new_entry;
+ }
+ /* check for more than one collision */
+ else
+ {
+ /* Find the IPA_NAT_DEL_TYPE_LAST entry in list */
+ nxt_indx = Read16BitFieldValue(tbl[new_entry].nxt_indx_pub_port,
+ NEXT_INDEX_FIELD);
+
+ while(nxt_indx != IPA_NAT_INVALID_NAT_ENTRY)
+ {
+ prev = nxt_indx;
+
+ nxt_indx -= tbl_ptr->table_entries;
+ nxt_indx = Read16BitFieldValue(expn_tbl[nxt_indx].nxt_indx_pub_port,
+ NEXT_INDEX_FIELD);
+
+ /* Handling error case */
+ if(prev == nxt_indx)
+ {
+ IPAERR("Error: Prev index:%d and next:%d index should not be same \n", prev, nxt_indx);
+ return IPA_NAT_INVALID_NAT_ENTRY;
+ }
+ }
+
+ sw_rule->prev_index = prev;
+ }
+
+ /* On collision check for the free entry in expansion table */
+ new_entry = ipa_nati_expn_tbl_free_entry(expn_tbl,
+ tbl_ptr->expn_table_entries);
+
+ if (IPA_NAT_INVALID_NAT_ENTRY == new_entry)
+ {
+ /* Expansion table is full return*/
+ IPAERR("expansion table is full\n");
+ return IPA_NAT_INVALID_NAT_ENTRY;
+ }
+ new_entry += tbl_ptr->table_entries;
+
+ IPADBG("new entry index %d\n",new_entry);
+ return new_entry;
+}
+
+/* returns expn table entry index */
+uint16_t ipa_nati_expn_tbl_free_entry(struct ipa_nat_rule *expn_tbl,
+ uint16_t size)
+{
+ int cnt;
+
+ for (cnt=1; cnt<size; cnt++)
+ {
+ if (!Read16BitFieldValue(expn_tbl[cnt].ip_cksm_enbl,
+ ENABLE_FIELD))
+ {
+ IPADBG("new expansion table entry index %d\n",cnt);
+ return cnt;
+ }
+ }
+
+ IPAERR("nat expansion table is full\n");
+ return 0;
+
+}
+
+uint16_t ipa_nati_generate_index_rule(const ipa_nat_ipv4_rule *clnt_rule,
+ struct ipa_nat_indx_tbl_sw_rule *sw_rule,
+ struct ipa_nat_ip4_table_cache *tbl_ptr)
+{
+ struct ipa_nat_indx_tbl_rule *indx_tbl, *indx_expn_tbl;
+ uint16_t prev=0, nxt_indx=0, new_entry;
+
+ indx_tbl =
+ (struct ipa_nat_indx_tbl_rule *)tbl_ptr->index_table_addr;
+ indx_expn_tbl =
+ (struct ipa_nat_indx_tbl_rule *)tbl_ptr->index_table_expn_addr;
+
+ new_entry = src_hash(clnt_rule->private_ip,
+ clnt_rule->private_port,
+ clnt_rule->target_ip,
+ clnt_rule->target_port,
+ clnt_rule->protocol,
+ tbl_ptr->table_entries-1);
+
+ /* check whether there is any collision
+ if no collision return */
+ if (!Read16BitFieldValue(indx_tbl[new_entry].tbl_entry_nxt_indx,
+ INDX_TBL_TBL_ENTRY_FIELD) )
+ {
+ sw_rule->prev_index = 0;
+ IPADBG("Source Nat Index Table Entry %d\n",new_entry);
+ return new_entry;
+ }
+
+ /* check for more than one collision */
+ if (Read16BitFieldValue(indx_tbl[new_entry].tbl_entry_nxt_indx,
+ INDX_TBL_NEXT_INDEX_FILED) == IPA_NAT_INVALID_NAT_ENTRY)
+ {
+ sw_rule->prev_index = new_entry;
+ IPADBG("First collosion. Entry %d\n",new_entry);
+ }
+ else
+ {
+ /* Find the IPA_NAT_DEL_TYPE_LAST entry in list */
+ nxt_indx = Read16BitFieldValue(indx_tbl[new_entry].tbl_entry_nxt_indx,
+ INDX_TBL_NEXT_INDEX_FILED);
+ //prev = nxt_indx;
+
+ while(nxt_indx != IPA_NAT_INVALID_NAT_ENTRY)
+ {
+ prev = nxt_indx;
+
+ nxt_indx -= tbl_ptr->table_entries;
+ nxt_indx = Read16BitFieldValue(indx_expn_tbl[nxt_indx].tbl_entry_nxt_indx,
+ INDX_TBL_NEXT_INDEX_FILED);
+
+ /* Handling error case */
+ if(prev == nxt_indx)
+ {
+ IPAERR("Error: Prev:%d and next:%d index should not be same \n", prev, nxt_indx);
+ return IPA_NAT_INVALID_NAT_ENTRY;
+ }
+ }
+
+ sw_rule->prev_index = prev;
+ }
+
+ /* On collision check for the free entry in expansion table */
+ new_entry = ipa_nati_index_expn_get_free_entry(
+ indx_expn_tbl,
+ tbl_ptr->expn_table_entries);
+
+ if ( IPA_NAT_INVALID_NAT_ENTRY == new_entry)
+ {
+ /* Expansion table is full return*/
+ IPAERR("index expansion table is full\n");
+ return IPA_NAT_INVALID_NAT_ENTRY;
+ }
+ new_entry += tbl_ptr->table_entries;
+
+ IPADBG("index table entry %d\n", new_entry);
+ return new_entry;
+}
+
+/* returns index expn table entry index */
+uint16_t ipa_nati_index_expn_get_free_entry(struct ipa_nat_indx_tbl_rule *indx_tbl,
+ uint16_t size)
+{
+ int cnt;
+ for (cnt=1; cnt<size; cnt++)
+ {
+ if (!Read16BitFieldValue(indx_tbl[cnt].tbl_entry_nxt_indx,
+ INDX_TBL_TBL_ENTRY_FIELD))
+ {
+ return cnt;
+ }
+ }
+
+ IPAERR("nat index expansion table is full\n");
+ return 0;
+}
+
+void ipa_nati_write_next_index(uint8_t tbl_indx,
+ nat_table_type tbl_type,
+ uint16_t value,
+ uint32_t offset)
+{
+ struct ipa_ioc_nat_dma_cmd *cmd;
+
+ IPADBG("Updating next index field of table %d on collosion using dma\n", tbl_type);
+ IPADBG("table index: %d, value: %d offset;%d \n", tbl_indx, value, offset);
+
+ cmd = (struct ipa_ioc_nat_dma_cmd *)
+ malloc( sizeof(struct ipa_ioc_nat_dma_cmd) +
+ sizeof(struct ipa_ioc_nat_dma_one));
+ if(NULL == cmd)
+ {
+ IPAERR("unable to allocate memory\n");
+ return;
+ }
+
+ cmd->dma[0].table_index = tbl_indx;
+ cmd->dma[0].base_addr = tbl_type;
+ cmd->dma[0].data = value;
+ cmd->dma[0].offset = offset;
+
+ cmd->entries = 1;
+ if (ioctl(ipv4_nat_cache.ipa_fd, IPA_IOC_NAT_DMA, cmd))
+ {
+ perror("ipa_nati_post_ipv4_dma_cmd(): ioctl error value");
+ IPAERR("unable to call dma icotl to update next index\n");
+ IPAERR("ipa fd %d\n", ipv4_nat_cache.ipa_fd);
+ goto fail;
+ }
+
+ fail:
+ free(cmd);
+
+ return;
+}
+
+void ipa_nati_copy_ipv4_rule_to_hw(
+ struct ipa_nat_ip4_table_cache *ipv4_cache,
+ struct ipa_nat_sw_rule *rule,
+ uint16_t entry, uint8_t tbl_index)
+{
+ struct ipa_nat_rule *tbl_ptr;
+ uint16_t prev_entry = rule->prev_index;
+ nat_table_type tbl_type;
+ uint32_t offset = 0;
+
+ if (entry < ipv4_cache->table_entries)
+ {
+ tbl_ptr = (struct ipa_nat_rule *)ipv4_cache->ipv4_rules_addr;
+
+ memcpy( &tbl_ptr[entry],
+ rule,
+ sizeof(struct ipa_nat_rule));
+ }
+ else
+ {
+ tbl_ptr = (struct ipa_nat_rule *)ipv4_cache->ipv4_expn_rules_addr;
+ memcpy( &tbl_ptr[entry - ipv4_cache->table_entries],
+ rule,
+ sizeof(struct ipa_nat_rule));
+ }
+
+ /* Update the previos entry next_index */
+ if(IPA_NAT_INVALID_NAT_ENTRY != prev_entry)
+ {
+
+ if (prev_entry < ipv4_cache->table_entries)
+ {
+ tbl_type = IPA_NAT_BASE_TBL;
+ tbl_ptr = (struct ipa_nat_rule *)ipv4_cache->ipv4_rules_addr;
+ }
+ else
+ {
+ tbl_type = IPA_NAT_EXPN_TBL;
+ /* tbp_ptr is already pointing to expansion table
+ no need to initialize it */
+ prev_entry = prev_entry - ipv4_cache->table_entries;
+ }
+
+ offset = ipa_nati_get_entry_offset(ipv4_cache, tbl_type, prev_entry);
+ offset += IPA_NAT_RULE_NEXT_FIELD_OFFSET;
+
+ ipa_nati_write_next_index(tbl_index, tbl_type, entry, offset);
+ }
+
+ return;
+}
+
+void ipa_nati_copy_ipv4_index_rule_to_hw(
+ struct ipa_nat_ip4_table_cache *ipv4_cache,
+ struct ipa_nat_indx_tbl_sw_rule *indx_sw_rule,
+ uint16_t entry,
+ uint8_t tbl_index)
+{
+ struct ipa_nat_indx_tbl_rule *tbl_ptr;
+ struct ipa_nat_sw_indx_tbl_rule sw_rule;
+ uint16_t prev_entry = indx_sw_rule->prev_index;
+ nat_table_type tbl_type;
+ uint16_t offset = 0;
+
+ sw_rule.next_index = indx_sw_rule->next_index;
+ sw_rule.tbl_entry = indx_sw_rule->tbl_entry;
+
+ if (entry < ipv4_cache->table_entries)
+ {
+ tbl_ptr = (struct ipa_nat_indx_tbl_rule *)ipv4_cache->index_table_addr;
+
+ memcpy( &tbl_ptr[entry],
+ &sw_rule,
+ sizeof(struct ipa_nat_indx_tbl_rule));
+ }
+ else
+ {
+ tbl_ptr = (struct ipa_nat_indx_tbl_rule *)ipv4_cache->index_table_expn_addr;
+
+ memcpy( &tbl_ptr[entry - ipv4_cache->table_entries],
+ &sw_rule,
+ sizeof(struct ipa_nat_indx_tbl_rule));
+ }
+
+ /* Update the next field of previous entry on collosion */
+ if (IPA_NAT_INVALID_NAT_ENTRY != prev_entry)
+ {
+ if (prev_entry < ipv4_cache->table_entries)
+ {
+ tbl_type = IPA_NAT_INDX_TBL;
+ tbl_ptr = (struct ipa_nat_indx_tbl_rule *)ipv4_cache->index_table_addr;
+ }
+ else
+ {
+ tbl_type = IPA_NAT_INDEX_EXPN_TBL;
+ /* tbp_ptr is already pointing to expansion table
+ no need to initialize it */
+ prev_entry = prev_entry - ipv4_cache->table_entries;
+ }
+
+ offset = ipa_nati_get_index_entry_offset(ipv4_cache, tbl_type, prev_entry);
+ offset += IPA_NAT_INDEX_RULE_NEXT_FIELD_OFFSET;
+
+ IPADBG("Updating next index field of index table on collosion using dma()\n");
+ ipa_nati_write_next_index(tbl_index, tbl_type, entry, offset);
+ }
+
+ return;
+}
+
+int ipa_nati_post_ipv4_dma_cmd(uint8_t tbl_indx,
+ uint16_t entry)
+{
+ struct ipa_ioc_nat_dma_cmd *cmd;
+ struct ipa_nat_rule *tbl_ptr;
+ uint32_t offset = ipv4_nat_cache.ip4_tbl[tbl_indx].tbl_addr_offset;
+ int ret = 0;
+
+ cmd = (struct ipa_ioc_nat_dma_cmd *)
+ malloc( sizeof(struct ipa_ioc_nat_dma_cmd) +
+ sizeof(struct ipa_ioc_nat_dma_one));
+ if(NULL == cmd)
+ {
+ IPAERR("unable to allocate memory\n");
+ return -1;
+ }
+
+ if (entry < ipv4_nat_cache.ip4_tbl[tbl_indx].table_entries)
+ {
+ tbl_ptr =
+ (struct ipa_nat_rule *)ipv4_nat_cache.ip4_tbl[tbl_indx].ipv4_rules_addr;
+
+ cmd->dma[0].table_index = tbl_indx;
+ cmd->dma[0].base_addr = IPA_NAT_BASE_TBL;
+ cmd->dma[0].data = IPA_NAT_FLAG_ENABLE_BIT_MASK;
+
+ cmd->dma[0].offset = (char *)&tbl_ptr[entry] - (char *)tbl_ptr;
+ cmd->dma[0].offset += IPA_NAT_RULE_FLAG_FIELD_OFFSET;
+ }
+ else
+ {
+ tbl_ptr =
+ (struct ipa_nat_rule *)ipv4_nat_cache.ip4_tbl[tbl_indx].ipv4_expn_rules_addr;
+ entry = entry - ipv4_nat_cache.ip4_tbl[tbl_indx].table_entries;
+
+ cmd->dma[0].table_index = tbl_indx;
+ cmd->dma[0].base_addr = IPA_NAT_EXPN_TBL;
+ cmd->dma[0].data = IPA_NAT_FLAG_ENABLE_BIT_MASK;
+
+ cmd->dma[0].offset = (char *)&tbl_ptr[entry] - (char *)tbl_ptr;
+ cmd->dma[0].offset += IPA_NAT_RULE_FLAG_FIELD_OFFSET;
+ cmd->dma[0].offset += offset;
+ }
+
+ cmd->entries = 1;
+ if (ioctl(ipv4_nat_cache.ipa_fd, IPA_IOC_NAT_DMA, cmd))
+ {
+ perror("ipa_nati_post_ipv4_dma_cmd(): ioctl error value");
+ IPAERR("unable to call dma icotl\n");
+ IPADBG("ipa fd %d\n",ipv4_nat_cache.ipa_fd);
+ ret = -1;
+ goto fail;
+ }
+ IPADBG("posted IPA_IOC_NAT_DMA to kernel successfully during add operation \n");
+
+
+ fail:
+ free(cmd);
+
+ return ret;
+}
+
+
+int ipa_nati_del_ipv4_rule(uint32_t tbl_hdl,
+ uint32_t rule_hdl)
+{
+ uint8_t expn_tbl;
+ uint16_t tbl_entry;
+ struct ipa_nat_ip4_table_cache *tbl_ptr;
+ del_type rule_pos;
+ uint8_t tbl_indx = (uint8_t)(tbl_hdl-1);
+
+ /* Parse the rule handle */
+ ipa_nati_parse_ipv4_rule_hdl(tbl_indx, (uint16_t)rule_hdl,
+ &expn_tbl, &tbl_entry);
+ if (IPA_NAT_INVALID_NAT_ENTRY == tbl_entry)
+ {
+ IPAERR("Invalid Rule Entry\n");
+ return -1;
+ }
+
+ IPADBG("Delete below rule\n");
+ IPADBG("tbl_entry:%d expn_tbl:%d \n",tbl_entry, expn_tbl);
+
+ tbl_ptr = &ipv4_nat_cache.ip4_tbl[tbl_indx];
+ if (!tbl_ptr->valid)
+ {
+ IPAERR("invalid table handle\n");
+ return -1;
+ }
+
+ ipa_nati_find_rule_pos(tbl_ptr, expn_tbl,
+ tbl_entry, &rule_pos);
+ IPADBG("rule_pos:%d\n", rule_pos);
+
+ if(0 != ipa_nati_post_del_dma_cmd(tbl_indx, tbl_entry,
+ expn_tbl, rule_pos))
+ {
+ return -1;
+ }
+
+ ipa_nati_del_dead_ipv4_head_nodes(tbl_indx);
+
+ /* Reset rule_id_array entry */
+ ipv4_nat_cache.ip4_tbl[tbl_indx].rule_id_array[rule_hdl-1] =
+ IPA_NAT_INVALID_NAT_ENTRY;
+
+#ifdef NAT_DUMP
+ IPADBG("Dumping Table after deleting rule\n");
+ ipa_nat_dump_ipv4_table(tbl_hdl);
+#endif
+
+ return 0;
+}
+
+void ReorderCmds(struct ipa_ioc_nat_dma_cmd *cmd, int size)
+{
+ int indx_tbl_start = 0, cnt, cnt1;
+ struct ipa_ioc_nat_dma_cmd *tmp;
+
+ IPADBG("called ReorderCmds() with entries :%d\n", cmd->entries);
+
+ for (cnt=0; cnt<cmd->entries; cnt++)
+ {
+ if (cmd->dma[cnt].base_addr == IPA_NAT_INDX_TBL ||
+ cmd->dma[cnt].base_addr == IPA_NAT_INDEX_EXPN_TBL)
+ {
+ indx_tbl_start = cnt;
+ break;
+ }
+ }
+
+ if (indx_tbl_start == 0)
+ {
+ IPADBG("Reorder not needed\n");
+ return;
+ }
+
+ tmp = (struct ipa_ioc_nat_dma_cmd *)malloc(size);
+ if (tmp == NULL)
+ {
+ IPAERR("unable to allocate memory\n");
+ return;
+ }
+
+ cnt1 = 0;
+ tmp->entries = cmd->entries;
+ for (cnt=indx_tbl_start; cnt<cmd->entries; cnt++)
+ {
+ memcpy(&tmp->dma[cnt1], &cmd->dma[cnt],
+ sizeof(struct ipa_ioc_nat_dma_one));
+ cnt1++;
+ }
+
+ for (cnt = 0; cnt<indx_tbl_start; cnt++)
+ {
+ memcpy(&tmp->dma[cnt1], &cmd->dma[cnt],
+ sizeof(struct ipa_ioc_nat_dma_one));
+ cnt1++;
+ }
+
+ memset(cmd, 0, size);
+ memcpy(cmd, tmp, size);
+ free(tmp);
+
+ return;
+}
+
+int ipa_nati_post_del_dma_cmd(uint8_t tbl_indx,
+ uint16_t cur_tbl_entry,
+ uint8_t expn_tbl,
+ del_type rule_pos)
+{
+
+#define MAX_DMA_ENTRIES_FOR_DEL 3
+
+ struct ipa_nat_ip4_table_cache *cache_ptr;
+ struct ipa_nat_indx_tbl_rule *indx_tbl_ptr;
+ struct ipa_nat_rule *tbl_ptr;
+ int ret = 0, size = 0;
+
+ uint16_t indx_tbl_entry = IPA_NAT_INVALID_NAT_ENTRY;
+ del_type indx_rule_pos;
+
+ struct ipa_ioc_nat_dma_cmd *cmd;
+ uint8_t no_of_cmds = 0;
+
+ uint16_t prev_entry = IPA_NAT_INVALID_NAT_ENTRY;
+ uint16_t next_entry = IPA_NAT_INVALID_NAT_ENTRY;
+ uint16_t table_entry;
+
+ size = sizeof(struct ipa_ioc_nat_dma_cmd) +
+ (MAX_DMA_ENTRIES_FOR_DEL * sizeof(struct ipa_ioc_nat_dma_one));
+
+ cmd = (struct ipa_ioc_nat_dma_cmd *)malloc(size);
+ if (NULL == cmd)
+ {
+ IPAERR("unable to allocate memory\n");
+ return -1;
+ }
+
+ cache_ptr = &ipv4_nat_cache.ip4_tbl[tbl_indx];
+ if (!expn_tbl)
+ {
+ tbl_ptr = (struct ipa_nat_rule *)cache_ptr->ipv4_rules_addr;
+ }
+ else
+ {
+ tbl_ptr = (struct ipa_nat_rule *)cache_ptr->ipv4_expn_rules_addr;
+ }
+
+
+ if (!Read16BitFieldValue(tbl_ptr[cur_tbl_entry].ip_cksm_enbl,
+ ENABLE_FIELD))
+ {
+ IPAERR("Deleting invalid(not enabled) rule\n");
+ ret = -1;
+ goto fail;
+ }
+
+ indx_tbl_entry = Read16BitFieldValue(tbl_ptr[cur_tbl_entry].sw_spec_params,
+ SW_SPEC_PARAM_INDX_TBL_ENTRY_FIELD);
+ /* ================================================
+ Base Table rule Deletion
+ ================================================*/
+ /* Just delete the current rule by disabling the flag field */
+ if (IPA_NAT_DEL_TYPE_ONLY_ONE == rule_pos)
+ {
+ cmd->dma[no_of_cmds].table_index = tbl_indx;
+ cmd->dma[no_of_cmds].base_addr = IPA_NAT_BASE_TBL;
+ cmd->dma[no_of_cmds].data = IPA_NAT_FLAG_DISABLE_BIT_MASK;
+
+ cmd->dma[no_of_cmds].offset =
+ ipa_nati_get_entry_offset(cache_ptr,
+ cmd->dma[no_of_cmds].base_addr,
+ cur_tbl_entry);
+ cmd->dma[no_of_cmds].offset += IPA_NAT_RULE_FLAG_FIELD_OFFSET;
+ }
+
+ /* Just update the protocol field to invalid */
+ if (IPA_NAT_DEL_TYPE_HEAD == rule_pos)
+ {
+ cmd->dma[no_of_cmds].table_index = tbl_indx;
+ cmd->dma[no_of_cmds].base_addr = IPA_NAT_BASE_TBL;
+ cmd->dma[no_of_cmds].data = IPA_NAT_INVALID_PROTO_FIELD_VALUE;
+
+ cmd->dma[no_of_cmds].offset =
+ ipa_nati_get_entry_offset(cache_ptr,
+ cmd->dma[no_of_cmds].base_addr,
+ cur_tbl_entry);
+ cmd->dma[no_of_cmds].offset += IPA_NAT_RULE_PROTO_FIELD_OFFSET;
+
+ IPADBG("writing invalid proto: 0x%x\n", cmd->dma[no_of_cmds].data);
+ }
+
+ /*
+ Update the previous entry of next_index field value
+ with current entry next_index field value
+ */
+ if (IPA_NAT_DEL_TYPE_MIDDLE == rule_pos)
+ {
+ prev_entry = Read16BitFieldValue(tbl_ptr[cur_tbl_entry].sw_spec_params,
+ SW_SPEC_PARAM_PREV_INDEX_FIELD);
+
+ cmd->dma[no_of_cmds].table_index = tbl_indx;
+ cmd->dma[no_of_cmds].data = Read16BitFieldValue(tbl_ptr[cur_tbl_entry].nxt_indx_pub_port,
+ NEXT_INDEX_FIELD);
+
+ cmd->dma[no_of_cmds].base_addr = IPA_NAT_BASE_TBL;
+ if (prev_entry >= cache_ptr->table_entries)
+ {
+ cmd->dma[no_of_cmds].base_addr = IPA_NAT_EXPN_TBL;
+ prev_entry -= cache_ptr->table_entries;
+ }
+
+ cmd->dma[no_of_cmds].offset = ipa_nati_get_entry_offset(cache_ptr,
+ cmd->dma[no_of_cmds].base_addr,
+ prev_entry);
+ cmd->dma[no_of_cmds].offset += IPA_NAT_RULE_NEXT_FIELD_OFFSET;
+
+ }
+
+ /*
+ Reset the previous entry of next_index field with 0
+ */
+ if (IPA_NAT_DEL_TYPE_LAST == rule_pos)
+ {
+ prev_entry = Read16BitFieldValue(tbl_ptr[cur_tbl_entry].sw_spec_params,
+ SW_SPEC_PARAM_PREV_INDEX_FIELD);
+
+ cmd->dma[no_of_cmds].table_index = tbl_indx;
+ cmd->dma[no_of_cmds].data = IPA_NAT_INVALID_NAT_ENTRY;
+
+ cmd->dma[no_of_cmds].base_addr = IPA_NAT_BASE_TBL;
+ if (prev_entry >= cache_ptr->table_entries)
+ {
+ cmd->dma[no_of_cmds].base_addr = IPA_NAT_EXPN_TBL;
+ prev_entry -= cache_ptr->table_entries;
+ }
+
+ cmd->dma[no_of_cmds].offset = ipa_nati_get_entry_offset(cache_ptr,
+ cmd->dma[no_of_cmds].base_addr,
+ prev_entry);
+ cmd->dma[no_of_cmds].offset += IPA_NAT_RULE_NEXT_FIELD_OFFSET;
+ }
+
+ /* ================================================
+ Base Table rule Deletion End
+ ================================================*/
+
+ /* ================================================
+ Index Table rule Deletion
+ ================================================*/
+ ipa_nati_find_index_rule_pos(cache_ptr,
+ indx_tbl_entry,
+ &indx_rule_pos);
+ IPADBG("Index table entry: 0x%x\n", indx_tbl_entry);
+ IPADBG("and position: %d\n", indx_rule_pos);
+ if (indx_tbl_entry >= cache_ptr->table_entries)
+ {
+ indx_tbl_entry -= cache_ptr->table_entries;
+ indx_tbl_ptr =
+ (struct ipa_nat_indx_tbl_rule *)cache_ptr->index_table_expn_addr;
+ }
+ else
+ {
+ indx_tbl_ptr =
+ (struct ipa_nat_indx_tbl_rule *)cache_ptr->index_table_addr;
+ }
+
+ /* Just delete the current rule by resetting nat_table_index field to 0 */
+ if (IPA_NAT_DEL_TYPE_ONLY_ONE == indx_rule_pos)
+ {
+ no_of_cmds++;
+ cmd->dma[no_of_cmds].base_addr = IPA_NAT_INDX_TBL;
+ cmd->dma[no_of_cmds].table_index = tbl_indx;
+ cmd->dma[no_of_cmds].data = IPA_NAT_INVALID_NAT_ENTRY;
+
+ cmd->dma[no_of_cmds].offset = ipa_nati_get_index_entry_offset(cache_ptr,
+ cmd->dma[no_of_cmds].base_addr,
+ indx_tbl_entry);
+ cmd->dma[no_of_cmds].offset += IPA_NAT_INDEX_RULE_NAT_INDEX_FIELD_OFFSET;
+ }
+
+ /* copy the next entry values to current entry */
+ if (IPA_NAT_DEL_TYPE_HEAD == indx_rule_pos)
+ {
+ next_entry = Read16BitFieldValue(indx_tbl_ptr[indx_tbl_entry].tbl_entry_nxt_indx,
+ INDX_TBL_NEXT_INDEX_FILED);
+ next_entry -= cache_ptr->table_entries;
+
+ no_of_cmds++;
+ cmd->dma[no_of_cmds].base_addr = IPA_NAT_INDX_TBL;
+ cmd->dma[no_of_cmds].table_index = tbl_indx;
+
+ /* Copy the nat_table_index field value of next entry */
+ indx_tbl_ptr =
+ (struct ipa_nat_indx_tbl_rule *)cache_ptr->index_table_expn_addr;
+ cmd->dma[no_of_cmds].data = Read16BitFieldValue(indx_tbl_ptr[next_entry].tbl_entry_nxt_indx,
+ INDX_TBL_TBL_ENTRY_FIELD);
+
+ cmd->dma[no_of_cmds].offset = ipa_nati_get_index_entry_offset(cache_ptr,
+ cmd->dma[no_of_cmds].base_addr,
+ indx_tbl_entry);
+ cmd->dma[no_of_cmds].offset += IPA_NAT_INDEX_RULE_NAT_INDEX_FIELD_OFFSET;
+
+ /* Copy the next_index field value of next entry */
+ no_of_cmds++;
+ cmd->dma[no_of_cmds].base_addr = IPA_NAT_INDX_TBL;
+ cmd->dma[no_of_cmds].table_index = tbl_indx;
+ cmd->dma[no_of_cmds].data = Read16BitFieldValue(indx_tbl_ptr[next_entry].tbl_entry_nxt_indx,
+ INDX_TBL_NEXT_INDEX_FILED);
+
+ cmd->dma[no_of_cmds].offset = ipa_nati_get_index_entry_offset(cache_ptr,
+ cmd->dma[no_of_cmds].base_addr,
+ indx_tbl_entry);
+ cmd->dma[no_of_cmds].offset += IPA_NAT_INDEX_RULE_NEXT_FIELD_OFFSET;
+ }
+
+ /*
+ Update the previous entry of next_index field value
+ with current entry next_index field value
+ */
+ if (IPA_NAT_DEL_TYPE_MIDDLE == indx_rule_pos)
+ {
+ prev_entry = cache_ptr->index_expn_table_meta[indx_tbl_entry].prev_index;
+
+ no_of_cmds++;
+ cmd->dma[no_of_cmds].table_index = tbl_indx;
+ cmd->dma[no_of_cmds].data = Read16BitFieldValue(indx_tbl_ptr[indx_tbl_entry].tbl_entry_nxt_indx,
+ INDX_TBL_NEXT_INDEX_FILED);
+
+ cmd->dma[no_of_cmds].base_addr = IPA_NAT_INDX_TBL;
+ if (prev_entry >= cache_ptr->table_entries)
+ {
+ cmd->dma[no_of_cmds].base_addr = IPA_NAT_INDEX_EXPN_TBL;
+ prev_entry -= cache_ptr->table_entries;
+ }
+
+ cmd->dma[no_of_cmds].offset = ipa_nati_get_index_entry_offset(cache_ptr,
+ cmd->dma[no_of_cmds].base_addr,
+ prev_entry);
+ cmd->dma[no_of_cmds].offset += IPA_NAT_INDEX_RULE_NEXT_FIELD_OFFSET;
+ }
+
+ /* Reset the previous entry next_index field with 0 */
+ if (IPA_NAT_DEL_TYPE_LAST == indx_rule_pos)
+ {
+ prev_entry = cache_ptr->index_expn_table_meta[indx_tbl_entry].prev_index;
+
+ no_of_cmds++;
+ cmd->dma[no_of_cmds].table_index = tbl_indx;
+ cmd->dma[no_of_cmds].data = IPA_NAT_INVALID_NAT_ENTRY;
+
+ cmd->dma[no_of_cmds].base_addr = IPA_NAT_INDX_TBL;
+ if (prev_entry >= cache_ptr->table_entries)
+ {
+ cmd->dma[no_of_cmds].base_addr = IPA_NAT_INDEX_EXPN_TBL;
+ prev_entry -= cache_ptr->table_entries;
+ }
+
+ cmd->dma[no_of_cmds].offset =
+ ipa_nati_get_index_entry_offset(cache_ptr,
+ cmd->dma[no_of_cmds].base_addr,
+ prev_entry);
+ cmd->dma[no_of_cmds].offset += IPA_NAT_INDEX_RULE_NEXT_FIELD_OFFSET;
+ }
+
+ /* ================================================
+ Index Table rule Deletion End
+ ================================================*/
+ cmd->entries = no_of_cmds + 1;
+
+ if (cmd->entries > 1)
+ {
+ ReorderCmds(cmd, size);
+ }
+ if (ioctl(ipv4_nat_cache.ipa_fd, IPA_IOC_NAT_DMA, cmd))
+ {
+ perror("ipa_nati_post_del_dma_cmd(): ioctl error value");
+ IPAERR("unable to post cmd\n");
+ IPADBG("ipa fd %d\n", ipv4_nat_cache.ipa_fd);
+ ret = -1;
+ goto fail;
+ }
+
+ /* if entry exist in IPA_NAT_DEL_TYPE_MIDDLE of list
+ Update the previous entry in sw specific parameters
+ */
+ if (IPA_NAT_DEL_TYPE_MIDDLE == rule_pos)
+ {
+ /* Retrieve the current entry prev_entry value */
+ prev_entry = Read16BitFieldValue(tbl_ptr[cur_tbl_entry].sw_spec_params,
+ SW_SPEC_PARAM_PREV_INDEX_FIELD);
+
+ /* Retrieve the next entry */
+ next_entry = Read16BitFieldValue(tbl_ptr[cur_tbl_entry].nxt_indx_pub_port,
+ NEXT_INDEX_FIELD);
+ next_entry -= cache_ptr->table_entries;
+
+ tbl_ptr = (struct ipa_nat_rule *)cache_ptr->ipv4_expn_rules_addr;
+
+ /* copy the current entry prev_entry value to next entry*/
+ UpdateSwSpecParams(&tbl_ptr[next_entry],
+ IPA_NAT_SW_PARAM_PREV_INDX_BYTE,
+ prev_entry);
+ }
+
+ /* Reset the other field values of current delete entry
+ In case of IPA_NAT_DEL_TYPE_HEAD, don't reset */
+ if (IPA_NAT_DEL_TYPE_HEAD != rule_pos)
+ {
+ memset(&tbl_ptr[cur_tbl_entry], 0, sizeof(struct ipa_nat_rule));
+ }
+
+ if (IPA_NAT_DEL_TYPE_HEAD == indx_rule_pos)
+ {
+ /* Reset the next entry to IPA_NAT_DEL_TYPE_HEAD as we copied
+ the next entry to IPA_NAT_DEL_TYPE_HEAD */
+ indx_tbl_ptr[next_entry].tbl_entry_nxt_indx = 0;
+
+ /*
+ In case of IPA_NAT_DEL_TYPE_HEAD, update the sw specific parameters
+ (index table entry) of base table entry
+ */
+ indx_tbl_ptr =
+ (struct ipa_nat_indx_tbl_rule *)cache_ptr->index_table_addr;
+ table_entry = Read16BitFieldValue(indx_tbl_ptr[indx_tbl_entry].tbl_entry_nxt_indx,
+ INDX_TBL_TBL_ENTRY_FIELD);
+ if (table_entry >= cache_ptr->table_entries)
+ {
+ tbl_ptr = (struct ipa_nat_rule *)cache_ptr->ipv4_expn_rules_addr;
+ table_entry -= cache_ptr->table_entries;
+ }
+ else
+ {
+ tbl_ptr = (struct ipa_nat_rule *)cache_ptr->ipv4_rules_addr;
+ }
+
+ UpdateSwSpecParams(&tbl_ptr[table_entry],
+ IPA_NAT_SW_PARAM_INDX_TBL_ENTRY_BYTE,
+ indx_tbl_entry);
+ }
+ else
+ {
+ /* Update the prev_entry value (in index_expn_table_meta)
+ for the next_entry in list with current entry prev_entry value
+ */
+ if (IPA_NAT_DEL_TYPE_MIDDLE == indx_rule_pos)
+ {
+ next_entry = Read16BitFieldValue(indx_tbl_ptr[indx_tbl_entry].tbl_entry_nxt_indx,
+ INDX_TBL_NEXT_INDEX_FILED);
+ if (next_entry >= cache_ptr->table_entries)
+ {
+ next_entry -= cache_ptr->table_entries;
+ }
+
+ cache_ptr->index_expn_table_meta[next_entry].prev_index =
+ cache_ptr->index_expn_table_meta[indx_tbl_entry].prev_index;
+
+ cache_ptr->index_expn_table_meta[indx_tbl_entry].prev_index =
+ IPA_NAT_INVALID_NAT_ENTRY;
+ }
+
+ IPADBG("At, indx_tbl_entry value: %d\n", indx_tbl_entry);
+ IPADBG("At, indx_tbl_entry member address: %p\n",
+ &indx_tbl_ptr[indx_tbl_entry].tbl_entry_nxt_indx);
+
+ indx_tbl_ptr[indx_tbl_entry].tbl_entry_nxt_indx = 0;
+
+ }
+
+fail:
+ free(cmd);
+
+ return ret;
+}
+
+void ipa_nati_find_index_rule_pos(
+ struct ipa_nat_ip4_table_cache *cache_ptr,
+ uint16_t tbl_entry,
+ del_type *rule_pos)
+{
+
+ struct ipa_nat_indx_tbl_rule *tbl_ptr;
+
+ if(tbl_entry >= cache_ptr->table_entries)
+ {
+ tbl_ptr =
+ (struct ipa_nat_indx_tbl_rule *)cache_ptr->index_table_expn_addr;
+
+ tbl_entry -= cache_ptr->table_entries;
+ if (Read16BitFieldValue(tbl_ptr[tbl_entry].tbl_entry_nxt_indx,
+ INDX_TBL_NEXT_INDEX_FILED) == IPA_NAT_INVALID_NAT_ENTRY)
+ {
+ *rule_pos = IPA_NAT_DEL_TYPE_LAST;
+ }
+ else
+ {
+ *rule_pos = IPA_NAT_DEL_TYPE_MIDDLE;
+ }
+ }
+ else
+ {
+ tbl_ptr =
+ (struct ipa_nat_indx_tbl_rule *)cache_ptr->index_table_addr;
+
+ if (Read16BitFieldValue(tbl_ptr[tbl_entry].tbl_entry_nxt_indx,
+ INDX_TBL_NEXT_INDEX_FILED) == IPA_NAT_INVALID_NAT_ENTRY)
+ {
+ *rule_pos = IPA_NAT_DEL_TYPE_ONLY_ONE;
+ }
+ else
+ {
+ *rule_pos = IPA_NAT_DEL_TYPE_HEAD;
+ }
+ }
+}
+
+void ipa_nati_find_rule_pos(struct ipa_nat_ip4_table_cache *cache_ptr,
+ uint8_t expn_tbl,
+ uint16_t tbl_entry,
+ del_type *rule_pos)
+{
+
+ struct ipa_nat_rule *tbl_ptr;
+
+ if(expn_tbl)
+ {
+ tbl_ptr = (struct ipa_nat_rule *)cache_ptr->ipv4_expn_rules_addr;
+ if ( Read16BitFieldValue(tbl_ptr[tbl_entry].nxt_indx_pub_port,
+ NEXT_INDEX_FIELD) == IPA_NAT_INVALID_NAT_ENTRY)
+ {
+ *rule_pos = IPA_NAT_DEL_TYPE_LAST;
+ }
+ else
+ {
+ *rule_pos = IPA_NAT_DEL_TYPE_MIDDLE;
+ }
+ }
+ else
+ {
+ tbl_ptr = (struct ipa_nat_rule *)cache_ptr->ipv4_rules_addr;
+ if( Read16BitFieldValue(tbl_ptr[tbl_entry].nxt_indx_pub_port,
+ NEXT_INDEX_FIELD) == IPA_NAT_INVALID_NAT_ENTRY)
+ {
+ *rule_pos = IPA_NAT_DEL_TYPE_ONLY_ONE;
+ }
+ else
+ {
+ *rule_pos = IPA_NAT_DEL_TYPE_HEAD;
+ }
+ }
+}
+
+void ipa_nati_del_dead_ipv4_head_nodes(uint8_t tbl_indx)
+{
+ struct ipa_nat_rule *tbl_ptr;
+ uint16_t cnt;
+
+ tbl_ptr =
+ (struct ipa_nat_rule *)ipv4_nat_cache.ip4_tbl[tbl_indx].ipv4_rules_addr;
+
+ for(cnt=0;
+ cnt<ipv4_nat_cache.ip4_tbl[tbl_indx].table_entries;
+ cnt++)
+ {
+
+ if(Read8BitFieldValue(tbl_ptr[cnt].ts_proto,
+ PROTOCOL_FIELD) == IPA_NAT_INVALID_PROTO_FIELD_CMP
+ &&
+ Read16BitFieldValue(tbl_ptr[cnt].nxt_indx_pub_port,
+ NEXT_INDEX_FIELD) == IPA_NAT_INVALID_NAT_ENTRY)
+ {
+ /* Delete the IPA_NAT_DEL_TYPE_HEAD node */
+ IPADBG("deleting the dead node 0x%x\n", cnt);
+ memset(&tbl_ptr[cnt], 0, sizeof(struct ipa_nat_rule));
+ }
+ } /* end of for loop */
+
+ return;
+}
+
+
+/* ========================================================
+ Debug functions
+ ========================================================*/
+#ifdef NAT_DUMP
+void ipa_nat_dump_ipv4_table(uint32_t tbl_hdl)
+{
+ struct ipa_nat_rule *tbl_ptr;
+ struct ipa_nat_indx_tbl_rule *indx_tbl_ptr;
+ int cnt;
+ uint8_t atl_one = 0;
+
+ if (IPA_NAT_INVALID_NAT_ENTRY == tbl_hdl ||
+ tbl_hdl > IPA_NAT_MAX_IP4_TBLS)
+ {
+ IPAERR("invalid table handle passed \n");
+ return;
+ }
+
+ /* Print ipv4 rules */
+ IPADBG("Dumping ipv4 active rules:\n");
+ tbl_ptr = (struct ipa_nat_rule *)
+ ipv4_nat_cache.ip4_tbl[tbl_hdl-1].ipv4_rules_addr;
+ for( cnt=0;
+ cnt<ipv4_nat_cache.ip4_tbl[tbl_hdl-1].table_entries;
+ cnt++)
+ {
+ if (Read16BitFieldValue( tbl_ptr[cnt].ip_cksm_enbl,
+ ENABLE_FIELD))
+ {
+ atl_one = 1;
+ ipa_nati_print_rule(&tbl_ptr[cnt], cnt);
+ ipa_nati_dump_rule_buf(&tbl_ptr[cnt],
+ sizeof(struct ipa_nat_rule),
+ cnt);
+ }
+ }
+ if(!atl_one)
+ {
+ IPADBG("No active base rules\n");
+ }
+ atl_one = 0;
+
+ /* Print ipv4 expansion rules */
+ IPADBG("Dumping ipv4 active expansion rules:\n");
+ tbl_ptr = (struct ipa_nat_rule *)
+ ipv4_nat_cache.ip4_tbl[tbl_hdl-1].ipv4_expn_rules_addr;
+ for( cnt=0;
+ cnt<ipv4_nat_cache.ip4_tbl[tbl_hdl-1].expn_table_entries;
+ cnt++)
+ {
+ if (Read16BitFieldValue(tbl_ptr[cnt].ip_cksm_enbl,
+ ENABLE_FIELD))
+ {
+ ipa_nati_print_rule(&tbl_ptr[cnt], cnt);
+ ipa_nati_dump_rule_buf(&tbl_ptr[cnt],
+ sizeof(struct ipa_nat_rule),
+ cnt);
+ }
+ }
+ if(!atl_one)
+ {
+ IPADBG("No active base expansion rules\n");
+ }
+ atl_one = 0;
+
+ /* Print ipv4 index rules */
+ IPADBG("Dumping ipv4 index active rules: \n");
+ indx_tbl_ptr = (struct ipa_nat_indx_tbl_rule *)
+ ipv4_nat_cache.ip4_tbl[tbl_hdl-1].index_table_addr;
+ for( cnt=0;
+ cnt<ipv4_nat_cache.ip4_tbl[tbl_hdl-1].table_entries;
+ cnt++)
+ {
+ if (Read16BitFieldValue(indx_tbl_ptr[cnt].tbl_entry_nxt_indx,
+ INDX_TBL_TBL_ENTRY_FIELD))
+ {
+ ipa_nati_dump_index_rule_buf(&indx_tbl_ptr[cnt],
+ sizeof(struct ipa_nat_indx_tbl_rule),
+ cnt);
+ }
+ }
+ if(!atl_one)
+ {
+ IPADBG("No active index table rules\n");
+ }
+ atl_one = 0;
+
+
+ /* Print ipv4 index expansion rules */
+ IPADBG("Dumping ipv4 index expansion active rules: \n");
+ indx_tbl_ptr = (struct ipa_nat_indx_tbl_rule *)
+ ipv4_nat_cache.ip4_tbl[tbl_hdl-1].index_table_expn_addr;
+ for ( cnt=0;
+ cnt<ipv4_nat_cache.ip4_tbl[tbl_hdl-1].expn_table_entries;
+ cnt++)
+ {
+ if (Read16BitFieldValue(indx_tbl_ptr[cnt].tbl_entry_nxt_indx,
+ INDX_TBL_TBL_ENTRY_FIELD))
+ {
+ ipa_nati_dump_index_rule_buf(&indx_tbl_ptr[cnt],
+ sizeof(struct ipa_nat_indx_tbl_rule),
+ cnt);
+ }
+ }
+ if(!atl_one)
+ {
+ IPADBG("No active index expansion rules\n");
+ }
+ atl_one = 0;
+
+}
+
+
+void ipa_nati_dump_rule_buf(void *param1, uint8_t size, uint32_t rule_id)
+{
+ int cnt = 0;
+ uint8_t temp[IPA_NAT_TABLE_ENTRY_SIZE];
+ uint64_t *rule = NULL;
+
+ memcpy(&temp, param1, sizeof(temp));
+ rule = (uint64_t *)temp;
+
+ IPADBG("Address :%p, rule id: %d size: %d\n",
+ rule, rule_id, size);
+ for(; cnt<size; )
+ {
+ uint8_t *byte = (uint8_t *)rule;
+
+ IPADBG("uint64[%d]: 0x%x:\n", cnt, (unsigned int)rule);
+ IPADBG("%02x\t%02x\t%02x\t%02x\n", byte[0], byte[1], byte[2], byte[3]);
+ IPADBG("%02x\t%02x\t%02x\t%02x\n", byte[4], byte[5], byte[6], byte[7]);
+
+ cnt += 8;
+ rule++;
+ }
+
+ return;
+}
+
+void ipa_nati_dump_index_rule_buf(void *param1, uint8_t size, uint32_t rule_id)
+{
+ int cnt = 0;
+ uint8_t temp[IPA_NAT_INDEX_TABLE_ENTRY_SIZE];
+ uint16_t *rule = NULL;
+
+ memcpy(&temp, param1, sizeof(temp));
+ rule = (uint16_t *)temp;
+
+ IPADBG("Address :%p, rule id: %d size: %d\n",
+ rule, rule_id, size);
+
+ for(; cnt<size; )
+ {
+ uint8_t *byte = (uint8_t *)rule;
+
+ IPADBG("uint64[%d]: 0x%x:\n", cnt, (unsigned int)rule);
+ IPADBG("%02x\t%02x\n", byte[0], byte[1]);
+ IPADBG("\n");
+
+ cnt += 2;
+ rule++;
+ }
+
+ return;
+}
+
+void ipa_nati_print_rule(struct ipa_nat_rule *param, uint32_t rule_id)
+{
+ struct ipa_nat_sw_rule sw_rule;
+ memcpy(&sw_rule, param, sizeof(sw_rule));
+
+ IPADBG("Printing NAT Rule:%d at memory location:%p\n", rule_id, param);
+
+ IPADBG("Target IP: 0x%x Target Port: 0x%x\n",
+ sw_rule.target_ip, sw_rule.target_port);
+
+ IPADBG("Private IP: 0x%x Private Port: 0x%x\n",
+ sw_rule.private_ip, sw_rule.private_port);
+
+ IPADBG("Public Port: 0x%x Next index: 0x%x\n",
+ sw_rule.public_port, sw_rule.next_index);
+
+ IPADBG("IP ChkSum: 0x%x Enable bit: 0x%x\n",
+ sw_rule.ip_chksum, sw_rule.enable);
+
+ IPADBG("Time Stamp: 0x%x Protocol: 0x%x\n",
+ sw_rule.time_stamp, sw_rule.protocol);
+
+ IPADBG("Prev Index: 0x%x Next Index: 0x%x\n",
+ sw_rule.prev_index, sw_rule.next_index);
+
+ IPADBG("TCP UDP Chksum: 0x%x\n", sw_rule.tcp_udp_chksum);
+
+ return;
+}
+#endif
diff --git a/ipanat/src/ipa_nat_logi.c b/ipanat/src/ipa_nat_logi.c
new file mode 100644
index 0000000..11991c9
--- /dev/null
+++ b/ipanat/src/ipa_nat_logi.c
@@ -0,0 +1,68 @@
+/*
+Copyright (c) 2013, The Linux Foundation. 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 name of The Linux 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 "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+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.
+*/
+/*!
+ @file
+ IPACM_log.cpp
+
+ @brief
+ This file implements the IPAM log functionality.
+
+ @Author
+ Skylar Chang
+
+*/
+#include "ipa_nat_logi.h"
+#include <stdlib.h>
+
+#define NAT_FILE_NAME "/usr/ipanat_log.txt"
+
+static FILE *nat_fp = NULL;
+char nat_log_buf[NAT_LOG_SIZE];
+
+void log_nat_message(char *msg)
+{
+ printf("%s", msg);
+#if 0
+ if(nat_fp == NULL)
+ {
+ nat_fp = fopen(NAT_FILE_NAME, "wb+");
+ if(nat_fp == NULL)
+ {
+ printf("unable to open file\n");
+ return;
+ }
+ }
+
+ fprintf(nat_fp, msg);
+ fflush(nat_fp);
+#endif
+ return;
+}
+
+