psmattas/device_motorola_sanders
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

potter: remove IPACM for now

Browse Source 
Change-Id: Ib2193f4c1350bed557c27fe6c2d004c8eb0fba18
This commit is contained in:
Vachounet
2017-08-23 12:30:21 +02:00
parent 0a882f4302
commit b0a241003f
85 changed files with 0 additions and 35474 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
data-ipa-cfg-mgr/Android.mk
View File

@@ -1,18 +0,0 @@
#
# Copyright (C) 2016 The CyanogenMod Project
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
LOCAL_PATH := $(call my-dir)
include $(call first-makefiles-under,$(LOCAL_PATH))

3
data-ipa-cfg-mgr/Makefile.am
View File

@@ -1,3 +0,0 @@
ACLOCAL_AMFLAGS = -I m4
AUTOMAKE_OPTIONS = foreign
SUBDIRS = ipanat/src ipacm/src/

57
data-ipa-cfg-mgr/configure.ac
View File

@@ -1,57 +0,0 @@
# -*- 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
PKG_CHECK_MODULES([LIBXML], [libxml-2.0])
AC_SUBST([LIBXML_CFLAGS])
AC_SUBST([LIBXML_LIBS])
# Checks for libraries.
AC_ARG_WITH(sanitized-headers,
AS_HELP_STRING([--with-sanitized-headers=DIR],
[Specify the location of the sanitized Linux headers]),
[CPPFLAGS="$CPPFLAGS -idirafter $withval"])
AC_ARG_WITH([glib],
AC_HELP_STRING([--with-glib],
[enable glib, building HLOS systems which use glib]))
if (test "x${with_glib}" = "xyes"); then
AC_DEFINE(ENABLE_USEGLIB, 1, [Define if HLOS systems uses glib])
PKG_CHECK_MODULES(GTHREAD, gthread-2.0 >= 2.16, dummy=yes,
AC_MSG_ERROR(GThread >= 2.16 is required))
PKG_CHECK_MODULES(GLIB, glib-2.0 >= 2.16, dummy=yes,
AC_MSG_ERROR(GLib >= 2.16 is required))
GLIB_CFLAGS="$GLIB_CFLAGS $GTHREAD_CFLAGS"
GLIB_LIBS="$GLIB_LIBS $GTHREAD_LIBS"
AC_SUBST(GLIB_CFLAGS)
AC_SUBST(GLIB_LIBS)
fi
AM_CONDITIONAL(USE_GLIB, test "x${with_glib}" = "xyes")
# 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

109
data-ipa-cfg-mgr/ipacm/inc/IPACM_CmdQueue.h
View File

@@ -1,109 +0,0 @@
/*
Copyright (c) 2013-2016, 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 <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_internal;
static MessageQueue *inst_external;
MessageQueue()
{
Head = NULL;
Tail = NULL;
}
public:
~MessageQueue() { }
void enqueue(Message *item);
static void* Process(void *);
static MessageQueue* getInstanceInternal();
static MessageQueue* getInstanceExternal();
};
#endif /* IPA_CONNTRACK_MESSAGE_H */

357
data-ipa-cfg-mgr/ipacm/inc/IPACM_Config.h
View File

@@ -1,357 +0,0 @@
/*
Copyright (c) 2013-2016, 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"
#include "IPACM_EvtDispatcher.h"
typedef struct
{
char iface_name[IPA_IFACE_NAME_LEN];
}NatIfaces;
/* for IPACM rm dependency use*/
typedef struct _ipa_rm_client
{
ipa_rm_resource_name producer_rm1;
ipa_rm_resource_name consumer_rm1;
ipa_rm_resource_name producer_rm2;
ipa_rm_resource_name consumer_rm2;
bool producer1_up; /* only monitor producer_rm1, not monitor producer_rm2 */
bool consumer1_up; /* only monitor consumer_rm1, not monitor consumer_rm2 */
bool rm_set; /* once producer1_up and consumer1_up, will add bi-directional dependency */
bool rx_bypass_ipa; /* support WLAN may not register RX-property, should not add dependency */
}ipa_rm_client;
#define MAX_NUM_EXT_PROPS 25
/* used to hold extended properties */
typedef struct
{
uint8_t num_ext_props;
ipa_ioc_ext_intf_prop prop[MAX_NUM_EXT_PROPS];
} ipacm_ext_prop;
/* iface */
class IPACM_Config
{
public:
/* IPACM ipa_client map to rm_resource*/
ipa_rm_resource_name ipa_client_rm_map_tbl[IPA_CLIENT_MAX];
/* IPACM monitored rm_depency table */
ipa_rm_client ipa_rm_tbl[IPA_MAX_RM_ENTRY];
/* IPACM rm_depency a2 endpoint check*/
int ipa_rm_a2_check;
/* 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 non nat iface names */
NatIfaces *pNatIfaces;
/* Store the bridge iface names */
char ipa_virtual_iface_name[IPA_IFACE_NAME_LEN];
/* 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;
bool ipacm_odu_router_mode;
bool ipacm_odu_enable;
bool ipacm_odu_embms_enable;
bool ipacm_ip_passthrough_mode;
int ipa_nat_iface_entries;
/* Store the total number of wlan guest ap configured */
int ipa_num_wlan_guest_ap;
/* Max valid rm entry */
int ipa_max_valid_rm_entry;
/* Store SW-enable or not */
bool ipa_sw_rt_enable;
/* Store bridge mode or not */
bool ipa_bridge_enable;
/* Store bridge netdev mac */
uint8_t bridge_mac[IPA_MAC_ADDR_SIZE];
/* Store the flt rule count for each producer client*/
int flt_rule_count_v4[IPA_CLIENT_CONS - IPA_CLIENT_PROD];
int flt_rule_count_v6[IPA_CLIENT_CONS - IPA_CLIENT_PROD];
/* IPACM routing table name for v4/v6 */
struct ipa_ioc_get_rt_tbl rt_tbl_lan_v4, rt_tbl_wan_v4, rt_tbl_default_v4, rt_tbl_v6, rt_tbl_wan_v6;
struct ipa_ioc_get_rt_tbl rt_tbl_wan_dl;
struct ipa_ioc_get_rt_tbl rt_tbl_odu_v4, rt_tbl_odu_v6;
bool isMCC_Mode;
/* To return the instance */
static IPACM_Config* GetInstance();
const char* getEventName(ipa_cm_event_id event_id);
inline void increaseFltRuleCount(int index, ipa_ip_type iptype, int increment)
{
if((index >= IPA_CLIENT_CONS - IPA_CLIENT_PROD) || (index < 0))
{
IPACMERR("Index is out of range: %d.\n", index);
return;
}
if(iptype == IPA_IP_v4)
{
flt_rule_count_v4[index] += increment;
IPACMDBG_H("Now num of v4 flt rules on client %d is %d.\n", index, flt_rule_count_v4[index]);
}
else
{
flt_rule_count_v6[index] += increment;
IPACMDBG_H("Now num of v6 flt rules on client %d is %d.\n", index, flt_rule_count_v6[index]);
}
return;
}
inline void decreaseFltRuleCount(int index, ipa_ip_type iptype, int decrement)
{
if((index >= IPA_CLIENT_CONS - IPA_CLIENT_PROD) || (index < 0))
{
IPACMERR("Index is out of range: %d.\n", index);
return;
}
if(iptype == IPA_IP_v4)
{
flt_rule_count_v4[index] -= decrement;
IPACMDBG_H("Now num of v4 flt rules on client %d is %d.\n", index, flt_rule_count_v4[index]);
}
else
{
flt_rule_count_v6[index] -= decrement;
IPACMDBG_H("Now num of v6 flt rules on client %d is %d.\n", index, flt_rule_count_v6[index]);
}
return;
}
inline int getFltRuleCount(int index, ipa_ip_type iptype)
{
if((index >= IPA_CLIENT_CONS - IPA_CLIENT_PROD) || (index < 0))
{
IPACMERR("Index is out of range: %d.\n", index);
return -1;
}
if(iptype == IPA_IP_v4)
{
return flt_rule_count_v4[index];
}
else
{
return flt_rule_count_v6[index];
}
}
inline int GetAlgPortCnt()
{
return ipa_num_alg_ports;
}
int GetAlgPorts(int nPorts, ipacm_alg *pAlgPorts);
inline int GetNatMaxEntries(void)
{
return ipa_nat_max_entries;
}
inline int GetNatIfacesCnt()
{
return ipa_nat_iface_entries;
}
int GetNatIfaces(int nPorts, NatIfaces *ifaces);
/* for IPACM resource manager dependency usage */
void AddRmDepend(ipa_rm_resource_name rm1,bool rx_bypass_ipa);
void DelRmDepend(ipa_rm_resource_name rm1);
int AddNatIfaces(char *dev_name);
int DelNatIfaces(char *dev_name);
inline void SetQmapId(uint8_t id)
{
qmap_id = id;
}
inline uint8_t GetQmapId()
{
return qmap_id;
}
int SetExtProp(ipa_ioc_query_intf_ext_props *prop);
ipacm_ext_prop* GetExtProp(ipa_ip_type ip_type);
int DelExtProp(ipa_ip_type ip_type);
int Init(void);
inline bool isPrivateSubnet(uint32_t ip_addr)
{
for(int cnt=0; cnt<ipa_num_private_subnet; cnt++)
{
if(private_subnet_table[cnt].subnet_addr ==
(private_subnet_table[cnt].subnet_mask & ip_addr))
{
return true;
}
}
return false;
}
#ifdef FEATURE_IPA_ANDROID
inline bool AddPrivateSubnet(uint32_t ip_addr, int ipa_if_index)
{
ipacm_cmd_q_data evt_data;
ipacm_event_data_fid *data_fid;
uint32_t subnet_mask = ~0;
for(int cnt=0; cnt<ipa_num_private_subnet; cnt++)
{
if(private_subnet_table[cnt].subnet_addr == ip_addr)
{
IPACMDBG("Already has private subnet_addr as: 0x%x in entry(%d) \n", ip_addr, cnt);
return true;
}
}
if(ipa_num_private_subnet < IPA_MAX_PRIVATE_SUBNET_ENTRIES)
{
IPACMDBG("Add IPACM private subnet_addr as: 0x%x in entry(%d) \n", ip_addr, ipa_num_private_subnet);
private_subnet_table[ipa_num_private_subnet].subnet_addr = ip_addr;
private_subnet_table[ipa_num_private_subnet].subnet_mask = (subnet_mask >> 8) << 8;
ipa_num_private_subnet++;
/* IPACM private subnet set changes */
data_fid = (ipacm_event_data_fid *)malloc(sizeof(ipacm_event_data_fid));
if(data_fid == NULL)
{
IPACMERR("unable to allocate memory for event data_fid\n");
return IPACM_FAILURE;
}
data_fid->if_index = ipa_if_index; // already ipa index, not fid index
evt_data.event = IPA_PRIVATE_SUBNET_CHANGE_EVENT;
evt_data.evt_data = data_fid;
/* Insert IPA_PRIVATE_SUBNET_CHANGE_EVENT to command queue */
IPACM_EvtDispatcher::PostEvt(&evt_data);
return true;
}
IPACMERR("IPACM private subnet_addr overflow, total entry(%d)\n", ipa_num_private_subnet);
return false;
}
inline bool DelPrivateSubnet(uint32_t ip_addr, int ipa_if_index)
{
ipacm_cmd_q_data evt_data;
ipacm_event_data_fid *data_fid;
for(int cnt=0; cnt<ipa_num_private_subnet; cnt++)
{
if(private_subnet_table[cnt].subnet_addr == ip_addr)
{
IPACMDBG("Found private subnet_addr as: 0x%x in entry(%d) \n", ip_addr, cnt);
for (; cnt < ipa_num_private_subnet - 1; cnt++)
{
private_subnet_table[cnt].subnet_addr = private_subnet_table[cnt+1].subnet_addr;
}
ipa_num_private_subnet = ipa_num_private_subnet - 1;
/* IPACM private subnet set changes */
data_fid = (ipacm_event_data_fid *)malloc(sizeof(ipacm_event_data_fid));
if(data_fid == NULL)
{
IPACMERR("unable to allocate memory for event data_fid\n");
return IPACM_FAILURE;
}
data_fid->if_index = ipa_if_index; // already ipa index, not fid index
evt_data.event = IPA_PRIVATE_SUBNET_CHANGE_EVENT;
evt_data.evt_data = data_fid;
/* Insert IPA_PRIVATE_SUBNET_CHANGE_EVENT to command queue */
IPACM_EvtDispatcher::PostEvt(&evt_data);
return true;
}
}
IPACMDBG("can't find private subnet_addr as: 0x%x \n", ip_addr);
return false;
}
#endif /* defined(FEATURE_IPA_ANDROID)*/
static const char *DEVICE_NAME_ODU;
private:
static IPACM_Config *pInstance;
static const char *DEVICE_NAME;
IPACM_Config(void);
int m_fd; /* File descriptor of the IPA device node /dev/ipa */
uint8_t qmap_id;
ipacm_ext_prop ext_prop_v4;
ipacm_ext_prop ext_prop_v6;
};
#endif /* IPACM_CONFIG */

104
data-ipa-cfg-mgr/ipacm/inc/IPACM_ConntrackClient.h
View File

@@ -1,104 +0,0 @@
/*
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 <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>
#include <sys/inotify.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);
static int IPA_Conntrack_Filters_Ignore_Bridge_Addrs(struct nfct_filter *filter);
static int IPA_Conntrack_Filters_Ignore_Local_Iface(struct nfct_filter *, ipacm_event_iface_up *);
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 *);
static void UpdateUDPFilters(void *, bool);
static void UpdateTCPFilters(void *, bool);
static void Read_TcpUdp_Timeout(char *in, int len);
static IPACM_ConntrackClient* GetInstance();
#ifdef IPACM_DEBUG
#define iptodot(X,Y) \
IPACMLOG(" %s(0x%x): %d.%d.%d.%d\n", X, Y, ((Y>>24) & 0xFF), ((Y>>16) & 0xFF), ((Y>>8) & 0xFF), (Y & 0xFF));
#endif
#define log_nat(A,B,C,D,E,F) \
IPACMDBG_H("protocol %d Private IP: %d.%d.%d.%d\t Target IP: %d.%d.%d.%d\t private port: %d public port: %d %s",A,((B>>24) & 0xFF), ((B>>16) & 0xFF), ((B>>8) & 0xFF), (B & 0xFF), ((C>>24) & 0xFF), ((C>>16) & 0xFF),((C>>8) & 0xFF),(C & 0xFF),D,E,F);
};
#endif /* IPACM_CONNTRACK_FILTER_H */

123
data-ipa-cfg-mgr/ipacm/inc/IPACM_ConntrackListener.h
View File

@@ -1,123 +0,0 @@
/*
Copyright (c) 2013-2016, 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 <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.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"
#ifdef CT_OPT
#include "IPACM_LanToLan.h"
#endif
#define MAX_IFACE_ADDRESS 50
#define MAX_STA_CLNT_IFACES 10
#define STA_CLNT_SUBNET_MASK 0xFFFFFF00
using namespace std;
typedef struct _nat_entry_bundle
{
struct nf_conntrack *ct;
enum nf_conntrack_msg_type type;
nat_table_entry *rule;
bool isTempEntry;
}nat_entry_bundle;
class IPACM_ConntrackListener : public IPACM_Listener
{
private:
bool isCTReg;
bool isNatThreadStart;
bool WanUp;
NatApp *nat_inst;
int NatIfaceCnt;
int StaClntCnt;
NatIfaces *pNatIfaces;
uint32_t nat_iface_ipv4_addr[MAX_IFACE_ADDRESS];
uint32_t nonnat_iface_ipv4_addr[MAX_IFACE_ADDRESS];
uint32_t sta_clnt_ipv4_addr[MAX_STA_CLNT_IFACES];
IPACM_Config *pConfig;
#ifdef CT_OPT
IPACM_LanToLan *p_lan2lan;
#endif
void ProcessCTMessage(void *);
void ProcessTCPorUDPMsg(struct nf_conntrack *,
enum nf_conntrack_msg_type, u_int8_t);
void TriggerWANUp(void *);
void TriggerWANDown(uint32_t);
int CreateNatThreads(void);
int CreateConnTrackThreads(void);
bool AddIface(nat_table_entry *, bool *);
void AddORDeleteNatEntry(const nat_entry_bundle *);
void PopulateTCPorUDPEntry(struct nf_conntrack *, uint32_t, nat_table_entry *);
void CheckSTAClient(const nat_table_entry *, bool *);
int CheckNatIface(ipacm_event_data_all *, bool *);
void HandleNonNatIPAddr(void *, bool);
#ifdef CT_OPT
void ProcessCTV6Message(void *);
void HandleLan2Lan(struct nf_conntrack *,
enum nf_conntrack_msg_type, nat_table_entry* );
#endif
public:
char wan_ifname[IPA_IFACE_NAME_LEN];
uint32_t wan_ipaddr;
bool isStaMode;
IPACM_ConntrackListener();
void event_callback(ipa_cm_event_id, void *data);
inline bool isWanUp()
{
return WanUp;
}
void HandleNeighIpAddrAddEvt(ipacm_event_data_all *);
void HandleNeighIpAddrDelEvt(uint32_t);
void HandleSTAClientAddEvt(uint32_t);
void HandleSTAClientDelEvt(uint32_t);
};
extern IPACM_ConntrackListener *CtList;
#endif /* IPACM_CONNTRACK_LISTENER */

133
data-ipa-cfg-mgr/ipacm/inc/IPACM_Conntrack_NATApp.h
View File

@@ -1,133 +0,0 @@
/*
Copyright (c) 2013-2016, 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 MAX_TEMP_ENTRIES 25
#define IPACM_TCP_FULL_FILE_NAME "/proc/sys/net/ipv4/netfilter/ip_conntrack_tcp_timeout_established"
#define IPACM_UDP_FULL_FILE_NAME "/proc/sys/net/ipv4/netfilter/ip_conntrack_udp_timeout_stream"
typedef struct _nat_table_entry
{
uint32_t private_ip;
uint16_t private_port;
uint32_t target_ip;
uint16_t target_port;
uint32_t public_ip;
uint16_t public_port;
u_int8_t protocol;
uint32_t timestamp;
bool dst_nat;
bool enabled;
uint32_t rule_hdl;
}nat_table_entry;
#define CHK_TBL_HDL() if(nat_table_hdl == 0){ return -1; }
class NatApp
{
private:
static NatApp *pInstance;
nat_table_entry *cache;
nat_table_entry temp[MAX_TEMP_ENTRIES];
uint32_t pub_ip_addr;
uint32_t pub_ip_addr_pre;
uint32_t nat_table_hdl;
int curCnt, max_entries;
ipacm_alg *pALGPorts;
uint16_t nALGPort;
uint32_t tcp_timeout;
uint32_t udp_timeout;
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);
uint32_t GetTableHdl(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);
int DelEntriesOnClntDiscon(uint32_t);
int DelEntriesOnSTAClntDiscon(uint32_t);
void Read_TcpUdp_Timeout(void);
void AddTempEntry(const nat_table_entry *);
void CacheEntry(const nat_table_entry *);
void DeleteTempEntry(const nat_table_entry *);
void FlushTempEntries(uint32_t, bool, bool isDummy = false);
};
#endif /* IPACM_CONNTRACK_NATAPP_H */

354
data-ipa-cfg-mgr/ipacm/inc/IPACM_Defs.h
View File

@@ -1,354 +0,0 @@
/*
Copyright (c) 2013-2016, 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 <unistd.h>
#include <fcntl.h>
#include <linux/msm_ipa.h>
#include "IPACM_Log.h"
#ifdef USE_GLIB
#include <glib.h>
#define strlcpy g_strlcpy
#define strlcat g_strlcat
#endif
extern "C"
{
#include <libnetfilter_conntrack/libnetfilter_conntrack.h>
#include <libnetfilter_conntrack/libnetfilter_conntrack_tcp.h>
}
#define IF_NAME_LEN 16
#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 0 // dst mac first then src mac
#define IPA_ODU_PARTIAL_HDR_OFFSET 8 // dst mac first then src mac
#define IPA_WLAN_PARTIAL_HDR_NAME_v4 "IEEE802_3_v4"
#define IPA_WLAN_PARTIAL_HDR_NAME_v6 "IEEE802_3_v6"
#define IPA_DUMMY_ETH_HDR_NAME_v6 "ETH_dummy_v6"
#define IPA_WAN_PARTIAL_HDR_NAME_v4 "IEEE802_3_STA_v4"
#define IPA_WAN_PARTIAL_HDR_NAME_v6 "IEEE802_3_STA_v6"
#define IPA_ETH_HDR_NAME_v4 "IPACM_ETH_v4"
#define IPA_ETH_HDR_NAME_v6 "IPACM_ETH_v6"
#define IPA_ODU_HDR_NAME_v4 "IPACM_ODU_v4"
#define IPA_ODU_HDR_NAME_v6 "IPACM_ODU_v6"
#define IPA_MAX_IFACE_ENTRIES 20
#define IPA_MAX_PRIVATE_SUBNET_ENTRIES 3
#define IPA_MAX_ALG_ENTRIES 20
#define IPA_MAX_RM_ENTRY 6
#define IPV4_ADDR_LINKLOCAL 0xA9FE0000
#define IPV4_ADDR_LINKLOCAL_MASK 0xFFFF0000
#define V4_DEFAULT_ROUTE_TABLE_NAME "ipa_dflt_rt"
#define V4_LAN_ROUTE_TABLE_NAME "COMRTBLLANv4"
#define V4_WAN_ROUTE_TABLE_NAME "WANRTBLv4"
#define WAN_DL_ROUTE_TABLE_NAME "ipa_dflt_wan_rt"
#define V6_COMMON_ROUTE_TABLE_NAME "COMRTBLv6"
#define V6_WAN_ROUTE_TABLE_NAME "WANRTBLv6"
#define V4_ODU_ROUTE_TABLE_NAME "ODURTBLv4"
#define V6_ODU_ROUTE_TABLE_NAME "ODURTBLv6"
#define WWAN_QMI_IOCTL_DEVICE_NAME "/dev/wwan_ioctl"
#define IPA_DEVICE_NAME "/dev/ipa"
#define MAX_NUM_PROP 2
#ifndef FEATURE_IPA_V3
#define IPA_MAX_FLT_RULE 50
#else
#define IPA_MAX_FLT_RULE 100
#endif
#define TCP_FIN_SHIFT 16
#define TCP_SYN_SHIFT 17
#define TCP_RST_SHIFT 18
#define NUM_IPV6_PREFIX_FLT_RULE 1
/*---------------------------------------------------------------------------
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 32
#define IPA_MAX_NUM_WAN_CLIENTS 10
#define IPA_MAX_NUM_ETH_CLIENTS 15
#define IPA_MAX_NUM_AMPDU_RULE 15
#define IPA_MAC_ADDR_SIZE 6
/*===========================================================================
GLOBAL DEFINITIONS AND DECLARATIONS
===========================================================================*/
typedef enum
{
IPA_CFG_CHANGE_EVENT, /* NULL */
IPA_PRIVATE_SUBNET_CHANGE_EVENT, /* ipacm_event_data_fid */
IPA_FIREWALL_CHANGE_EVENT, /* NULL */
IPA_LINK_UP_EVENT, /* ipacm_event_data_fid */
IPA_LINK_DOWN_EVENT, /* ipacm_event_data_fid */
IPA_USB_LINK_UP_EVENT, /* ipacm_event_data_fid */
IPA_BRIDGE_LINK_UP_EVENT, /* ipacm_event_data_all */
IPA_WAN_EMBMS_LINK_UP_EVENT, /* ipacm_event_data_mac */
IPA_ADDR_ADD_EVENT, /* ipacm_event_data_addr */
IPA_ADDR_DEL_EVENT, /* no use */
IPA_ROUTE_ADD_EVENT, /* ipacm_event_data_addr */
IPA_ROUTE_DEL_EVENT, /* ipacm_event_data_addr */
IPA_WAN_UPSTREAM_ROUTE_ADD_EVENT, /* ipacm_event_data_fid */
IPA_WAN_UPSTREAM_ROUTE_DEL_EVENT, /* ipacm_event_data_fid */
IPA_WLAN_AP_LINK_UP_EVENT, /* ipacm_event_data_mac */
IPA_WLAN_STA_LINK_UP_EVENT, /* ipacm_event_data_mac */
IPA_WLAN_LINK_DOWN_EVENT, /* ipacm_event_data_mac */
IPA_WLAN_CLIENT_ADD_EVENT, /* ipacm_event_data_mac */
IPA_WLAN_CLIENT_ADD_EVENT_EX, /* ipacm_event_data_wlan_ex */
IPA_WLAN_CLIENT_DEL_EVENT, /* ipacm_event_data_mac */
IPA_WLAN_CLIENT_POWER_SAVE_EVENT, /* ipacm_event_data_mac */
IPA_WLAN_CLIENT_RECOVER_EVENT, /* ipacm_event_data_mac */
IPA_NEW_NEIGH_EVENT, /* ipacm_event_data_all */
IPA_DEL_NEIGH_EVENT, /* ipacm_event_data_all */
IPA_NEIGH_CLIENT_IP_ADDR_ADD_EVENT, /* ipacm_event_data_all */
IPA_NEIGH_CLIENT_IP_ADDR_DEL_EVENT, /* ipacm_event_data_all */
IPA_SW_ROUTING_ENABLE, /* NULL */
IPA_SW_ROUTING_DISABLE, /* NULL */
IPA_PROCESS_CT_MESSAGE, /* ipacm_ct_evt_data */
IPA_PROCESS_CT_MESSAGE_V6, /* ipacm_ct_evt_data */
IPA_LAN_TO_LAN_NEW_CONNECTION, /* ipacm_event_connection */
IPA_LAN_TO_LAN_DEL_CONNECTION, /* ipacm_event_connection */
IPA_WLAN_SWITCH_TO_SCC, /* No Data */
IPA_WLAN_SWITCH_TO_MCC, /* No Data */
IPA_CRADLE_WAN_MODE_SWITCH, /* ipacm_event_cradle_wan_mode */
IPA_WAN_XLAT_CONNECT_EVENT, /* ipacm_event_data_fid */
IPA_TETHERING_STATS_UPDATE_EVENT, /* ipacm_event_data_fid */
IPA_NETWORK_STATS_UPDATE_EVENT, /* ipacm_event_data_fid */
IPA_EXTERNAL_EVENT_MAX,
IPA_HANDLE_WAN_UP, /* ipacm_event_iface_up */
IPA_HANDLE_WAN_DOWN, /* ipacm_event_iface_up */
IPA_HANDLE_WAN_UP_V6, /* NULL */
IPA_HANDLE_WAN_DOWN_V6, /* NULL */
IPA_HANDLE_WAN_UP_TETHER, /* ipacm_event_iface_up_tehter */
IPA_HANDLE_WAN_DOWN_TETHER, /* ipacm_event_iface_up_tehter */
IPA_HANDLE_WAN_UP_V6_TETHER, /* ipacm_event_iface_up_tehter */
IPA_HANDLE_WAN_DOWN_V6_TETHER, /* ipacm_event_iface_up_tehter */
IPA_HANDLE_WLAN_UP, /* ipacm_event_iface_up */
IPA_HANDLE_LAN_UP, /* ipacm_event_iface_up */
IPA_ETH_BRIDGE_IFACE_UP, /* ipacm_event_eth_bridge*/
IPA_ETH_BRIDGE_IFACE_DOWN, /* ipacm_event_eth_bridge*/
IPA_ETH_BRIDGE_CLIENT_ADD, /* ipacm_event_eth_bridge */
IPA_ETH_BRIDGE_CLIENT_DEL, /* ipacm_event_eth_bridge*/
IPA_ETH_BRIDGE_WLAN_SCC_MCC_SWITCH, /* ipacm_event_eth_bridge*/
IPA_LAN_DELETE_SELF, /* ipacm_event_data_fid */
IPACM_EVENT_MAX
} ipa_cm_event_id;
typedef struct
{
uint8_t num_rule;
uint32_t rule_hdl[MAX_NUM_PROP];
} lan_to_lan_rt_rule_hdl;
typedef enum
{
LAN_IF = 0,
WLAN_IF,
WAN_IF,
VIRTUAL_IF,
ETH_IF,
EMBMS_IF,
ODU_IF,
UNKNOWN_IF
} ipacm_iface_type;
typedef enum
{
ROUTER = 0,
BRIDGE
} ipacm_cradle_iface_mode;
typedef enum
{
FULL,
INTERNET
} ipacm_wlan_access_mode;
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;
ipacm_cradle_iface_mode if_mode;
ipacm_wlan_access_mode wlan_mode;
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[IPA_MAC_ADDR_SIZE];
} ipacm_event_data_all;
class IPACM_Lan;
typedef struct
{
ipacm_cradle_iface_mode cradle_wan_mode;
} ipacm_event_cradle_wan_mode;
typedef struct
{
IPACM_Lan *p_iface;
ipa_ip_type iptype;
uint8_t mac_addr[6];
} ipacm_event_eth_bridge;
typedef struct
{
enum ipa_ip_type iptype;
uint32_t src_ipv4_addr;
uint32_t dst_ipv4_addr;
uint32_t src_ipv6_addr[4];
uint32_t dst_ipv6_addr[4];
} ipacm_event_connection;
typedef struct _ipacm_event_data_fid
{
int if_index;
} ipacm_event_data_fid;
typedef struct
{
ipacm_iface_type if_cat;
} ipacm_event_data_if_cat;
typedef struct _ipacm_event_data_iptype
{
int if_index;
int if_index_tether;
enum ipa_ip_type iptype;
#ifdef IPA_WAN_MSG_IPv6_ADDR_GW_LEN
uint32_t ipv4_addr_gw;
uint32_t ipv6_addr_gw[4];
#endif
} ipacm_event_data_iptype;
typedef struct _ipacm_event_data_addr
{
enum ipa_ip_type iptype;
int if_index;
uint32_t ipv4_addr_gw;
uint32_t ipv4_addr;
uint32_t ipv4_addr_mask;
uint32_t ipv6_addr[4];
uint32_t ipv6_addr_mask[4];
uint32_t ipv6_addr_gw[4];
} ipacm_event_data_addr;
typedef struct _ipacm_event_data_mac
{
int if_index;
int ipa_if_cate;
uint8_t mac_addr[IPA_MAC_ADDR_SIZE];
} ipacm_event_data_mac;
typedef struct
{
int if_index;
uint8_t num_of_attribs;
struct ipa_wlan_hdr_attrib_val attribs[0];
} ipacm_event_data_wlan_ex;
typedef struct _ipacm_event_iface_up
{
char ifname[IPA_IFACE_NAME_LEN];
uint32_t ipv4_addr;
uint32_t addr_mask;
uint32_t ipv6_prefix[2];
bool is_sta;
uint8_t xlat_mux_id;
}ipacm_event_iface_up;
typedef struct _ipacm_event_iface_up_tether
{
uint32_t if_index_tether;
uint32_t ipv6_prefix[2];
bool is_sta;
}ipacm_event_iface_up_tehter;
typedef enum
{
Q6_WAN = 0,
WLAN_WAN,
ECM_WAN
} ipacm_wan_iface_type;
typedef struct _ipacm_ifacemgr_data
{
int if_index;
ipacm_wan_iface_type if_type;
uint8_t mac_addr[IPA_MAC_ADDR_SIZE];
}ipacm_ifacemgr_data;
#endif /* IPA_CM_DEFS_H */

76
data-ipa-cfg-mgr/ipacm/inc/IPACM_EvtDispatcher.h
View File

@@ -1,76 +0,0 @@
/*
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 */

76
data-ipa-cfg-mgr/ipacm/inc/IPACM_Filtering.h
View File

@@ -1,76 +0,0 @@
/*
Copyright (c) 2013-2016, 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>
#include <linux/rmnet_ipa_fd_ioctl.h>
class IPACM_Filtering
{
public:
IPACM_Filtering();
~IPACM_Filtering();
bool AddFilteringRule(struct ipa_ioc_add_flt_rule const *ruleTable);
bool AddFilteringRuleAfter(struct ipa_ioc_add_flt_rule_after 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);
bool AddWanDLFilteringRule(struct ipa_ioc_add_flt_rule const *rule_table_v4, struct ipa_ioc_add_flt_rule const * rule_table_v6, uint8_t mux_id);
bool SendFilteringRuleIndex(struct ipa_fltr_installed_notif_req_msg_v01* table);
bool ModifyFilteringRule(struct ipa_ioc_mdfy_flt_rule* ruleTable);
ipa_filter_action_enum_v01 GetQmiFilterAction(ipa_flt_action action);
private:
static const char *DEVICE_NAME;
int fd; /* File descriptor of the IPA device node /dev/ipa */
};
#endif //IPACM_FILTERING_H

70
data-ipa-cfg-mgr/ipacm/inc/IPACM_Header.h
View File

@@ -1,70 +0,0 @@
/*
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);
bool AddHeaderProcCtx(struct ipa_ioc_add_hdr_proc_ctx* pHeader);
bool DeleteHeaderProcCtx(uint32_t hdl);
IPACM_Header();
~IPACM_Header();
bool DeviceNodeIsOpened();
};
#endif

153
data-ipa-cfg-mgr/ipacm/inc/IPACM_Iface.h
View File

@@ -1,153 +0,0 @@
/*
Copyright (c) 2013-2016, 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_Config.h"
#include "IPACM_Defs.h"
#include <string.h>
/* current support 2 ipv6-address*/
#define MAX_DEFAULT_v4_ROUTE_RULES 1
#define MAX_DEFAULT_v6_ROUTE_RULES 2
#define IPV4_DEFAULT_FILTERTING_RULES 3
#ifdef FEATURE_IPA_ANDROID
#define IPV6_DEFAULT_FILTERTING_RULES 6
#else
#define IPV6_DEFAULT_FILTERTING_RULES 3
#endif
#define IPV6_DEFAULT_LAN_FILTERTING_RULES 1
#define IPV6_NUM_ADDR 3
#define MAX_SOFTWAREROUTING_FILTERTING_RULES 2
#define INVALID_IFACE -1
/* 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 category */
ipacm_iface_type ipa_if_cate;
/* IPACM interface name */
char dev_name[IF_NAME_LEN];
/* IPACM interface iptype v4, v6 or both */
ipa_ip_type ip_type;
/* IPACM interface v6 ip-address*/
uint32_t ipv6_addr[MAX_DEFAULT_v6_ROUTE_RULES][4];
uint32_t software_routing_fl_rule_hdl[MAX_SOFTWAREROUTING_FILTERTING_RULES];
bool softwarerouting_act;
/* IPACM number of default route rules for ipv6*/
int num_dft_rt_v6;
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];
/* create additional set of v6 RT-rules in Wanv6RT table*/
uint32_t dft_rt_rule_hdl[MAX_DEFAULT_v4_ROUTE_RULES+2*MAX_DEFAULT_v6_ROUTE_RULES];
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 ipa_interface ipv4_addr by given linux interface_index */
static void iface_addr_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);
/* Change IP Type.*/
void config_ip_type(ipa_ip_type iptype);
/* Get interface index */
virtual int ipa_get_if_index(char * if_name, int * if_index);
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 */

90
data-ipa-cfg-mgr/ipacm/inc/IPACM_IfaceManager.h
View File

@@ -1,90 +0,0 @@
/*
Copyright (c) 2013-2016, 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_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(ipacm_ifacemgr_data *);
/* 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 */

390
data-ipa-cfg-mgr/ipacm/inc/IPACM_Lan.h
View File

@@ -1,390 +0,0 @@
/*
Copyright (c) 2013-2016, 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"
#include "IPACM_Config.h"
#include "IPACM_Conntrack_NATApp.h"
#define IPA_WAN_DEFAULT_FILTER_RULE_HANDLES 1
#define IPA_PRIV_SUBNET_FILTER_RULE_HANDLES 3
#define IPA_NUM_ODU_ROUTE_RULES 2
#define MAX_WAN_UL_FILTER_RULES MAX_NUM_EXT_PROPS
#define NUM_IPV4_ICMP_FLT_RULE 1
#define NUM_IPV6_ICMP_FLT_RULE 1
/* ndc bandwidth ipatetherstats <ifaceIn> <ifaceOut> */
/* <in->out_bytes> <in->out_pkts> <out->in_bytes> <out->in_pkts */
#define PIPE_STATS "%s %s %lu %lu %lu %lu"
#define IPA_PIPE_STATS_FILE_NAME "/data/misc/ipa/tether_stats"
/* store each lan-iface unicast routing rule and its handler*/
struct ipa_lan_rt_rule
{
ipa_ip_type ip;
uint32_t v4_addr;
uint32_t v4_addr_mask;
uint32_t v6_addr[4];
uint32_t rt_rule_hdl[0];
};
/* Support multiple eth client */
typedef struct _eth_client_rt_hdl
{
uint32_t eth_rt_rule_hdl_v4;
uint32_t eth_rt_rule_hdl_v6[IPV6_NUM_ADDR];
uint32_t eth_rt_rule_hdl_v6_wan[IPV6_NUM_ADDR];
}eth_client_rt_hdl;
typedef struct _ipa_eth_client
{
uint8_t mac[IPA_MAC_ADDR_SIZE];
uint32_t v4_addr;
uint32_t v6_addr[IPV6_NUM_ADDR][4];
uint32_t hdr_hdl_v4;
uint32_t hdr_hdl_v6;
bool route_rule_set_v4;
int route_rule_set_v6;
bool ipv4_set;
int ipv6_set;
bool ipv4_header_set;
bool ipv6_header_set;
eth_client_rt_hdl eth_rt_hdl[0]; /* depends on number of tx properties */
}ipa_eth_client;
/* 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_MAX_PRIVATE_SUBNET_ENTRIES];
/* LAN-iface's callback function */
void event_callback(ipa_cm_event_id event, void *data);
virtual int handle_wan_up(ipa_ip_type ip_type);
/* configure filter rule for wan_up event*/
virtual int handle_wan_up_ex(ipacm_ext_prop* ext_prop, ipa_ip_type iptype, uint8_t xlat_mux_id);
/* delete filter rule for wan_down event*/
virtual int handle_wan_down(bool is_sta_mode);
/* delete filter rule for wan_down event*/
virtual int handle_wan_down_v6(bool is_sta_mode);
/* 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);
int handle_addr_evt_odu_bridge(ipacm_event_data_addr* data);
int handle_del_ipv6_addr(ipacm_event_data_all *data);
static bool odu_up;
/* install UL filter rule from Q6 */
virtual int handle_uplink_filter_rule(ipacm_ext_prop* prop, ipa_ip_type iptype, uint8_t xlat_mux_id);
int handle_cradle_wan_mode_switch(bool is_wan_bridge_mode);
int install_ipv4_icmp_flt_rule();
/* add header processing context and return handle to lan2lan controller */
int eth_bridge_add_hdr_proc_ctx(ipa_hdr_l2_type peer_l2_hdr_type, uint32_t *hdl);
/* add routing rule and return handle to lan2lan controller */
int eth_bridge_add_rt_rule(uint8_t *mac, char *rt_tbl_name, uint32_t hdr_proc_ctx_hdl,
ipa_hdr_l2_type peer_l2_hdr_type, ipa_ip_type iptype, uint32_t *rt_rule_hdl, int *rt_rule_count);
/* modify routing rule*/
int eth_bridge_modify_rt_rule(uint8_t *mac, uint32_t hdr_proc_ctx_hdl,
ipa_hdr_l2_type peer_l2_hdr_type, ipa_ip_type iptype, uint32_t *rt_rule_hdl, int rt_rule_count);
/* add filtering rule and return handle to lan2lan controller */
int eth_bridge_add_flt_rule(uint8_t *mac, uint32_t rt_tbl_hdl, ipa_ip_type iptype, uint32_t *flt_rule_hdl);
/* delete filtering rule */
int eth_bridge_del_flt_rule(uint32_t flt_rule_hdl, ipa_ip_type iptype);
/* delete routing rule */
int eth_bridge_del_rt_rule(uint32_t rt_rule_hdl, ipa_ip_type iptype);
/* delete header processing context */
int eth_bridge_del_hdr_proc_ctx(uint32_t hdr_proc_ctx_hdl);
protected:
int each_client_rt_rule_count[IPA_IP_MAX];
uint32_t eth_bridge_flt_rule_offset[IPA_IP_MAX];
/* mac address has to be provided for client related events */
void eth_bridge_post_event(ipa_cm_event_id evt, ipa_ip_type iptype, uint8_t *mac);
virtual int add_dummy_private_subnet_flt_rule(ipa_ip_type iptype);
int handle_private_subnet_android(ipa_ip_type iptype);
int reset_to_dummy_flt_rule(ipa_ip_type iptype, uint32_t rule_hdl);
virtual int install_ipv6_prefix_flt_rule(uint32_t* prefix);
virtual void delete_ipv6_prefix_flt_rule();
int install_ipv6_icmp_flt_rule();
void post_del_self_evt();
/* handle tethering stats */
int handle_tethering_stats_event(ipa_get_data_stats_resp_msg_v01 *data);
/* handle tethering client */
int handle_tethering_client(bool reset, ipacm_client_enum ipa_client);
/* store ipv4 UL filter rule handlers from Q6*/
uint32_t wan_ul_fl_rule_hdl_v4[MAX_WAN_UL_FILTER_RULES];
/* store ipv6 UL filter rule handlers from Q6*/
uint32_t wan_ul_fl_rule_hdl_v6[MAX_WAN_UL_FILTER_RULES];
uint32_t ipv4_icmp_flt_rule_hdl[NUM_IPV4_ICMP_FLT_RULE];
uint32_t ipv6_prefix_flt_rule_hdl[NUM_IPV6_PREFIX_FLT_RULE];
uint32_t ipv6_icmp_flt_rule_hdl[NUM_IPV6_ICMP_FLT_RULE];
int num_wan_ul_fl_rule_v4;
int num_wan_ul_fl_rule_v6;
bool is_active;
bool modem_ul_v4_set;
bool modem_ul_v6_set;
uint32_t if_ipv4_subnet;
uint32_t ipv6_prefix[2];
private:
/* get hdr proc ctx type given source and destination l2 hdr type */
ipa_hdr_proc_type eth_bridge_get_hdr_proc_type(ipa_hdr_l2_type t1, ipa_hdr_l2_type t2);
/* get partial header (header template of hdr proc ctx) */
int eth_bridge_get_hdr_template_hdl(uint32_t* hdr_hdl);
/* dynamically allocate lan iface's unicast routing rule structure */
bool is_mode_switch; /* indicate mode switch, need post internal up event */
int eth_client_len;
ipa_eth_client *eth_client;
int header_name_count;
int num_eth_client;
NatApp *Nat_App;
int ipv6_set;
uint32_t ODU_hdr_hdl_v4, ODU_hdr_hdl_v6;
uint32_t *odu_route_rule_v4_hdl;
uint32_t *odu_route_rule_v6_hdl;
bool ipv4_header_set;
bool ipv6_header_set;
inline ipa_eth_client* get_client_memptr(ipa_eth_client *param, int cnt)
{
char *ret = ((char *)param) + (eth_client_len * cnt);
return (ipa_eth_client *)ret;
}
inline int get_eth_client_index(uint8_t *mac_addr)
{
int cnt;
int num_eth_client_tmp = num_eth_client;
IPACMDBG_H("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_eth_client_tmp; cnt++)
{
IPACMDBG_H("stored MAC %02x:%02x:%02x:%02x:%02x:%02x\n",
get_client_memptr(eth_client, cnt)->mac[0],
get_client_memptr(eth_client, cnt)->mac[1],
get_client_memptr(eth_client, cnt)->mac[2],
get_client_memptr(eth_client, cnt)->mac[3],
get_client_memptr(eth_client, cnt)->mac[4],
get_client_memptr(eth_client, cnt)->mac[5]);
if(memcmp(get_client_memptr(eth_client, cnt)->mac,
mac_addr,
sizeof(get_client_memptr(eth_client, cnt)->mac)) == 0)
{
IPACMDBG_H("Matched client index: %d\n", cnt);
return cnt;
}
}
return IPACM_INVALID_INDEX;
}
inline int delete_eth_rtrules(int clt_indx, ipa_ip_type iptype)
{
uint32_t tx_index;
uint32_t rt_hdl;
int num_v6;
if(iptype == IPA_IP_v4)
{
for(tx_index = 0; tx_index < iface_query->num_tx_props; tx_index++)
{
if((tx_prop->tx[tx_index].ip == IPA_IP_v4) && (get_client_memptr(eth_client, clt_indx)->route_rule_set_v4==true)) /* for ipv4 */
{
IPACMDBG_H("Delete client index %d ipv4 RT-rules for tx:%d\n",clt_indx,tx_index);
rt_hdl = get_client_memptr(eth_client, clt_indx)->eth_rt_hdl[tx_index].eth_rt_rule_hdl_v4;
if(m_routing.DeleteRoutingHdl(rt_hdl, IPA_IP_v4) == false)
{
return IPACM_FAILURE;
}
}
} /* end of for loop */
/* clean the ipv4 RT rules for eth-client:clt_indx */
if(get_client_memptr(eth_client, clt_indx)->route_rule_set_v4==true) /* for ipv4 */
{
get_client_memptr(eth_client, clt_indx)->route_rule_set_v4 = false;
}
}
if(iptype == IPA_IP_v6)
{
for(tx_index = 0; tx_index < iface_query->num_tx_props; tx_index++)
{
if((tx_prop->tx[tx_index].ip == IPA_IP_v6) && (get_client_memptr(eth_client, clt_indx)->route_rule_set_v6 != 0)) /* for ipv6 */
{
for(num_v6 =0;num_v6 < get_client_memptr(eth_client, clt_indx)->route_rule_set_v6;num_v6++)
{
IPACMDBG_H("Delete client index %d ipv6 RT-rules for %d-st ipv6 for tx:%d\n", clt_indx,num_v6,tx_index);
rt_hdl = get_client_memptr(eth_client, clt_indx)->eth_rt_hdl[tx_index].eth_rt_rule_hdl_v6[num_v6];
if(m_routing.DeleteRoutingHdl(rt_hdl, IPA_IP_v6) == false)
{
return IPACM_FAILURE;
}
rt_hdl = get_client_memptr(eth_client, clt_indx)->eth_rt_hdl[tx_index].eth_rt_rule_hdl_v6_wan[num_v6];
if(m_routing.DeleteRoutingHdl(rt_hdl, IPA_IP_v6) == false)
{
return IPACM_FAILURE;
}
}
}
} /* end of for loop */
/* clean the ipv6 RT rules for eth-client:clt_indx */
if(get_client_memptr(eth_client, clt_indx)->route_rule_set_v6 != 0) /* for ipv6 */
{
get_client_memptr(eth_client, clt_indx)->route_rule_set_v6 = 0;
}
}
return IPACM_SUCCESS;
}
/* handle eth client initial, construct full headers (tx property) */
int handle_eth_hdr_init(uint8_t *mac_addr);
/* handle eth client ip-address */
int handle_eth_client_ipaddr(ipacm_event_data_all *data);
/* handle eth client routing rule*/
int handle_eth_client_route_rule(uint8_t *mac_addr, ipa_ip_type iptype);
/*handle eth client del mode*/
int handle_eth_client_down_evt(uint8_t *mac_addr);
/* handle odu client initial, construct full headers (tx property) */
int handle_odu_hdr_init(uint8_t *mac_addr);
/* handle odu default route rule configuration */
int handle_odu_route_add();
/* handle odu default route rule deletion */
int handle_odu_route_del();
/*handle lan iface down event*/
int handle_down_evt();
/*handle reset usb-client rt-rules */
int handle_lan_client_reset_rt(ipa_ip_type iptype);
};
#endif /* IPACM_LAN_H */

202
data-ipa-cfg-mgr/ipacm/inc/IPACM_LanToLan.h
View File

@@ -1,202 +0,0 @@
/*
Copyright (c) 2014, 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_LanToLan.h
*
* Created on: Mar 4th, 2014
* Author: Shihuan Liu
*/
#ifndef IPACM_LANTOLAN_H
#define IPACM_LANTOLAN_H
#include <stdint.h>
#include "linux/msm_ipa.h"
#include "IPACM_Iface.h"
#include "IPACM_Defs.h"
#include "IPACM_Lan.h"
#ifdef FEATURE_IPA_ANDROID
#include <libxml/list.h>
#else/* defined(FEATURE_IPA_ANDROID) */
#include <list>
#endif /* ndefined(FEATURE_IPA_ANDROID)*/
#define MAX_NUM_CACHED_CLIENT_ADD_EVENT 10
#define MAX_NUM_IFACE 10
#define MAX_NUM_CLIENT 16
struct rt_rule_info
{
int num_hdl[IPA_IP_MAX]; /* one client may need more than one routing rules on the same routing table depending on tx_prop */
uint32_t rule_hdl[IPA_IP_MAX][MAX_NUM_PROP];
};
struct client_info
{
uint8_t mac_addr[6];
rt_rule_info inter_iface_rt_rule_hdl[IPA_HDR_L2_MAX]; /* routing rule handles of inter interface communication based on source l2 header type */
rt_rule_info intra_iface_rt_rule_hdl; /* routing rule handles of inter interface communication */
};
struct flt_rule_info
{
client_info *p_client;
uint32_t flt_rule_hdl[IPA_IP_MAX];
};
struct peer_iface_info
{
class IPACM_LanToLan_Iface *peer;
char rt_tbl_name_for_rt[IPA_IP_MAX][IPA_RESOURCE_NAME_MAX];
char rt_tbl_name_for_flt[IPA_IP_MAX][IPA_RESOURCE_NAME_MAX];
list<flt_rule_info> flt_rule;
};
class IPACM_LanToLan_Iface
{
public:
IPACM_LanToLan_Iface(IPACM_Lan *p_iface);
~IPACM_LanToLan_Iface();
void add_client_rt_rule_for_new_iface();
void add_all_inter_interface_client_flt_rule(ipa_ip_type iptype);
void add_all_intra_interface_client_flt_rule(ipa_ip_type iptype);
void handle_down_event();
void handle_wlan_scc_mcc_switch();
void handle_intra_interface_info();
void handle_new_iface_up(char rt_tbl_name_for_flt[][IPA_RESOURCE_NAME_MAX], char rt_tbl_name_for_rt[][IPA_RESOURCE_NAME_MAX],
IPACM_LanToLan_Iface *peer_iface);
void handle_client_add(uint8_t *mac);
void handle_client_del(uint8_t *mac);
void print_data_structure_info();
IPACM_Lan* get_iface_pointer();
bool get_m_is_ip_addr_assigned(ipa_ip_type iptype);
void set_m_is_ip_addr_assigned(ipa_ip_type iptype, bool value);
bool get_m_support_inter_iface_offload();
bool get_m_support_intra_iface_offload();
void increment_ref_cnt_peer_l2_hdr_type(ipa_hdr_l2_type peer_l2_type);
void decrement_ref_cnt_peer_l2_hdr_type(ipa_hdr_l2_type peer_l2_type);
private:
IPACM_Lan *m_p_iface;
bool m_is_ip_addr_assigned[IPA_IP_MAX];
bool m_support_inter_iface_offload;
bool m_support_intra_iface_offload;
int ref_cnt_peer_l2_hdr_type[IPA_HDR_L2_MAX]; /* reference count of l2 header type of peer interfaces */
uint32_t hdr_proc_ctx_for_inter_interface[IPA_HDR_L2_MAX];
uint32_t hdr_proc_ctx_for_intra_interface;
list<client_info> m_client_info; /* client list */
list<peer_iface_info> m_peer_iface_info; /* peer information list */
/* The following members are for intra-interface communication*/
peer_iface_info m_intra_interface_info;
void add_one_client_flt_rule(IPACM_LanToLan_Iface *peer_iface, client_info *client);
void add_client_flt_rule(peer_iface_info *peer, client_info *client, ipa_ip_type iptype);
void del_one_client_flt_rule(IPACM_LanToLan_Iface *peer_iface, client_info *client);
void del_client_flt_rule(peer_iface_info *peer, client_info *client);
void add_client_rt_rule(peer_iface_info *peer, client_info *client);
void del_client_rt_rule(peer_iface_info *peer, client_info *client);
void clear_all_flt_rule_for_one_peer_iface(peer_iface_info *peer);
void clear_all_rt_rule_for_one_peer_iface(peer_iface_info *peer);
void add_hdr_proc_ctx(ipa_hdr_l2_type peer_l2_type);
void del_hdr_proc_ctx(ipa_hdr_l2_type peer_l2_type);
void print_peer_info(peer_iface_info *peer_info);
};
class IPACM_LanToLan : public IPACM_Listener
{
public:
IPACM_LanToLan();
private:
~IPACM_LanToLan();
list<class IPACM_LanToLan_Iface> m_iface;
list<ipacm_event_eth_bridge> m_cached_client_add_event;
void handle_iface_up(ipacm_event_eth_bridge *data);
void handle_iface_down(ipacm_event_eth_bridge *data);
void handle_client_add(ipacm_event_eth_bridge *data);
void handle_client_del(ipacm_event_eth_bridge *data);
void handle_wlan_scc_mcc_switch(ipacm_event_eth_bridge *data);
void handle_new_iface_up(IPACM_LanToLan_Iface *new_iface, IPACM_LanToLan_Iface *exist_iface);
void event_callback(ipa_cm_event_id event, void* param);
void handle_cached_client_add_event(IPACM_Lan *p_iface);
void clear_cached_client_add_event(IPACM_Lan *p_iface);
void print_data_structure_info();
};
#endif

54
data-ipa-cfg-mgr/ipacm/inc/IPACM_Listener.h
View File

@@ -1,54 +0,0 @@
/*
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;
virtual ~IPACM_Listener(void) {};
};
#endif /* IPACM_LISTENER_H */

102
data-ipa-cfg-mgr/ipacm/inc/IPACM_Log.h
View File

@@ -1,102 +0,0 @@
/*
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>
#include <syslog.h>
#define MAX_BUF_LEN 256
#ifdef FEATURE_IPA_ANDROID
#define IPACMLOG_FILE "/dev/socket/ipacm_log_file"
#else/* defined(FEATURE_IPA_ANDROID) */
#define IPACMLOG_FILE "/etc/ipacm_log_file"
#endif /* defined(NOT FEATURE_IPA_ANDROID)*/
typedef struct ipacm_log_buffer_s {
char user_data[MAX_BUF_LEN];
} ipacm_log_buffer_t;
void ipacm_log_send( void * user_data);
static char buffer_send[MAX_BUF_LEN];
static char dmesg_cmd[MAX_BUF_LEN];
#define IPACMDBG_DMESG(fmt, ...) memset(buffer_send, 0, MAX_BUF_LEN);\
snprintf(buffer_send,MAX_BUF_LEN,"%s:%d %s: " fmt, __FILE__, __LINE__, __FUNCTION__, ##__VA_ARGS__);\
ipacm_log_send (buffer_send);\
printf("%s:%d %s() " fmt, __FILE__, __LINE__, __FUNCTION__, ##__VA_ARGS__); \
memset(dmesg_cmd, 0, MAX_BUF_LEN);\
snprintf(dmesg_cmd, MAX_BUF_LEN, "echo %s > /dev/kmsg", buffer_send);\
system(dmesg_cmd);
#ifdef DEBUG
#define PERROR(fmt) memset(buffer_send, 0, MAX_BUF_LEN);\
snprintf(buffer_send,MAX_BUF_LEN,"%s:%d %s()", __FILE__, __LINE__, __FUNCTION__);\
ipacm_log_send (buffer_send); \
perror(fmt);
#define IPACMERR(fmt, ...) memset(buffer_send, 0, MAX_BUF_LEN);\
snprintf(buffer_send,MAX_BUF_LEN,"ERROR: %s:%d %s() " fmt, __FILE__, __LINE__, __FUNCTION__, ##__VA_ARGS__);\
ipacm_log_send (buffer_send);\
printf("ERROR: %s:%d %s() " fmt, __FILE__, __LINE__, __FUNCTION__, ##__VA_ARGS__);
#define IPACMDBG_H(fmt, ...) memset(buffer_send, 0, MAX_BUF_LEN);\
snprintf(buffer_send,MAX_BUF_LEN,"%s:%d %s() " fmt, __FILE__, __LINE__, __FUNCTION__, ##__VA_ARGS__);\
ipacm_log_send (buffer_send);\
printf("%s:%d %s() " fmt, __FILE__, __LINE__, __FUNCTION__, ##__VA_ARGS__);
#else
#define PERROR(fmt) perror(fmt)
#define IPACMERR(fmt, ...) printf("ERR: %s:%d %s() " fmt, __FILE__, __LINE__, __FUNCTION__, ##__VA_ARGS__);
#define IPACMDBG_H(fmt, ...) printf("%s:%d %s() " fmt, __FILE__, __LINE__, __FUNCTION__, ##__VA_ARGS__);
#endif
#define IPACMDBG(fmt, ...) printf("%s:%d %s() " fmt, __FILE__, __LINE__, __FUNCTION__, ##__VA_ARGS__);
#define IPACMLOG(fmt, ...) printf(fmt, ##__VA_ARGS__);
#ifdef __cplusplus
}
#endif
#endif /* IPACM_LOG_H */

81
data-ipa-cfg-mgr/ipacm/inc/IPACM_Neighbor.h
View File

@@ -1,81 +0,0 @@
/*
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 100
struct ipa_neighbor_client
{
uint8_t mac_addr[6];
int iface_index;
uint32_t v4_addr;
int ipa_if_num;
};
class IPACM_Neighbor : public IPACM_Listener
{
public:
IPACM_Neighbor();
void event_callback(ipa_cm_event_id event,
void *data);
private:
int num_neighbor_client;
int circular_index;
ipa_neighbor_client neighbor_client[IPA_MAX_NUM_NEIGHBOR_CLIENTS];
};
#endif /* IPACM_NEIGHBOR_H */

223
data-ipa-cfg-mgr/ipacm/inc/IPACM_Netlink.h
View File

@@ -1,223 +0,0 @@
/*
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 (2048)
/*---------------------------------------------------------------------------
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;
struct sockaddr_storage local_addr;
struct sockaddr_storage bcast_addr;
struct sockaddr_storage acast_addr;
struct sockaddr_storage mcast_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 */

78
data-ipa-cfg-mgr/ipacm/inc/IPACM_Routing.h
View File

@@ -1,78 +0,0 @@
/*
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 DeviceNodeIsOpened();
bool DeleteRoutingHdl(uint32_t rt_rule_hdl, ipa_ip_type ip);
bool ModifyRoutingRule(struct ipa_ioc_mdfy_rt_rule *);
private:
static const char *DEVICE_NAME;
int m_fd; /* File descriptor of the IPA device node /dev/ipa */
bool PutRoutingTable(uint32_t routingTableHandle);
};
#endif //IPACM_ROUTING_H

499
data-ipa-cfg-mgr/ipacm/inc/IPACM_Wan.h
View File

@@ -1,499 +0,0 @@
/*
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 3 /*1 for v4, 2 for v6*/
#define IPA_V2_NUM_DEFAULT_WAN_FILTER_RULE_IPV4 2
#ifdef FEATURE_IPA_ANDROID
#define IPA_V2_NUM_DEFAULT_WAN_FILTER_RULE_IPV6 6
#else
#define IPA_V2_NUM_DEFAULT_WAN_FILTER_RULE_IPV6 3
#endif
#define NETWORK_STATS "%s %lu %lu %lu %lu"
#define IPA_NETWORK_STATS_FILE_NAME "/data/misc/ipa/network_stats"
typedef struct _wan_client_rt_hdl
{
uint32_t wan_rt_rule_hdl_v4;
uint32_t wan_rt_rule_hdl_v6[IPV6_NUM_ADDR];
uint32_t wan_rt_rule_hdl_v6_wan[IPV6_NUM_ADDR];
}wan_client_rt_hdl;
typedef struct _ipa_wan_client
{
ipacm_event_data_wlan_ex* p_hdr_info;
uint8_t mac[IPA_MAC_ADDR_SIZE];
uint32_t v4_addr;
uint32_t v6_addr[IPV6_NUM_ADDR][4];
uint32_t hdr_hdl_v4;
uint32_t hdr_hdl_v6;
bool route_rule_set_v4;
int route_rule_set_v6;
bool ipv4_set;
int ipv6_set;
bool ipv4_header_set;
bool ipv6_header_set;
bool power_save_set;
wan_client_rt_hdl wan_rt_hdl[0]; /* depends on number of tx properties */
}ipa_wan_client;
/* wan iface */
class IPACM_Wan : public IPACM_Iface
{
public:
static bool wan_up;
static bool wan_up_v6;
static uint8_t xlat_mux_id;
/* IPACM interface name */
static char wan_up_dev_name[IF_NAME_LEN];
static uint32_t curr_wan_ip;
IPACM_Wan(int, ipacm_wan_iface_type, uint8_t *);
virtual ~IPACM_Wan();
static bool isWanUP(int ipa_if_num_tether)
{
#ifdef FEATURE_IPA_ANDROID
int i;
for (i=0; i < ipa_if_num_tether_v4_total;i++)
{
if (ipa_if_num_tether_v4[i] == ipa_if_num_tether)
{
IPACMDBG_H("support ipv4 tether_iface(%s)\n",
IPACM_Iface::ipacmcfg->iface_table[ipa_if_num_tether].iface_name);
return wan_up;
break;
}
}
return false;
#else
return wan_up;
#endif
}
static bool isWanUP_V6(int ipa_if_num_tether)
{
#ifdef FEATURE_IPA_ANDROID
int i;
for (i=0; i < ipa_if_num_tether_v6_total;i++)
{
if (ipa_if_num_tether_v6[i] == ipa_if_num_tether)
{
IPACMDBG_H("support ipv6 tether_iface(%s)\n",
IPACM_Iface::ipacmcfg->iface_table[ipa_if_num_tether].iface_name);
return wan_up_v6;
break;
}
}
return false;
#else
return wan_up_v6;
#endif
}
static uint32_t getWANIP()
{
return curr_wan_ip;
}
static bool getXlat_Mux_Id()
{
return xlat_mux_id;
}
void event_callback(ipa_cm_event_id event,
void *data);
static struct ipa_flt_rule_add flt_rule_v4[IPA_MAX_FLT_RULE];
static struct ipa_flt_rule_add flt_rule_v6[IPA_MAX_FLT_RULE];
static int num_v4_flt_rule;
static int num_v6_flt_rule;
ipacm_wan_iface_type m_is_sta_mode;
static bool backhaul_is_sta_mode;
static bool is_ext_prop_set;
static uint32_t backhaul_ipv6_prefix[2];
static bool embms_is_on;
static bool backhaul_is_wan_bridge;
static bool isWan_Bridge_Mode()
{
return backhaul_is_wan_bridge;
}
#ifdef FEATURE_IPA_ANDROID
/* IPACM interface id */
static int ipa_if_num_tether_v4_total;
static int ipa_if_num_tether_v4[IPA_MAX_IFACE_ENTRIES];
static int ipa_if_num_tether_v6_total;
static int ipa_if_num_tether_v6[IPA_MAX_IFACE_ENTRIES];
#endif
private:
bool is_ipv6_frag_firewall_flt_rule_installed;
uint32_t ipv6_frag_firewall_flt_rule_hdl;
uint32_t *wan_route_rule_v4_hdl;
uint32_t *wan_route_rule_v6_hdl;
uint32_t *wan_route_rule_v6_hdl_a5;
uint32_t hdr_hdl_sta_v4;
uint32_t hdr_hdl_sta_v6;
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];
uint32_t ipv6_dest_flt_rule_hdl[MAX_DEFAULT_v6_ROUTE_RULES];
int num_ipv6_dest_flt_rule;
uint32_t ODU_fl_hdl[IPA_NUM_DEFAULT_WAN_FILTER_RULES];
int num_firewall_v4,num_firewall_v6;
uint32_t wan_v4_addr;
uint32_t wan_v4_addr_gw;
uint32_t wan_v6_addr_gw[4];
bool wan_v4_addr_set;
bool wan_v4_addr_gw_set;
bool wan_v6_addr_gw_set;
bool active_v4;
bool active_v6;
bool header_set_v4;
bool header_set_v6;
bool header_partial_default_wan_v4;
bool header_partial_default_wan_v6;
uint8_t ext_router_mac_addr[IPA_MAC_ADDR_SIZE];
uint8_t netdev_mac[IPA_MAC_ADDR_SIZE];
static int num_ipv4_modem_pdn;
static int num_ipv6_modem_pdn;
int modem_ipv4_pdn_index;
int modem_ipv6_pdn_index;
bool is_default_gateway;
uint32_t ipv6_prefix[2];
/* IPACM firewall Configuration file*/
IPACM_firewall_conf_t firewall_config;
/* STA mode wan-client*/
int wan_client_len;
ipa_wan_client *wan_client;
int header_name_count;
int num_wan_client;
uint8_t invalid_mac[IPA_MAC_ADDR_SIZE];
bool is_xlat;
/* update network stats for CNE */
int ipa_network_stats_fd;
uint32_t hdr_hdl_dummy_v6;
uint32_t hdr_proc_hdl_dummy_v6;
inline ipa_wan_client* get_client_memptr(ipa_wan_client *param, int cnt)
{
char *ret = ((char *)param) + (wan_client_len * cnt);
return (ipa_wan_client *)ret;
}
inline int get_wan_client_index(uint8_t *mac_addr)
{
int cnt;
int num_wan_client_tmp = num_wan_client;
IPACMDBG_H("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_wan_client_tmp; cnt++)
{
IPACMDBG_H("stored MAC %02x:%02x:%02x:%02x:%02x:%02x\n",
get_client_memptr(wan_client, cnt)->mac[0],
get_client_memptr(wan_client, cnt)->mac[1],
get_client_memptr(wan_client, cnt)->mac[2],
get_client_memptr(wan_client, cnt)->mac[3],
get_client_memptr(wan_client, cnt)->mac[4],
get_client_memptr(wan_client, cnt)->mac[5]);
if(memcmp(get_client_memptr(wan_client, cnt)->mac,
mac_addr,
sizeof(get_client_memptr(wan_client, cnt)->mac)) == 0)
{
IPACMDBG_H("Matched client index: %d\n", cnt);
return cnt;
}
}
return IPACM_INVALID_INDEX;
}
inline int get_wan_client_index_ipv4(uint32_t ipv4_addr)
{
int cnt;
int num_wan_client_tmp = num_wan_client;
IPACMDBG_H("Passed IPv4 %x\n", ipv4_addr);
for(cnt = 0; cnt < num_wan_client_tmp; cnt++)
{
if (get_client_memptr(wan_client, cnt)->ipv4_set)
{
IPACMDBG_H("stored IPv4 %x\n", get_client_memptr(wan_client, cnt)->v4_addr);
if(ipv4_addr == get_client_memptr(wan_client, cnt)->v4_addr)
{
IPACMDBG_H("Matched client index: %d\n", cnt);
IPACMDBG_H("The MAC is %02x:%02x:%02x:%02x:%02x:%02x\n",
get_client_memptr(wan_client, cnt)->mac[0],
get_client_memptr(wan_client, cnt)->mac[1],
get_client_memptr(wan_client, cnt)->mac[2],
get_client_memptr(wan_client, cnt)->mac[3],
get_client_memptr(wan_client, cnt)->mac[4],
get_client_memptr(wan_client, cnt)->mac[5]);
IPACMDBG_H("header set ipv4(%d) ipv6(%d)\n",
get_client_memptr(wan_client, cnt)->ipv4_header_set,
get_client_memptr(wan_client, cnt)->ipv6_header_set);
return cnt;
}
}
}
return IPACM_INVALID_INDEX;
}
inline int get_wan_client_index_ipv6(uint32_t* ipv6_addr)
{
int cnt, v6_num;
int num_wan_client_tmp = num_wan_client;
IPACMDBG_H("Get ipv6 address 0x%08x.0x%08x.0x%08x.0x%08x\n", ipv6_addr[0], ipv6_addr[1], ipv6_addr[2], ipv6_addr[3]);
for(cnt = 0; cnt < num_wan_client_tmp; cnt++)
{
if (get_client_memptr(wan_client, cnt)->ipv6_set)
{
for(v6_num=0;v6_num < get_client_memptr(wan_client, cnt)->ipv6_set;v6_num++)
{
IPACMDBG_H("stored IPv6 0x%08x.0x%08x.0x%08x.0x%08x\n", get_client_memptr(wan_client, cnt)->v6_addr[v6_num][0],
get_client_memptr(wan_client, cnt)->v6_addr[v6_num][1],
get_client_memptr(wan_client, cnt)->v6_addr[v6_num][2],
get_client_memptr(wan_client, cnt)->v6_addr[v6_num][3]);
if(ipv6_addr[0] == get_client_memptr(wan_client, cnt)->v6_addr[v6_num][0] &&
ipv6_addr[1] == get_client_memptr(wan_client, cnt)->v6_addr[v6_num][1] &&
ipv6_addr[2]== get_client_memptr(wan_client, cnt)->v6_addr[v6_num][2] &&
ipv6_addr[3] == get_client_memptr(wan_client, cnt)->v6_addr[v6_num][3])
{
IPACMDBG_H("Matched client index: %d\n", cnt);
IPACMDBG_H("The MAC is %02x:%02x:%02x:%02x:%02x:%02x\n",
get_client_memptr(wan_client, cnt)->mac[0],
get_client_memptr(wan_client, cnt)->mac[1],
get_client_memptr(wan_client, cnt)->mac[2],
get_client_memptr(wan_client, cnt)->mac[3],
get_client_memptr(wan_client, cnt)->mac[4],
get_client_memptr(wan_client, cnt)->mac[5]);
IPACMDBG_H("header set ipv4(%d) ipv6(%d)\n",
get_client_memptr(wan_client, cnt)->ipv4_header_set,
get_client_memptr(wan_client, cnt)->ipv6_header_set);
return cnt;
}
}
}
}
return IPACM_INVALID_INDEX;
}
inline int delete_wan_rtrules(int clt_indx, ipa_ip_type iptype)
{
uint32_t tx_index;
uint32_t rt_hdl;
int num_v6;
if(iptype == IPA_IP_v4)
{
for(tx_index = 0; tx_index < iface_query->num_tx_props; tx_index++)
{
if((tx_prop->tx[tx_index].ip == IPA_IP_v4) && (get_client_memptr(wan_client, clt_indx)->route_rule_set_v4==true)) /* for ipv4 */
{
IPACMDBG_H("Delete client index %d ipv4 Qos rules for tx:%d \n",clt_indx,tx_index);
rt_hdl = get_client_memptr(wan_client, clt_indx)->wan_rt_hdl[tx_index].wan_rt_rule_hdl_v4;
if(m_routing.DeleteRoutingHdl(rt_hdl, IPA_IP_v4) == false)
{
return IPACM_FAILURE;
}
}
} /* end of for loop */
/* clean the 4 Qos ipv4 RT rules for client:clt_indx */
if(get_client_memptr(wan_client, clt_indx)->route_rule_set_v4==true) /* for ipv4 */
{
get_client_memptr(wan_client, clt_indx)->route_rule_set_v4 = false;
}
}
if(iptype == IPA_IP_v6)
{
for(tx_index = 0; tx_index < iface_query->num_tx_props; tx_index++)
{
if((tx_prop->tx[tx_index].ip == IPA_IP_v6) && (get_client_memptr(wan_client, clt_indx)->route_rule_set_v6 != 0)) /* for ipv6 */
{
for(num_v6 =0;num_v6 < get_client_memptr(wan_client, clt_indx)->route_rule_set_v6;num_v6++)
{
IPACMDBG_H("Delete client index %d ipv6 Qos rules for %d-st ipv6 for tx:%d\n", clt_indx,num_v6,tx_index);
rt_hdl = get_client_memptr(wan_client, clt_indx)->wan_rt_hdl[tx_index].wan_rt_rule_hdl_v6[num_v6];
if(m_routing.DeleteRoutingHdl(rt_hdl, IPA_IP_v6) == false)
{
return IPACM_FAILURE;
}
rt_hdl = get_client_memptr(wan_client, clt_indx)->wan_rt_hdl[tx_index].wan_rt_rule_hdl_v6_wan[num_v6];
if(m_routing.DeleteRoutingHdl(rt_hdl, IPA_IP_v6) == false)
{
return IPACM_FAILURE;
}
}
}
} /* end of for loop */
/* clean the 4 Qos ipv6 RT rules for client:clt_indx */
if(get_client_memptr(wan_client, clt_indx)->route_rule_set_v6 != 0) /* for ipv6 */
{
get_client_memptr(wan_client, clt_indx)->route_rule_set_v6 = 0;
}
}
return IPACM_SUCCESS;
}
int handle_wan_hdr_init(uint8_t *mac_addr);
int handle_wan_client_ipaddr(ipacm_event_data_all *data);
int handle_wan_client_route_rule(uint8_t *mac_addr, ipa_ip_type iptype);
/* handle new_address event */
int handle_addr_evt(ipacm_event_data_addr *data);
/* wan default route/filter rule configuration */
int handle_route_add_evt(ipa_ip_type iptype);
/* construct complete STA ethernet header */
int handle_sta_header_add_evt();
bool check_dft_firewall_rules_attr_mask(IPACM_firewall_conf_t *firewall_config);
#ifdef FEATURE_IPA_ANDROID
/* wan posting supported tether_iface */
int post_wan_up_tether_evt(ipa_ip_type iptype, int ipa_if_num_tether);
int post_wan_down_tether_evt(ipa_ip_type iptype, int ipa_if_num_tether);
#endif
int config_dft_firewall_rules(ipa_ip_type iptype);
/* configure the initial firewall filter rules */
int config_dft_embms_rules(ipa_ioc_add_flt_rule *pFilteringTable_v4, ipa_ioc_add_flt_rule *pFilteringTable_v6);
int handle_route_del_evt(ipa_ip_type iptype);
int del_dft_firewall_rules(ipa_ip_type iptype);
int handle_down_evt();
/*handle wan-iface down event */
int handle_down_evt_ex();
/* wan default route/filter rule delete */
int handle_route_del_evt_ex(ipa_ip_type iptype);
/* configure the initial firewall filter rules */
int config_dft_firewall_rules_ex(struct ipa_flt_rule_add* rules, int rule_offset,
ipa_ip_type iptype);
/* init filtering rule in wan dl filtering table */
int init_fl_rule_ex(ipa_ip_type iptype);
/* add ICMP and ALG rules in wan dl filtering table */
int add_icmp_alg_rules(struct ipa_flt_rule_add* rules, int rule_offset, ipa_ip_type iptype);
/* query extended property */
int query_ext_prop();
ipa_ioc_query_intf_ext_props *ext_prop;
int config_wan_firewall_rule(ipa_ip_type iptype);
int del_wan_firewall_rule(ipa_ip_type iptype);
int add_dft_filtering_rule(struct ipa_flt_rule_add* rules, int rule_offset, ipa_ip_type iptype);
int install_wan_filtering_rule(bool is_sw_routing);
void change_to_network_order(ipa_ip_type iptype, ipa_rule_attrib* attrib);
bool is_global_ipv6_addr(uint32_t* ipv6_addr);
void handle_wlan_SCC_MCC_switch(bool, ipa_ip_type);
void handle_wan_client_SCC_MCC_switch(bool, ipa_ip_type);
int handle_network_stats_evt();
int m_fd_ipa;
int handle_network_stats_update(ipa_get_apn_data_stats_resp_msg_v01 *data);
/* construct dummy ethernet header */
int add_dummy_rx_hdr();
};
#endif /* IPACM_WAN_H */

240
data-ipa-cfg-mgr/ipacm/inc/IPACM_Wlan.h
View File

@@ -1,240 +0,0 @@
/*
Copyright (c) 2013-2016, 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"
#include "IPACM_Conntrack_NATApp.h"
typedef struct _wlan_client_rt_hdl
{
uint32_t wifi_rt_rule_hdl_v4;
uint32_t wifi_rt_rule_hdl_v6[IPV6_NUM_ADDR];
uint32_t wifi_rt_rule_hdl_v6_wan[IPV6_NUM_ADDR];
}wlan_client_rt_hdl;
typedef struct _ipa_wlan_client
{
ipacm_event_data_wlan_ex* p_hdr_info;
uint8_t mac[IPA_MAC_ADDR_SIZE];
uint32_t v4_addr;
uint32_t v6_addr[IPV6_NUM_ADDR][4];
uint32_t hdr_hdl_v4;
uint32_t hdr_hdl_v6;
bool route_rule_set_v4;
int route_rule_set_v6;
bool ipv4_set;
int ipv6_set;
bool ipv4_header_set;
bool ipv6_header_set;
bool power_save_set;
wlan_client_rt_hdl wifi_rt_hdl[0]; /* depends on number of tx properties */
}ipa_wlan_client;
/* wlan iface */
class IPACM_Wlan : public IPACM_Lan
{
public:
IPACM_Wlan(int iface_index);
virtual ~IPACM_Wlan(void);
static int total_num_wifi_clients;
void event_callback(ipa_cm_event_id event, void *data);
bool is_guest_ap();
private:
bool m_is_guest_ap;
/* handle wlan access mode switch in ethernet bridging*/
void eth_bridge_handle_wlan_mode_switch();
int wlan_client_len;
ipa_wlan_client *wlan_client;
int header_name_count;
int num_wifi_client;
int wlan_ap_index;
static int num_wlan_ap_iface;
NatApp *Nat_App;
inline ipa_wlan_client* get_client_memptr(ipa_wlan_client *param, int cnt)
{
char *ret = ((char *)param) + (wlan_client_len * cnt);
return (ipa_wlan_client *)ret;
}
inline int get_wlan_client_index(uint8_t *mac_addr)
{
int cnt;
int num_wifi_client_tmp = num_wifi_client;
IPACMDBG_H("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_H("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_H("Matched client index: %d\n", cnt);
return cnt;
}
}
return IPACM_INVALID_INDEX;
}
inline int delete_default_qos_rtrules(int clt_indx, ipa_ip_type iptype)
{
uint32_t tx_index;
uint32_t rt_hdl;
int num_v6;
if(iptype == IPA_IP_v4)
{
for(tx_index = 0; tx_index < iface_query->num_tx_props; tx_index++)
{
if((tx_prop->tx[tx_index].ip == IPA_IP_v4) && (get_client_memptr(wlan_client, clt_indx)->route_rule_set_v4==true)) /* for ipv4 */
{
IPACMDBG_H("Delete client index %d ipv4 Qos rules for tx:%d \n",clt_indx,tx_index);
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;
}
}
} /* end of for loop */
/* clean the 4 Qos ipv4 RT rules for client:clt_indx */
if(get_client_memptr(wlan_client, clt_indx)->route_rule_set_v4==true) /* for ipv4 */
{
get_client_memptr(wlan_client, clt_indx)->route_rule_set_v4 = false;
}
}
if(iptype == IPA_IP_v6)
{
for(tx_index = 0; tx_index < iface_query->num_tx_props; tx_index++)
{
if((tx_prop->tx[tx_index].ip == IPA_IP_v6) && (get_client_memptr(wlan_client, clt_indx)->route_rule_set_v6 != 0)) /* for ipv6 */
{
for(num_v6 =0;num_v6 < get_client_memptr(wlan_client, clt_indx)->route_rule_set_v6;num_v6++)
{
IPACMDBG_H("Delete client index %d ipv6 Qos rules for %d-st ipv6 for tx:%d\n", clt_indx,num_v6,tx_index);
rt_hdl = get_client_memptr(wlan_client, clt_indx)->wifi_rt_hdl[tx_index].wifi_rt_rule_hdl_v6[num_v6];
if(m_routing.DeleteRoutingHdl(rt_hdl, IPA_IP_v6) == false)
{
return IPACM_FAILURE;
}
rt_hdl = get_client_memptr(wlan_client, clt_indx)->wifi_rt_hdl[tx_index].wifi_rt_rule_hdl_v6_wan[num_v6];
if(m_routing.DeleteRoutingHdl(rt_hdl, IPA_IP_v6) == false)
{
return IPACM_FAILURE;
}
}
}
} /* end of for loop */
/* clean the 4 Qos ipv6 RT rules for client:clt_indx */
if(get_client_memptr(wlan_client, clt_indx)->route_rule_set_v6 != 0) /* for ipv6 */
{
get_client_memptr(wlan_client, clt_indx)->route_rule_set_v6 = 0;
}
}
return IPACM_SUCCESS;
}
/* for handle wifi client initial,copy all partial headers (tx property) */
int handle_wlan_client_init_ex(ipacm_event_data_wlan_ex *data);
/*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);
/*handle wlan iface down event*/
int handle_down_evt();
/*handle reset wifi-client rt-rules */
int handle_wlan_client_reset_rt(ipa_ip_type iptype);
void handle_SCC_MCC_switch(ipa_ip_type);
};
#endif /* IPACM_WLAN_H */

303
data-ipa-cfg-mgr/ipacm/inc/IPACM_Xml.h
View File

@@ -1,303 +0,0 @@
/*
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
#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>
#ifdef __cplusplus
extern "C" {
#endif
#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 ODU_TAG "ODUCFG"
#define ODUMODE_TAG "OduMode"
#define ODUEMBMS_OFFLOAD_TAG "eMBMS_offload"
#define ODU_ROUTER_TAG "router"
#define ODU_BRIDGE_TAG "bridge"
#define IPACMCFG_TAG "IPACM"
#define IPACMIFACECFG_TAG "IPACMIface"
#define IFACE_TAG "Iface"
#define NAME_TAG "Name"
#define CATEGORY_TAG "Category"
#define MODE_TAG "Mode"
#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 WLAN_FULL_MODE_TAG "full"
#define WLAN_INTERNET_MODE_TAG "internet"
#define WLAN_MODE_TAG "WlanMode"
#define VIRTUALIF_TAG "VIRTUAL"
#define UNKNOWNIF_TAG "UNKNOWN"
#define ODUIF_TAG "ODU"
#define EMBMSIF_TAG "EMBMS"
#define ETHIF_TAG "ETH"
#define IFACE_ROUTER_MODE_TAG "ROUTER"
#define IFACE_BRIDGE_MODE_TAG "BRIDGE"
#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 FirewallEnabled_TAG "FirewallEnabled"
#define FirewallPktsAllowed_TAG "FirewallPktsAllowed"
#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"
#define IP_PassthroughFlag_TAG "IPPassthroughFlag"
#define IP_PassthroughMode_TAG "IPPassthroughMode"
/*---------------------------------------------------------------------------
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];
bool rule_action_accept;
bool firewall_enable;
} 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;
bool odu_enable;
bool router_mode_enable;
bool odu_embms_enable;
int num_wlan_guest_ap;
bool ip_passthrough_mode;
} 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

98
data-ipa-cfg-mgr/ipacm/src/Android.mk
View File

@@ -1,98 +0,0 @@
BOARD_PLATFORM_LIST := msm8916
BOARD_PLATFORM_LIST += msm8909
ifneq ($(call is-board-platform-in-list,$(BOARD_PLATFORM_LIST)),true)
ifneq (,$(filter $(QCOM_BOARD_PLATFORMS),$(TARGET_BOARD_PLATFORM)))
ifneq (, $(filter aarch64 arm arm64, $(TARGET_ARCH)))
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_C_INCLUDES := $(LOCAL_PATH)/../src
LOCAL_C_INCLUDES += $(LOCAL_PATH)/../inc
LOCAL_C_INCLUDES += $(LOCAL_PATH)/../../ipanat/inc
ifeq ($(call is-platform-sdk-version-at-least,20),true)
LOCAL_C_INCLUDES += external/icu/icu4c/source/common
else
LOCAL_C_INCLUDES += external/icu4c/common
endif
LOCAL_C_INCLUDES += external/libxml2/include
LOCAL_C_INCLUDES += external/libnetfilter_conntrack/include
LOCAL_C_INCLUDES += external/libnfnetlink/include
LOCAL_C_INCLUDES += $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr/include
LOCAL_ADDITIONAL_DEPENDENCIES := $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr
LOCAL_CFLAGS := -v
LOCAL_CFLAGS += -DFEATURE_IPA_ANDROID
ifneq (,$(filter userdebug eng, $(TARGET_BUILD_VARIANT)))
LOCAL_CFLAGS += -DDEBUG
endif
ifeq ($(TARGET_BOARD_PLATFORM),msmcobalt)
LOCAL_CFLAGS += -DFEATURE_IPA_V3
endif
filetoadd = bionic/libc/kernel/arch-arm/asm/posix_types.h
LOCAL_CFLAGS += $(shell if [ -a $(filetoadd) ] ; then echo -include $(filetoadd) ; fi ;)
filetoadd = bionic/libc/kernel/arch-arm/asm/byteorder.h
LOCAL_CFLAGS += $(shell if [ -a $(filetoadd) ] ; then echo -include $(filetoadd) ; fi ;)
LOCAL_SRC_FILES := IPACM_Main.cpp \
IPACM_EvtDispatcher.cpp \
IPACM_Config.cpp \
IPACM_CmdQueue.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 \
IPACM_Conntrack_NATApp.cpp\
IPACM_ConntrackClient.cpp \
IPACM_ConntrackListener.cpp \
IPACM_Log.cpp
LOCAL_MODULE := ipacm
LOCAL_CLANG := false
LOCAL_MODULE_TAGS := optional
LOCAL_SHARED_LIBRARIES := libipanat
LOCAL_SHARED_LIBRARIES += libxml2
LOCAL_SHARED_LIBRARIES += libnfnetlink
LOCAL_SHARED_LIBRARIES += libnetfilter_conntrack
LOCAL_CLANG := true
include $(BUILD_EXECUTABLE)
################################################################################
define ADD_TEST
include $(CLEAR_VARS)
LOCAL_MODULE := $1
LOCAL_SRC_FILES := $1
LOCAL_MODULE_CLASS := ipacm
LOCAL_MODULE_TAGS := debug
LOCAL_MODULE_PATH := $(TARGET_OUT_ETC)
include $(BUILD_PREBUILT)
endef
include $(CLEAR_VARS)
LOCAL_MODULE := IPACM_cfg.xml
LOCAL_MODULE_CLASS := ETC
LOCAL_MODULE_PATH := $(TARGET_OUT_ETC)
LOCAL_MODULE_TAGS := optional
LOCAL_SRC_FILES := $(LOCAL_MODULE)
LOCAL_MODULE_OWNER := ipacm
include $(BUILD_PREBUILT)
endif # $(TARGET_ARCH)
endif
endif

205
data-ipa-cfg-mgr/ipacm/src/IPACM_CmdQueue.cpp
View File

@@ -1,205 +0,0 @@
/*
Copyright (c) 2013-2016, 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"
#include "IPACM_Iface.h"
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond_var = PTHREAD_COND_INITIALIZER;
MessageQueue* MessageQueue::inst_internal = NULL;
MessageQueue* MessageQueue::inst_external = NULL;
MessageQueue* MessageQueue::getInstanceInternal()
{
if(inst_internal == NULL)
{
inst_internal = new MessageQueue();
if(inst_internal == NULL)
{
IPACMERR("unable to create internal Message Queue instance\n");
return NULL;
}
}
return inst_internal;
}
MessageQueue* MessageQueue::getInstanceExternal()
{
if(inst_external == NULL)
{
inst_external = new MessageQueue();
if(inst_external == NULL)
{
IPACMERR("unable to create external Message Queue instance\n");
return NULL;
}
}
return inst_external;
}
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 *MsgQueueInternal = NULL;
MessageQueue *MsgQueueExternal = NULL;
Message *item = NULL;
IPACMDBG("MessageQueue::Process()\n");
MsgQueueInternal = MessageQueue::getInstanceInternal();
if(MsgQueueInternal == NULL)
{
IPACMERR("unable to start internal cmd queue process\n");
return NULL;
}
MsgQueueExternal = MessageQueue::getInstanceExternal();
if(MsgQueueExternal == NULL)
{
IPACMERR("unable to start external cmd queue process\n");
return NULL;
}
while(1)
{
if(pthread_mutex_lock(&mutex) != 0)
{
IPACMERR("unable to lock the mutex\n");
return NULL;
}
item = MsgQueueInternal->dequeue();
if(item == NULL)
{
item = MsgQueueExternal->dequeue();
if(item)
{
IPACMDBG("Get event %s from external queue.\n",
IPACM_Iface::ipacmcfg->getEventName(item->evt.data.event));
}
}
else
{
IPACMDBG("Get event %s from internal queue.\n",
IPACM_Iface::ipacmcfg->getEventName(item->evt.data.event));
}
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 event ID: %d\n",item,item->evt.data.event);
item->evt.callback_ptr(&item->evt.data);
delete item;
item = NULL;
}
} /* Go forever until a termination indication is received */
}

824
data-ipa-cfg-mgr/ipacm/src/IPACM_Config.cpp
View File

@@ -1,824 +0,0 @@
/*
Copyright (c) 2013-2016, 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>
#include <sys/ioctl.h>
#include <fcntl.h>
IPACM_Config *IPACM_Config::pInstance = NULL;
const char *IPACM_Config::DEVICE_NAME = "/dev/ipa";
const char *IPACM_Config::DEVICE_NAME_ODU = "/dev/odu_ipa_bridge";
#define __stringify(x...) #x
const char *ipacm_event_name[] = {
__stringify(IPA_CFG_CHANGE_EVENT), /* NULL */
__stringify(IPA_PRIVATE_SUBNET_CHANGE_EVENT), /* ipacm_event_data_fid */
__stringify(IPA_FIREWALL_CHANGE_EVENT), /* NULL */
__stringify(IPA_LINK_UP_EVENT), /* ipacm_event_data_fid */
__stringify(IPA_LINK_DOWN_EVENT), /* ipacm_event_data_fid */
__stringify(IPA_USB_LINK_UP_EVENT), /* ipacm_event_data_fid */
__stringify(IPA_BRIDGE_LINK_UP_EVENT), /* ipacm_event_data_all */
__stringify(IPA_WAN_EMBMS_LINK_UP_EVENT), /* ipacm_event_data_mac */
__stringify(IPA_ADDR_ADD_EVENT), /* ipacm_event_data_addr */
__stringify(IPA_ADDR_DEL_EVENT), /* no use */
__stringify(IPA_ROUTE_ADD_EVENT), /* ipacm_event_data_addr */
__stringify(IPA_ROUTE_DEL_EVENT), /* ipacm_event_data_addr */
__stringify(IPA_WAN_UPSTREAM_ROUTE_ADD_EVENT), /* ipacm_event_data_fid */
__stringify(IPA_WAN_UPSTREAM_ROUTE_DEL_EVENT), /* ipacm_event_data_fid */
__stringify(IPA_WLAN_AP_LINK_UP_EVENT), /* ipacm_event_data_mac */
__stringify(IPA_WLAN_STA_LINK_UP_EVENT), /* ipacm_event_data_mac */
__stringify(IPA_WLAN_LINK_DOWN_EVENT), /* ipacm_event_data_mac */
__stringify(IPA_WLAN_CLIENT_ADD_EVENT), /* ipacm_event_data_mac */
__stringify(IPA_WLAN_CLIENT_ADD_EVENT_EX), /* ipacm_event_data_wlan_ex */
__stringify(IPA_WLAN_CLIENT_DEL_EVENT), /* ipacm_event_data_mac */
__stringify(IPA_WLAN_CLIENT_POWER_SAVE_EVENT), /* ipacm_event_data_mac */
__stringify(IPA_WLAN_CLIENT_RECOVER_EVENT), /* ipacm_event_data_mac */
__stringify(IPA_NEW_NEIGH_EVENT), /* ipacm_event_data_all */
__stringify(IPA_DEL_NEIGH_EVENT), /* ipacm_event_data_all */
__stringify(IPA_NEIGH_CLIENT_IP_ADDR_ADD_EVENT), /* ipacm_event_data_all */
__stringify(IPA_NEIGH_CLIENT_IP_ADDR_DEL_EVENT), /* ipacm_event_data_all */
__stringify(IPA_SW_ROUTING_ENABLE), /* NULL */
__stringify(IPA_SW_ROUTING_DISABLE), /* NULL */
__stringify(IPA_PROCESS_CT_MESSAGE), /* ipacm_ct_evt_data */
__stringify(IPA_PROCESS_CT_MESSAGE_V6), /* ipacm_ct_evt_data */
__stringify(IPA_LAN_TO_LAN_NEW_CONNECTION), /* ipacm_event_connection */
__stringify(IPA_LAN_TO_LAN_DEL_CONNECTION), /* ipacm_event_connection */
__stringify(IPA_WLAN_SWITCH_TO_SCC), /* No Data */
__stringify(IPA_WLAN_SWITCH_TO_MCC), /* No Data */
__stringify(IPA_CRADLE_WAN_MODE_SWITCH), /* ipacm_event_cradle_wan_mode */
__stringify(IPA_WAN_XLAT_CONNECT_EVENT), /* ipacm_event_data_fid */
__stringify(IPA_TETHERING_STATS_UPDATE_EVENT), /* ipacm_event_data_fid */
__stringify(IPA_NETWORK_STATS_UPDATE_EVENT), /* ipacm_event_data_fid */
__stringify(IPA_EXTERNAL_EVENT_MAX),
__stringify(IPA_HANDLE_WAN_UP), /* ipacm_event_iface_up */
__stringify(IPA_HANDLE_WAN_DOWN), /* ipacm_event_iface_up */
__stringify(IPA_HANDLE_WAN_UP_V6), /* NULL */
__stringify(IPA_HANDLE_WAN_DOWN_V6), /* NULL */
__stringify(IPA_HANDLE_WAN_UP_TETHER), /* ipacm_event_iface_up_tehter */
__stringify(IPA_HANDLE_WAN_DOWN_TETHER), /* ipacm_event_iface_up_tehter */
__stringify(IPA_HANDLE_WAN_UP_V6_TETHER), /* ipacm_event_iface_up_tehter */
__stringify(IPA_HANDLE_WAN_DOWN_V6_TETHER), /* ipacm_event_iface_up_tehter */
__stringify(IPA_HANDLE_WLAN_UP), /* ipacm_event_iface_up */
__stringify(IPA_HANDLE_LAN_UP), /* ipacm_event_iface_up */
__stringify(IPA_ETH_BRIDGE_IFACE_UP), /* ipacm_event_eth_bridge*/
__stringify(IPA_ETH_BRIDGE_IFACE_DOWN), /* ipacm_event_eth_bridge*/
__stringify(IPA_ETH_BRIDGE_CLIENT_ADD), /* ipacm_event_eth_bridge*/
__stringify(IPA_ETH_BRIDGE_CLIENT_DEL), /* ipacm_event_eth_bridge*/
__stringify(IPA_ETH_BRIDGE_WLAN_SCC_MCC_SWITCH), /* ipacm_event_eth_bridge*/
__stringify(IPA_LAN_DELETE_SELF), /* ipacm_event_data_fid */
__stringify(IPACM_EVENT_MAX),
};
IPACM_Config::IPACM_Config()
{
iface_table = NULL;
alg_table = NULL;
pNatIfaces = NULL;
memset(&ipa_client_rm_map_tbl, 0, sizeof(ipa_client_rm_map_tbl));
memset(&ipa_rm_tbl, 0, sizeof(ipa_rm_tbl));
ipa_rm_a2_check=0;
ipacm_odu_enable = false;
ipacm_odu_router_mode = false;
ipa_num_wlan_guest_ap = 0;
ipa_num_ipa_interfaces = 0;
ipa_num_private_subnet = 0;
ipa_num_alg_ports = 0;
ipa_nat_max_entries = 0;
ipa_nat_iface_entries = 0;
ipa_sw_rt_enable = false;
ipa_bridge_enable = false;
isMCC_Mode = false;
ipa_max_valid_rm_entry = 0;
memset(&rt_tbl_default_v4, 0, sizeof(rt_tbl_default_v4));
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));
memset(&rt_tbl_wan_v6, 0, sizeof(rt_tbl_wan_v6));
memset(&rt_tbl_wan_dl, 0, sizeof(rt_tbl_wan_dl));
memset(&rt_tbl_odu_v4, 0, sizeof(rt_tbl_odu_v4));
memset(&rt_tbl_odu_v6, 0, sizeof(rt_tbl_odu_v6));
memset(&ext_prop_v4, 0, sizeof(ext_prop_v4));
memset(&ext_prop_v6, 0, sizeof(ext_prop_v6));
qmap_id = ~0;
memset(flt_rule_count_v4, 0, (IPA_CLIENT_CONS - IPA_CLIENT_PROD)*sizeof(int));
memset(flt_rule_count_v6, 0, (IPA_CLIENT_CONS - IPA_CLIENT_PROD)*sizeof(int));
memset(bridge_mac, 0, IPA_MAC_ADDR_SIZE*sizeof(uint8_t));
IPACMDBG_H(" 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));
if(cfg == NULL)
{
IPACMERR("Unable to allocate cfg memory.\n");
return IPACM_FAILURE;
}
uint32_t subnet_addr;
uint32_t subnet_mask;
int i, ret = IPACM_SUCCESS;
struct in_addr in_addr_print;
m_fd = open(DEVICE_NAME, O_RDWR);
if (0 > m_fd)
{
IPACMERR("Failed opening %s.\n", DEVICE_NAME);
}
strncpy(IPACM_config_file, "/etc/IPACM_cfg.xml", sizeof(IPACM_config_file));
IPACMDBG_H("\n IPACM XML file is %s \n", IPACM_config_file);
if (IPACM_SUCCESS == ipacm_read_cfg_xml(IPACM_config_file, cfg))
{
IPACMDBG_H("\n IPACM XML read OK \n");
}
else
{
IPACMERR("\n IPACM XML read failed \n");
ret = IPACM_FAILURE;
goto fail;
}
/* Check wlan AP-AP access mode configuration */
if (cfg->num_wlan_guest_ap == 2)
{
IPACMDBG_H("IPACM_Config::Both wlan APs can not be configured in guest ap mode. \n");
IPACMDBG_H("IPACM_Config::configure both APs in full access mode or at least one in guest ap mode. \n");
ret = IPACM_FAILURE;
goto fail;
}
/* Construct IPACM Iface table */
ipa_num_ipa_interfaces = cfg->iface_config.num_iface_entries;
if (iface_table != NULL)
{
free(iface_table);
iface_table = NULL;
IPACMDBG_H("RESET IPACM_Config::iface_table\n");
}
iface_table = (ipa_ifi_dev_name_t *)calloc(ipa_num_ipa_interfaces,
sizeof(ipa_ifi_dev_name_t));
if(iface_table == NULL)
{
IPACMERR("Unable to allocate iface_table memory.\n");
ret = IPACM_FAILURE;
goto fail;
}
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;
iface_table[i].if_mode = cfg->iface_config.iface_entries[i].if_mode;
iface_table[i].wlan_mode = cfg->iface_config.iface_entries[i].wlan_mode;
IPACMDBG_H("IPACM_Config::iface_table[%d] = %s, cat=%d, mode=%d wlan-mode=%d \n", i, iface_table[i].iface_name,
iface_table[i].if_cat, iface_table[i].if_mode, iface_table[i].wlan_mode);
/* copy bridge interface name to ipacmcfg */
if( iface_table[i].if_cat == VIRTUAL_IF)
{
strlcpy(ipa_virtual_iface_name, iface_table[i].iface_name, sizeof(ipa_virtual_iface_name));
IPACMDBG_H("ipa_virtual_iface_name(%s) \n", ipa_virtual_iface_name);
}
}
/* Construct IPACM Private_Subnet table */
memset(&private_subnet_table, 0, sizeof(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);
memcpy(&in_addr_print,&subnet_addr,sizeof(in_addr_print));
IPACMDBG_H("%dst::private_subnet_table= %s \n ", i,
inet_ntoa(in_addr_print));
subnet_mask = htonl(private_subnet_table[i].subnet_mask);
memcpy(&in_addr_print,&subnet_mask,sizeof(in_addr_print));
IPACMDBG_H("%dst::private_subnet_table= %s \n ", i,
inet_ntoa(in_addr_print));
}
/* Construct IPACM ALG table */
ipa_num_alg_ports = cfg->alg_config.num_alg_entries;
if (alg_table != NULL)
{
free(alg_table);
alg_table = NULL;
IPACMDBG_H("RESET IPACM_Config::alg_table \n");
}
alg_table = (ipacm_alg *)calloc(ipa_num_alg_ports,
sizeof(ipacm_alg));
if(alg_table == NULL)
{
IPACMERR("Unable to allocate alg_table memory.\n");
ret = IPACM_FAILURE;
free(iface_table);
goto fail;;
}
for (i = 0; i < cfg->alg_config.num_alg_entries; i++)
{
alg_table[i].protocol = cfg->alg_config.alg_entries[i].protocol;
alg_table[i].port = cfg->alg_config.alg_entries[i].port;
IPACMDBG_H("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_H("Nat Maximum Entries %d\n", ipa_nat_max_entries);
/* Find ODU is either router mode or bridge mode*/
ipacm_odu_enable = cfg->odu_enable;
ipacm_odu_router_mode = cfg->router_mode_enable;
ipacm_odu_embms_enable = cfg->odu_embms_enable;
IPACMDBG_H("ipacm_odu_enable %d\n", ipacm_odu_enable);
IPACMDBG_H("ipacm_odu_mode %d\n", ipacm_odu_router_mode);
IPACMDBG_H("ipacm_odu_embms_enable %d\n", ipacm_odu_embms_enable);
ipacm_ip_passthrough_mode = cfg->ip_passthrough_mode;
IPACMDBG_H("ipacm_ip_passthrough_mode %d. \n", ipacm_ip_passthrough_mode);
ipa_num_wlan_guest_ap = cfg->num_wlan_guest_ap;
IPACMDBG_H("ipa_num_wlan_guest_ap %d\n",ipa_num_wlan_guest_ap);
/* Allocate more non-nat entries if the monitored iface dun have Tx/Rx properties */
if (pNatIfaces != NULL)
{
free(pNatIfaces);
pNatIfaces = NULL;
IPACMDBG_H("RESET IPACM_Config::pNatIfaces \n");
}
ipa_nat_iface_entries = 0;
pNatIfaces = (NatIfaces *)calloc(ipa_num_ipa_interfaces, sizeof(NatIfaces));
if (pNatIfaces == NULL)
{
IPACMERR("unable to allocate nat ifaces\n");
ret = IPACM_FAILURE;
free(iface_table);
free(alg_table);
goto fail;
}
/* Construct the routing table ictol name in iface static member*/
rt_tbl_default_v4.ip = IPA_IP_v4;
strncpy(rt_tbl_default_v4.name, V4_DEFAULT_ROUTE_TABLE_NAME, sizeof(rt_tbl_default_v4.name));
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_wan_v4.ip = IPA_IP_v4;
strncpy(rt_tbl_wan_v4.name, V4_WAN_ROUTE_TABLE_NAME, sizeof(rt_tbl_wan_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_v6.ip = IPA_IP_v6;
strncpy(rt_tbl_wan_v6.name, V6_WAN_ROUTE_TABLE_NAME, sizeof(rt_tbl_wan_v6.name));
rt_tbl_odu_v4.ip = IPA_IP_v4;
strncpy(rt_tbl_odu_v4.name, V4_ODU_ROUTE_TABLE_NAME, sizeof(rt_tbl_odu_v4.name));
rt_tbl_odu_v6.ip = IPA_IP_v6;
strncpy(rt_tbl_odu_v6.name, V6_ODU_ROUTE_TABLE_NAME, sizeof(rt_tbl_odu_v6.name));
rt_tbl_wan_dl.ip = IPA_IP_MAX;
strncpy(rt_tbl_wan_dl.name, WAN_DL_ROUTE_TABLE_NAME, sizeof(rt_tbl_wan_dl.name));
/* Construct IPACM ipa_client map to rm_resource table */
ipa_client_rm_map_tbl[IPA_CLIENT_WLAN1_PROD]= IPA_RM_RESOURCE_WLAN_PROD;
ipa_client_rm_map_tbl[IPA_CLIENT_USB_PROD]= IPA_RM_RESOURCE_USB_PROD;
ipa_client_rm_map_tbl[IPA_CLIENT_A5_WLAN_AMPDU_PROD]= IPA_RM_RESOURCE_HSIC_PROD;
ipa_client_rm_map_tbl[IPA_CLIENT_A2_EMBEDDED_PROD]= IPA_RM_RESOURCE_Q6_PROD;
ipa_client_rm_map_tbl[IPA_CLIENT_A2_TETHERED_PROD]= IPA_RM_RESOURCE_Q6_PROD;
ipa_client_rm_map_tbl[IPA_CLIENT_APPS_LAN_WAN_PROD]= IPA_RM_RESOURCE_Q6_PROD;
ipa_client_rm_map_tbl[IPA_CLIENT_WLAN1_CONS]= IPA_RM_RESOURCE_WLAN_CONS;
ipa_client_rm_map_tbl[IPA_CLIENT_WLAN2_CONS]= IPA_RM_RESOURCE_WLAN_CONS;
ipa_client_rm_map_tbl[IPA_CLIENT_WLAN3_CONS]= IPA_RM_RESOURCE_WLAN_CONS;
ipa_client_rm_map_tbl[IPA_CLIENT_WLAN4_CONS]= IPA_RM_RESOURCE_WLAN_CONS;
ipa_client_rm_map_tbl[IPA_CLIENT_USB_CONS]= IPA_RM_RESOURCE_USB_CONS;
ipa_client_rm_map_tbl[IPA_CLIENT_A2_EMBEDDED_CONS]= IPA_RM_RESOURCE_Q6_CONS;
ipa_client_rm_map_tbl[IPA_CLIENT_A2_TETHERED_CONS]= IPA_RM_RESOURCE_Q6_CONS;
ipa_client_rm_map_tbl[IPA_CLIENT_APPS_WAN_CONS]= IPA_RM_RESOURCE_Q6_CONS;
ipa_client_rm_map_tbl[IPA_CLIENT_ODU_PROD]= IPA_RM_RESOURCE_ODU_ADAPT_PROD;
ipa_client_rm_map_tbl[IPA_CLIENT_ODU_EMB_CONS]= IPA_RM_RESOURCE_ODU_ADAPT_CONS;
ipa_client_rm_map_tbl[IPA_CLIENT_ODU_TETH_CONS]= IPA_RM_RESOURCE_ODU_ADAPT_CONS;
/* Create the entries which IPACM wants to add dependencies on */
ipa_rm_tbl[0].producer_rm1 = IPA_RM_RESOURCE_WLAN_PROD;
ipa_rm_tbl[0].consumer_rm1 = IPA_RM_RESOURCE_Q6_CONS;
ipa_rm_tbl[0].producer_rm2 = IPA_RM_RESOURCE_Q6_PROD;
ipa_rm_tbl[0].consumer_rm2 = IPA_RM_RESOURCE_WLAN_CONS;
ipa_rm_tbl[1].producer_rm1 = IPA_RM_RESOURCE_USB_PROD;
ipa_rm_tbl[1].consumer_rm1 = IPA_RM_RESOURCE_Q6_CONS;
ipa_rm_tbl[1].producer_rm2 = IPA_RM_RESOURCE_Q6_PROD;
ipa_rm_tbl[1].consumer_rm2 = IPA_RM_RESOURCE_USB_CONS;
ipa_rm_tbl[2].producer_rm1 = IPA_RM_RESOURCE_WLAN_PROD;
ipa_rm_tbl[2].consumer_rm1 = IPA_RM_RESOURCE_USB_CONS;
ipa_rm_tbl[2].producer_rm2 = IPA_RM_RESOURCE_USB_PROD;
ipa_rm_tbl[2].consumer_rm2 = IPA_RM_RESOURCE_WLAN_CONS;
ipa_rm_tbl[3].producer_rm1 = IPA_RM_RESOURCE_ODU_ADAPT_PROD;
ipa_rm_tbl[3].consumer_rm1 = IPA_RM_RESOURCE_Q6_CONS;
ipa_rm_tbl[3].producer_rm2 = IPA_RM_RESOURCE_Q6_PROD;
ipa_rm_tbl[3].consumer_rm2 = IPA_RM_RESOURCE_ODU_ADAPT_CONS;
ipa_rm_tbl[4].producer_rm1 = IPA_RM_RESOURCE_WLAN_PROD;
ipa_rm_tbl[4].consumer_rm1 = IPA_RM_RESOURCE_ODU_ADAPT_CONS;
ipa_rm_tbl[4].producer_rm2 = IPA_RM_RESOURCE_ODU_ADAPT_PROD;
ipa_rm_tbl[4].consumer_rm2 = IPA_RM_RESOURCE_WLAN_CONS;
ipa_rm_tbl[5].producer_rm1 = IPA_RM_RESOURCE_ODU_ADAPT_PROD;
ipa_rm_tbl[5].consumer_rm1 = IPA_RM_RESOURCE_USB_CONS;
ipa_rm_tbl[5].producer_rm2 = IPA_RM_RESOURCE_USB_PROD;
ipa_rm_tbl[5].consumer_rm2 = IPA_RM_RESOURCE_ODU_ADAPT_CONS;
ipa_max_valid_rm_entry = 6; /* max is IPA_MAX_RM_ENTRY (6)*/
IPACMDBG_H(" depend MAP-0 rm index %d to rm index: %d \n", IPA_RM_RESOURCE_WLAN_PROD, IPA_RM_RESOURCE_Q6_CONS);
IPACMDBG_H(" depend MAP-1 rm index %d to rm index: %d \n", IPA_RM_RESOURCE_USB_PROD, IPA_RM_RESOURCE_Q6_CONS);
IPACMDBG_H(" depend MAP-2 rm index %d to rm index: %d \n", IPA_RM_RESOURCE_WLAN_PROD, IPA_RM_RESOURCE_USB_CONS);
IPACMDBG_H(" depend MAP-3 rm index %d to rm index: %d \n", IPA_RM_RESOURCE_ODU_ADAPT_PROD, IPA_RM_RESOURCE_Q6_CONS);
IPACMDBG_H(" depend MAP-4 rm index %d to rm index: %d \n", IPA_RM_RESOURCE_WLAN_PROD, IPA_RM_RESOURCE_ODU_ADAPT_CONS);
IPACMDBG_H(" depend MAP-5 rm index %d to rm index: %d \n", IPA_RM_RESOURCE_ODU_ADAPT_PROD, IPA_RM_RESOURCE_USB_CONS);
fail:
if (cfg != NULL)
{
free(cfg);
cfg = NULL;
}
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;
IPACMERR("unable to initialize config instance\n");
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;
}
int IPACM_Config::GetNatIfaces(int nIfaces, NatIfaces *pIfaces)
{
if (nIfaces <= 0 || pIfaces == NULL)
{
IPACMERR("Invalid input\n");
return -1;
}
for (int cnt=0; cnt<nIfaces; cnt++)
{
memcpy(pIfaces[cnt].iface_name,
pNatIfaces[cnt].iface_name,
sizeof(pIfaces[cnt].iface_name));
}
return 0;
}
int IPACM_Config::AddNatIfaces(char *dev_name)
{
int i;
/* Check if this iface already in NAT-iface*/
for(i = 0; i < ipa_nat_iface_entries; i++)
{
if(strncmp(dev_name,
pNatIfaces[i].iface_name,
sizeof(pNatIfaces[i].iface_name)) == 0)
{
IPACMDBG("Interface (%s) is add to nat iface already\n", dev_name);
return 0;
}
}
IPACMDBG_H("Add iface %s to NAT-ifaces, origin it has %d nat ifaces\n",
dev_name, ipa_nat_iface_entries);
ipa_nat_iface_entries++;
if (ipa_nat_iface_entries < ipa_num_ipa_interfaces)
{
memcpy(pNatIfaces[ipa_nat_iface_entries - 1].iface_name,
dev_name, IPA_IFACE_NAME_LEN);
IPACMDBG_H("Add Nat IfaceName: %s ,update nat-ifaces number: %d\n",
pNatIfaces[ipa_nat_iface_entries - 1].iface_name,
ipa_nat_iface_entries);
}
return 0;
}
int IPACM_Config::DelNatIfaces(char *dev_name)
{
int i = 0;
IPACMDBG_H("Del iface %s from NAT-ifaces, origin it has %d nat ifaces\n",
dev_name, ipa_nat_iface_entries);
for (i = 0; i < ipa_nat_iface_entries; i++)
{
if (strcmp(dev_name, pNatIfaces[i].iface_name) == 0)
{
IPACMDBG_H("Find Nat IfaceName: %s ,previous nat-ifaces number: %d\n",
pNatIfaces[i].iface_name, ipa_nat_iface_entries);
/* Reset the matched entry */
memset(pNatIfaces[i].iface_name, 0, IPA_IFACE_NAME_LEN);
for (; i < ipa_nat_iface_entries - 1; i++)
{
memcpy(pNatIfaces[i].iface_name,
pNatIfaces[i + 1].iface_name, IPA_IFACE_NAME_LEN);
/* Reset the copied entry */
memset(pNatIfaces[i + 1].iface_name, 0, IPA_IFACE_NAME_LEN);
}
ipa_nat_iface_entries--;
IPACMDBG_H("Update nat-ifaces number: %d\n", ipa_nat_iface_entries);
return 0;
}
}
IPACMDBG_H("Can't find Nat IfaceName: %s with total nat-ifaces number: %d\n",
dev_name, ipa_nat_iface_entries);
return 0;
}
/* for IPACM resource manager dependency usage
add either Tx or Rx ipa_rm_resource_name and
also indicate that endpoint property if valid */
void IPACM_Config::AddRmDepend(ipa_rm_resource_name rm1,bool rx_bypass_ipa)
{
int retval = 0;
struct ipa_ioc_rm_dependency dep;
IPACMDBG_H(" Got rm add-depend index : %d \n", rm1);
/* ipa_rm_a2_check: IPA_RM_RESOURCE_Q6_CONS*/
if(rm1 == IPA_RM_RESOURCE_Q6_CONS)
{
ipa_rm_a2_check+=1;
IPACMDBG_H("got %d times default RT routing from A2 \n", ipa_rm_a2_check);
}
for(int i=0;i<ipa_max_valid_rm_entry;i++)
{
if(rm1 == ipa_rm_tbl[i].producer_rm1)
{
ipa_rm_tbl[i].producer1_up = true;
/* entry1's producer actually dun have registered Rx-property */
ipa_rm_tbl[i].rx_bypass_ipa = rx_bypass_ipa;
IPACMDBG_H("Matched RM_table entry: %d's producer_rm1 with non_rx_prop: %d \n", i,ipa_rm_tbl[i].rx_bypass_ipa);
if(ipa_rm_tbl[i].consumer1_up == true && ipa_rm_tbl[i].rm_set == false)
{
IPACMDBG_H("SETUP RM_table entry %d's bi-direction dependency \n", i);
/* add bi-directional dependency*/
if(ipa_rm_tbl[i].rx_bypass_ipa)
{
IPACMDBG_H("Skip ADD entry %d's dependency between WLAN-Pro: %d, Con: %d \n", i, ipa_rm_tbl[i].producer_rm1,ipa_rm_tbl[i].consumer_rm1);
}
else
{
memset(&dep, 0, sizeof(dep));
dep.resource_name = ipa_rm_tbl[i].producer_rm1;
dep.depends_on_name = ipa_rm_tbl[i].consumer_rm1;
retval = ioctl(m_fd, IPA_IOC_RM_ADD_DEPENDENCY, &dep);
IPACMDBG_H("ADD entry %d's dependency between Pro: %d, Con: %d \n", i,dep.resource_name,dep.depends_on_name);
if (retval)
{
IPACMERR("Failed adding dependecny for RM_table entry %d's bi-direction dependency (error:%d) \n", i,retval);
}
}
memset(&dep, 0, sizeof(dep));
dep.resource_name = ipa_rm_tbl[i].producer_rm2;
dep.depends_on_name = ipa_rm_tbl[i].consumer_rm2;
retval = ioctl(m_fd, IPA_IOC_RM_ADD_DEPENDENCY, &dep);
IPACMDBG_H("ADD entry %d's dependency between Pro: %d, Con: %d \n", i,dep.resource_name,dep.depends_on_name);
if (retval)
{
IPACMERR("Failed adding dependecny for RM_table entry %d's bi-direction dependency (error:%d) \n", i,retval);
}
ipa_rm_tbl[i].rm_set = true;
}
else
{
IPACMDBG_H("Not SETUP RM_table entry %d: prod_up:%d, cons_up:%d, rm_set: %d \n", i,ipa_rm_tbl[i].producer1_up, ipa_rm_tbl[i].consumer1_up, ipa_rm_tbl[i].rm_set);
}
}
if(rm1 == ipa_rm_tbl[i].consumer_rm1)
{
ipa_rm_tbl[i].consumer1_up = true;
IPACMDBG_H("Matched RM_table entry: %d's consumer_rm1 \n", i);
if(ipa_rm_tbl[i].producer1_up == true && ipa_rm_tbl[i].rm_set == false)
{
IPACMDBG_H("SETUP RM_table entry %d's bi-direction dependency \n", i);
/* add bi-directional dependency*/
if(ipa_rm_tbl[i].rx_bypass_ipa)
{
IPACMDBG_H("Skip ADD entry %d's dependency between WLAN-Pro: %d, Con: %d \n", i, ipa_rm_tbl[i].producer_rm1,ipa_rm_tbl[i].consumer_rm1);
}
else
{
memset(&dep, 0, sizeof(dep));
dep.resource_name = ipa_rm_tbl[i].producer_rm1;
dep.depends_on_name = ipa_rm_tbl[i].consumer_rm1;
retval = ioctl(m_fd, IPA_IOC_RM_ADD_DEPENDENCY, &dep);
IPACMDBG_H("ADD entry %d's dependency between Pro: %d, Con: %d \n", i,dep.resource_name,dep.depends_on_name);
if (retval)
{
IPACMERR("Failed adding dependecny for RM_table entry %d's bi-direction dependency (error:%d) \n", i,retval);
}
}
memset(&dep, 0, sizeof(dep));
dep.resource_name = ipa_rm_tbl[i].producer_rm2;
dep.depends_on_name = ipa_rm_tbl[i].consumer_rm2;
retval = ioctl(m_fd, IPA_IOC_RM_ADD_DEPENDENCY, &dep);
IPACMDBG_H("ADD entry %d's dependency between Pro: %d, Con: %d \n", i,dep.resource_name,dep.depends_on_name);
if (retval)
{
IPACMERR("Failed adding dependecny for RM_table entry %d's bi-direction dependency (error:%d) \n", i,retval);
}
ipa_rm_tbl[i].rm_set = true;
}
else
{
IPACMDBG_H("Not SETUP RM_table entry %d: prod_up:%d, cons_up:%d, rm_set: %d \n", i,ipa_rm_tbl[i].producer1_up, ipa_rm_tbl[i].consumer1_up, ipa_rm_tbl[i].rm_set);
}
}
}
return ;
}
/* for IPACM resource manager dependency usage
delete either Tx or Rx ipa_rm_resource_name */
void IPACM_Config::DelRmDepend(ipa_rm_resource_name rm1)
{
int retval = 0;
struct ipa_ioc_rm_dependency dep;
IPACMDBG_H(" Got rm del-depend index : %d \n", rm1);
/* ipa_rm_a2_check: IPA_RM_RESOURCE_Q6_CONS*/
if(rm1 == IPA_RM_RESOURCE_Q6_CONS)
{
ipa_rm_a2_check-=1;
IPACMDBG_H("Left %d times default RT routing from A2 \n", ipa_rm_a2_check);
}
for(int i=0;i<ipa_max_valid_rm_entry;i++)
{
if(rm1 == ipa_rm_tbl[i].producer_rm1)
{
if(ipa_rm_tbl[i].rm_set == true)
{
IPACMDBG_H("Matched RM_table entry: %d's producer_rm1 and dependency is up \n", i);
ipa_rm_tbl[i].rm_set = false;
/* delete bi-directional dependency*/
if(ipa_rm_tbl[i].rx_bypass_ipa)
{
IPACMDBG_H("Skip DEL entry %d's dependency between WLAN-Pro: %d, Con: %d \n", i, ipa_rm_tbl[i].producer_rm1,ipa_rm_tbl[i].consumer_rm1);
}
else
{
memset(&dep, 0, sizeof(dep));
dep.resource_name = ipa_rm_tbl[i].producer_rm1;
dep.depends_on_name = ipa_rm_tbl[i].consumer_rm1;
retval = ioctl(m_fd, IPA_IOC_RM_DEL_DEPENDENCY, &dep);
IPACMDBG_H("Delete entry %d's dependency between Pro: %d, Con: %d \n", i,dep.resource_name,dep.depends_on_name);
if (retval)
{
IPACMERR("Failed deleting dependecny for RM_table entry %d's bi-direction dependency (error:%d) \n", i,retval);
}
}
memset(&dep, 0, sizeof(dep));
dep.resource_name = ipa_rm_tbl[i].producer_rm2;
dep.depends_on_name = ipa_rm_tbl[i].consumer_rm2;
retval = ioctl(m_fd, IPA_IOC_RM_DEL_DEPENDENCY, &dep);
IPACMDBG_H("Delete entry %d's dependency between Pro: %d, Con: %d \n", i,dep.resource_name,dep.depends_on_name);
if (retval)
{
IPACMERR("Failed deleting dependecny for RM_table entry %d's bi-direction dependency (error:%d) \n", i,retval);
}
}
ipa_rm_tbl[i].producer1_up = false;
ipa_rm_tbl[i].rx_bypass_ipa = false;
}
if(rm1 == ipa_rm_tbl[i].consumer_rm1)
{
/* ipa_rm_a2_check: IPA_RM_RESOURCE_!6_CONS*/
if(ipa_rm_tbl[i].consumer_rm1 == IPA_RM_RESOURCE_Q6_CONS && ipa_rm_a2_check == 1)
{
IPACMDBG_H(" still have %d default RT routing from A2 \n", ipa_rm_a2_check);
continue;
}
if(ipa_rm_tbl[i].rm_set == true)
{
IPACMDBG_H("Matched RM_table entry: %d's consumer_rm1 and dependency is up \n", i);
ipa_rm_tbl[i].rm_set = false;
/* delete bi-directional dependency*/
if(ipa_rm_tbl[i].rx_bypass_ipa)
{
IPACMDBG_H("Skip DEL entry %d's dependency between WLAN-Pro: %d, Con: %d \n", i, ipa_rm_tbl[i].producer_rm1,ipa_rm_tbl[i].consumer_rm1);
}
else
{
memset(&dep, 0, sizeof(dep));
dep.resource_name = ipa_rm_tbl[i].producer_rm1;
dep.depends_on_name = ipa_rm_tbl[i].consumer_rm1;
retval = ioctl(m_fd, IPA_IOC_RM_DEL_DEPENDENCY, &dep);
IPACMDBG_H("Delete entry %d's dependency between Pro: %d, Con: %d \n", i,dep.resource_name,dep.depends_on_name);
if (retval)
{
IPACMERR("Failed deleting dependecny for RM_table entry %d's bi-direction dependency (error:%d) \n", i,retval);
}
}
memset(&dep, 0, sizeof(dep));
dep.resource_name = ipa_rm_tbl[i].producer_rm2;
dep.depends_on_name = ipa_rm_tbl[i].consumer_rm2;
retval = ioctl(m_fd, IPA_IOC_RM_DEL_DEPENDENCY, &dep);
IPACMDBG_H("Delete entry %d's dependency between Pro: %d, Con: %d \n", i,dep.resource_name,dep.depends_on_name);
if (retval)
{
IPACMERR("Failed deleting dependecny for RM_table entry %d's bi-direction dependency (error:%d) \n", i,retval);
}
}
ipa_rm_tbl[i].consumer1_up = false;
}
}
return ;
}
int IPACM_Config::SetExtProp(ipa_ioc_query_intf_ext_props *prop)
{
int i, num;
if(prop == NULL || prop->num_ext_props <= 0)
{
IPACMERR("There is no extended property!\n");
return IPACM_FAILURE;
}
num = prop->num_ext_props;
for(i=0; i<num; i++)
{
if(prop->ext[i].ip == IPA_IP_v4)
{
if(ext_prop_v4.num_ext_props >= MAX_NUM_EXT_PROPS)
{
IPACMERR("IPv4 extended property table is full!\n");
continue;
}
memcpy(&ext_prop_v4.prop[ext_prop_v4.num_ext_props], &prop->ext[i], sizeof(struct ipa_ioc_ext_intf_prop));
ext_prop_v4.num_ext_props++;
}
else if(prop->ext[i].ip == IPA_IP_v6)
{
if(ext_prop_v6.num_ext_props >= MAX_NUM_EXT_PROPS)
{
IPACMERR("IPv6 extended property table is full!\n");
continue;
}
memcpy(&ext_prop_v6.prop[ext_prop_v6.num_ext_props], &prop->ext[i], sizeof(struct ipa_ioc_ext_intf_prop));
ext_prop_v6.num_ext_props++;
}
else
{
IPACMERR("The IP type is not expected!\n");
return IPACM_FAILURE;
}
}
IPACMDBG_H("Set extended property succeeded.\n");
return IPACM_SUCCESS;
}
ipacm_ext_prop* IPACM_Config::GetExtProp(ipa_ip_type ip_type)
{
if(ip_type == IPA_IP_v4)
return &ext_prop_v4;
else if(ip_type == IPA_IP_v6)
return &ext_prop_v6;
else
{
IPACMERR("Failed to get extended property: the IP version is neither IPv4 nor IPv6!\n");
return NULL;
}
}
int IPACM_Config::DelExtProp(ipa_ip_type ip_type)
{
if(ip_type != IPA_IP_v6)
{
memset(&ext_prop_v4, 0, sizeof(ext_prop_v4));
}
if(ip_type != IPA_IP_v4)
{
memset(&ext_prop_v6, 0, sizeof(ext_prop_v6));
}
return IPACM_SUCCESS;
}
const char* IPACM_Config::getEventName(ipa_cm_event_id event_id)
{
if(event_id >= sizeof(ipacm_event_name)/sizeof(ipacm_event_name[0]))
{
IPACMERR("Event name array is not consistent with event array!\n");
return NULL;
}
return ipacm_event_name[event_id];
}

652
data-ipa-cfg-mgr/ipacm/src/IPACM_ConntrackClient.cpp
View File

@@ -1,652 +0,0 @@
/*
Copyright (c) 2013-2016, 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 <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_Iface.h"
#include "IPACM_ConntrackListener.h"
#include "IPACM_ConntrackClient.h"
#include "IPACM_Log.h"
#define LO_NAME "lo"
extern IPACM_EvtDispatcher cm_dis;
extern void ParseCTMessage(struct nf_conntrack *ct);
IPACM_ConntrackClient *IPACM_ConntrackClient::pInstance = NULL;
IPACM_ConntrackListener *CtList = NULL;
/* ================================
Local Function Definitions
=================================
*/
IPACM_ConntrackClient::IPACM_ConntrackClient()
{
IPACMDBG("\n");
tcp_hdl = NULL;
udp_hdl = NULL;
tcp_filter = NULL;
udp_filter = NULL;
}
IPACM_ConntrackClient* IPACM_ConntrackClient::GetInstance()
{
if(pInstance == NULL)
{
pInstance = new IPACM_ConntrackClient();
pInstance->udp_filter = nfct_filter_create();
if(pInstance->udp_filter == NULL)
{
IPACMERR("unable to create UDP filter\n");
delete pInstance;
return NULL;
}
IPACMDBG("Created UDP filter\n");
pInstance->tcp_filter = nfct_filter_create();
if(pInstance->tcp_filter == NULL)
{
IPACMERR("unable to create TCP filter\n");
delete pInstance;
return NULL;
}
IPACMDBG("Created TCP filter\n");
}
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;
uint8_t ip_type = 0;
IPACMDBG("Event callback called with msgtype: %d\n",type);
/* Retrieve ip type */
ip_type = nfct_get_attr_u8(ct, ATTR_REPL_L3PROTO);
#ifndef CT_OPT
if(AF_INET6 == ip_type)
{
IPACMDBG("Ignoring ipv6(%d) connections\n", ip_type);
goto IGNORE;
}
#endif
ct_data = (ipacm_ct_evt_data *)malloc(sizeof(ipacm_ct_evt_data));
if(ct_data == NULL)
{
IPACMERR("unable to allocate memory \n");
goto IGNORE;
}
ct_data->ct = ct;
ct_data->type = type;
evt_data.event = IPA_PROCESS_CT_MESSAGE;
evt_data.evt_data = (void *)ct_data;
#ifdef CT_OPT
if(AF_INET6 == ip_type)
{
evt_data.event = IPA_PROCESS_CT_MESSAGE_V6;
}
#endif
if(0 != IPACM_EvtDispatcher::PostEvt(&evt_data))
{
IPACMERR("Error sending Conntrack message to processing thread!\n");
free(ct_data);
goto IGNORE;
}
/* 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;
IGNORE:
nfct_destroy(ct);
return NFCT_CB_STOLEN;
}
int IPACM_ConntrackClient::IPA_Conntrack_Filters_Ignore_Bridge_Addrs
(
struct nfct_filter *filter
)
{
int fd;
fd = socket(AF_INET, SOCK_DGRAM, 0);
if(fd < 0)
{
PERROR("unable to open socket");
return -1;
}
int ret;
uint32_t ipv4_addr;
struct ifreq ifr;
/* retrieve bridge interface ipv4 address */
memset(&ifr, 0, sizeof(struct ifreq));
ifr.ifr_addr.sa_family = AF_INET;
(void)strncpy(ifr.ifr_name, IPACM_Iface::ipacmcfg->ipa_virtual_iface_name, sizeof(ifr.ifr_name));
IPACMDBG("bridge interface name (%s)\n", ifr.ifr_name);
ret = ioctl(fd, SIOCGIFADDR, &ifr);
if (ret < 0)
{
IPACMERR("unable to retrieve (%s) interface address\n",ifr.ifr_name);
close(fd);
return -1;
}
IPACMDBG("Interface (%s) address %s\n", ifr.ifr_name, inet_ntoa(((struct sockaddr_in *)&ifr.ifr_addr)->sin_addr));
ipv4_addr = ntohl(((struct sockaddr_in *)&ifr.ifr_addr)->sin_addr.s_addr);
close(fd);
/* ignore whatever is destined to or originates from broadcast ip address */
struct nfct_filter_ipv4 filter_ipv4;
filter_ipv4.addr = ipv4_addr;
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);
return 0;
}
int IPACM_ConntrackClient::IPA_Conntrack_Filters_Ignore_Local_Iface
(
struct nfct_filter *filter,
ipacm_event_iface_up *param
)
{
struct nfct_filter_ipv4 filter_ipv4;
filter_ipv4.addr = param->ipv4_addr;
filter_ipv4.mask = 0xffffffff;
/* ignore whatever is destined to local interfaces */
IPACMDBG("Ignore connections destinated to interface %s", param->ifname);
iptodot("with ipv4 address", param->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 from interface %s", param->ifname);
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);
/* Retrieve broadcast address */
/* Intialize with 255.255.255.255 */
uint32_t bc_ip_addr = 0xFFFFFFFF;
/* calculate broadcast address from addr and addr_mask */
bc_ip_addr = (bc_ip_addr & (~param->addr_mask));
bc_ip_addr = (bc_ip_addr | (param->ipv4_addr & param->addr_mask));
/* netfitler expecting in host-byte order */
filter_ipv4.addr = bc_ip_addr;
filter_ipv4.mask = 0xffffffff;
iptodot("with broadcast 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);
return 0;
}
/* 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
)
{
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);
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 = 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();
if(pClient == NULL)
{
IPACMERR("unable to get conntrack client instance\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)
{
NatApp *nat_inst = NULL;
#ifdef IPACM_DEBUG
IPACMDBG("\n");
#endif
nat_inst = NatApp::GetInstance();
if(nat_inst == NULL)
{
IPACMERR("unable to create nat instance\n");
return NULL;
}
while(1)
{
nat_inst->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;
unsigned subscrips = 0;
IPACMDBG("\n");
pClient = IPACM_ConntrackClient::GetInstance();
if(pClient == NULL)
{
IPACMERR("unable to get conntrack client instance\n");
return NULL;
}
subscrips = (NF_NETLINK_CONNTRACK_UPDATE | NF_NETLINK_CONNTRACK_DESTROY);
#ifdef CT_OPT
subscrips |= NF_NETLINK_CONNTRACK_NEW;
#endif
pClient->tcp_hdl = nfct_open(CONNTRACK, subscrips);
if(pClient->tcp_hdl == NULL)
{
PERROR("nfct_open\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_H("tcp handle:%p, fd:%d\n", pClient->tcp_hdl, nfct_fd(pClient->tcp_hdl));
#ifndef CT_OPT
nfct_callback_register(pClient->tcp_hdl,
(nf_conntrack_msg_type) (NFCT_T_UPDATE | NFCT_T_DESTROY | NFCT_T_NEW),
IPAConntrackEventCB, NULL);
#else
nfct_callback_register(pClient->tcp_hdl, (nf_conntrack_msg_type) NFCT_T_ALL, IPAConntrackEventCB, NULL);
#endif
/* 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;
}
/* 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_H("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 */
ctcatch:
ret = nfct_catch(pClient->udp_hdl);
if(ret == -1)
{
IPACMDBG("(%d)(%s)\n", ret, strerror(errno));
return NULL;
}
else
{
IPACMDBG("ctcatch ret:%d\n", ret);
goto ctcatch;
}
IPACMDBG("Exit from udp thread with ret: %d\n", ret);
/* 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, bool isWan)
{
static bool isIgnore = false;
int ret = 0;
IPACM_ConntrackClient *pClient = NULL;
pClient = IPACM_ConntrackClient::GetInstance();
if(pClient == NULL)
{
IPACMERR("unable to retrieve conntrack client instance\n");
return;
}
if(pClient->udp_filter == NULL)
{
return;
}
if(!isWan)
{
IPA_Conntrack_Filters_Ignore_Local_Iface(pClient->udp_filter,
(ipacm_event_iface_up *)param);
if(!isIgnore)
{
IPA_Conntrack_Filters_Ignore_Bridge_Addrs(pClient->udp_filter);
IPA_Conntrack_Filters_Ignore_Local_Addrs(pClient->udp_filter);
isIgnore = true;
}
}
/* 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, bool isWan)
{
static bool isIgnore = false;
int ret = 0;
IPACM_ConntrackClient *pClient = NULL;
pClient = IPACM_ConntrackClient::GetInstance();
if(pClient == NULL)
{
IPACMERR("unable to retrieve conntrack client instance\n");
return;
}
if(pClient->tcp_filter == NULL)
return;
if(!isWan)
{
IPA_Conntrack_Filters_Ignore_Local_Iface(pClient->tcp_filter,
(ipacm_event_iface_up *)param);
if(!isIgnore)
{
IPA_Conntrack_Filters_Ignore_Bridge_Addrs(pClient->udp_filter);
IPA_Conntrack_Filters_Ignore_Local_Addrs(pClient->udp_filter);
isIgnore = true;
}
}
/* 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;
}

1200
data-ipa-cfg-mgr/ipacm/src/IPACM_ConntrackListener.cpp
View File

File diff suppressed because it is too large Load Diff

969
data-ipa-cfg-mgr/ipacm/src/IPACM_Conntrack_NATApp.cpp
View File

@@ -1,969 +0,0 @@
/*
Copyright (c) 2013-2016, 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 INVALID_IP_ADDR 0x0
/* 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;
memset(temp, 0, sizeof(temp));
}
int NatApp::Init(void)
{
IPACM_Config *pConfig;
int size = 0;
pConfig = IPACM_Config::GetInstance();
if(pConfig == NULL)
{
IPACMERR("Unable to get Config instance\n");
return -1;
}
max_entries = pConfig->GetNatMaxEntries();
size = (sizeof(nat_table_entry) * max_entries);
cache = (nat_table_entry *)malloc(size);
if(cache == NULL)
{
IPACMERR("Unable to allocate memory for cache\n");
goto fail;
}
IPACMDBG("Allocated %d bytes for config manager nat cache\n", size);
memset(cache, 0, size);
nALGPort = pConfig->GetAlgPortCnt();
if(nALGPort > 0)
{
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;
int cnt = 0;
ipa_nat_ipv4_rule nat_rule;
IPACMDBG_H("%s() %d\n", __FUNCTION__, __LINE__);
/* Not reset the cache wait it timeout by destroy event */
#if 0
if (pub_ip != pub_ip_addr_pre)
{
IPACMDBG("Reset the cache because NAT-ipv4 different\n");
memset(cache, 0, sizeof(nat_table_entry) * max_entries);
curCnt = 0;
}
#endif
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;
}
/* Add back the cached NAT-entry */
if (pub_ip == pub_ip_addr_pre)
{
IPACMDBG("Restore the cache to ipa NAT-table\n");
for(cnt = 0; cnt < max_entries; cnt++)
{
if(cache[cnt].private_ip !=0)
{
memset(&nat_rule, 0 , sizeof(nat_rule));
nat_rule.private_ip = cache[cnt].private_ip;
nat_rule.target_ip = cache[cnt].target_ip;
nat_rule.target_port = cache[cnt].target_port;
nat_rule.private_port = cache[cnt].private_port;
nat_rule.public_port = cache[cnt].public_port;
nat_rule.protocol = cache[cnt].protocol;
if(ipa_nat_add_ipv4_rule(nat_table_hdl, &nat_rule, &cache[cnt].rule_hdl) < 0)
{
IPACMERR("unable to add the rule delete from cache\n");
memset(&cache[cnt], 0, sizeof(cache[cnt]));
curCnt--;
continue;
}
cache[cnt].enabled = true;
IPACMDBG("On wan-iface reset added below rule successfully\n");
iptodot("Private IP", nat_rule.private_ip);
iptodot("Target IP", nat_rule.target_ip);
IPACMDBG("Private Port:%d \t Target Port: %d\t", nat_rule.private_port, nat_rule.target_port);
IPACMDBG("Public Port:%d\n", nat_rule.public_port);
IPACMDBG("protocol: %d\n", nat_rule.protocol);
}
}
}
pub_ip_addr = pub_ip;
return 0;
}
void NatApp::Reset()
{
int cnt = 0;
nat_table_hdl = 0;
pub_ip_addr = 0;
/* NAT tbl deleted, reset enabled bit */
for(cnt = 0; cnt < max_entries; cnt++)
{
cache[cnt].enabled = false;
}
}
int NatApp::DeleteTable(uint32_t pub_ip)
{
int ret;
IPACMDBG_H("%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;
}
pub_ip_addr_pre = pub_ip_addr;
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 < 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)
{
log_nat(rule->protocol,rule->private_ip,rule->target_ip,rule->private_port,\
rule->target_port,"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__);
log_nat(rule->protocol,rule->private_ip,rule->target_ip,rule->private_port,\
rule->target_port,"for deletion\n");
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(cache[cnt].enabled == true)
{
if(ipa_nat_del_ipv4_rule(nat_table_hdl, cache[cnt].rule_hdl) < 0)
{
IPACMERR("%s() %d deletion failed\n", __FUNCTION__, __LINE__);
}
IPACMDBG_H("Deleted Nat entry(%d) Successfully\n", cnt);
}
else
{
IPACMDBG_H("Deleted Nat entry(%d) only from cache\n", cnt);
}
memset(&cache[cnt], 0, sizeof(cache[cnt]));
curCnt--;
break;
}
}
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();
log_nat(rule->protocol,rule->private_ip,rule->target_ip,rule->private_port,\
rule->target_port,"for addition\n");
if(isAlgPort(rule->protocol, rule->private_port) ||
isAlgPort(rule->protocol, rule->target_port))
{
IPACMERR("connection using ALG Port, ignore\n");
return -1;
}
if(rule->private_ip == 0 ||
rule->target_ip == 0 ||
rule->private_port == 0 ||
rule->target_port == 0 ||
rule->protocol == 0)
{
IPACMERR("Invalid Connection, ignoring it\n");
return 0;
}
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(isPwrSaveIf(rule->private_ip) ||
isPwrSaveIf(rule->target_ip))
{
IPACMDBG("Device is Power Save mode: Dont insert into nat table but cache\n");
cache[cnt].enabled = false;
cache[cnt].rule_hdl = 0;
}
else
{
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].enabled = true;
}
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;
}
if(cache[cnt].enabled == true)
{
IPACMDBG_H("Added rule(%d) successfully\n", cnt);
}
else
{
IPACMDBG_H("Cached rule(%d) successfully\n", cnt);
}
return 0;
}
void NatApp::UpdateCTUdpTs(nat_table_entry *rule, uint32_t new_ts)
{
int ret;
iptodot("Private IP:", rule->private_ip);
iptodot("Target IP:", rule->target_ip);
IPACMDBG("Private Port: %d, Target Port: %d\n", rule->private_port, rule->target_port);
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);
if(rule->protocol == IPPROTO_UDP)
{
nfct_set_attr_u8(ct, ATTR_L4PROTO, rule->protocol);
nfct_set_attr_u32(ct, ATTR_TIMEOUT, udp_timeout);
}
else
{
nfct_set_attr_u8(ct, ATTR_L4PROTO, rule->protocol);
nfct_set_attr_u32(ct, ATTR_TIMEOUT, tcp_timeout);
}
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");
}
iptodot("Source IP:", nfct_get_attr_u32(ct, ATTR_IPV4_SRC));
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 %d connection with time: %d\n",
rule->protocol, nfct_get_attr_u32(ct, ATTR_TIMEOUT));
ret = nfct_query(ct_hdl, NFCT_Q_UPDATE, ct);
if(ret == -1)
{
IPACMERR("unable to update time stamp");
DeleteEntry(rule);
}
else
{
rule->timestamp = new_ts;
IPACMDBG("Updated time stamp successfully\n");
}
return;
}
void NatApp::UpdateUDPTimeStamp()
{
int cnt;
uint32_t ts;
bool read_to = false;
for(cnt = 0; cnt < max_entries; cnt++)
{
ts = 0;
if(cache[cnt].enabled == true &&
(cache[cnt].private_ip != cache[cnt].public_ip))
{
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(cache[cnt].timestamp == ts)
{
IPACMDBG("No Change in Time Stamp: cahce:%d, ipahw:%d\n",
cache[cnt].timestamp, ts);
continue;
}
if (read_to == false) {
read_to = true;
Read_TcpUdp_Timeout();
}
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;
IPACMDBG_H("Received IP address: 0x%x\n", client_lan_ip);
if(client_lan_ip == INVALID_IP_ADDR)
{
IPACMERR("Invalid ip address received\n");
return -1;
}
/* check for duplicate events */
for(cnt = 0; cnt < IPA_MAX_NUM_WIFI_CLIENTS; cnt++)
{
if(PwrSaveIfs[cnt] == client_lan_ip)
{
IPACMDBG("The client 0x%x is already in power save\n", client_lan_ip);
return 0;
}
}
for(cnt = 0; cnt < IPA_MAX_NUM_WIFI_CLIENTS; cnt++)
{
if(PwrSaveIfs[cnt] == 0)
{
PwrSaveIfs[cnt] = client_lan_ip;
break;
}
}
for(cnt = 0; cnt < max_entries; cnt++)
{
if(cache[cnt].private_ip == client_lan_ip &&
cache[cnt].enabled == true)
{
if(ipa_nat_del_ipv4_rule(nat_table_hdl, cache[cnt].rule_hdl) < 0)
{
IPACMERR("unable to delete the rule\n");
continue;
}
cache[cnt].enabled = false;
cache[cnt].rule_hdl = 0;
}
}
return 0;
}
int NatApp::ResetPwrSaveIf(uint32_t client_lan_ip)
{
int cnt;
ipa_nat_ipv4_rule nat_rule;
IPACMDBG_H("Received ip address: 0x%x\n", client_lan_ip);
if(client_lan_ip == INVALID_IP_ADDR)
{
IPACMERR("Invalid ip address received\n");
return -1;
}
for(cnt = 0; cnt < IPA_MAX_NUM_WIFI_CLIENTS; cnt++)
{
if(PwrSaveIfs[cnt] == client_lan_ip)
{
PwrSaveIfs[cnt] = 0;
break;
}
}
for(cnt = 0; cnt < max_entries; cnt++)
{
IPACMDBG("cache (%d): enable %d, ip 0x%x\n", cnt, cache[cnt].enabled, cache[cnt].private_ip);
if(cache[cnt].private_ip == client_lan_ip &&
cache[cnt].enabled == false)
{
memset(&nat_rule, 0 , sizeof(nat_rule));
nat_rule.private_ip = cache[cnt].private_ip;
nat_rule.target_ip = cache[cnt].target_ip;
nat_rule.target_port = cache[cnt].target_port;
nat_rule.private_port = cache[cnt].private_port;
nat_rule.public_port = cache[cnt].public_port;
nat_rule.protocol = cache[cnt].protocol;
if(ipa_nat_add_ipv4_rule(nat_table_hdl, &nat_rule, &cache[cnt].rule_hdl) < 0)
{
IPACMERR("unable to add the rule delete from cache\n");
memset(&cache[cnt], 0, sizeof(cache[cnt]));
curCnt--;
continue;
}
cache[cnt].enabled = true;
IPACMDBG("On power reset added below rule successfully\n");
iptodot("Private IP", nat_rule.private_ip);
iptodot("Target IP", nat_rule.target_ip);
IPACMDBG("Private Port:%d \t Target Port: %d\t", nat_rule.private_port, nat_rule.target_port);
IPACMDBG("Public Port:%d\n", nat_rule.public_port);
IPACMDBG("protocol: %d\n", nat_rule.protocol);
}
}
return -1;
}
uint32_t NatApp::GetTableHdl(uint32_t in_ip_addr)
{
if(in_ip_addr == pub_ip_addr)
{
return nat_table_hdl;
}
return -1;
}
void NatApp::AddTempEntry(const nat_table_entry *new_entry)
{
int cnt;
IPACMDBG("Received below Temp Nat entry\n");
iptodot("Private IP", new_entry->private_ip);
iptodot("Target IP", new_entry->target_ip);
IPACMDBG("Private Port: %d\t Target Port: %d\t", new_entry->private_port, new_entry->target_port);
IPACMDBG("protocolcol: %d\n", new_entry->protocol);
if(isAlgPort(new_entry->protocol, new_entry->private_port) ||
isAlgPort(new_entry->protocol, new_entry->target_port))
{
IPACMDBG("connection using ALG Port. Dont insert into nat cache\n");
return;
}
if(ChkForDup(new_entry))
{
return;
}
for(cnt=0; cnt<MAX_TEMP_ENTRIES; cnt++)
{
if(temp[cnt].private_ip == new_entry->private_ip &&
temp[cnt].target_ip == new_entry->target_ip &&
temp[cnt].private_port == new_entry->private_port &&
temp[cnt].target_port == new_entry->target_port &&
temp[cnt].protocol == new_entry->protocol)
{
IPACMDBG("Received duplicate Temp entry\n");
return;
}
}
for(cnt=0; cnt<MAX_TEMP_ENTRIES; cnt++)
{
if(temp[cnt].private_ip == 0 &&
temp[cnt].target_ip == 0)
{
memcpy(&temp[cnt], new_entry, sizeof(nat_table_entry));
IPACMDBG("Added Temp Entry\n");
return;
}
}
IPACMDBG("Unable to add temp entry, cache full\n");
return;
}
void NatApp::DeleteTempEntry(const nat_table_entry *entry)
{
int cnt;
IPACMDBG("Received below nat entry\n");
iptodot("Private IP", entry->private_ip);
iptodot("Target IP", entry->target_ip);
IPACMDBG("Private Port: %d\t Target Port: %d\n", entry->private_port, entry->target_port);
IPACMDBG("protocol: %d\n", entry->protocol);
for(cnt=0; cnt<MAX_TEMP_ENTRIES; cnt++)
{
if(temp[cnt].private_ip == entry->private_ip &&
temp[cnt].target_ip == entry->target_ip &&
temp[cnt].private_port == entry->private_port &&
temp[cnt].target_port == entry->target_port &&
temp[cnt].protocol == entry->protocol)
{
memset(&temp[cnt], 0, sizeof(nat_table_entry));
IPACMDBG("Delete Temp Entry\n");
return;
}
}
IPACMDBG("No Such Temp Entry exists\n");
return;
}
void NatApp::FlushTempEntries(uint32_t ip_addr, bool isAdd,
bool isDummy)
{
int cnt;
int ret;
IPACMDBG_H("Received below with isAdd:%d ", isAdd);
iptodot("IP Address: ", ip_addr);
for(cnt=0; cnt<MAX_TEMP_ENTRIES; cnt++)
{
if(temp[cnt].private_ip == ip_addr ||
temp[cnt].target_ip == ip_addr)
{
if(isAdd)
{
if(temp[cnt].public_ip == pub_ip_addr)
{
if (isDummy) {
/* To avoild DL expections for non IPA path */
temp[cnt].private_ip = temp[cnt].public_ip;
temp[cnt].private_port = temp[cnt].public_port;
IPACMDBG("Flushing dummy temp rule");
iptodot("Private IP", temp[cnt].private_ip);
}
ret = AddEntry(&temp[cnt]);
if(ret)
{
IPACMERR("unable to add temp entry: %d\n", ret);
continue;
}
}
}
memset(&temp[cnt], 0, sizeof(nat_table_entry));
}
}
return;
}
int NatApp::DelEntriesOnClntDiscon(uint32_t ip_addr)
{
int cnt, tmp = 0;
IPACMDBG_H("Received IP address: 0x%x\n", ip_addr);
if(ip_addr == INVALID_IP_ADDR)
{
IPACMERR("Invalid ip address received\n");
return -1;
}
for(cnt = 0; cnt < IPA_MAX_NUM_WIFI_CLIENTS; cnt++)
{
if(PwrSaveIfs[cnt] == ip_addr)
{
PwrSaveIfs[cnt] = 0;
IPACMDBG("Remove %d power save entry\n", cnt);
break;
}
}
for(cnt = 0; cnt < max_entries; cnt++)
{
if(cache[cnt].private_ip == ip_addr)
{
if(cache[cnt].enabled == true)
{
if(ipa_nat_del_ipv4_rule(nat_table_hdl, cache[cnt].rule_hdl) < 0)
{
IPACMERR("unable to delete the rule\n");
continue;
}
else
{
IPACMDBG("won't delete the rule\n");
cache[cnt].enabled = false;
tmp++;
}
}
IPACMDBG("won't delete the rule for entry %d, enabled %d\n",cnt, cache[cnt].enabled);
}
}
IPACMDBG("Deleted (but cached) %d entries\n", tmp);
return 0;
}
int NatApp::DelEntriesOnSTAClntDiscon(uint32_t ip_addr)
{
int cnt, tmp = curCnt;
IPACMDBG_H("Received IP address: 0x%x\n", ip_addr);
if(ip_addr == INVALID_IP_ADDR)
{
IPACMERR("Invalid ip address received\n");
return -1;
}
for(cnt = 0; cnt < max_entries; cnt++)
{
if(cache[cnt].target_ip == ip_addr)
{
if(cache[cnt].enabled == true)
{
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--;
}
}
IPACMDBG("Deleted %d entries\n", (tmp - curCnt));
return 0;
}
void NatApp::CacheEntry(const nat_table_entry *rule)
{
int cnt;
if(rule->private_ip == 0 ||
rule->target_ip == 0 ||
rule->private_port == 0 ||
rule->target_port == 0 ||
rule->protocol == 0)
{
IPACMERR("Invalid Connection, ignoring it\n");
return;
}
if(!ChkForDup(rule))
{
for(cnt=0; 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;
}
else
{
cache[cnt].enabled = false;
cache[cnt].rule_hdl = 0;
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].public_ip = rule->public_ip;
cache[cnt].dst_nat = rule->dst_nat;
curCnt++;
}
}
else
{
IPACMERR("Duplicate rule. Ignore it\n");
return;
}
IPACMDBG("Cached rule(%d) successfully\n", cnt);
return;
}
void NatApp::Read_TcpUdp_Timeout(void) {
FILE *udp_fd = NULL, *tcp_fd = NULL;
/* Read UDP timeout value */
udp_fd = fopen(IPACM_UDP_FULL_FILE_NAME, "r");
if (udp_fd == NULL) {
IPACMERR("unable to open %s\n", IPACM_UDP_FULL_FILE_NAME);
goto fail;
}
if (fscanf(udp_fd, "%d", &udp_timeout) != 1) {
IPACMERR("Error reading udp timeout\n");
}
IPACMDBG_H("udp timeout value: %d\n", udp_timeout);
/* Read TCP timeout value */
tcp_fd = fopen(IPACM_TCP_FULL_FILE_NAME, "r");
if (tcp_fd == NULL) {
IPACMERR("unable to open %s\n", IPACM_TCP_FULL_FILE_NAME);
goto fail;
}
if (fscanf(tcp_fd, "%d", &tcp_timeout) != 1) {
IPACMERR("Error reading tcp timeout\n");
}
IPACMDBG_H("tcp timeout value: %d\n", tcp_timeout);
fail:
if (udp_fd) {
fclose(udp_fd);
}
if (tcp_fd) {
fclose(tcp_fd);
}
return;
}

214
data-ipa-cfg-mgr/ipacm/src/IPACM_EvtDispatcher.cpp
View File

@@ -1,214 +0,0 @@
/*
Copyright (c) 2013-2016, 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;
extern uint32_t ipacm_event_stats[IPACM_EVENT_MAX];
int IPACM_EvtDispatcher::PostEvt
(
ipacm_cmd_q_data *data
)
{
Message *item = NULL;
MessageQueue *MsgQueue = NULL;
if(data->event < IPA_EXTERNAL_EVENT_MAX)
{
IPACMDBG("Insert event into external queue.\n");
MsgQueue = MessageQueue::getInstanceExternal();
}
else
{
IPACMDBG("Insert event into internal queue.\n");
MsgQueue = MessageQueue::getInstanceInternal();
}
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;
}
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, tmp1;
if(head == NULL)
{
IPACMDBG("Queue is empty\n");
}
while(tmp != NULL)
{
memcpy(&tmp1, tmp, sizeof(tmp1));
if(data->event == tmp1.event)
{
ipacm_event_stats[data->event]++;
tmp1.obj->event_callback(data->event, data->evt_data);
IPACMDBG(" Find matched registered events\n");
}
tmp = tmp1.next;
}
IPACMDBG(" Finished process events\n");
if(data->evt_data != NULL)
{
IPACMDBG("free the event:%d data: %p\n", data->event, data->evt_data);
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;
}

536
data-ipa-cfg-mgr/ipacm/src/IPACM_Filtering.cpp
View File

@@ -1,536 +0,0 @@
/*
Copyright (c) 2013-2016, 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>
#include "IPACM_Defs.h"
const char *IPACM_Filtering::DEVICE_NAME = "/dev/ipa";
IPACM_Filtering::IPACM_Filtering()
{
fd = open(DEVICE_NAME, O_RDWR);
if (fd < 0)
{
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::AddFilteringRuleAfter(struct ipa_ioc_add_flt_rule_after const *ruleTable)
{
#ifdef FEATURE_IPA_V3
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\n", ruleTable->ep);
IPACMDBG("commit value: %d\n", ruleTable->commit);
retval = ioctl(fd, IPA_IOC_ADD_FLT_RULE_AFTER, ruleTable);
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);
}
}
if (retval != 0)
{
IPACMERR("Failed adding Filtering rule %p\n", ruleTable);
return false;
}
IPACMDBG("Added Filtering rule %p\n", ruleTable);
#endif
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;
const uint8_t UNIT_RULES = 1;
len = (sizeof(struct ipa_ioc_del_flt_rule)) + (UNIT_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;
}
for (cnt = 0; cnt < num_rules; cnt++)
{
memset(flt_rule, 0, len);
flt_rule->commit = 1;
flt_rule->num_hdls = UNIT_RULES;
flt_rule->ip = ip;
if (flt_rule_hdls[cnt] == 0)
{
IPACMERR("invalid filter handle passed, ignoring it: %d\n", cnt)
}
else
{
flt_rule->hdl[0].status = -1;
flt_rule->hdl[0].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;
}
else
{
if (flt_rule->hdl[0].status != 0)
{
IPACMERR("Filter rule hdl 0x%x deletion failed with error:%d\n",
flt_rule->hdl[0].hdl, flt_rule->hdl[0].status);
res = false;
goto fail;
}
}
}
}
fail:
free(flt_rule);
return res;
}
bool IPACM_Filtering::AddWanDLFilteringRule(struct ipa_ioc_add_flt_rule const *rule_table_v4, struct ipa_ioc_add_flt_rule const * rule_table_v6, uint8_t mux_id)
{
int ret = 0, cnt, num_rules = 0, pos = 0;
ipa_install_fltr_rule_req_msg_v01 qmi_rule_msg;
#ifdef FEATURE_IPA_V3
ipa_install_fltr_rule_req_ex_msg_v01 qmi_rule_ex_msg;
#endif
int fd_wwan_ioctl = open(WWAN_QMI_IOCTL_DEVICE_NAME, O_RDWR);
if(fd_wwan_ioctl < 0)
{
IPACMERR("Failed to open %s.\n",WWAN_QMI_IOCTL_DEVICE_NAME);
return false;
}
if(rule_table_v4 != NULL)
{
num_rules += rule_table_v4->num_rules;
IPACMDBG_H("Get %d WAN DL IPv4 filtering rules.\n", rule_table_v4->num_rules);
}
if(rule_table_v6 != NULL)
{
num_rules += rule_table_v6->num_rules;
IPACMDBG_H("Get %d WAN DL IPv6 filtering rules.\n", rule_table_v6->num_rules);
}
/* if it is not IPA v3, use old QMI format */
#ifndef FEATURE_IPA_V3
if(num_rules > QMI_IPA_MAX_FILTERS_V01)
{
IPACMERR("The number of filtering rules exceed limit.\n");
close(fd_wwan_ioctl);
return false;
}
else
{
memset(&qmi_rule_msg, 0, sizeof(qmi_rule_msg));
if (num_rules > 0)
{
qmi_rule_msg.filter_spec_list_valid = true;
}
else
{
qmi_rule_msg.filter_spec_list_valid = false;
}
qmi_rule_msg.filter_spec_list_len = num_rules;
qmi_rule_msg.source_pipe_index_valid = 0;
IPACMDBG_H("Get %d WAN DL filtering rules in total.\n", num_rules);
if(rule_table_v4 != NULL)
{
for(cnt = rule_table_v4->num_rules - 1; cnt >= 0; cnt--)
{
if (pos < QMI_IPA_MAX_FILTERS_V01)
{
qmi_rule_msg.filter_spec_list[pos].filter_spec_identifier = pos;
qmi_rule_msg.filter_spec_list[pos].ip_type = QMI_IPA_IP_TYPE_V4_V01;
qmi_rule_msg.filter_spec_list[pos].filter_action = GetQmiFilterAction(rule_table_v4->rules[cnt].rule.action);
qmi_rule_msg.filter_spec_list[pos].is_routing_table_index_valid = 1;
qmi_rule_msg.filter_spec_list[pos].route_table_index = rule_table_v4->rules[cnt].rule.rt_tbl_idx;
qmi_rule_msg.filter_spec_list[pos].is_mux_id_valid = 1;
qmi_rule_msg.filter_spec_list[pos].mux_id = mux_id;
memcpy(&qmi_rule_msg.filter_spec_list[pos].filter_rule,
&rule_table_v4->rules[cnt].rule.eq_attrib,
sizeof(struct ipa_filter_rule_type_v01));
pos++;
}
else
{
IPACMERR(" QMI only support max %d rules, current (%d)\n ",QMI_IPA_MAX_FILTERS_V01, pos);
}
}
}
if(rule_table_v6 != NULL)
{
for(cnt = rule_table_v6->num_rules - 1; cnt >= 0; cnt--)
{
if (pos < QMI_IPA_MAX_FILTERS_V01)
{
qmi_rule_msg.filter_spec_list[pos].filter_spec_identifier = pos;
qmi_rule_msg.filter_spec_list[pos].ip_type = QMI_IPA_IP_TYPE_V6_V01;
qmi_rule_msg.filter_spec_list[pos].filter_action = GetQmiFilterAction(rule_table_v6->rules[cnt].rule.action);
qmi_rule_msg.filter_spec_list[pos].is_routing_table_index_valid = 1;
qmi_rule_msg.filter_spec_list[pos].route_table_index = rule_table_v6->rules[cnt].rule.rt_tbl_idx;
qmi_rule_msg.filter_spec_list[pos].is_mux_id_valid = 1;
qmi_rule_msg.filter_spec_list[pos].mux_id = mux_id;
memcpy(&qmi_rule_msg.filter_spec_list[pos].filter_rule,
&rule_table_v6->rules[cnt].rule.eq_attrib,
sizeof(struct ipa_filter_rule_type_v01));
pos++;
}
else
{
IPACMERR(" QMI only support max %d rules, current (%d)\n ",QMI_IPA_MAX_FILTERS_V01, pos);
}
}
}
ret = ioctl(fd_wwan_ioctl, WAN_IOC_ADD_FLT_RULE, &qmi_rule_msg);
if (ret != 0)
{
IPACMERR("Failed adding Filtering rule %p with ret %d\n ", &qmi_rule_msg, ret);
close(fd_wwan_ioctl);
return false;
}
}
/* if it is IPA v3, use new QMI format */
#else
if(num_rules > QMI_IPA_MAX_FILTERS_EX_V01)
{
IPACMERR("The number of filtering rules exceed limit.\n");
close(fd_wwan_ioctl);
return false;
}
else
{
memset(&qmi_rule_ex_msg, 0, sizeof(qmi_rule_ex_msg));
if (num_rules > 0)
{
qmi_rule_ex_msg.filter_spec_ex_list_valid = true;
}
else
{
qmi_rule_ex_msg.filter_spec_ex_list_valid = false;
}
qmi_rule_ex_msg.filter_spec_ex_list_len = num_rules;
qmi_rule_ex_msg.source_pipe_index_valid = 0;
IPACMDBG_H("Get %d WAN DL filtering rules in total.\n", num_rules);
if(rule_table_v4 != NULL)
{
for(cnt = rule_table_v4->num_rules - 1; cnt >= 0; cnt--)
{
if (pos < QMI_IPA_MAX_FILTERS_EX_V01)
{
qmi_rule_ex_msg.filter_spec_ex_list[pos].ip_type = QMI_IPA_IP_TYPE_V4_V01;
qmi_rule_ex_msg.filter_spec_ex_list[pos].filter_action = GetQmiFilterAction(rule_table_v4->rules[cnt].rule.action);
qmi_rule_ex_msg.filter_spec_ex_list[pos].is_routing_table_index_valid = 1;
qmi_rule_ex_msg.filter_spec_ex_list[pos].route_table_index = rule_table_v4->rules[cnt].rule.rt_tbl_idx;
qmi_rule_ex_msg.filter_spec_ex_list[pos].is_mux_id_valid = 1;
qmi_rule_ex_msg.filter_spec_ex_list[pos].mux_id = mux_id;
qmi_rule_ex_msg.filter_spec_ex_list[pos].rule_id = rule_table_v4->rules[cnt].rule.rule_id;
qmi_rule_ex_msg.filter_spec_ex_list[pos].is_rule_hashable = rule_table_v4->rules[cnt].rule.hashable;
memcpy(&qmi_rule_ex_msg.filter_spec_ex_list[pos].filter_rule,
&rule_table_v4->rules[cnt].rule.eq_attrib,
sizeof(struct ipa_filter_rule_type_v01));
pos++;
}
else
{
IPACMERR(" QMI only support max %d rules, current (%d)\n ",QMI_IPA_MAX_FILTERS_EX_V01, pos);
}
}
}
if(rule_table_v6 != NULL)
{
for(cnt = rule_table_v6->num_rules - 1; cnt >= 0; cnt--)
{
if (pos < QMI_IPA_MAX_FILTERS_EX_V01)
{
qmi_rule_ex_msg.filter_spec_ex_list[pos].ip_type = QMI_IPA_IP_TYPE_V6_V01;
qmi_rule_ex_msg.filter_spec_ex_list[pos].filter_action = GetQmiFilterAction(rule_table_v6->rules[cnt].rule.action);
qmi_rule_ex_msg.filter_spec_ex_list[pos].is_routing_table_index_valid = 1;
qmi_rule_ex_msg.filter_spec_ex_list[pos].route_table_index = rule_table_v6->rules[cnt].rule.rt_tbl_idx;
qmi_rule_ex_msg.filter_spec_ex_list[pos].is_mux_id_valid = 1;
qmi_rule_ex_msg.filter_spec_ex_list[pos].mux_id = mux_id;
qmi_rule_ex_msg.filter_spec_ex_list[pos].rule_id = rule_table_v6->rules[cnt].rule.rule_id;
qmi_rule_ex_msg.filter_spec_ex_list[pos].is_rule_hashable = rule_table_v6->rules[cnt].rule.hashable;
memcpy(&qmi_rule_ex_msg.filter_spec_ex_list[pos].filter_rule,
&rule_table_v6->rules[cnt].rule.eq_attrib,
sizeof(struct ipa_filter_rule_type_v01));
pos++;
}
else
{
IPACMERR(" QMI only support max %d rules, current (%d)\n ",QMI_IPA_MAX_FILTERS_EX_V01, pos);
}
}
}
ret = ioctl(fd_wwan_ioctl, WAN_IOC_ADD_FLT_RULE_EX, &qmi_rule_ex_msg);
if (ret != 0)
{
IPACMERR("Failed adding Filtering rule %p with ret %d\n ", &qmi_rule_ex_msg, ret);
close(fd_wwan_ioctl);
return false;
}
}
#endif
close(fd_wwan_ioctl);
return true;
}
bool IPACM_Filtering::SendFilteringRuleIndex(struct ipa_fltr_installed_notif_req_msg_v01* table)
{
int ret = 0;
int fd_wwan_ioctl = open(WWAN_QMI_IOCTL_DEVICE_NAME, O_RDWR);
if(fd_wwan_ioctl < 0)
{
IPACMERR("Failed to open %s.\n",WWAN_QMI_IOCTL_DEVICE_NAME);
return false;
}
ret = ioctl(fd_wwan_ioctl, WAN_IOC_ADD_FLT_RULE_INDEX, table);
if (ret != 0)
{
IPACMERR("Failed adding filtering rule index %p with ret %d\n", table, ret);
close(fd_wwan_ioctl);
return false;
}
IPACMDBG("Added Filtering rule index %p\n", table);
close(fd_wwan_ioctl);
return true;
}
ipa_filter_action_enum_v01 IPACM_Filtering::GetQmiFilterAction(ipa_flt_action action)
{
switch(action)
{
case IPA_PASS_TO_ROUTING:
return QMI_IPA_FILTER_ACTION_ROUTING_V01;
case IPA_PASS_TO_SRC_NAT:
return QMI_IPA_FILTER_ACTION_SRC_NAT_V01;
case IPA_PASS_TO_DST_NAT:
return QMI_IPA_FILTER_ACTION_DST_NAT_V01;
case IPA_PASS_TO_EXCEPTION:
return QMI_IPA_FILTER_ACTION_EXCEPTION_V01;
default:
return IPA_FILTER_ACTION_ENUM_MAX_ENUM_VAL_V01;
}
}
bool IPACM_Filtering::ModifyFilteringRule(struct ipa_ioc_mdfy_flt_rule* ruleTable)
{
int i, ret = 0;
IPACMDBG("Printing filtering add attributes\n");
IPACMDBG("IP type: %d Number of rules: %d commit value: %d\n", ruleTable->ip, ruleTable->num_rules, ruleTable->commit);
for (i=0; i<ruleTable->num_rules; i++)
{
IPACMDBG("Filter rule:%d attrib mask: 0x%x\n", i, ruleTable->rules[i].rule.attrib.attrib_mask);
}
ret = ioctl(fd, IPA_IOC_MDFY_FLT_RULE, ruleTable);
if (ret != 0)
{
IPACMERR("Failed modifying filtering rule %p\n", ruleTable);
for (i = 0; i < ruleTable->num_rules; i++)
{
if (ruleTable->rules[i].status != 0)
{
IPACMERR("Modifying filter rule %d failed\n", i);
}
}
return false;
}
IPACMDBG("Modified filtering rule %p\n", ruleTable);
return true;
}

236
data-ipa-cfg-mgr/ipacm/src/IPACM_Header.cpp
View File

@@ -1,236 +0,0 @@
/*
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)
{
IPACMERR("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))
{
IPACMERR("Header hdl:(%x) deletion failed! status: %d\n", hd_rule_entry->hdl,hd_rule_entry->status);
res = false;
goto fail;
}
IPACMDBG_H("Deleted Header hdl:(%x) successfully\n", hd_rule_entry->hdl);
fail:
free(pHeaderDescriptor);
return res;
}
bool IPACM_Header::AddHeaderProcCtx(struct ipa_ioc_add_hdr_proc_ctx* pHeader)
{
int ret = 0;
//call the Driver ioctl to add header processing context
ret = ioctl(m_fd, IPA_IOC_ADD_HDR_PROC_CTX, pHeader);
return (ret == 0);
}
bool IPACM_Header::DeleteHeaderProcCtx(uint32_t hdl)
{
int len, ret;
struct ipa_ioc_del_hdr_proc_ctx* pHeaderTable = NULL;
len = sizeof(struct ipa_ioc_del_hdr_proc_ctx) + sizeof(struct ipa_hdr_proc_ctx_del);
pHeaderTable = (struct ipa_ioc_del_hdr_proc_ctx*)malloc(len);
if(pHeaderTable == NULL)
{
IPACMERR("Failed to allocate buffer.\n");
return false;
}
memset(pHeaderTable, 0, len);
pHeaderTable->commit = 1;
pHeaderTable->num_hdls = 1;
pHeaderTable->hdl[0].hdl = hdl;
ret = ioctl(m_fd, IPA_IOC_DEL_HDR_PROC_CTX, pHeaderTable);
if(ret != 0)
{
IPACMERR("Failed to delete hdr proc ctx: return value %d, status %d\n",
ret, pHeaderTable->hdl[0].status);
}
free(pHeaderTable);
return (ret == 0);
}

995
data-ipa-cfg-mgr/ipacm/src/IPACM_Iface.cpp
View File

@@ -1,995 +0,0 @@
/*
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 <IPACM_Netlink.h>
#include <IPACM_Iface.h>
#include <IPACM_Lan.h>
#include <IPACM_Wan.h>
#include <IPACM_Wlan.h>
#include <string.h>
extern "C"
{
#include <ifaddrs.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_v6 = 0;
softwarerouting_act = false;
ipa_if_num = iface_index;
ipa_if_cate = IPACM_Iface::ipacmcfg->iface_table[iface_index].if_cat;
iface_query = NULL;
tx_prop = NULL;
rx_prop = NULL;
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));
memset(ipv6_addr, 0, sizeof(ipv6_addr));
query_iface_property();
IPACMDBG_H(" 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");
if (softwarerouting_act == true)
{
IPACMDBG("already setup software_routing rule for (%s)iface ip-family %d\n",
IPACM_Iface::ipacmcfg->iface_table[ipa_if_num].iface_name, ip_type);
return IPACM_SUCCESS;
}
if(rx_prop == NULL)
{
IPACMDBG("No rx properties registered for iface %s\n", dev_name);
return IPACM_SUCCESS;
}
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->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;
#ifdef FEATURE_IPA_V3
flt_rule_entry.rule.hashable = true;
#endif
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))
{
IPACMERR("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;
}
IPACM_Iface::ipacmcfg->increaseFltRuleCount(rx_prop->rx[0].src_pipe, IPA_IP_v4, 1);
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))
{
IPACMERR("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;
}
IPACM_Iface::ipacmcfg->increaseFltRuleCount(rx_prop->rx[0].src_pipe, IPA_IP_v6, 1);
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;
#if 0
}
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))
{
IPACMERR("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;
}
IPACM_Iface::ipacmcfg->increaseFltRuleCount(rx_prop->rx[0].src_pipe, ip_type, 1);
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;
}
#endif
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;
if (rx_prop == NULL)
{
IPACMDBG("No rx properties registered for iface %s\n", dev_name);
return IPACM_SUCCESS;
}
if (softwarerouting_act == false)
{
IPACMDBG("already delete software_routing rule for (%s)iface ip-family %d\n", IPACM_Iface::ipacmcfg->iface_table[ipa_if_num].iface_name, ip_type);
return IPACM_SUCCESS;
}
// if (ip_type == IPA_IP_MAX)
// {
/* ipv4 case */
if (m_filtering.DeleteFilteringHdls(&software_routing_fl_rule_hdl[0],
IPA_IP_v4, 1) == false)
{
IPACMERR("Error Adding Filtering rule, aborting...\n");
res = IPACM_FAILURE;
goto fail;
}
IPACM_Iface::ipacmcfg->decreaseFltRuleCount(rx_prop->rx[0].src_pipe, IPA_IP_v4, 1);
/* ipv6 case */
if (m_filtering.DeleteFilteringHdls(&software_routing_fl_rule_hdl[1],
IPA_IP_v6, 1) == false)
{
IPACMERR("Error Adding Filtering rule, aborting...\n");
res = IPACM_FAILURE;
goto fail;
}
IPACM_Iface::ipacmcfg->decreaseFltRuleCount(rx_prop->rx[0].src_pipe, IPA_IP_v6, 1);
softwarerouting_act = false;
#if 0
}
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)
{
IPACMERR("Error Adding Filtering rule, aborting...\n");
res = IPACM_FAILURE;
goto fail;
}
IPACM_Iface::ipacmcfg->decreaseFltRuleCount(rx_prop->rx[0].src_pipe, ip, 1);
softwarerouting_act = false;
}
#endif
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 = INVALID_IFACE;
int i = 0;
struct ifreq ifr;
if(IPACM_Iface::ipacmcfg->iface_table == NULL)
{
IPACMERR("Iface table in IPACM_Config is not available.\n");
return link;
}
/* 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_H("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_H("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_H("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 ipa_interface ipv4_addr by given linux interface_index */
void IPACM_Iface::iface_addr_query
(
int interface_index
)
{
int fd;
struct ifreq ifr;
struct ifaddrs *myaddrs, *ifa;
ipacm_cmd_q_data evt_data;
ipacm_event_data_addr *data_addr;
struct in_addr iface_ipv4;
/* use linux interface-index to find interface name */
if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
{
PERROR("get interface name socket create failed");
return ;
}
memset(&ifr, 0, sizeof(struct ifreq));
ifr.ifr_ifindex = interface_index;
IPACMDBG_H("Interface index %d\n", interface_index);
if (ioctl(fd, SIOCGIFNAME, &ifr) < 0)
{
PERROR("call_ioctl_on_dev: ioctl failed:");
close(fd);
return ;
}
IPACMDBG_H("Interface index %d name: %s\n", interface_index,ifr.ifr_name);
close(fd);
/* query ipv4/v6 address */
if(getifaddrs(&myaddrs) != 0)
{
IPACMERR("getifaddrs");
return ;
}
for (ifa = myaddrs; ifa != NULL; ifa = ifa->ifa_next)
{
if (ifa->ifa_addr == NULL)
continue;
if (!(ifa->ifa_flags & IFF_UP))
continue;
if(strcmp(ifr.ifr_name,ifa->ifa_name) == 0) // find current iface
{
IPACMDBG_H("Internal post new_addr event for iface %s\n", ifa->ifa_name);
switch (ifa->ifa_addr->sa_family)
{
case AF_INET:
{
struct sockaddr_in *s4 = (struct sockaddr_in *)ifa->ifa_addr;
IPACMDBG_H("ipv4 address %s\n",inet_ntoa(s4->sin_addr));
iface_ipv4 = s4->sin_addr;
/* post new_addr 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");
freeifaddrs(myaddrs);
return ;
}
data_addr->iptype = IPA_IP_v4;
data_addr->if_index = interface_index;
data_addr->ipv4_addr = iface_ipv4.s_addr;
data_addr->ipv4_addr = ntohl(data_addr->ipv4_addr);
IPACMDBG_H("Posting IPA_ADDR_ADD_EVENT with if index:%d, ipv4 addr:0x%x\n",
data_addr->if_index,
data_addr->ipv4_addr);
evt_data.event = IPA_ADDR_ADD_EVENT;
evt_data.evt_data = data_addr;
IPACM_EvtDispatcher::PostEvt(&evt_data);
break;
}
case AF_INET6:
{
struct sockaddr_in6 *s6 = (struct sockaddr_in6 *)ifa->ifa_addr;
/* post new_addr 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");
freeifaddrs(myaddrs);
return ;
}
data_addr->iptype = IPA_IP_v6;
data_addr->if_index = interface_index;
memcpy(data_addr->ipv6_addr,
&s6->sin6_addr,
sizeof(data_addr->ipv6_addr));
data_addr->ipv6_addr[0] = ntohl(data_addr->ipv6_addr[0]);
data_addr->ipv6_addr[1] = ntohl(data_addr->ipv6_addr[1]);
data_addr->ipv6_addr[2] = ntohl(data_addr->ipv6_addr[2]);
data_addr->ipv6_addr[3] = ntohl(data_addr->ipv6_addr[3]);
IPACMDBG_H("Posting IPA_ADDR_ADD_EVENT with if index:%d, ipv6 addr:0x%x:%x:%x:%x\n",
data_addr->if_index,
data_addr->ipv6_addr[0], data_addr->ipv6_addr[1], data_addr->ipv6_addr[2], data_addr->ipv6_addr[3]);
evt_data.event = IPA_ADDR_ADD_EVENT;
evt_data.evt_data = data_addr;
IPACM_EvtDispatcher::PostEvt(&evt_data);
break;
}
default:
continue;
}
}
}
freeifaddrs(myaddrs);
return ;
}
/*Query the IPA endpoint property */
int IPACM_Iface::query_iface_property(void)
{
int res = IPACM_SUCCESS, fd = 0;
uint32_t cnt=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));
if(iface_query == NULL)
{
IPACMERR("Unable to allocate iface_query memory.\n");
close(fd);
return IPACM_FAILURE;
}
IPACMDBG_H("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;
}
if(iface_query->num_tx_props > 0)
{
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));
if(tx_prop == NULL)
{
IPACMERR("Unable to allocate tx_prop memory.\n");
close(fd);
return IPACM_FAILURE;
}
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;
}
if (res != IPACM_FAILURE)
{
for (cnt = 0; cnt < tx_prop->num_tx_props; cnt++)
{
IPACMDBG_H("Tx(%d):attrib-mask:0x%x, ip-type: %d, dst_pipe: %d, alt_dst_pipe: %d, header: %s\n",
cnt, tx_prop->tx[cnt].attrib.attrib_mask,
tx_prop->tx[cnt].ip, tx_prop->tx[cnt].dst_pipe,
tx_prop->tx[cnt].alt_dst_pipe,
tx_prop->tx[cnt].hdr_name);
if (tx_prop->tx[cnt].dst_pipe == 0)
{
IPACMERR("Tx(%d): wrong tx property: dst_pipe: 0.\n", cnt);
close(fd);
return IPACM_FAILURE;
}
if (tx_prop->tx[cnt].alt_dst_pipe == 0 &&
((memcmp(dev_name, "wlan0", sizeof("wlan0")) == 0) ||
(memcmp(dev_name, "wlan1", sizeof("wlan1")) == 0)))
{
IPACMERR("Tx(%d): wrong tx property: alt_dst_pipe: 0. \n", cnt);
close(fd);
return IPACM_FAILURE;
}
}
}
}
if (iface_query->num_rx_props > 0)
{
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));
if(rx_prop == NULL)
{
IPACMERR("Unable to allocate rx_prop memory.\n");
close(fd);
return IPACM_FAILURE;
}
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)
{
for (cnt = 0; cnt < rx_prop->num_rx_props; cnt++)
{
IPACMDBG_H("Rx(%d):attrib-mask:0x%x, ip-type: %d, src_pipe: %d\n",
cnt, rx_prop->rx[cnt].attrib.attrib_mask, rx_prop->rx[cnt].ip, rx_prop->rx[cnt].src_pipe);
}
}
}
/* Add Natting iface to IPACM_Config if there is Rx/Tx property */
if (rx_prop != NULL || tx_prop != NULL)
{
IPACMDBG_H(" Has rx/tx properties registered for iface %s, add for NATTING \n", dev_name);
IPACM_Iface::ipacmcfg->AddNatIfaces(dev_name);
}
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;
/* Adding this hack because WLAN may not registered for Rx-endpoint, other ifaces will always have*/
const char *dev_wlan0="wlan0";
const char *dev_wlan1="wlan1";
const char *dev_ecm0="ecm0";
/* ADD corresponding ipa_rm_resource_name of RX-endpoint before adding all IPV4V6 FT-rules */
if((IPACM_Iface::ipacmcfg->iface_table[ipa_if_num].if_cat== WAN_IF) || (IPACM_Iface::ipacmcfg->iface_table[ipa_if_num].if_cat== EMBMS_IF))
{
IPACMDBG_H(" NOT add producer dependency on dev %s with registered rx-prop cat:%d \n", dev_name, IPACM_Iface::ipacmcfg->iface_table[ipa_if_num].if_cat);
}
else
{
if(rx_prop != NULL)
{
IPACMDBG_H("dev %s add producer dependency\n", dev_name);
IPACMDBG_H("depend Got pipe %d rm index : %d \n", rx_prop->rx[0].src_pipe, IPACM_Iface::ipacmcfg->ipa_client_rm_map_tbl[rx_prop->rx[0].src_pipe]);
IPACM_Iface::ipacmcfg->AddRmDepend(IPACM_Iface::ipacmcfg->ipa_client_rm_map_tbl[rx_prop->rx[0].src_pipe],false);
}
else
{
/* only wlan may take software-path, not register Rx-property*/
if(strcmp(dev_name,dev_wlan0) == 0 || strcmp(dev_name,dev_wlan1) == 0)
{
IPACMDBG_H("dev %s add producer dependency\n", dev_name);
IPACMDBG_H("depend Got piperm index : %d \n", IPA_RM_RESOURCE_HSIC_PROD);
IPACM_Iface::ipacmcfg->AddRmDepend(IPA_RM_RESOURCE_HSIC_PROD,true);
}
if(strcmp(dev_name,dev_ecm0) == 0)
{
IPACMDBG_H("dev %s add producer dependency\n", dev_name);
IPACMDBG_H("depend Got piperm index : %d \n", IPA_RM_RESOURCE_USB_PROD);
IPACM_Iface::ipacmcfg->AddRmDepend(IPA_RM_RESOURCE_USB_PROD,true);
}
}
}
if (rx_prop == NULL)
{
IPACMDBG_H("No rx properties registered for iface %s\n", dev_name);
return IPACM_SUCCESS;
}
/* 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)
{
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 = 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.rule.retain_hdr = 1;
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;
#ifdef FEATURE_IPA_V3
flt_rule_entry.at_rear = false;
flt_rule_entry.rule.hashable = false;
#endif
IPACMDBG_H("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;
#ifdef FEATURE_IPA_V3
flt_rule_entry.at_rear = true;
flt_rule_entry.rule.hashable = true;
#endif
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;
#ifdef FEATURE_IPA_V3
flt_rule_entry.at_rear = true;
flt_rule_entry.rule.hashable = true;
#endif
memcpy(&(m_pFilteringTable->rules[2]), &flt_rule_entry, sizeof(struct ipa_flt_rule_add));
if (false == m_filtering.AddFilteringRule(m_pFilteringTable))
{
IPACMERR("Error Adding Filtering rule, aborting...\n");
res = IPACM_FAILURE;
goto fail;
}
else
{
IPACM_Iface::ipacmcfg->increaseFltRuleCount(rx_prop->rx[0].src_pipe, IPA_IP_v4, IPV4_DEFAULT_FILTERTING_RULES);
/* 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_H("Default v4 filter Rule %d HDL:0x%x\n", i, dft_v4fl_rule_hdl[i]);
}
else
{
IPACMERR("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)
{
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 = iptype;
m_pFilteringTable->num_rules = (uint8_t)IPV6_DEFAULT_FILTERTING_RULES;
memset(&flt_rule_entry, 0, sizeof(struct ipa_flt_rule_add));
flt_rule_entry.rule.retain_hdr = 1;
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;
#ifdef FEATURE_IPA_V3
flt_rule_entry.at_rear = true;
flt_rule_entry.rule.hashable = true;
#endif
memcpy(&(m_pFilteringTable->rules[0]), &flt_rule_entry, sizeof(struct ipa_flt_rule_add));
/* Configuring fe80::/10 Link-Scoped Unicast Filtering Rule */
flt_rule_entry.rule.attrib.u.v6.dst_addr_mask[0] = 0XFFC00000;
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] = 0xFE800000;
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;
#ifdef FEATURE_IPA_V3
flt_rule_entry.at_rear = true;
flt_rule_entry.rule.hashable = true;
#endif
memcpy(&(m_pFilteringTable->rules[1]), &flt_rule_entry, sizeof(struct ipa_flt_rule_add));
/* Configuring fec0::/10 Reserved by IETF Filtering Rule */
flt_rule_entry.rule.attrib.u.v6.dst_addr_mask[0] = 0XFFC00000;
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] = 0xFEC00000;
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;
#ifdef FEATURE_IPA_V3
flt_rule_entry.at_rear = true;
flt_rule_entry.rule.hashable = true;
#endif
memcpy(&(m_pFilteringTable->rules[2]), &flt_rule_entry, sizeof(struct ipa_flt_rule_add));
#ifdef FEATURE_IPA_ANDROID
IPACMDBG_H("Add TCP ctrl rules: total num %d\n", IPV6_DEFAULT_FILTERTING_RULES);
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.retain_hdr = 1;
flt_rule_entry.rule.to_uc = 0;
flt_rule_entry.rule.action = IPA_PASS_TO_EXCEPTION;
flt_rule_entry.rule.eq_attrib_type = 1;
flt_rule_entry.rule.eq_attrib.rule_eq_bitmap = 0;
if(rx_prop->rx[0].attrib.attrib_mask & IPA_FLT_META_DATA)
{
flt_rule_entry.rule.eq_attrib.rule_eq_bitmap |= (1<<14);
flt_rule_entry.rule.eq_attrib.metadata_meq32_present = 1;
flt_rule_entry.rule.eq_attrib.metadata_meq32.offset = 0;
flt_rule_entry.rule.eq_attrib.metadata_meq32.value = rx_prop->rx[0].attrib.meta_data;
flt_rule_entry.rule.eq_attrib.metadata_meq32.mask = rx_prop->rx[0].attrib.meta_data_mask;
}
flt_rule_entry.rule.eq_attrib.rule_eq_bitmap |= (1<<1);
flt_rule_entry.rule.eq_attrib.protocol_eq_present = 1;
flt_rule_entry.rule.eq_attrib.protocol_eq = IPACM_FIREWALL_IPPROTO_TCP;
flt_rule_entry.rule.eq_attrib.rule_eq_bitmap |= (1<<8);
flt_rule_entry.rule.eq_attrib.num_ihl_offset_meq_32 = 1;
flt_rule_entry.rule.eq_attrib.ihl_offset_meq_32[0].offset = 12;
/* add TCP FIN rule*/
flt_rule_entry.rule.eq_attrib.ihl_offset_meq_32[0].value = (((uint32_t)1)<<TCP_FIN_SHIFT);
flt_rule_entry.rule.eq_attrib.ihl_offset_meq_32[0].mask = (((uint32_t)1)<<TCP_FIN_SHIFT);
memcpy(&(m_pFilteringTable->rules[3]), &flt_rule_entry, sizeof(struct ipa_flt_rule_add));
/* add TCP SYN rule*/
flt_rule_entry.rule.eq_attrib.ihl_offset_meq_32[0].value = (((uint32_t)1)<<TCP_SYN_SHIFT);
flt_rule_entry.rule.eq_attrib.ihl_offset_meq_32[0].mask = (((uint32_t)1)<<TCP_SYN_SHIFT);
memcpy(&(m_pFilteringTable->rules[4]), &flt_rule_entry, sizeof(struct ipa_flt_rule_add));
/* add TCP RST rule*/
flt_rule_entry.rule.eq_attrib.ihl_offset_meq_32[0].value = (((uint32_t)1)<<TCP_RST_SHIFT);
flt_rule_entry.rule.eq_attrib.ihl_offset_meq_32[0].mask = (((uint32_t)1)<<TCP_RST_SHIFT);
memcpy(&(m_pFilteringTable->rules[5]), &flt_rule_entry, sizeof(struct ipa_flt_rule_add));
#endif
if (m_filtering.AddFilteringRule(m_pFilteringTable) == false)
{
IPACMERR("Error Adding Filtering rule, aborting...\n");
res = IPACM_FAILURE;
goto fail;
}
else
{
IPACM_Iface::ipacmcfg->increaseFltRuleCount(rx_prop->rx[0].src_pipe, IPA_IP_v6, IPV6_DEFAULT_FILTERTING_RULES);
/* 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_H("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;
}
/* get ipa interface name */
int IPACM_Iface::ipa_get_if_index
(
char * if_name,
int * if_index
)
{
int fd;
struct ifreq ifr;
if((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
{
IPACMERR("get interface index socket create failed \n");
return IPACM_FAILURE;
}
memset(&ifr, 0, sizeof(struct ifreq));
(void)strncpy(ifr.ifr_name, if_name, sizeof(ifr.ifr_name));
IPACMDBG_H("interface name (%s)\n", if_name);
if (ioctl(fd,SIOCGIFINDEX , &ifr) < 0)
{
IPACMERR("call_ioctl_on_dev: ioctl failed, interface name (%s):\n", ifr.ifr_name);
close(fd);
return IPACM_FAILURE;
}
*if_index = ifr.ifr_ifindex;
IPACMDBG_H("Interface index %d\n", *if_index);
close(fd);
return IPACM_SUCCESS;
}
void IPACM_Iface::config_ip_type(ipa_ip_type iptype)
{
/* 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_H(" interface(%s:%d) already in ip-type %d\n", dev_name, ipa_if_num, ip_type);
return;
}
if (ip_type == IPA_IP_v6)
{
ip_type = IPA_IP_MAX;
}
else
{
ip_type = IPA_IP_v4;
}
IPACMDBG_H(" 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_H(" interface(%s:%d) already in ip-type %d\n", dev_name, ipa_if_num, ip_type);
return;
}
if (ip_type == IPA_IP_v4)
{
ip_type = IPA_IP_MAX;
}
else
{
ip_type = IPA_IP_v6;
}
IPACMDBG_H(" interface(%s:%d) now ip-type is %d\n", dev_name, ipa_if_num, ip_type);
}
return;
}

565
data-ipa-cfg-mgr/ipacm/src/IPACM_IfaceManager.cpp
View File

@@ -1,565 +0,0 @@
/*
Copyright (c) 2013-2016, 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_CFG_CHANGE_EVENT, this); // register for IPA_CFG_CHANGE event
IPACM_EvtDispatcher::registr(IPA_LINK_UP_EVENT, this);
IPACM_EvtDispatcher::registr(IPA_WLAN_AP_LINK_UP_EVENT, this); // register for wlan AP-iface
IPACM_EvtDispatcher::registr(IPA_WLAN_STA_LINK_UP_EVENT, this); // register for wlan STA-iface
#ifndef FEATURE_IPA_ANDROID
/* only MDM targets support device on bridge mode */
IPACM_EvtDispatcher::registr(IPA_BRIDGE_LINK_UP_EVENT, this); // register for IPA_BRIDGE_LINK_UP_EVENT event
#endif /* not defined(FEATURE_IPA_ANDROID)*/
IPACM_EvtDispatcher::registr(IPA_USB_LINK_UP_EVENT, this); // register for USB-iface
IPACM_EvtDispatcher::registr(IPA_WAN_EMBMS_LINK_UP_EVENT, this); // register for wan eMBMS-iface
return;
}
void IPACM_IfaceManager::event_callback(ipa_cm_event_id event, void *param)
{
int ipa_interface_index;
ipacm_event_data_fid *evt_data = (ipacm_event_data_fid *)param;
ipacm_event_data_mac *StaData = (ipacm_event_data_mac *)param;
ipacm_event_data_all *data_all = (ipacm_event_data_all *)param;
ipacm_ifacemgr_data ifmgr_data = {0};
switch(event)
{
case IPA_CFG_CHANGE_EVENT:
IPACMDBG_H(" RESET IPACM_cfg \n");
IPACM_Iface::ipacmcfg->Init();
break;
case IPA_BRIDGE_LINK_UP_EVENT:
IPACMDBG_H(" Save the bridge0 mac info in IPACM_cfg \n");
ipa_interface_index = IPACM_Iface::iface_ipa_index_query(data_all->if_index);
/* check for failure return */
if (IPACM_FAILURE == ipa_interface_index) {
IPACMERR("IPA_BRIDGE_LINK_UP_EVENT: not supported iface id: %d\n", data_all->if_index);
break;
}
/* check if iface is bridge interface*/
if (strcmp(IPACM_Iface::ipacmcfg->ipa_virtual_iface_name, IPACM_Iface::ipacmcfg->iface_table[ipa_interface_index].iface_name) == 0)
{
IPACM_Iface::ipacmcfg->ipa_bridge_enable = true;
memcpy(IPACM_Iface::ipacmcfg->bridge_mac,
data_all->mac_addr,
sizeof(IPACM_Iface::ipacmcfg->bridge_mac));
IPACMDBG_H("cached bridge0 MAC %02x:%02x:%02x:%02x:%02x:%02x\n",
IPACM_Iface::ipacmcfg->bridge_mac[0], IPACM_Iface::ipacmcfg->bridge_mac[1], IPACM_Iface::ipacmcfg->bridge_mac[2],
IPACM_Iface::ipacmcfg->bridge_mac[3], IPACM_Iface::ipacmcfg->bridge_mac[4], IPACM_Iface::ipacmcfg->bridge_mac[5]);
}
break;
case IPA_LINK_UP_EVENT:
IPACMDBG_H("Recieved IPA_LINK_UP_EVENT event: link up %d: \n", evt_data->if_index);
ipa_interface_index = IPACM_Iface::iface_ipa_index_query(evt_data->if_index);
/* check for failure return */
if (IPACM_FAILURE == ipa_interface_index) {
IPACMERR("IPA_LINK_UP_EVENT: not supported iface id: %d\n", evt_data->if_index);
break;
}
/* LTE-backhaul */
if(IPACM_Iface::ipacmcfg->iface_table[ipa_interface_index].if_cat == EMBMS_IF)
{
IPACMDBG("WAN-EMBMS (%s) link already up, iface: %d: \n", IPACM_Iface::ipacmcfg->iface_table[ipa_interface_index].iface_name,evt_data->if_index);
}
else if(IPACM_Iface::ipacmcfg->iface_table[ipa_interface_index].if_cat == WAN_IF)
{
IPACMDBG_H("WAN-LTE (%s) link up, iface: %d: \n", IPACM_Iface::ipacmcfg->iface_table[ipa_interface_index].iface_name,evt_data->if_index);
ifmgr_data.if_index = evt_data->if_index;
ifmgr_data.if_type = Q6_WAN;
create_iface_instance(&ifmgr_data);
}
break;
case IPA_USB_LINK_UP_EVENT:
IPACMDBG_H("Recieved IPA_USB_LINK_UP_EVENT event: link up %d: \n", evt_data->if_index);
ipa_interface_index = IPACM_Iface::iface_ipa_index_query(evt_data->if_index);
/* check for failure return */
if (IPACM_FAILURE == ipa_interface_index) {
IPACMERR("IPA_USB_LINK_UP_EVENT: not supported iface id: %d\n", evt_data->if_index);
break;
}
/* check if it's WAN_IF */
if(IPACM_Iface::ipacmcfg->iface_table[ipa_interface_index].if_cat == WAN_IF)
{
/* usb-backhaul using sta_mode ECM_WAN*/
IPACMDBG_H("WAN-usb (%s) link up, iface: %d: \n", IPACM_Iface::ipacmcfg->iface_table[ipa_interface_index].iface_name, evt_data->if_index);
ifmgr_data.if_index = evt_data->if_index;
ifmgr_data.if_type = ECM_WAN;
create_iface_instance(&ifmgr_data);
}
else
{
ifmgr_data.if_index = evt_data->if_index;
ifmgr_data.if_type = Q6_WAN;
create_iface_instance(&ifmgr_data);
}
break;
case IPA_WLAN_AP_LINK_UP_EVENT:
ipa_interface_index = IPACM_Iface::iface_ipa_index_query(evt_data->if_index);
/* check for failure return */
if (IPACM_FAILURE == ipa_interface_index) {
IPACMERR("IPA_WLAN_AP_LINK_UP_EVENT: not supported iface id: %d\n", evt_data->if_index);
break;
}
/* change iface category from unknown to WLAN_IF */
if(IPACM_Iface::ipacmcfg->iface_table[ipa_interface_index].if_cat == UNKNOWN_IF)
{
IPACM_Iface::ipacmcfg->iface_table[ipa_interface_index].if_cat = WLAN_IF;
IPACMDBG_H("WLAN AP (%s) link up, iface: %d: \n", IPACM_Iface::ipacmcfg->iface_table[ipa_interface_index].iface_name,evt_data->if_index);
ifmgr_data.if_index = evt_data->if_index;
ifmgr_data.if_type = Q6_WAN;
create_iface_instance(&ifmgr_data);
}
else
{
IPACMDBG_H("iface %s already up and act as %d mode: \n",IPACM_Iface::ipacmcfg->iface_table[ipa_interface_index].iface_name,IPACM_Iface::ipacmcfg->iface_table[ipa_interface_index].if_cat);
}
break;
case IPA_WLAN_STA_LINK_UP_EVENT:
ipa_interface_index = IPACM_Iface::iface_ipa_index_query(StaData->if_index);
/* check for failure return */
if (IPACM_FAILURE == ipa_interface_index) {
IPACMERR("IPA_WLAN_STA_LINK_UP_EVENT: not supported iface id: %d\n", StaData->if_index);
break;
}
/* change iface category from unknown to WAN_IF */
if(IPACM_Iface::ipacmcfg->iface_table[ipa_interface_index].if_cat == UNKNOWN_IF)
{
/* wlan-backhaul using sta_mode WLAN_WAN */
IPACM_Iface::ipacmcfg->iface_table[ipa_interface_index].if_cat = WAN_IF;
IPACMDBG_H("WLAN STA (%s) link up, iface: %d: \n",
IPACM_Iface::ipacmcfg->iface_table[ipa_interface_index].iface_name, StaData->if_index);
ifmgr_data.if_index = StaData->if_index;
ifmgr_data.if_type = WLAN_WAN;
memcpy(ifmgr_data.mac_addr, StaData->mac_addr, sizeof(ifmgr_data.mac_addr));
create_iface_instance(&ifmgr_data);
}
else
{
IPACMDBG_H("iface %s already up and act as %d mode: \n",
IPACM_Iface::ipacmcfg->iface_table[ipa_interface_index].iface_name,
IPACM_Iface::ipacmcfg->iface_table[ipa_interface_index].if_cat);
}
break;
/* Add new instance open for eMBMS iface and wan iface */
case IPA_WAN_EMBMS_LINK_UP_EVENT:
ipa_interface_index = IPACM_Iface::iface_ipa_index_query(evt_data->if_index);
/* check for failure return */
if (IPACM_FAILURE == ipa_interface_index) {
IPACMERR("IPA_WAN_EMBMS_LINK_UP_EVENT: not supported iface id: %d\n", evt_data->if_index);
break;
}
/* change iface category from unknown to EMBMS_IF */
if ((IPACM_Iface::ipacmcfg->ipacm_odu_enable == true) && (IPACM_Iface::ipacmcfg->ipacm_odu_embms_enable == true))
{
IPACMDBG(" ODU-mode enable or not (%d) \n",IPACM_Iface::ipacmcfg->ipacm_odu_enable);
if(IPACM_Iface::ipacmcfg->iface_table[ipa_interface_index].if_cat == WAN_IF)
{
IPACM_Iface::ipacmcfg->iface_table[ipa_interface_index].if_cat=EMBMS_IF;
IPACMDBG("WAN eMBMS (%s) link up, iface: %d: \n", IPACM_Iface::ipacmcfg->iface_table[ipa_interface_index].iface_name,evt_data->if_index);
ifmgr_data.if_index = StaData->if_index;
ifmgr_data.if_type = Q6_WAN;
create_iface_instance(&ifmgr_data);
}
else
{
IPACMDBG("iface %s already up and act as %d mode: \n",IPACM_Iface::ipacmcfg->iface_table[ipa_interface_index].iface_name,IPACM_Iface::ipacmcfg->iface_table[ipa_interface_index].if_cat);
}
}
break;
default:
break;
}
return;
}
int IPACM_IfaceManager::create_iface_instance(ipacm_ifacemgr_data *param)
{
int if_index = param->if_index;
ipacm_wan_iface_type is_sta_mode = param->if_type;
int ipa_interface_index;
ipa_interface_index = IPACM_Iface::iface_ipa_index_query(if_index);
if(ipa_interface_index == INVALID_IFACE)
{
IPACMDBG_H("Unhandled interface received, fid: %d\n",if_index);
return IPACM_SUCCESS;
}
/* 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_H("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);
#ifdef FEATURE_IPA_ANDROID
IPACM_EvtDispatcher::registr(IPA_HANDLE_WAN_UP_TETHER, lan);
IPACM_EvtDispatcher::registr(IPA_HANDLE_WAN_UP_V6_TETHER, lan);
IPACM_EvtDispatcher::registr(IPA_HANDLE_WAN_DOWN_TETHER, lan);
IPACM_EvtDispatcher::registr(IPA_HANDLE_WAN_DOWN_V6_TETHER, lan);
#else
IPACM_EvtDispatcher::registr(IPA_HANDLE_WAN_UP, lan);
IPACM_EvtDispatcher::registr(IPA_HANDLE_WAN_UP_V6, lan);
IPACM_EvtDispatcher::registr(IPA_HANDLE_WAN_DOWN, lan);
IPACM_EvtDispatcher::registr(IPA_HANDLE_WAN_DOWN_V6, lan);
#endif
IPACM_EvtDispatcher::registr(IPA_CFG_CHANGE_EVENT, lan); // register for IPA_CFG_CHANGE event
IPACM_EvtDispatcher::registr(IPA_PRIVATE_SUBNET_CHANGE_EVENT, lan); // register for IPA_PRIVATE_SUBNET_CHANGE_EVENT event
#ifdef FEATURE_IPA_ANDROID
IPACM_EvtDispatcher::registr(IPA_TETHERING_STATS_UPDATE_EVENT, lan);
#endif
IPACM_EvtDispatcher::registr(IPA_CRADLE_WAN_MODE_SWITCH, lan);
IPACM_EvtDispatcher::registr(IPA_LINK_DOWN_EVENT, lan);
/* IPA_LAN_DELETE_SELF should be always last */
IPACM_EvtDispatcher::registr(IPA_LAN_DELETE_SELF, lan);
IPACMDBG_H("ipa_LAN (%s):ipa_index (%d) instance open/registr ok\n", lan->dev_name, lan->ipa_if_num);
registr(ipa_interface_index, lan);
/* solve the new_addr comes earlier issue */
IPACM_Iface::iface_addr_query(if_index);
}
break;
case ETH_IF:
{
IPACMDBG_H("Creating ETH interface in router mode\n");
IPACM_Lan *ETH = new IPACM_Lan(ipa_interface_index);
IPACM_EvtDispatcher::registr(IPA_ADDR_ADD_EVENT, ETH);
IPACM_EvtDispatcher::registr(IPA_NEIGH_CLIENT_IP_ADDR_ADD_EVENT, ETH);
IPACM_EvtDispatcher::registr(IPA_SW_ROUTING_ENABLE, ETH);
IPACM_EvtDispatcher::registr(IPA_SW_ROUTING_DISABLE, ETH);
IPACM_EvtDispatcher::registr(IPA_HANDLE_WAN_UP, ETH);
IPACM_EvtDispatcher::registr(IPA_HANDLE_WAN_UP_V6, ETH);
IPACM_EvtDispatcher::registr(IPA_HANDLE_WAN_DOWN, ETH);
IPACM_EvtDispatcher::registr(IPA_HANDLE_WAN_DOWN_V6, ETH);
IPACM_EvtDispatcher::registr(IPA_CRADLE_WAN_MODE_SWITCH, ETH);
IPACM_EvtDispatcher::registr(IPA_LINK_DOWN_EVENT, ETH);
/* IPA_LAN_DELETE_SELF should be always last */
IPACM_EvtDispatcher::registr(IPA_LAN_DELETE_SELF, ETH);
IPACMDBG_H("ipa_LAN (%s):ipa_index (%d) instance open/registr ok\n", ETH->dev_name, ETH->ipa_if_num);
registr(ipa_interface_index, ETH);
/* solve the new_addr comes earlier issue */
IPACM_Iface::iface_addr_query(if_index);
}
break;
case ODU_IF:
{
if(IPACM_Iface::ipacmcfg->ipacm_odu_router_mode == true)
{
IPACMDBG_H("Creating ODU interface in router mode\n");
IPACM_Lan *odu = new IPACM_Lan(ipa_interface_index);
IPACM_EvtDispatcher::registr(IPA_ADDR_ADD_EVENT, odu);
IPACM_EvtDispatcher::registr(IPA_NEIGH_CLIENT_IP_ADDR_ADD_EVENT, odu);
IPACM_EvtDispatcher::registr(IPA_NEIGH_CLIENT_IP_ADDR_DEL_EVENT, odu);
IPACM_EvtDispatcher::registr(IPA_SW_ROUTING_ENABLE, odu);
IPACM_EvtDispatcher::registr(IPA_SW_ROUTING_DISABLE, odu);
IPACM_EvtDispatcher::registr(IPA_HANDLE_WAN_UP, odu);
IPACM_EvtDispatcher::registr(IPA_HANDLE_WAN_UP_V6, odu);
IPACM_EvtDispatcher::registr(IPA_HANDLE_WAN_DOWN, odu);
IPACM_EvtDispatcher::registr(IPA_HANDLE_WAN_DOWN_V6, odu);
IPACM_EvtDispatcher::registr(IPA_CRADLE_WAN_MODE_SWITCH, odu);
IPACM_EvtDispatcher::registr(IPA_LINK_DOWN_EVENT, odu);
/* IPA_LAN_DELETE_SELF should be always last */
IPACM_EvtDispatcher::registr(IPA_LAN_DELETE_SELF, odu);
IPACMDBG_H("ipa_LAN (%s):ipa_index (%d) instance open/registr ok\n", odu->dev_name, odu->ipa_if_num);
registr(ipa_interface_index, odu);
/* solve the new_addr comes earlier issue */
IPACM_Iface::iface_addr_query(if_index);
}
else
{
IPACMDBG_H("Creating ODU interface in bridge mode\n");
IPACM_Lan *odu = new IPACM_Lan(ipa_interface_index);
IPACM_EvtDispatcher::registr(IPA_ADDR_ADD_EVENT, odu);
IPACM_EvtDispatcher::registr(IPA_NEIGH_CLIENT_IP_ADDR_ADD_EVENT, odu);
IPACM_EvtDispatcher::registr(IPA_SW_ROUTING_ENABLE, odu);
IPACM_EvtDispatcher::registr(IPA_SW_ROUTING_DISABLE, odu);
IPACM_EvtDispatcher::registr(IPA_LINK_DOWN_EVENT, odu);
/* IPA_LAN_DELETE_SELF should be always last */
IPACM_EvtDispatcher::registr(IPA_LAN_DELETE_SELF, odu);
IPACMDBG_H("ipa_LAN (%s):ipa_index (%d) instance open/registr ok\n", odu->dev_name, odu->ipa_if_num);
registr(ipa_interface_index, odu);
/* solve the new_addr comes earlier issue */
IPACM_Iface::iface_addr_query(if_index);
}
}
break;
case WLAN_IF:
{
IPACMDBG_H("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_ADD_EVENT_EX, 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);
#ifdef FEATURE_IPA_ANDROID
IPACM_EvtDispatcher::registr(IPA_HANDLE_WAN_UP_TETHER, wl);
IPACM_EvtDispatcher::registr(IPA_HANDLE_WAN_UP_V6_TETHER, wl);
IPACM_EvtDispatcher::registr(IPA_HANDLE_WAN_DOWN_TETHER, wl);
IPACM_EvtDispatcher::registr(IPA_HANDLE_WAN_DOWN_V6_TETHER, wl);
#else
IPACM_EvtDispatcher::registr(IPA_HANDLE_WAN_UP, wl);
IPACM_EvtDispatcher::registr(IPA_HANDLE_WAN_UP_V6, wl);
IPACM_EvtDispatcher::registr(IPA_HANDLE_WAN_DOWN, wl);
IPACM_EvtDispatcher::registr(IPA_HANDLE_WAN_DOWN_V6, wl);
#endif
IPACM_EvtDispatcher::registr(IPA_PRIVATE_SUBNET_CHANGE_EVENT, wl); // register for IPA_PRIVATE_SUBNET_CHANGE_EVENT event
#ifdef FEATURE_ETH_BRIDGE_LE
IPACM_EvtDispatcher::registr(IPA_CFG_CHANGE_EVENT, wl);
#endif
IPACM_EvtDispatcher::registr(IPA_CRADLE_WAN_MODE_SWITCH, wl);
IPACM_EvtDispatcher::registr(IPA_WLAN_LINK_DOWN_EVENT, wl);
#ifndef FEATURE_IPA_ANDROID
IPACM_EvtDispatcher::registr(IPA_WLAN_SWITCH_TO_SCC, wl);
IPACM_EvtDispatcher::registr(IPA_WLAN_SWITCH_TO_MCC, wl);
#else
IPACM_EvtDispatcher::registr(IPA_TETHERING_STATS_UPDATE_EVENT, wl);
#endif
/* IPA_LAN_DELETE_SELF should be always last */
IPACM_EvtDispatcher::registr(IPA_LAN_DELETE_SELF, wl);
IPACMDBG_H("ipa_WLAN (%s):ipa_index (%d) instance open/registr ok\n", wl->dev_name, wl->ipa_if_num);
registr(ipa_interface_index, wl);
/* solve the new_addr comes earlier issue */
IPACM_Iface::iface_addr_query(if_index);
}
break;
case WAN_IF:
{
if((IPACM_Iface::ipacmcfg->ipacm_odu_enable == false) || (IPACM_Iface::ipacmcfg->ipacm_odu_router_mode == true))
{
IPACMDBG_H("Creating Wan interface\n");
IPACM_Wan *w;
if(is_sta_mode == WLAN_WAN)
{
w = new IPACM_Wan(ipa_interface_index, is_sta_mode, param->mac_addr);
}
else
{
w = new IPACM_Wan(ipa_interface_index, is_sta_mode, NULL);
}
IPACM_EvtDispatcher::registr(IPA_ADDR_ADD_EVENT, w);
#ifdef FEATURE_IPA_ANDROID
IPACM_EvtDispatcher::registr(IPA_WAN_UPSTREAM_ROUTE_ADD_EVENT, w);
IPACM_EvtDispatcher::registr(IPA_WAN_UPSTREAM_ROUTE_DEL_EVENT, w);
if(is_sta_mode == Q6_WAN)
{
IPACM_EvtDispatcher::registr(IPA_NETWORK_STATS_UPDATE_EVENT, w);
};
#else/* defined(FEATURE_IPA_ANDROID) */
IPACM_EvtDispatcher::registr(IPA_ROUTE_ADD_EVENT, w);
IPACM_EvtDispatcher::registr(IPA_ROUTE_DEL_EVENT, w);
#endif /* not defined(FEATURE_IPA_ANDROID)*/
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_CFG_CHANGE_EVENT, w); // register for IPA_CFG_CHANGE event
IPACM_EvtDispatcher::registr(IPA_WAN_XLAT_CONNECT_EVENT, w);
if(is_sta_mode == WLAN_WAN)
{
IPACM_EvtDispatcher::registr(IPA_WLAN_LINK_DOWN_EVENT, w); // for STA mode
#ifndef FEATURE_IPA_ANDROID
IPACM_EvtDispatcher::registr(IPA_WLAN_SWITCH_TO_SCC, w);
IPACM_EvtDispatcher::registr(IPA_WLAN_SWITCH_TO_MCC, w);
#endif
}
else
{
IPACM_EvtDispatcher::registr(IPA_LINK_DOWN_EVENT, w);
}
IPACMDBG_H("ipa_WAN (%s):ipa_index (%d) instance open/registr ok\n", w->dev_name, w->ipa_if_num);
registr(ipa_interface_index, w);
/* solve the new_addr comes earlier issue */
IPACM_Iface::iface_addr_query(if_index);
}
}
break;
/* WAN-eMBMS instance */
case EMBMS_IF:
{
IPACMDBG("Creating Wan-eMBSM interface\n");
IPACM_Wan *embms = new IPACM_Wan(ipa_interface_index, is_sta_mode, NULL);
IPACM_EvtDispatcher::registr(IPA_LINK_DOWN_EVENT, embms);
IPACMDBG("ipa_WAN (%s):ipa_index (%d) instance open/registr ok\n", embms->dev_name, embms->ipa_if_num);
registr(ipa_interface_index, embms);
}
break;
default:
IPACMDBG_H("Unhandled interface category received iface name: %s, category: %d\n",
IPACM_Iface::ipacmcfg->iface_table[ipa_interface_index].iface_name,
IPACM_Iface::ipacmcfg->iface_table[ipa_interface_index].if_cat);
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_H("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_H("No existed iface-instance name: %s,\n",
IPACM_Iface::ipacmcfg->iface_table[ipa_if_index].iface_name);
return IPA_INSTANCE_NOT_FOUND;
}

4229
data-ipa-cfg-mgr/ipacm/src/IPACM_Lan.cpp
View File

File diff suppressed because it is too large Load Diff

1262
data-ipa-cfg-mgr/ipacm/src/IPACM_LanToLan.cpp
View File

File diff suppressed because it is too large Load Diff

107
data-ipa-cfg-mgr/ipacm/src/IPACM_Log.cpp
View File

@@ -1,107 +0,0 @@
/*
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>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <fcntl.h>
#include <unistd.h>
#include <asm/types.h>
#include <linux/if.h>
#include <sys/un.h>
#include <errno.h>
#include <IPACM_Defs.h>
void logmessage(int log_level)
{
return;
}
/* start IPACMDIAG socket*/
int create_socket(unsigned int *sockfd)
{
if ((*sockfd = socket(AF_UNIX, SOCK_DGRAM, 0)) == IPACM_FAILURE)
{
perror("Error creating ipacm_log socket\n");
return IPACM_FAILURE;
}
if(fcntl(*sockfd, F_SETFD, FD_CLOEXEC) < 0)
{
perror("Couldn't set ipacm_log Close on Exec\n");
}
return IPACM_SUCCESS;
}
void ipacm_log_send( void * user_data)
{
ipacm_log_buffer_t ipacm_log_buffer;
int numBytes=0, len;
struct sockaddr_un ipacmlog_socket;
static unsigned int ipacm_log_sockfd = 0;
if(ipacm_log_sockfd == 0)
{
/* start ipacm_log socket */
if(create_socket(&ipacm_log_sockfd) < 0)
{
printf("unable to create ipacm_log socket\n");
return;
}
printf("create ipacm_log socket successfully\n");
}
ipacmlog_socket.sun_family = AF_UNIX;
strcpy(ipacmlog_socket.sun_path, IPACMLOG_FILE);
len = strlen(ipacmlog_socket.sun_path) + sizeof(ipacmlog_socket.sun_family);
memcpy(ipacm_log_buffer.user_data, user_data, MAX_BUF_LEN);
//printf("send : %s\n", ipacm_log_buffer.user_data);
if ((numBytes = sendto(ipacm_log_sockfd, (void *)&ipacm_log_buffer, sizeof(ipacm_log_buffer.user_data), 0,
(struct sockaddr *)&ipacmlog_socket, len)) == -1)
{
printf("Send Failed(%d) %s \n",errno,strerror(errno));
return;
}
return;
}

939
data-ipa-cfg-mgr/ipacm/src/IPACM_Main.cpp
View File

@@ -1,939 +0,0 @@
/*
Copyright (c) 2013-2016, 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_Main.cpp
@brief
This file implements the IPAM functionality.
@Author
Skylar Chang
*/
/******************************************************************************
IPCM_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 <signal.h>
#include "linux/ipa_qmi_service_v01.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"
#include "IPACM_ConntrackClient.h"
#include "IPACM_Netlink.h"
/* not defined(FEATURE_IPA_ANDROID)*/
#ifndef FEATURE_IPA_ANDROID
#include "IPACM_LanToLan.h"
#endif
#define IPA_DRIVER "/dev/ipa"
#define IPACM_FIREWALL_FILE_NAME "mobileap_firewall.xml"
#define IPACM_CFG_FILE_NAME "IPACM_cfg.xml"
#ifdef FEATURE_IPA_ANDROID
#define IPACM_PID_FILE "/data/misc/ipa/ipacm.pid"
#define IPACM_DIR_NAME "/data"
#else/* defined(FEATURE_IPA_ANDROID) */
#define IPACM_PID_FILE "/etc/ipacm.pid"
#define IPACM_DIR_NAME "/etc"
#endif /* defined(NOT FEATURE_IPA_ANDROID)*/
#define IPACM_NAME "ipacm"
#define INOTIFY_EVENT_SIZE (sizeof(struct inotify_event))
#define INOTIFY_BUF_LEN (INOTIFY_EVENT_SIZE + 2*sizeof(IPACM_FIREWALL_FILE_NAME))
#define IPA_DRIVER_WLAN_EVENT_MAX_OF_ATTRIBS 3
#define IPA_DRIVER_WLAN_EVENT_SIZE (sizeof(struct ipa_wlan_msg_ex)+ IPA_DRIVER_WLAN_EVENT_MAX_OF_ATTRIBS*sizeof(ipa_wlan_hdr_attrib_val))
#define IPA_DRIVER_PIPE_STATS_EVENT_SIZE (sizeof(struct ipa_get_data_stats_resp_msg_v01))
#define IPA_DRIVER_WLAN_META_MSG (sizeof(struct ipa_msg_meta))
#define IPA_DRIVER_WLAN_BUF_LEN (IPA_DRIVER_PIPE_STATS_EVENT_SIZE + IPA_DRIVER_WLAN_META_MSG)
uint32_t ipacm_event_stats[IPACM_EVENT_MAX];
bool ipacm_logging = true;
void ipa_is_ipacm_running(void);
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_H("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 | IN_MOVE;
inotify_fd = inotify_init();
if (inotify_fd < 0)
{
PERROR("inotify_init");
}
IPACMDBG_H("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);
if (length < 0)
{
IPACMERR("inotify read() error return length: %d and mask: 0x%x\n", length, mask);
continue;
}
struct inotify_event* event;
event = (struct inotify_event*)malloc(length);
if(event == NULL)
{
IPACMERR("Failed to allocate memory.\n");
return NULL;
}
memset(event, 0, length);
memcpy(event, buffer, length);
if (event->len > 0)
{
if ( (event->mask & IN_MODIFY) || (event->mask & IN_MOVE))
{
if (event->mask & IN_ISDIR)
{
IPACMDBG_H("The directory %s was 0x%x\n", event->name, event->mask);
}
else if (!strncmp(event->name, IPACM_FIREWALL_FILE_NAME, event->len)) // firewall_rule change
{
IPACMDBG_H("File \"%s\" was 0x%x\n", event->name, event->mask);
IPACMDBG_H("The interested file %s .\n", IPACM_FIREWALL_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);
}
else if (!strncmp(event->name, IPACM_CFG_FILE_NAME, event->len)) // IPACM_configuration change
{
IPACMDBG_H("File \"%s\" was 0x%x\n", event->name, event->mask);
IPACMDBG_H("The interested file %s .\n", IPACM_CFG_FILE_NAME);
evt_data.event = IPA_CFG_CHANGE_EVENT;
evt_data.evt_data = NULL;
/* Insert IPA_FIREWALL_CHANGE_EVENT to command queue */
IPACM_EvtDispatcher::PostEvt(&evt_data);
}
}
IPACMDBG_H("Received monitoring event %s.\n", event->name);
}
free(event);
}
(void)inotify_rm_watch(inotify_fd, wd);
(void)close(inotify_fd);
return NULL;
}
/* start IPACM wan-driver notifier */
void* ipa_driver_msg_notifier(void *param)
{
int length, fd, cnt;
char buffer[IPA_DRIVER_WLAN_BUF_LEN];
struct ipa_msg_meta event_hdr;
struct ipa_ecm_msg event_ecm;
struct ipa_wan_msg event_wan;
struct ipa_wlan_msg_ex event_ex_o;
struct ipa_wlan_msg *event_wlan=NULL;
struct ipa_wlan_msg_ex *event_ex= NULL;
struct ipa_get_data_stats_resp_msg_v01 event_data_stats;
struct ipa_get_apn_data_stats_resp_msg_v01 event_network_stats;
ipacm_cmd_q_data evt_data;
ipacm_event_data_mac *data = NULL;
ipacm_event_data_fid *data_fid = NULL;
ipacm_event_data_iptype *data_iptype = NULL;
ipacm_event_data_wlan_ex *data_ex;
ipa_get_data_stats_resp_msg_v01 *data_tethering_stats = NULL;
ipa_get_apn_data_stats_resp_msg_v01 *data_network_stats = NULL;
ipacm_cmd_q_data new_neigh_evt;
ipacm_event_data_all* new_neigh_data;
fd = open(IPA_DRIVER, O_RDWR);
if (fd < 0)
{
IPACMERR("Failed opening %s.\n", IPA_DRIVER);
return NULL;
}
while (1)
{
IPACMDBG_H("Waiting for nofications from IPA driver \n");
memset(buffer, 0, sizeof(buffer));
memset(&evt_data, 0, sizeof(evt_data));
memset(&new_neigh_evt, 0, sizeof(ipacm_cmd_q_data));
new_neigh_data = NULL;
data = NULL;
data_fid = NULL;
data_tethering_stats = NULL;
data_network_stats = NULL;
length = read(fd, buffer, IPA_DRIVER_WLAN_BUF_LEN);
if (length < 0)
{
PERROR("didn't read IPA_driver correctly");
continue;
}
memcpy(&event_hdr, buffer,sizeof(struct ipa_msg_meta));
IPACMDBG_H("Message type: %d\n", event_hdr.msg_type);
IPACMDBG_H("Event header length received: %d\n",event_hdr.msg_len);
/* Insert WLAN_DRIVER_EVENT to command queue */
switch (event_hdr.msg_type)
{
case SW_ROUTING_ENABLE:
IPACMDBG_H("Received SW_ROUTING_ENABLE\n");
evt_data.event = IPA_SW_ROUTING_ENABLE;
IPACMDBG_H("Not supported anymore\n");
continue;
case SW_ROUTING_DISABLE:
IPACMDBG_H("Received SW_ROUTING_DISABLE\n");
evt_data.event = IPA_SW_ROUTING_DISABLE;
IPACMDBG_H("Not supported anymore\n");
continue;
case WLAN_AP_CONNECT:
event_wlan = (struct ipa_wlan_msg *) (buffer + sizeof(struct ipa_msg_meta));
IPACMDBG_H("Received WLAN_AP_CONNECT name: %s\n",event_wlan->name);
IPACMDBG_H("AP Mac Address %02x:%02x:%02x:%02x:%02x:%02x\n",
event_wlan->mac_addr[0], event_wlan->mac_addr[1], event_wlan->mac_addr[2],
event_wlan->mac_addr[3], event_wlan->mac_addr[4], event_wlan->mac_addr[5]);
data_fid = (ipacm_event_data_fid *)malloc(sizeof(ipacm_event_data_fid));
if(data_fid == NULL)
{
IPACMERR("unable to allocate memory for event_wlan data_fid\n");
return NULL;
}
ipa_get_if_index(event_wlan->name, &(data_fid->if_index));
evt_data.event = IPA_WLAN_AP_LINK_UP_EVENT;
evt_data.evt_data = data_fid;
break;
case WLAN_AP_DISCONNECT:
event_wlan = (struct ipa_wlan_msg *)(buffer + sizeof(struct ipa_msg_meta));
IPACMDBG_H("Received WLAN_AP_DISCONNECT name: %s\n",event_wlan->name);
IPACMDBG_H("AP Mac Address %02x:%02x:%02x:%02x:%02x:%02x\n",
event_wlan->mac_addr[0], event_wlan->mac_addr[1], event_wlan->mac_addr[2],
event_wlan->mac_addr[3], event_wlan->mac_addr[4], event_wlan->mac_addr[5]);
data_fid = (ipacm_event_data_fid *)malloc(sizeof(ipacm_event_data_fid));
if(data_fid == NULL)
{
IPACMERR("unable to allocate memory for event_wlan data_fid\n");
return NULL;
}
ipa_get_if_index(event_wlan->name, &(data_fid->if_index));
evt_data.event = IPA_WLAN_LINK_DOWN_EVENT;
evt_data.evt_data = data_fid;
break;
case WLAN_STA_CONNECT:
event_wlan = (struct ipa_wlan_msg *)(buffer + sizeof(struct ipa_msg_meta));
IPACMDBG_H("Received WLAN_STA_CONNECT name: %s\n",event_wlan->name);
IPACMDBG_H("STA Mac Address %02x:%02x:%02x:%02x:%02x:%02x\n",
event_wlan->mac_addr[0], event_wlan->mac_addr[1], event_wlan->mac_addr[2],
event_wlan->mac_addr[3], event_wlan->mac_addr[4], event_wlan->mac_addr[5]);
data = (ipacm_event_data_mac *)malloc(sizeof(ipacm_event_data_mac));
if(data == NULL)
{
IPACMERR("unable to allocate memory for event_wlan data_fid\n");
return NULL;
}
memcpy(data->mac_addr,
event_wlan->mac_addr,
sizeof(event_wlan->mac_addr));
ipa_get_if_index(event_wlan->name, &(data->if_index));
evt_data.event = IPA_WLAN_STA_LINK_UP_EVENT;
evt_data.evt_data = data;
break;
case WLAN_STA_DISCONNECT:
event_wlan = (struct ipa_wlan_msg *)(buffer + sizeof(struct ipa_msg_meta));
IPACMDBG_H("Received WLAN_STA_DISCONNECT name: %s\n",event_wlan->name);
IPACMDBG_H("STA Mac Address %02x:%02x:%02x:%02x:%02x:%02x\n",
event_wlan->mac_addr[0], event_wlan->mac_addr[1], event_wlan->mac_addr[2],
event_wlan->mac_addr[3], event_wlan->mac_addr[4], event_wlan->mac_addr[5]);
data_fid = (ipacm_event_data_fid *)malloc(sizeof(ipacm_event_data_fid));
if(data_fid == NULL)
{
IPACMERR("unable to allocate memory for event_wlan data_fid\n");
return NULL;
}
ipa_get_if_index(event_wlan->name, &(data_fid->if_index));
evt_data.event = IPA_WLAN_LINK_DOWN_EVENT;
evt_data.evt_data = data_fid;
break;
case WLAN_CLIENT_CONNECT:
event_wlan = (struct ipa_wlan_msg *)(buffer + sizeof(struct ipa_msg_meta));
IPACMDBG_H("Received WLAN_CLIENT_CONNECT\n");
IPACMDBG_H("Mac Address %02x:%02x:%02x:%02x:%02x:%02x\n",
event_wlan->mac_addr[0], event_wlan->mac_addr[1], event_wlan->mac_addr[2],
event_wlan->mac_addr[3], event_wlan->mac_addr[4], event_wlan->mac_addr[5]);
data = (ipacm_event_data_mac *)malloc(sizeof(ipacm_event_data_mac));
if (data == NULL)
{
IPACMERR("unable to allocate memory for event_wlan data\n");
return NULL;
}
memcpy(data->mac_addr,
event_wlan->mac_addr,
sizeof(event_wlan->mac_addr));
ipa_get_if_index(event_wlan->name, &(data->if_index));
evt_data.event = IPA_WLAN_CLIENT_ADD_EVENT;
evt_data.evt_data = data;
break;
case WLAN_CLIENT_CONNECT_EX:
IPACMDBG_H("Received WLAN_CLIENT_CONNECT_EX\n");
memcpy(&event_ex_o, buffer + sizeof(struct ipa_msg_meta),sizeof(struct ipa_wlan_msg_ex));
if(event_ex_o.num_of_attribs > IPA_DRIVER_WLAN_EVENT_MAX_OF_ATTRIBS)
{
IPACMERR("buffer size overflow\n");
return NULL;
}
length = sizeof(ipa_wlan_msg_ex)+ event_ex_o.num_of_attribs * sizeof(ipa_wlan_hdr_attrib_val);
IPACMDBG_H("num_of_attribs %d, length %d\n", event_ex_o.num_of_attribs, length);
event_ex = (ipa_wlan_msg_ex *)malloc(length);
if(event_ex == NULL )
{
IPACMERR("Unable to allocate memory\n");
return NULL;
}
memcpy(event_ex, buffer + sizeof(struct ipa_msg_meta), length);
data_ex = (ipacm_event_data_wlan_ex *)malloc(sizeof(ipacm_event_data_wlan_ex) + event_ex_o.num_of_attribs * sizeof(ipa_wlan_hdr_attrib_val));
if (data_ex == NULL)
{
IPACMERR("unable to allocate memory for event data\n");
return NULL;
}
data_ex->num_of_attribs = event_ex->num_of_attribs;
memcpy(data_ex->attribs,
event_ex->attribs,
event_ex->num_of_attribs * sizeof(ipa_wlan_hdr_attrib_val));
ipa_get_if_index(event_ex->name, &(data_ex->if_index));
evt_data.event = IPA_WLAN_CLIENT_ADD_EVENT_EX;
evt_data.evt_data = data_ex;
/* Construct new_neighbor msg with netdev device internally */
new_neigh_data = (ipacm_event_data_all*)malloc(sizeof(ipacm_event_data_all));
if(new_neigh_data == NULL)
{
IPACMERR("Failed to allocate memory.\n");
return NULL;
}
memset(new_neigh_data, 0, sizeof(ipacm_event_data_all));
new_neigh_data->iptype = IPA_IP_v6;
for(cnt = 0; cnt < event_ex->num_of_attribs; cnt++)
{
if(event_ex->attribs[cnt].attrib_type == WLAN_HDR_ATTRIB_MAC_ADDR)
{
memcpy(new_neigh_data->mac_addr, event_ex->attribs[cnt].u.mac_addr, sizeof(new_neigh_data->mac_addr));
IPACMDBG_H("Mac Address %02x:%02x:%02x:%02x:%02x:%02x\n",
event_ex->attribs[cnt].u.mac_addr[0], event_ex->attribs[cnt].u.mac_addr[1], event_ex->attribs[cnt].u.mac_addr[2],
event_ex->attribs[cnt].u.mac_addr[3], event_ex->attribs[cnt].u.mac_addr[4], event_ex->attribs[cnt].u.mac_addr[5]);
}
else if(event_ex->attribs[cnt].attrib_type == WLAN_HDR_ATTRIB_STA_ID)
{
IPACMDBG_H("Wlan client id %d\n",event_ex->attribs[cnt].u.sta_id);
}
else
{
IPACMDBG_H("Wlan message has unexpected type!\n");
}
}
new_neigh_data->if_index = data_ex->if_index;
new_neigh_evt.evt_data = (void*)new_neigh_data;
new_neigh_evt.event = IPA_NEW_NEIGH_EVENT;
free(event_ex);
break;
case WLAN_CLIENT_DISCONNECT:
IPACMDBG_H("Received WLAN_CLIENT_DISCONNECT\n");
event_wlan = (struct ipa_wlan_msg *)(buffer + sizeof(struct ipa_msg_meta));
IPACMDBG_H("Mac Address %02x:%02x:%02x:%02x:%02x:%02x\n",
event_wlan->mac_addr[0], event_wlan->mac_addr[1], event_wlan->mac_addr[2],
event_wlan->mac_addr[3], event_wlan->mac_addr[4], event_wlan->mac_addr[5]);
data = (ipacm_event_data_mac *)malloc(sizeof(ipacm_event_data_mac));
if (data == NULL)
{
IPACMERR("unable to allocate memory for event_wlan data\n");
return NULL;
}
memcpy(data->mac_addr,
event_wlan->mac_addr,
sizeof(event_wlan->mac_addr));
ipa_get_if_index(event_wlan->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_H("Received WLAN_CLIENT_POWER_SAVE_MODE\n");
event_wlan = (struct ipa_wlan_msg *)(buffer + sizeof(struct ipa_msg_meta));
IPACMDBG_H("Mac Address %02x:%02x:%02x:%02x:%02x:%02x\n",
event_wlan->mac_addr[0], event_wlan->mac_addr[1], event_wlan->mac_addr[2],
event_wlan->mac_addr[3], event_wlan->mac_addr[4], event_wlan->mac_addr[5]);
data = (ipacm_event_data_mac *)malloc(sizeof(ipacm_event_data_mac));
if (data == NULL)
{
IPACMERR("unable to allocate memory for event_wlan data\n");
return NULL;
}
memcpy(data->mac_addr,
event_wlan->mac_addr,
sizeof(event_wlan->mac_addr));
ipa_get_if_index(event_wlan->name, &(data->if_index));
evt_data.event = IPA_WLAN_CLIENT_POWER_SAVE_EVENT;
evt_data.evt_data = data;
break;
case WLAN_CLIENT_NORMAL_MODE:
IPACMDBG_H("Received WLAN_CLIENT_NORMAL_MODE\n");
event_wlan = (struct ipa_wlan_msg *)(buffer + sizeof(struct ipa_msg_meta));
IPACMDBG_H("Mac Address %02x:%02x:%02x:%02x:%02x:%02x\n",
event_wlan->mac_addr[0], event_wlan->mac_addr[1], event_wlan->mac_addr[2],
event_wlan->mac_addr[3], event_wlan->mac_addr[4], event_wlan->mac_addr[5]);
data = (ipacm_event_data_mac *)malloc(sizeof(ipacm_event_data_mac));
if (data == NULL)
{
IPACMERR("unable to allocate memory for event_wlan data\n");
return NULL;
}
memcpy(data->mac_addr,
event_wlan->mac_addr,
sizeof(event_wlan->mac_addr));
ipa_get_if_index(event_wlan->name, &(data->if_index));
evt_data.evt_data = data;
evt_data.event = IPA_WLAN_CLIENT_RECOVER_EVENT;
break;
case ECM_CONNECT:
memcpy(&event_ecm, buffer + sizeof(struct ipa_msg_meta), sizeof(struct ipa_ecm_msg));
IPACMDBG_H("Received ECM_CONNECT name: %s\n",event_ecm.name);
data_fid = (ipacm_event_data_fid *)malloc(sizeof(ipacm_event_data_fid));
if(data_fid == NULL)
{
IPACMERR("unable to allocate memory for event_ecm data_fid\n");
return NULL;
}
data_fid->if_index = event_ecm.ifindex;
evt_data.event = IPA_USB_LINK_UP_EVENT;
evt_data.evt_data = data_fid;
break;
case ECM_DISCONNECT:
memcpy(&event_ecm, buffer + sizeof(struct ipa_msg_meta), sizeof(struct ipa_ecm_msg));
IPACMDBG_H("Received ECM_DISCONNECT name: %s\n",event_ecm.name);
data_fid = (ipacm_event_data_fid *)malloc(sizeof(ipacm_event_data_fid));
if(data_fid == NULL)
{
IPACMERR("unable to allocate memory for event_ecm data_fid\n");
return NULL;
}
data_fid->if_index = event_ecm.ifindex;
evt_data.event = IPA_LINK_DOWN_EVENT;
evt_data.evt_data = data_fid;
break;
/* Add for 8994 Android case */
case WAN_UPSTREAM_ROUTE_ADD:
memcpy(&event_wan, buffer + sizeof(struct ipa_msg_meta), sizeof(struct ipa_wan_msg));
IPACMDBG_H("Received WAN_UPSTREAM_ROUTE_ADD name: %s, tethered name: %s\n", event_wan.upstream_ifname, event_wan.tethered_ifname);
data_iptype = (ipacm_event_data_iptype *)malloc(sizeof(ipacm_event_data_iptype));
if(data_iptype == NULL)
{
IPACMERR("unable to allocate memory for event_ecm data_iptype\n");
return NULL;
}
ipa_get_if_index(event_wan.upstream_ifname, &(data_iptype->if_index));
ipa_get_if_index(event_wan.tethered_ifname, &(data_iptype->if_index_tether));
data_iptype->iptype = event_wan.ip;
#ifdef IPA_WAN_MSG_IPv6_ADDR_GW_LEN
data_iptype->ipv4_addr_gw = event_wan.ipv4_addr_gw;
data_iptype->ipv6_addr_gw[0] = event_wan.ipv6_addr_gw[0];
data_iptype->ipv6_addr_gw[1] = event_wan.ipv6_addr_gw[1];
data_iptype->ipv6_addr_gw[2] = event_wan.ipv6_addr_gw[2];
data_iptype->ipv6_addr_gw[3] = event_wan.ipv6_addr_gw[3];
IPACMDBG_H("default gw ipv4 (%x)\n", data_iptype->ipv4_addr_gw);
IPACMDBG_H("IPV6 gateway: %08x:%08x:%08x:%08x \n",
data_iptype->ipv6_addr_gw[0], data_iptype->ipv6_addr_gw[1], data_iptype->ipv6_addr_gw[2], data_iptype->ipv6_addr_gw[3]);
#endif
IPACMDBG_H("Received WAN_UPSTREAM_ROUTE_ADD: fid(%d) tether_fid(%d) ip-type(%d)\n", data_iptype->if_index,
data_iptype->if_index_tether, data_iptype->iptype);
evt_data.event = IPA_WAN_UPSTREAM_ROUTE_ADD_EVENT;
evt_data.evt_data = data_iptype;
break;
case WAN_UPSTREAM_ROUTE_DEL:
memcpy(&event_wan, buffer + sizeof(struct ipa_msg_meta), sizeof(struct ipa_wan_msg));
IPACMDBG_H("Received WAN_UPSTREAM_ROUTE_DEL name: %s, tethered name: %s\n", event_wan.upstream_ifname, event_wan.tethered_ifname);
data_iptype = (ipacm_event_data_iptype *)malloc(sizeof(ipacm_event_data_iptype));
if(data_iptype == NULL)
{
IPACMERR("unable to allocate memory for event_ecm data_iptype\n");
return NULL;
}
ipa_get_if_index(event_wan.upstream_ifname, &(data_iptype->if_index));
ipa_get_if_index(event_wan.tethered_ifname, &(data_iptype->if_index_tether));
data_iptype->iptype = event_wan.ip;
IPACMDBG_H("Received WAN_UPSTREAM_ROUTE_DEL: fid(%d) ip-type(%d)\n", data_iptype->if_index, data_iptype->iptype);
evt_data.event = IPA_WAN_UPSTREAM_ROUTE_DEL_EVENT;
evt_data.evt_data = data_iptype;
break;
/* End of adding for 8994 Android case */
/* Add for embms case */
case WAN_EMBMS_CONNECT:
memcpy(&event_wan, buffer + sizeof(struct ipa_msg_meta), sizeof(struct ipa_wan_msg));
IPACMDBG("Received WAN_EMBMS_CONNECT name: %s\n",event_wan.upstream_ifname);
data_fid = (ipacm_event_data_fid *)malloc(sizeof(ipacm_event_data_fid));
if(data_fid == NULL)
{
IPACMERR("unable to allocate memory for event data_fid\n");
return NULL;
}
ipa_get_if_index(event_wan.upstream_ifname, &(data_fid->if_index));
evt_data.event = IPA_WAN_EMBMS_LINK_UP_EVENT;
evt_data.evt_data = data_fid;
break;
case WLAN_SWITCH_TO_SCC:
IPACMDBG_H("Received WLAN_SWITCH_TO_SCC\n");
case WLAN_WDI_ENABLE:
IPACMDBG_H("Received WLAN_WDI_ENABLE\n");
if (IPACM_Iface::ipacmcfg->isMCC_Mode == true)
{
IPACM_Iface::ipacmcfg->isMCC_Mode = false;
evt_data.event = IPA_WLAN_SWITCH_TO_SCC;
break;
}
continue;
case WLAN_SWITCH_TO_MCC:
IPACMDBG_H("Received WLAN_SWITCH_TO_MCC\n");
case WLAN_WDI_DISABLE:
IPACMDBG_H("Received WLAN_WDI_DISABLE\n");
if (IPACM_Iface::ipacmcfg->isMCC_Mode == false)
{
IPACM_Iface::ipacmcfg->isMCC_Mode = true;
evt_data.event = IPA_WLAN_SWITCH_TO_MCC;
break;
}
continue;
case WAN_XLAT_CONNECT:
memcpy(&event_wan, buffer + sizeof(struct ipa_msg_meta),
sizeof(struct ipa_wan_msg));
IPACMDBG_H("Received WAN_XLAT_CONNECT name: %s\n",
event_wan.upstream_ifname);
/* post IPA_LINK_UP_EVENT event
* may be WAN interface is not up
*/
data_fid = (ipacm_event_data_fid *)calloc(1, sizeof(ipacm_event_data_fid));
if(data_fid == NULL)
{
IPACMERR("unable to allocate memory for xlat event\n");
return NULL;
}
ipa_get_if_index(event_wan.upstream_ifname, &(data_fid->if_index));
evt_data.event = IPA_LINK_UP_EVENT;
evt_data.evt_data = data_fid;
IPACMDBG_H("Posting IPA_LINK_UP_EVENT event:%d\n", evt_data.event);
IPACM_EvtDispatcher::PostEvt(&evt_data);
/* post IPA_WAN_XLAT_CONNECT_EVENT event */
memset(&evt_data, 0, sizeof(evt_data));
data_fid = (ipacm_event_data_fid *)calloc(1, sizeof(ipacm_event_data_fid));
if(data_fid == NULL)
{
IPACMERR("unable to allocate memory for xlat event\n");
return NULL;
}
ipa_get_if_index(event_wan.upstream_ifname, &(data_fid->if_index));
evt_data.event = IPA_WAN_XLAT_CONNECT_EVENT;
evt_data.evt_data = data_fid;
IPACMDBG_H("Posting IPA_WAN_XLAT_CONNECT_EVENT event:%d\n", evt_data.event);
break;
case IPA_TETHERING_STATS_UPDATE_STATS:
memcpy(&event_data_stats, buffer + sizeof(struct ipa_msg_meta), sizeof(struct ipa_get_data_stats_resp_msg_v01));
data_tethering_stats = (ipa_get_data_stats_resp_msg_v01 *)malloc(sizeof(struct ipa_get_data_stats_resp_msg_v01));
if(data_tethering_stats == NULL)
{
IPACMERR("unable to allocate memory for event data_tethering_stats\n");
return NULL;
}
memcpy(data_tethering_stats,
&event_data_stats,
sizeof(struct ipa_get_data_stats_resp_msg_v01));
IPACMDBG("Received IPA_TETHERING_STATS_UPDATE_STATS ipa_stats_type: %d\n",data_tethering_stats->ipa_stats_type);
IPACMDBG("Received %d UL, %d DL pipe stats\n",data_tethering_stats->ul_src_pipe_stats_list_len, data_tethering_stats->dl_dst_pipe_stats_list_len);
evt_data.event = IPA_TETHERING_STATS_UPDATE_EVENT;
evt_data.evt_data = data_tethering_stats;
break;
case IPA_TETHERING_STATS_UPDATE_NETWORK_STATS:
memcpy(&event_network_stats, buffer + sizeof(struct ipa_msg_meta), sizeof(struct ipa_get_apn_data_stats_resp_msg_v01));
data_network_stats = (ipa_get_apn_data_stats_resp_msg_v01 *)malloc(sizeof(ipa_get_apn_data_stats_resp_msg_v01));
if(data_network_stats == NULL)
{
IPACMERR("unable to allocate memory for event data_network_stats\n");
return NULL;
}
memcpy(data_network_stats,
&event_network_stats,
sizeof(struct ipa_get_apn_data_stats_resp_msg_v01));
IPACMDBG("Received %d apn network stats \n", data_network_stats->apn_data_stats_list_len);
evt_data.event = IPA_NETWORK_STATS_UPDATE_EVENT;
evt_data.evt_data = data_network_stats;
break;
default:
IPACMDBG_H("Unhandled message type: %d\n", event_hdr.msg_type);
continue;
}
/* finish command queue */
IPACMDBG_H("Posting event:%d\n", evt_data.event);
IPACM_EvtDispatcher::PostEvt(&evt_data);
/* push new_neighbor with netdev device internally */
if(new_neigh_data != NULL)
{
IPACMDBG_H("Internally post event IPA_NEW_NEIGH_EVENT\n");
IPACM_EvtDispatcher::PostEvt(&new_neigh_evt);
}
}
(void)close(fd);
return NULL;
}
void IPACM_Sig_Handler(int sig)
{
int cnt;
ipacm_cmd_q_data evt_data;
printf("Received Signal: %d\n", sig);
memset(&evt_data, 0, sizeof(evt_data));
switch(sig)
{
case SIGUSR1:
IPACMDBG_H("Received SW_ROUTING_ENABLE request \n");
evt_data.event = IPA_SW_ROUTING_ENABLE;
IPACM_Iface::ipacmcfg->ipa_sw_rt_enable = true;
break;
case SIGUSR2:
IPACMDBG_H("Received SW_ROUTING_DISABLE request \n");
evt_data.event = IPA_SW_ROUTING_DISABLE;
IPACM_Iface::ipacmcfg->ipa_sw_rt_enable = false;
break;
}
/* finish command queue */
IPACMDBG_H("Posting event:%d\n", evt_data.event);
IPACM_EvtDispatcher::PostEvt(&evt_data);
return;
}
void RegisterForSignals(void)
{
signal(SIGUSR1, IPACM_Sig_Handler);
signal(SIGUSR2, IPACM_Sig_Handler);
}
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;
/* check if ipacm is already running or not */
ipa_is_ipacm_running();
IPACMDBG_H("In main()\n");
IPACM_Neighbor *neigh = new IPACM_Neighbor();
IPACM_IfaceManager *ifacemgr = new IPACM_IfaceManager();
#ifdef FEATURE_ETH_BRIDGE_LE
IPACM_LanToLan* lan2lan = new IPACM_LanToLan();
#endif
IPACM_ConntrackClient *cc = IPACM_ConntrackClient::GetInstance();
CtList = new IPACM_ConntrackListener();
IPACMDBG_H("Staring IPA main\n");
IPACMDBG_H("ipa_cmdq_successful\n");
RegisterForSignals();
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_H("created command queue thread\n");
if(pthread_setname_np(cmd_queue_thread, "cmd queue process") != 0)
{
IPACMERR("unable to set thread name\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_H("created netlink thread\n");
if(pthread_setname_np(netlink_thread, "netlink socket") != 0)
{
IPACMERR("unable to set thread name\n");
}
}
/* Enable Firewall support only on MDM targets */
#ifndef FEATURE_IPA_ANDROID
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_H("created firewall monitor thread\n");
if(pthread_setname_np(monitor_thread, "firewall cfg process") != 0)
{
IPACMERR("unable to set thread name\n");
}
}
#endif
if (IPACM_SUCCESS == ipa_driver_thread)
{
ret = pthread_create(&ipa_driver_thread, NULL, ipa_driver_msg_notifier, NULL);
if (IPACM_SUCCESS != ret)
{
IPACMERR("unable to create ipa_driver_wlan thread\n");
return ret;
}
IPACMDBG_H("created ipa_driver_wlan thread\n");
if(pthread_setname_np(ipa_driver_thread, "ipa driver ntfy") != 0)
{
IPACMERR("unable to set thread name\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_is_ipacm_running
===========================================================================*/
/*!
@brief
Determine whether there's already an IPACM process running, if so, terminate
the current one
@return
None
@note
- Dependencies
- None
- Side Effects
- None
*/
/*=========================================================================*/
void ipa_is_ipacm_running(void) {
int fd;
struct flock lock;
int retval;
fd = open(IPACM_PID_FILE, O_RDWR | O_CREAT, 0600);
if ( fd <= 0 )
{
IPACMERR("Failed to open %s, error is %d - %s\n",
IPACM_PID_FILE, errno, strerror(errno));
exit(0);
}
/*
* Getting an exclusive Write lock on the file, if it fails,
* it means that another instance of IPACM is running and it
* got the lock before us.
*/
memset(&lock, 0, sizeof(lock));
lock.l_type = F_WRLCK;
retval = fcntl(fd, F_SETLK, &lock);
if (retval != 0)
{
retval = fcntl(fd, F_GETLK, &lock);
if (retval == 0)
{
IPACMERR("Unable to get lock on file %s (my PID %d), PID %d already has it\n",
IPACM_PID_FILE, getpid(), lock.l_pid);
close(fd);
exit(0);
}
}
else
{
IPACMERR("PID %d is IPACM main process\n", getpid());
}
return;
}
/*===========================================================================
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)strlcpy(ifr.ifr_name, if_name, sizeof(ifr.ifr_name));
if (ioctl(fd, SIOCGIFINDEX, &ifr) < 0)
{
IPACMERR("call_ioctl_on_dev: ioctl failed: can't find device %s",if_name);
*if_index = -1;
close(fd);
return IPACM_FAILURE;
}
*if_index = ifr.ifr_ifindex;
close(fd);
return IPACM_SUCCESS;
}

570
data-ipa-cfg-mgr/ipacm/src/IPACM_Neighbor.cpp
View File

@@ -1,570 +0,0 @@
/*
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;
circular_index = 0;
memset(neighbor_client, 0, IPA_MAX_NUM_NEIGHBOR_CLIENTS * sizeof(ipa_neighbor_client));
IPACM_EvtDispatcher::registr(IPA_WLAN_CLIENT_ADD_EVENT_EX, this);
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_all = 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);
switch (event)
{
case IPA_WLAN_CLIENT_ADD_EVENT_EX:
{
ipacm_event_data_wlan_ex *data = (ipacm_event_data_wlan_ex *)param;
ipa_interface_index = IPACM_Iface::iface_ipa_index_query(data->if_index);
/* check for failure return */
if (IPACM_FAILURE == ipa_interface_index) {
IPACMERR("IPA_WLAN_CLIENT_ADD_EVENT_EX: not supported iface id: %d\n", data->if_index);
break;
}
uint8_t client_mac_addr[6];
IPACMDBG_H("Received IPA_WLAN_CLIENT_ADD_EVENT\n");
for(i = 0; i < data->num_of_attribs; i++)
{
if(data->attribs[i].attrib_type == WLAN_HDR_ATTRIB_MAC_ADDR)
{
memcpy(client_mac_addr,
data->attribs[i].u.mac_addr,
sizeof(client_mac_addr));
IPACMDBG_H("AP Mac Address %02x:%02x:%02x:%02x:%02x:%02x\n",
client_mac_addr[0], client_mac_addr[1], client_mac_addr[2],
client_mac_addr[3], client_mac_addr[4], client_mac_addr[5]);
}
else
{
IPACMDBG_H("The attribute type is not expected!\n");
}
}
for (i = 0; i < num_neighbor_client_temp; i++)
{
/* find the client */
if (memcmp(neighbor_client[i].mac_addr, client_mac_addr, sizeof(neighbor_client[i].mac_addr)) == 0)
{
/* check if iface is not bridge interface*/
if (strcmp(IPACM_Iface::ipacmcfg->ipa_virtual_iface_name, IPACM_Iface::ipacmcfg->iface_table[ipa_interface_index].iface_name) != 0)
{
/* use previous ipv4 first */
if(data->if_index != neighbor_client[i].iface_index)
{
IPACMERR("update new kernel iface index \n");
neighbor_client[i].iface_index = data->if_index;
}
/* check if client associated with previous network interface */
if(ipa_interface_index != neighbor_client[i].ipa_if_num)
{
IPACMERR("client associate to different AP \n");
return;
}
if (neighbor_client[i].v4_addr != 0) /* not 0.0.0.0 */
{
evt_data.event = IPA_NEIGH_CLIENT_IP_ADDR_ADD_EVENT;
data_all = (ipacm_event_data_all *)malloc(sizeof(ipacm_event_data_all));
if (data_all == NULL)
{
IPACMERR("Unable to allocate memory\n");
return;
}
data_all->iptype = IPA_IP_v4;
data_all->if_index = neighbor_client[i].iface_index;
data_all->ipv4_addr = neighbor_client[i].v4_addr; //use previous ipv4 address
memcpy(data_all->mac_addr,
neighbor_client[i].mac_addr,
sizeof(data_all->mac_addr));
evt_data.evt_data = (void *)data_all;
IPACM_EvtDispatcher::PostEvt(&evt_data);
/* ask for replaced iface name*/
ipa_interface_index = IPACM_Iface::iface_ipa_index_query(data_all->if_index);
/* check for failure return */
if (IPACM_FAILURE == ipa_interface_index) {
IPACMERR("not supported iface id: %d\n", data_all->if_index);
} else {
IPACMDBG_H("Posted event %d, with %s for ipv4 client re-connect\n",
evt_data.event,
IPACM_Iface::ipacmcfg->iface_table[ipa_interface_index].iface_name);
}
}
}
break;
}
}
}
break;
default:
{
if (event == IPA_NEW_NEIGH_EVENT)
{
IPACMDBG_H("Received IPA_NEW_NEIGH_EVENT\n");
}
else
{
IPACMDBG_H("Received IPA_DEL_NEIGH_EVENT\n");
}
ipacm_event_data_all *data = (ipacm_event_data_all *)param;
ipa_interface_index = IPACM_Iface::iface_ipa_index_query(data->if_index);
/* check for failure return */
if (IPACM_FAILURE == ipa_interface_index) {
IPACMERR("not supported iface id: %d\n", data->if_index);
break;
}
if (data->iptype == IPA_IP_v4)
{
if (data->ipv4_addr != 0) /* not 0.0.0.0 */
{
IPACMDBG("Got Neighbor event with ipv4 address: 0x%x \n", data->ipv4_addr);
/* check if ipv4 address is link local(169.254.xxx.xxx) */
if ((data->ipv4_addr & IPV4_ADDR_LINKLOCAL_MASK) == IPV4_ADDR_LINKLOCAL)
{
IPACMDBG_H("This is link local ipv4 address: 0x%x : ignore this NEIGH_EVENT\n", data->ipv4_addr);
return;
}
/* check if iface is bridge interface*/
if (strcmp(IPACM_Iface::ipacmcfg->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;
neighbor_client[i].v4_addr = data->ipv4_addr; // cache client's previous ipv4 address
/* 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
/* not to clean-up the client mac cache on bridge0 delneigh */
evt_data.event = IPA_NEIGH_CLIENT_IP_ADDR_DEL_EVENT;
data_all = (ipacm_event_data_all *)malloc(sizeof(ipacm_event_data_all));
if (data_all == NULL)
{
IPACMERR("Unable to allocate memory\n");
return;
}
memcpy(data_all, data, sizeof(ipacm_event_data_all));
evt_data.evt_data = (void *)data_all;
IPACM_EvtDispatcher::PostEvt(&evt_data);
/* ask for replaced iface name*/
ipa_interface_index = IPACM_Iface::iface_ipa_index_query(data_all->if_index);
/* check for failure return */
if (IPACM_FAILURE == ipa_interface_index) {
IPACMERR("not supported iface id: %d\n", data_all->if_index);
} else {
IPACMDBG_H("Posted event %d,\
with %s for ipv4\n",
evt_data.event,
IPACM_Iface::ipacmcfg->iface_table[ipa_interface_index].iface_name);
}
break;
}
}
}
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;
/* Also save to cache for ipv4 */
/*searh if seen this client or not*/
for (i = 0; i < num_neighbor_client_temp; i++)
{
/* find the client */
if (memcmp(neighbor_client[i].mac_addr, data->mac_addr, sizeof(neighbor_client[i].mac_addr)) == 0)
{
/* update the network interface client associated */
neighbor_client[i].iface_index = data->if_index;
neighbor_client[i].ipa_if_num = ipa_interface_index;
neighbor_client[i].v4_addr = data->ipv4_addr; // cache client's previous ipv4 address
IPACMDBG_H("update cache %d-entry, with %s iface, ipv4 address: 0x%x\n",
i,
IPACM_Iface::ipacmcfg->iface_table[ipa_interface_index].iface_name,
data->ipv4_addr);
break;
}
}
/* not find client */
if (i == num_neighbor_client_temp)
{
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;
/* cache the network interface client associated */
neighbor_client[num_neighbor_client_temp].ipa_if_num = ipa_interface_index;
neighbor_client[num_neighbor_client_temp].v4_addr = data->ipv4_addr;
num_neighbor_client++;
IPACMDBG_H("Cache 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);
}
else
{
IPACMERR("error: neighbor client oversize! recycle %d-st entry ! \n", circular_index);
memcpy(neighbor_client[circular_index].mac_addr,
data->mac_addr,
sizeof(data->mac_addr));
neighbor_client[circular_index].iface_index = data->if_index;
/* cache the network interface client associated */
neighbor_client[circular_index].ipa_if_num = ipa_interface_index;
neighbor_client[circular_index].v4_addr = 0;
IPACMDBG_H("Copy wlan-iface client MAC %02x:%02x:%02x:%02x:%02x:%02x\n, total client: %d, circular %d\n",
neighbor_client[circular_index].mac_addr[0],
neighbor_client[circular_index].mac_addr[1],
neighbor_client[circular_index].mac_addr[2],
neighbor_client[circular_index].mac_addr[3],
neighbor_client[circular_index].mac_addr[4],
neighbor_client[circular_index].mac_addr[5],
num_neighbor_client,
circular_index);
circular_index++;
}
}
}
else
{
evt_data.event = IPA_NEIGH_CLIENT_IP_ADDR_DEL_EVENT;
/*searh if seen this client or not*/
for (i = 0; i < num_neighbor_client_temp; i++)
{
/* find the client */
if (memcmp(neighbor_client[i].mac_addr, data->mac_addr, sizeof(neighbor_client[i].mac_addr)) == 0)
{
IPACMDBG_H("Clean %d-st Cached client-MAC %02x:%02x:%02x:%02x:%02x:%02x\n, total client: %d\n",
i,
neighbor_client[i].mac_addr[0],
neighbor_client[i].mac_addr[1],
neighbor_client[i].mac_addr[2],
neighbor_client[i].mac_addr[3],
neighbor_client[i].mac_addr[4],
neighbor_client[i].mac_addr[5],
num_neighbor_client);
memset(neighbor_client[i].mac_addr, 0, sizeof(neighbor_client[i].mac_addr));
neighbor_client[i].iface_index = 0;
neighbor_client[i].v4_addr = 0;
neighbor_client[i].ipa_if_num = 0;
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].iface_index = neighbor_client[i+1].iface_index;
neighbor_client[i].v4_addr = neighbor_client[i+1].v4_addr;
neighbor_client[i].ipa_if_num = neighbor_client[i+1].ipa_if_num;
}
num_neighbor_client--;
IPACMDBG_H(" total number of left cased clients: %d\n", num_neighbor_client);
break;
}
}
/* not find client, no need clean-up */
}
data_all = (ipacm_event_data_all *)malloc(sizeof(ipacm_event_data_all));
if (data_all == NULL)
{
IPACMERR("Unable to allocate memory\n");
return;
}
memcpy(data_all, data, sizeof(ipacm_event_data_all));
evt_data.evt_data = (void *)data_all;
IPACM_EvtDispatcher::PostEvt(&evt_data);
IPACMDBG_H("Posted event %d with %s for ipv4\n",
evt_data.event,
IPACM_Iface::ipacmcfg->iface_table[ipa_interface_index].iface_name);
}
}
}
else
{ //ipv6 starts
if ((data->ipv6_addr[0]) || (data->ipv6_addr[1]) || (data->ipv6_addr[2]) || (data->ipv6_addr[3]))
{
IPACMDBG("Got New_Neighbor event with ipv6 address \n");
/* check if iface is bridge interface*/
if (strcmp(IPACM_Iface::ipacmcfg->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;
data_all = (ipacm_event_data_all *)malloc(sizeof(ipacm_event_data_all));
if (data_all == NULL)
{
IPACMERR("Unable to allocate memory\n");
return;
}
memcpy(data_all, data, sizeof(ipacm_event_data_all));
evt_data.evt_data = (void *)data_all;
IPACM_EvtDispatcher::PostEvt(&evt_data);
/* ask for replaced iface name*/
ipa_interface_index = IPACM_Iface::iface_ipa_index_query(data_all->if_index);
/* check for failure return */
if (IPACM_FAILURE == ipa_interface_index) {
IPACMERR("not supported iface id: %d\n", data_all->if_index);
} else {
IPACMDBG_H("Posted event %d,\
with %s for ipv6\n",
evt_data.event,
IPACM_Iface::ipacmcfg->iface_table[ipa_interface_index].iface_name);
}
break;
};
}
}
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;
data_all = (ipacm_event_data_all *)malloc(sizeof(ipacm_event_data_all));
if (data_all == NULL)
{
IPACMERR("Unable to allocate memory\n");
return;
}
memcpy(data_all, data, sizeof(ipacm_event_data_all));
evt_data.evt_data = (void *)data_all;
IPACM_EvtDispatcher::PostEvt(&evt_data);
IPACMDBG_H("Posted event %d with %s for ipv6\n",
evt_data.event,
IPACM_Iface::ipacmcfg->iface_table[ipa_interface_index].iface_name);
}
}
else
{
IPACMDBG(" Got Neighbor event with no ipv6/ipv4 address \n");
/*no ipv6 in data searh if seen this client or not*/
for (i = 0; i < num_neighbor_client_temp; i++)
{
/* find the client */
if (memcmp(neighbor_client[i].mac_addr, data->mac_addr, sizeof(neighbor_client[i].mac_addr)) == 0)
{
IPACMDBG_H(" find %d-st client, MAC %02x:%02x:%02x:%02x:%02x:%02x\n, total client: %d\n",
i,
neighbor_client[i].mac_addr[0],
neighbor_client[i].mac_addr[1],
neighbor_client[i].mac_addr[2],
neighbor_client[i].mac_addr[3],
neighbor_client[i].mac_addr[4],
neighbor_client[i].mac_addr[5],
num_neighbor_client);
/* check if iface is not bridge interface*/
if (strcmp(IPACM_Iface::ipacmcfg->ipa_virtual_iface_name, IPACM_Iface::ipacmcfg->iface_table[ipa_interface_index].iface_name) != 0)
{
/* use previous ipv4 first */
if(data->if_index != neighbor_client[i].iface_index)
{
IPACMDBG_H("update new kernel iface index \n");
neighbor_client[i].iface_index = data->if_index;
}
/* check if client associated with previous network interface */
if(ipa_interface_index != neighbor_client[i].ipa_if_num)
{
IPACMDBG_H("client associate to different AP \n");
}
if (neighbor_client[i].v4_addr != 0) /* not 0.0.0.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;
data_all = (ipacm_event_data_all *)malloc(sizeof(ipacm_event_data_all));
if (data_all == NULL)
{
IPACMERR("Unable to allocate memory\n");
return;
}
data_all->iptype = IPA_IP_v4;
data_all->if_index = neighbor_client[i].iface_index;
data_all->ipv4_addr = neighbor_client[i].v4_addr; //use previous ipv4 address
memcpy(data_all->mac_addr,
neighbor_client[i].mac_addr,
sizeof(data_all->mac_addr));
evt_data.evt_data = (void *)data_all;
IPACM_EvtDispatcher::PostEvt(&evt_data);
/* ask for replaced iface name*/
ipa_interface_index = IPACM_Iface::iface_ipa_index_query(data_all->if_index);
/* check for failure return */
if (IPACM_FAILURE == ipa_interface_index) {
IPACMERR("not supported iface id: %d\n", data_all->if_index);
} else {
IPACMDBG_H("Posted event %d,\
with %s for ipv4 client re-connect\n",
evt_data.event,
IPACM_Iface::ipacmcfg->iface_table[ipa_interface_index].iface_name);
}
}
}
/* delete cache neighbor entry */
if (event == IPA_DEL_NEIGH_EVENT)
{
IPACMDBG_H("Clean %d-st Cached client-MAC %02x:%02x:%02x:%02x:%02x:%02x\n, total client: %d\n",
i,
neighbor_client[i].mac_addr[0],
neighbor_client[i].mac_addr[1],
neighbor_client[i].mac_addr[2],
neighbor_client[i].mac_addr[3],
neighbor_client[i].mac_addr[4],
neighbor_client[i].mac_addr[5],
num_neighbor_client);
memset(neighbor_client[i].mac_addr, 0, sizeof(neighbor_client[i].mac_addr));
neighbor_client[i].iface_index = 0;
neighbor_client[i].v4_addr = 0;
neighbor_client[i].ipa_if_num = 0;
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].iface_index = neighbor_client[i+1].iface_index;
neighbor_client[i].v4_addr = neighbor_client[i+1].v4_addr;
neighbor_client[i].ipa_if_num = neighbor_client[i+1].ipa_if_num;
}
num_neighbor_client--;
IPACMDBG_H(" total number of left cased clients: %d\n", num_neighbor_client);
}
break;
}
}
/* not find client */
if ((i == num_neighbor_client_temp) && (event == IPA_NEW_NEIGH_EVENT))
{
/* check if iface is not bridge interface*/
if (strcmp(IPACM_Iface::ipacmcfg->ipa_virtual_iface_name, IPACM_Iface::ipacmcfg->iface_table[ipa_interface_index].iface_name) != 0)
{
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;
/* cache the network interface client associated */
neighbor_client[num_neighbor_client_temp].ipa_if_num = ipa_interface_index;
neighbor_client[num_neighbor_client_temp].v4_addr = 0;
num_neighbor_client++;
IPACMDBG_H("Copy 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);
return;
}
else
{
IPACMERR("error: neighbor client oversize! recycle %d-st entry ! \n", circular_index);
memcpy(neighbor_client[circular_index].mac_addr,
data->mac_addr,
sizeof(data->mac_addr));
neighbor_client[circular_index].iface_index = data->if_index;
/* cache the network interface client associated */
neighbor_client[circular_index].ipa_if_num = ipa_interface_index;
neighbor_client[circular_index].v4_addr = 0;
IPACMDBG_H("Copy wlan-iface client MAC %02x:%02x:%02x:%02x:%02x:%02x\n, total client: %d, circular %d\n",
neighbor_client[circular_index].mac_addr[0],
neighbor_client[circular_index].mac_addr[1],
neighbor_client[circular_index].mac_addr[2],
neighbor_client[circular_index].mac_addr[3],
neighbor_client[circular_index].mac_addr[4],
neighbor_client[circular_index].mac_addr[5],
num_neighbor_client,
circular_index);
circular_index++;
return;
}
}
}
}
} //ipv6 ends
}
break;
}
return;
}

1773
data-ipa-cfg-mgr/ipacm/src/IPACM_Netlink.cpp
View File

File diff suppressed because it is too large Load Diff

276
data-ipa-cfg-mgr/ipacm/src/IPACM_Routing.cpp
View File

@@ -1,276 +0,0 @@
/*
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)
{
IPACMERR("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, cnt=0;
bool isInvalid = false;
if (!DeviceNodeIsOpened())
{
IPACMERR("Device is not opened\n");
return false;
}
for(cnt=0; cnt<ruleTable->num_rules; cnt++)
{
if(ruleTable->rules[cnt].rule.dst > IPA_CLIENT_MAX)
{
IPACMERR("Invalid dst pipe, Rule:%d dst_pipe:%d\n", cnt, ruleTable->rules[cnt].rule.dst);
isInvalid = true;
}
}
if(isInvalid)
{
return false;
}
retval = ioctl(m_fd, IPA_IOC_ADD_RT_RULE, ruleTable);
if (retval)
{
IPACMERR("Failed adding routing rule %p\n", ruleTable);
return false;
}
for(cnt=0; cnt<ruleTable->num_rules; cnt++)
{
IPACMDBG("Rule:%d dst_pipe:%d\n", cnt, ruleTable->rules[cnt].rule.dst);
}
IPACMDBG_H("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_H("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_H("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_H("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_H("IPA_IOCTL_GET_RT_TBL ioctl issued to IPA routing block.\n");
/* put routing table right after successfully get routing table */
PutRoutingTable(routingTable->hdl);
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_H("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(" No route handle passed. Ignoring it\n");
return res;
}
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_H("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;
}
bool IPACM_Routing::ModifyRoutingRule(struct ipa_ioc_mdfy_rt_rule *mdfyRules)
{
int retval = 0, cnt;
if (!DeviceNodeIsOpened())
{
IPACMERR("Device is not opened\n");
return false;
}
retval = ioctl(m_fd, IPA_IOC_MDFY_RT_RULE, mdfyRules);
if (retval)
{
IPACMERR("Failed modifying routing rules %p\n", mdfyRules);
return false;
}
for(cnt=0; cnt<mdfyRules->num_rules; cnt++)
{
if(mdfyRules->rules[cnt].status != 0)
{
IPACMERR("Unable to modify rule: %d\n", cnt);
}
}
IPACMDBG_H("Modified routing rules %p\n", mdfyRules);
return true;
}

6139
data-ipa-cfg-mgr/ipacm/src/IPACM_Wan.cpp
View File

File diff suppressed because it is too large Load Diff

2036
data-ipa-cfg-mgr/ipacm/src/IPACM_Wlan.cpp
View File

File diff suppressed because it is too large Load Diff

1176
data-ipa-cfg-mgr/ipacm/src/IPACM_Xml.cpp
View File

File diff suppressed because it is too large Load Diff

175
data-ipa-cfg-mgr/ipacm/src/IPACM_cfg.xml
View File

@@ -1,175 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<system xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="ipacm_cfg.xsd">
<ODUCFG>
<OduMode>router</OduMode>
<eMBMS_offload>0</eMBMS_offload>
</ODUCFG>
<IPACM>
<IPACMIface>
<Iface>
<Name>rndis0</Name>
<Category>LAN</Category>
</Iface>
<Iface>
<Name>ecm0</Name>
<Category>LAN</Category>
<Mode>ROUTER</Mode>
</Iface>
<Iface>
<Name>rmnet_data0</Name>
<Category>WAN</Category>
<Mode>ROUTER</Mode>
</Iface>
<Iface>
<Name>rmnet_data1</Name>
<Category>WAN</Category>
</Iface>
<Iface>
<Name>rmnet_data2</Name>
<Category>WAN</Category>
</Iface>
<Iface>
<Name>rmnet_data3</Name>
<Category>WAN</Category>
</Iface>
<Iface>
<Name>rmnet_data4</Name>
<Category>WAN</Category>
</Iface>
<Iface>
<Name>rmnet_data5</Name>
<Category>WAN</Category>
</Iface>
<Iface>
<Name>rmnet_data6</Name>
<Category>WAN</Category>
</Iface>
<Iface>
<Name>rmnet_data7</Name>
<Category>WAN</Category>
</Iface>
<Iface>
<Name>softap0</Name>
<Category>UNKNOWN</Category>
<WlanMode>full</WlanMode>
</Iface>
<Iface>
<Name>wlan0</Name>
<Category>UNKNOWN</Category>
<WlanMode>full</WlanMode>
</Iface>
<Iface>
<Name>wlan1</Name>
<Category>UNKNOWN</Category>
<WlanMode>full</WlanMode>
</Iface>
<Iface>
<Name>wlan2</Name>
<Category>UNKNOWN</Category>
<WlanMode>full</WlanMode>
</Iface>
<Iface>
<Name>wlan3</Name>
<Category>UNKNOWN</Category>
<WlanMode>full</WlanMode>
</Iface>
<Iface>
<Name>eth0</Name>
<Category>ODU</Category>
</Iface>
<Iface>
<Name>bridge0</Name>
<Category>VIRTUAL</Category>
</Iface>
</IPACMIface>
<IPPassthroughFlag>
<IPPassthroughMode>0</IPPassthroughMode>
</IPPassthroughFlag>
<IPACMPrivateSubnet>
<Subnet>
<SubnetAddress>192.168.225.0</SubnetAddress>
<SubnetMask>255.255.255.0</SubnetMask>
</Subnet>
</IPACMPrivateSubnet>
<IPACMALG>
<ALG>
<Protocol>TCP</Protocol>
<Port>21</Port>
<Description>FTP</Description>
</ALG>
<ALG>
<Protocol>TCP</Protocol>
<Port>554</Port>
<Description>RTSP</Description>
</ALG>
<ALG>
<Protocol>TCP</Protocol>
<Port>5060</Port>
<Description>SIP</Description>
</ALG>
<ALG>
<Protocol>UDP</Protocol>
<Port>5060</Port>
<Description>SIP</Description>
</ALG>
<ALG>
<Protocol>TCP</Protocol>
<Port>1723</Port>
<Description>PPTP</Description>
</ALG>
<ALG>
<Protocol>UDP</Protocol>
<Port>69</Port>
<Description>TFTP</Description>
</ALG>
<ALG>
<Protocol>UDP</Protocol>
<Port>53</Port>
<Description>DNS</Description>
</ALG>
<ALG>
<Protocol>TCP</Protocol>
<Port>53</Port>
<Description>DNS</Description>
</ALG>
<ALG>
<Protocol>UDP</Protocol>
<Port>10080</Port>
<Description>AMANDA</Description>
</ALG>
<ALG>
<Protocol>UDP</Protocol>
<Port>1719</Port>
<Description>H323</Description>
</ALG>
<ALG>
<Protocol>TCP</Protocol>
<Port>1720</Port>
<Description>H323</Description>
</ALG>
<ALG>
<Protocol>TCP</Protocol>
<Port>6667</Port>
<Description>IRC</Description>
</ALG>
<ALG>
<Protocol>UDP</Protocol>
<Port>137</Port>
<Description>NETBIOS_NS</Description>
</ALG>
<ALG>
<Protocol>UDP</Protocol>
<Port>138</Port>
<Description>NETBIOS_NS</Description>
</ALG>
<ALG>
<Protocol>TCP</Protocol>
<Port>6566</Port>
<Description>SANE</Description>
</ALG>
</IPACMALG>
<IPACMNAT>
<MaxNatEntries>500</MaxNatEntries>
</IPACMNAT>
</IPACM>
</system>

55
data-ipa-cfg-mgr/ipacm/src/Makefile.am
View File

@@ -1,55 +0,0 @@
AM_CPPFLAGS = -I./../inc \
-I$(top_srcdir)/ipanat/inc \
${LIBXML_CFLAGS}
AM_CPPFLAGS += -Wall -Wundef -Wno-trigraphs
AM_CPPFLAGS += -DDEBUG -g -DFEATURE_ETH_BRIDGE_LE
AM_CPPFLAGS += -DFEATURE_IPA_V3
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 \
IPACM_LanToLan.cpp
bin_PROGRAMS = ipacm
requiredlibs = ${LIBXML_LIB} -lxml2 -lpthread -lnetfilter_conntrack -lnfnetlink\
../../ipanat/src/libipanat.la
AM_CPPFLAGS += "-std=c++0x"
if USE_GLIB
ipacm_CFLAGS = $(AM_CFLAGS) -DUSE_GLIB @GLIB_CFLAGS@
ipacm_LDFLAGS = -lpthread @GLIB_LIBS@
ipacm_CPPFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(AM_CPPFLAGS) @GLIB_CFLAGS@
else
ipacm_CFLAGS = $(AM_CFLAGS)
ipacm_LDFLAGS = -lpthread
ipacm_CPPFLAGS = $(AM_CPPFLAGS)
endif
ipacm_LDADD = $(requiredlibs)
LOCAL_MODULE := libipanat
LOCAL_PRELINK_MODULE := false
include $(BUILD_SHARED_LIBRARY)
etcdir = ${sysconfdir}
etc_SCRIPTS = IPACM_cfg.xml
init_ddir = ${sysconfdir}/init.d
init_d_SCRIPTS = start_ipacm_le

7
data-ipa-cfg-mgr/ipacm/src/mobileap_firewall.xml
View File

@@ -1,7 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<system xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="mobileap_firewall_cfg.xsd">
<MobileAPFirewallCfg>
<FirewallEnabled>1</FirewallEnabled>
<FirewallPktsAllowed>0</FirewallPktsAllowed>
</MobileAPFirewallCfg>
</system>

57
data-ipa-cfg-mgr/ipacm/src/start_ipacm_le
View File

@@ -1,57 +0,0 @@
#! /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

116
data-ipa-cfg-mgr/ipanat/inc/ipa_nat_drv.h
View File

@@ -1,116 +0,0 @@
/*
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);

482
data-ipa-cfg-mgr/ipanat/inc/ipa_nat_drvi.h
View File

@@ -1,482 +0,0 @@
/*
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 <errno.h>
#include <pthread.h>
#include "ipa_nat_logi.h"
#define NAT_DUMP
/*======= 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
uint16_t cur_tbl_cnt;
uint16_t cur_expn_tbl_cnt;
};
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*,
nat_table_type tbl_type,
uint16_t indx_tbl_entry);
uint32_t ipa_nati_get_entry_offset(
struct ipa_nat_ip4_table_cache*,
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*, uint16_t*);
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);
int ipa_nati_add_ipv4_rule(uint32_t tbl_hdl,
const ipa_nat_ipv4_rule *clnt_rule,
uint32_t *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);
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);
uint16_t Read16BitFieldValue(uint32_t param,
ipa_nat_rule_field_type fld_type);
/* ========================================================
Debug functions
========================================================*/
#ifdef NAT_DUMP
void ipa_nati_print_rule(struct ipa_nat_rule*, uint32_t);
void ipa_nat_dump_ipv4_table(uint32_t);
void ipa_nati_print_index_rule(struct ipa_nat_indx_tbl_rule*,
uint32_t, uint16_t);
int ipa_nati_query_nat_rules(uint32_t, nat_table_type);
#endif
#endif /* #ifndef IPA_NAT_DRVI_H */

73
data-ipa-cfg-mgr/ipanat/inc/ipa_nat_logi.h
View File

@@ -1,73 +0,0 @@
/*
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>
#include <syslog.h>
#define PERROR(fmt) printf("%s:%d %s()", __FILE__, __LINE__, __FUNCTION__);\
perror(fmt);
#define IPAERR(fmt, ...) printf("ERR: %s:%d %s() " fmt, __FILE__, __LINE__, __FUNCTION__, ##__VA_ARGS__);
#ifdef DEBUG
#define IPADBG(fmt, ...) printf("%s:%d %s() " fmt, __FILE__, __LINE__, __FUNCTION__, ##__VA_ARGS__);
#define IPADUMP(fmt, ...) printf(fmt, ##__VA_ARGS__);
#else
#define IPADBG(fmt, ...)
#define IPADUMP(fmt, ...)
#endif
#ifdef __cplusplus
}
#endif
#endif /* IPA_NAT_LOGI_H */

28
data-ipa-cfg-mgr/ipanat/src/Android.mk
View File

@@ -1,28 +0,0 @@
BOARD_PLATFORM_LIST := msm8916
BOARD_PLATFORM_LIST += msm8909
ifneq ($(call is-board-platform-in-list,$(BOARD_PLATFORM_LIST)),true)
ifneq (,$(filter $(QCOM_BOARD_PLATFORMS),$(TARGET_BOARD_PLATFORM)))
ifneq (, $(filter aarch64 arm arm64, $(TARGET_ARCH)))
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_C_INCLUDES := $(LOCAL_PATH)/../inc
LOCAL_C_INCLUDES += $(LOCAL_PATH)
LOCAL_C_INCLUDES += $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr/include
LOCAL_ADDITIONAL_DEPENDENCIES := $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr
LOCAL_SRC_FILES := ipa_nat_drv.c \
ipa_nat_drvi.c
LOCAL_CFLAGS := -DDEBUG
LOCAL_MODULE := libipanat
LOCAL_MODULE_TAGS := optional
LOCAL_PRELINK_MODULE := false
LOCAL_CLANG := true
include $(BUILD_SHARED_LIBRARY)
endif # $(TARGET_ARCH)
endif
endif

21
data-ipa-cfg-mgr/ipanat/src/Makefile.am
View File

@@ -1,21 +0,0 @@
AM_CFLAGS = -Wall -Wundef -Wstrict-prototypes -Wno-trigraphs
AM_CFLAGS += -I./../inc
#AM_CFLAGS += -DDEBUG -g
common_CFLAGS = -DUSE_GLIB @GLIB_CFLAGS@
common_LDFLAGS = -lrt @GLIB_LIBS@
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) $(common_CFLAGS)
libipanat_la_LDFLAGS = -shared $(common_LDFLAGS) -version-info 1:0:0

175
data-ipa-cfg-mgr/ipanat/src/ipa_nat_drv.c
View File

@@ -1,175 +0,0 @@
/*
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 -EINVAL;
}
ret = ipa_nati_add_ipv4_tbl(public_ip_addr,
number_of_entries,
tbl_hdl);
if (ret != 0) {
IPAERR("unable to add table \n");
return -EINVAL;
}
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 -EINVAL;
}
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)
{
int result = -EINVAL;
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 result;
}
IPADBG("Passed Table handle: 0x%x\n", tbl_hdl);
if (ipa_nati_add_ipv4_rule(tbl_hdl, clnt_rule, rule_hdl) != 0) {
return result;
}
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)
{
int result = -EINVAL;
if (IPA_NAT_INVALID_NAT_ENTRY == tbl_hdl ||
IPA_NAT_INVALID_NAT_ENTRY == rule_hdl) {
IPAERR("invalide parameters\n");
return result;
}
IPADBG("Passed Table: 0x%x and rule handle 0x%x\n", tbl_hdl, rule_hdl);
result = ipa_nati_del_ipv4_rule(tbl_hdl, rule_hdl);
if (result) {
IPAERR("unable to delete rule from hw \n");
return result;
}
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 -EINVAL;
}
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);
}

2340
data-ipa-cfg-mgr/ipanat/src/ipa_nat_drvi.c
View File

File diff suppressed because it is too large Load Diff

49
data-ipa-cfg-mgr/ipanat/src/ipa_nat_logi.c
View File

@@ -1,49 +0,0 @@
/*
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>
#include <unistd.h>
void log_nat_message(char *msg)
{
return;
}

53
data-ipa-cfg-mgr/ipanat/test/Android.mk
View File

@@ -1,53 +0,0 @@
BOARD_PLATFORM_LIST := msm8916
BOARD_PLATFORM_LIST += msm8909
ifneq ($(call is-board-platform-in-list,$(BOARD_PLATFORM_LIST)),true)
ifneq (,$(filter $(QCOM_BOARD_PLATFORMS),$(TARGET_BOARD_PLATFORM)))
ifneq (, $(filter aarch64 arm arm64, $(TARGET_ARCH)))
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_C_INCLUDES := $(LOCAL_PATH)/
LOCAL_C_INCLUDES += $(LOCAL_PATH)/../../ipanat/inc
LOCAL_C_INCLUDES += $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr/include
LOCAL_ADDITIONAL_DEPENDENCIES := $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr
LOCAL_MODULE := ipa_nat_test
LOCAL_SRC_FILES := ipa_nat_test000.c \
ipa_nat_test001.c \
ipa_nat_test002.c \
ipa_nat_test003.c \
ipa_nat_test004.c \
ipa_nat_test005.c \
ipa_nat_test006.c \
ipa_nat_test007.c \
ipa_nat_test008.c \
ipa_nat_test009.c \
ipa_nat_test010.c \
ipa_nat_test011.c \
ipa_nat_test012.c \
ipa_nat_test013.c \
ipa_nat_test014.c \
ipa_nat_test015.c \
ipa_nat_test016.c \
ipa_nat_test017.c \
ipa_nat_test018.c \
ipa_nat_test019.c \
ipa_nat_test020.c \
ipa_nat_test021.c \
ipa_nat_test022.c \
main.c
LOCAL_SHARED_LIBRARIES := libipanat
LOCAL_MODULE_TAGS := debug
LOCAL_MODULE_PATH := $(TARGET_OUT_DATA)/kernel-tests/ip_accelerator
include $(BUILD_EXECUTABLE)
endif # $(TARGET_ARCH)
endif
endif

42
data-ipa-cfg-mgr/ipanat/test/Makefile.am
View File

@@ -1,42 +0,0 @@
AM_CPPFLAGS = -I./../inc \
-I$(top_srcdir)/ipanat/inc
AM_CPPFLAGS += -Wall -Wundef -Wno-trigraphs
AM_CPPFLAGS += -g
ipanattest_SOURCES = ipa_nat_test000.c \
ipa_nat_test001.c \
ipa_nat_test002.c \
ipa_nat_test003.c \
ipa_nat_test004.c \
ipa_nat_test005.c \
ipa_nat_test006.c \
ipa_nat_test007.c \
ipa_nat_test008.c \
ipa_nat_test009.c \
ipa_nat_test010.c \
ipa_nat_test011.c \
ipa_nat_test012.c \
ipa_nat_test013.c \
ipa_nat_test014.c \
ipa_nat_test015.c \
ipa_nat_test016.c \
ipa_nat_test017.c \
ipa_nat_test018.c \
ipa_nat_test019.c \
ipa_nat_test020.c \
ipa_nat_test021.c \
ipa_nat_test022.c \
main.c
bin_PROGRAMS = ipanattest
requiredlibs = ../src/libipanat.la
ipanattest_LDADD = $(requiredlibs)
LOCAL_MODULE := libipanat
LOCAL_PRELINK_MODULE := false
include $(BUILD_SHARED_LIBRARY)

18
data-ipa-cfg-mgr/ipanat/test/README.txt
View File

@@ -1,18 +0,0 @@
1 To run this suite separately(each test case creates table and delete table) use below command
- To execute test suite nt times with n entries, command "ipanatest sep nt n"
Example: To execute test suite 1 time with 100 entries, command "ipanattest sep 100"
2. To run test suite not separately(creates table and delete table only once) use below command
- To execute test suite nt times with n entries, command "ipanatest reg nt n"
Example: To execute test suite 5 times with 32 entries, command "ipanattest reg 5 32"
3. To run inotify regression test use command, "ipanattest inotify nt"
Example: To execute inotify 5 times, command "ipanattest inotify 5"
4. if we just give command "ipanattest", runs test suite 1 time with 100 entries (non separate)

104
data-ipa-cfg-mgr/ipanat/test/ipa_nat_test.h
View File

@@ -1,104 +0,0 @@
/*
* Copyright (c) 2014, 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 FILES FOR MODULE
===========================================================================*/
#include "stdint.h" /* uint32_t */
#include "stdio.h"
#include <netinet/in.h> /* for proto definitions */
#define u32 uint32_t
#define u16 uint16_t
#define u8 uint8_t
/*============ Preconditions to run NAT Test cases =========*/
#define IPA_NAT_TEST_PRE_COND_TE 20
#define CHECK_ERR1(x, tbl_hdl) \
if(ipa_nat_validate_ipv4_table(tbl_hdl)) { \
if(sep) {\
ipa_nat_del_ipv4_tbl(tbl_hdl); \
}\
return -1;\
}\
if(x) { \
IPAERR("%d\n", ret); \
if(sep) {\
ipa_nat_del_ipv4_tbl(tbl_hdl); \
}\
return -1; \
}
#define CHECK_ERR(x) if(x) { \
IPAERR("%d\n", ret); \
return -1;\
}
#if 0
#define CHECK_ERR(x) if(x) { \
IPAERR("%d\n", ret); \
if(sep) {\
ipa_nat_del_ipv4_tbl(tbl_hdl); \
}\
return -1;\
}
#endif
#define IPADBG(fmt, args...) printf(" %s:%d " fmt, __FUNCTION__, __LINE__, ## args)
#define IPAERR(fmt, args...) printf(" %s:%d " fmt, __FUNCTION__, __LINE__, ## args)
#define NAT_DUMP
int ipa_nat_validate_ipv4_table(u32);
int ipa_nat_test000(int, u32, u8);
int ipa_nat_test001(int, u32, u8);
int ipa_nat_test002(int, u32, u8);
int ipa_nat_test003(int, u32, u8);
int ipa_nat_test004(int, u32, u8);
int ipa_nat_test005(int, u32, u8);
int ipa_nat_test006(int, u32, u8);
int ipa_nat_test007(int, u32, u8);
int ipa_nat_test008(int, u32, u8);
int ipa_nat_test009(int, u32, u8);
int ipa_nat_test010(int, u32, u8);
int ipa_nat_test011(int, u32, u8);
int ipa_nat_test012(int, u32, u8);
int ipa_nat_test013(int, u32, u8);
int ipa_nat_test014(int, u32, u8);
int ipa_nat_test015(int, u32, u8);
int ipa_nat_test016(int, u32, u8);
int ipa_nat_test017(int, u32, u8);
int ipa_nat_test018(int, u32, u8);
int ipa_nat_test019(int, u32, u8);
int ipa_nat_test020(int, u32, u8);
int ipa_nat_test021(int, int);
int ipa_nat_test022(int, u32, u8);

69
data-ipa-cfg-mgr/ipanat/test/ipa_nat_test000.c
View File

@@ -1,69 +0,0 @@
/*
* Copyright (c) 2014, 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_test000.c
@brief
Verify the following scenario:
1. Add ipv4 table
2. Delete ipv4 table
*/
/*===========================================================================*/
#include "ipa_nat_test.h"
#include "ipa_nat_drv.h"
int ipa_nat_test000(int total_entries, u32 tbl_hdl, u8 sep)
{
int ret;
u32 pub_ip_add = 0x011617c0; /* "192.23.22.1" */
ret = ipa_nat_add_ipv4_tbl(pub_ip_add, total_entries, &tbl_hdl);
if (0 != ret)
{
IPAERR("unable to create ipv4 nat table and returning Error:%d\n", ret);
return -1;
}
IPADBG("create nat ipv4 table successfully() \n");
IPADBG("calling ipa_nat_del_ipv4_tbl() \n");
ret = ipa_nat_del_ipv4_tbl(tbl_hdl);
if (0 != ret)
{
IPAERR("Unable to delete ipv4 nat table %d\n", ret);
return -1;
}
IPADBG("deleted ipv4 nat table successfully. Test passed \n");
return 0;
}

77
data-ipa-cfg-mgr/ipanat/test/ipa_nat_test001.c
View File

@@ -1,77 +0,0 @@
/*
* Copyright (c) 2014, 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_test001.c
@brief
Verify the following scenario:
1. Add ipv4 table
2. Add ipv4 rule
3. Delete ipv4 table
*/
/*===========================================================================*/
#include "ipa_nat_test.h"
#include "ipa_nat_drv.h"
int ipa_nat_test001(int total_entries, u32 tbl_hdl, u8 sep)
{
int ret;
u32 rule_hdl;
ipa_nat_ipv4_rule ipv4_rule;
u32 pub_ip_add = 0x011617c0; /* "192.23.22.1" */
ipv4_rule.target_ip = 0xC1171601; /* 193.23.22.1 */
ipv4_rule.target_port = 1234;
ipv4_rule.private_ip = 0xC2171601; /* 194.23.22.1 */
ipv4_rule.private_port = 5678;
ipv4_rule.protocol = IPPROTO_TCP;
ipv4_rule.public_port = 9050;
IPADBG("%s()\n",__FUNCTION__);
if(sep)
{
ret = ipa_nat_add_ipv4_tbl(pub_ip_add, total_entries, &tbl_hdl);
CHECK_ERR(ret);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl);
CHECK_ERR(ret);
ret = ipa_nat_del_ipv4_tbl(tbl_hdl);
CHECK_ERR(ret);
}
return 0;
}

85
data-ipa-cfg-mgr/ipanat/test/ipa_nat_test002.c
View File

@@ -1,85 +0,0 @@
/*
* Copyright (c) 2014, 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_test002.c
@brief
Verify the following scenario:
1. Add ipv4 table
2. Add ipv4 rule
3. delete ipv4 rule
4. Delete ipv4 table
*/
/*=========================================================================*/
#include "ipa_nat_test.h"
#include "ipa_nat_drv.h"
int ipa_nat_test002(int total_entries, u32 tbl_hdl, u8 sep)
{
int ret;
u32 rule_hdl;
ipa_nat_ipv4_rule ipv4_rule;
u32 pub_ip_add = 0x011617c0; /* "192.23.22.1" */
ipv4_rule.target_ip = 0xC1171601; /* 193.23.22.1 */
ipv4_rule.target_port = 1234;
ipv4_rule.private_ip = 0xC2171601; /* 194.23.22.1 */
ipv4_rule.private_port = 5678;
ipv4_rule.protocol = IPPROTO_TCP;
ipv4_rule.public_port = 9050;
IPADBG("%s()\n",__FUNCTION__);
if(sep)
{
ret = ipa_nat_add_ipv4_tbl(pub_ip_add, total_entries, &tbl_hdl);
CHECK_ERR(ret);
}
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl);
CHECK_ERR(ret);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl);
CHECK_ERR(ret);
if(sep)
{
ret = ipa_nat_del_ipv4_tbl(tbl_hdl);
CHECK_ERR(ret);
}
return 0;
}

82
data-ipa-cfg-mgr/ipanat/test/ipa_nat_test003.c
View File

@@ -1,82 +0,0 @@
/*
* Copyright (c) 2014, 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_ipa_nat_test003.cpp
@brief
Verify the following scenario:
1. Add ipv4 table
2. Add ipv4 rule
3. Add ipv4 rule
4. Delete ipv4 table
*/
/*=========================================================================*/
#include "ipa_nat_test.h"
#include "ipa_nat_drv.h"
int ipa_nat_test003(int total_entries, u32 tbl_hdl, u8 sep)
{
int ret;
u32 rule_hdl, rule_hdl1;
ipa_nat_ipv4_rule ipv4_rule;
u32 pub_ip_add = 0x011617c0; /* "192.23.22.1" */
ipv4_rule.target_ip = 0xC1171601; /* 193.23.22.1 */
ipv4_rule.target_port = 1234;
ipv4_rule.private_ip = 0xC2171601; /* 194.23.22.1 */
ipv4_rule.private_port = 5678;
ipv4_rule.protocol = IPPROTO_TCP;
ipv4_rule.public_port = 9050;
IPADBG("%s():\n",__FUNCTION__);
if(sep)
{
ret = ipa_nat_add_ipv4_tbl(pub_ip_add, total_entries, &tbl_hdl);
CHECK_ERR(ret);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl);
CHECK_ERR(ret);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl1);
CHECK_ERR(ret);
ret = ipa_nat_del_ipv4_tbl(tbl_hdl);
CHECK_ERR(ret);
}
return 0;
}

70
data-ipa-cfg-mgr/ipanat/test/ipa_nat_test004.c
View File

@@ -1,70 +0,0 @@
/*
* Copyright (c) 2014, 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_test004.cpp
@brief
Verify the following scenario:
1. Add ipv4 table
2. Query nat table handle
3. Delete ipv4 table
*/
/*===========================================================================*/
#include "ipa_nat_test.h"
#include "ipa_nat_drv.h"
int ipa_nat_test004(int total_entries, u32 tbl_hdl, u8 sep)
{
int ret = 0;
u32 tbl_hdl1 = 0;
u32 pub_ip_add = 0x011617c0; /* "192.23.22.1" */
IPADBG("%s():\n",__FUNCTION__);
if(sep)
{
ret = ipa_nat_add_ipv4_tbl(pub_ip_add, total_entries, &tbl_hdl);
CHECK_ERR(ret);
ret = ipa_nat_del_ipv4_tbl(tbl_hdl);
CHECK_ERR(ret);
ret = ipa_nat_del_ipv4_tbl(tbl_hdl1);
if(ret == 0)
{
IPAERR("able to delete table using invalid table handle\n");
return -1;
}
}
return 0;
}

83
data-ipa-cfg-mgr/ipanat/test/ipa_nat_test005.c
View File

@@ -1,83 +0,0 @@
/*
* Copyright (c) 2014, 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_test005.c
@brief
Verify the following scenario:
1. Add ipv4 table
2. Add ipv4 rule
3. Delete ipv4 rule
4. Add ipv4 rule
5. Delete ipv4 table
*/
/*=========================================================================*/
#include "ipa_nat_test.h"
#include "ipa_nat_drv.h"
int ipa_nat_test005(int total_entries, u32 tbl_hdl, u8 sep)
{
int ret = 0;
u32 rule_hdl, rule_hdl1;
ipa_nat_ipv4_rule ipv4_rule;
u32 pub_ip_add = 0x011617c0; /* "192.23.22.1" */
ipv4_rule.target_ip = 0xC1171601; /* 193.23.22.1 */
ipv4_rule.target_port = 1234;
ipv4_rule.private_ip = 0xC2171601; /* 194.23.22.1 */
ipv4_rule.private_port = 5678;
ipv4_rule.protocol = IPPROTO_TCP;
ipv4_rule.public_port = 9050;
if (sep)
{
ret = ipa_nat_add_ipv4_tbl(pub_ip_add, total_entries, &tbl_hdl);
CHECK_ERR(ret);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl);
CHECK_ERR(ret);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl);
CHECK_ERR(ret);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl1);
CHECK_ERR(ret);
ret = ipa_nat_del_ipv4_tbl(tbl_hdl);
CHECK_ERR(ret);
}
return 0;
}

91
data-ipa-cfg-mgr/ipanat/test/ipa_nat_test006.c
View File

@@ -1,91 +0,0 @@
/*
* Copyright (c) 2014, 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_test006.c
@brief
Verify the following scenario:
1. Add ipv4 table
2. add same ipv rules
3. delete first followed by second
4. Delete ipv4 table
*/
/*=========================================================================*/
#include "ipa_nat_test.h"
#include "ipa_nat_drv.h"
int ipa_nat_test006(int total_entries, u32 tbl_hdl, u8 sep)
{
int ret=0;
u32 rule_hdl, rule_hdl1;
ipa_nat_ipv4_rule ipv4_rule;
u32 pub_ip_add = 0x011617c0; /* "192.23.22.1" */
ipv4_rule.target_ip = 0xC1171601; /* 193.23.22.1 */
ipv4_rule.target_port = 1234;
ipv4_rule.private_ip = 0xC2171601; /* 194.23.22.1 */
ipv4_rule.private_port = 5678;
ipv4_rule.protocol = IPPROTO_TCP;
ipv4_rule.public_port = 9050;
IPADBG("%s():\n",__FUNCTION__);
if(sep)
{
ret = ipa_nat_add_ipv4_tbl(pub_ip_add, total_entries, &tbl_hdl);
CHECK_ERR(ret);
}
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl);
CHECK_ERR(ret);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl1);
CHECK_ERR(ret);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl);
CHECK_ERR(ret);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl1);
CHECK_ERR(ret);
if(sep)
{
ret = ipa_nat_del_ipv4_tbl(tbl_hdl);
CHECK_ERR(ret);
}
return 0;
}

88
data-ipa-cfg-mgr/ipanat/test/ipa_nat_test007.c
View File

@@ -1,88 +0,0 @@
/*
* Copyright (c) 2014, 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_test007.cpp
@brief
Verify the following scenario:
1. Add ipv4 table
2. add same ipv rules
3. delete second followed by first
4. Delete ipv4 table
*/
/*=========================================================================*/
#include "ipa_nat_test.h"
#include "ipa_nat_drv.h"
int ipa_nat_test007(int total_entries, u32 tbl_hdl, u8 sep)
{
int ret;
u32 rule_hdl, rule_hdl1;
ipa_nat_ipv4_rule ipv4_rule;
u32 pub_ip_add = 0x011617c0; /* "192.23.22.1" */
ipv4_rule.target_ip = 0xC1171601; /* 193.23.22.1 */
ipv4_rule.target_port = 1234;
ipv4_rule.private_ip = 0xC2171601; /* 194.23.22.1 */
ipv4_rule.private_port = 5678;
ipv4_rule.protocol = IPPROTO_TCP;
ipv4_rule.public_port = 9050;
IPADBG("%s():\n",__FUNCTION__);
if(sep)
{
ret = ipa_nat_add_ipv4_tbl(pub_ip_add, total_entries, &tbl_hdl);
CHECK_ERR(ret);
}
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl);
CHECK_ERR(ret);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl1);
CHECK_ERR(ret);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl1);
CHECK_ERR(ret);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl);
CHECK_ERR(ret);
if(sep)
{
ret = ipa_nat_del_ipv4_tbl(tbl_hdl);
CHECK_ERR(ret);
}
return 0;
}

94
data-ipa-cfg-mgr/ipanat/test/ipa_nat_test008.c
View File

@@ -1,94 +0,0 @@
/*
* Copyright (c) 2014, 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_test008.c
@brief
Verify the following scenario:
1. Add ipv4 table
2. add 2 distinct rules
3. delete first followed by second
4. Delete ipv4 table
*/
/*=========================================================================*/
#include "ipa_nat_test.h"
#include "ipa_nat_drv.h"
int ipa_nat_test008(int total_entries, u32 tbl_hdl, u8 sep)
{
int ret;
u32 rule_hdl, rule_hdl1;
ipa_nat_ipv4_rule ipv4_rule, ipv4_rule1;
u32 pub_ip_add = 0x011617c0; /* "192.23.22.1" */
ipv4_rule.target_ip = 0xC1171601; /* 193.23.22.1 */
ipv4_rule.target_port = 1234;
ipv4_rule.private_ip = 0xC2171601; /* 194.23.22.1 */
ipv4_rule.private_port = 5678;
ipv4_rule.protocol = IPPROTO_TCP;
ipv4_rule.public_port = 9050;
ipv4_rule1.target_ip = 0xC1171602; /* 193.23.22.2 */
ipv4_rule1.target_port = 1234;
ipv4_rule1.private_ip = 0xC2171602; /* 194.23.22.2 */
ipv4_rule1.private_port = 5678;
ipv4_rule1.protocol = IPPROTO_TCP;
ipv4_rule1.public_port = 9050;
IPADBG("%s():\n",__FUNCTION__);
if(sep)
{
ret = ipa_nat_add_ipv4_tbl(pub_ip_add, total_entries, &tbl_hdl);
CHECK_ERR(ret);
}
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl);
CHECK_ERR(ret);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule1, &rule_hdl1);
CHECK_ERR(ret);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl);
CHECK_ERR(ret);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl1);
CHECK_ERR(ret);
if(sep)
{
ret = ipa_nat_del_ipv4_tbl(tbl_hdl);
CHECK_ERR(ret);
}
return 0;
}

96
data-ipa-cfg-mgr/ipanat/test/ipa_nat_test009.c
View File

@@ -1,96 +0,0 @@
/*
* Copyright (c) 2014, 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_test009.cpp
@brief
Verify the following scenario:
1. Add ipv4 table
2. add 2 distinct rules
3. delete second followed by first
4. Delete ipv4 table
*/
/*=========================================================================*/
#include "ipa_nat_test.h"
#include "ipa_nat_drv.h"
int ipa_nat_test009(int total_entries, u32 tbl_hdl, u8 sep)
{
int ret;
u32 rule_hdl, rule_hdl1;
ipa_nat_ipv4_rule ipv4_rule, ipv4_rule1;
u32 pub_ip_add = 0x011617c0; /* "192.23.22.1" */
ipv4_rule.target_ip = 0xC1171601; /* 193.23.22.1 */
ipv4_rule.target_port = 1234;
ipv4_rule.private_ip = 0xC2171601; /* 194.23.22.1 */
ipv4_rule.private_port = 5678;
ipv4_rule.protocol = IPPROTO_TCP;
ipv4_rule.public_port = 9050;
ipv4_rule1.target_ip = 0xC1171602; /* 193.23.22.2 */
ipv4_rule1.target_port = 1234;
ipv4_rule1.private_ip = 0xC2171602; /* 194.23.22.2 */
ipv4_rule1.private_port = 5678;
ipv4_rule1.protocol = IPPROTO_TCP;
ipv4_rule1.public_port = 9050;
IPADBG("%s():\n",__FUNCTION__);
if(sep)
{
ret = ipa_nat_add_ipv4_tbl(pub_ip_add, total_entries, &tbl_hdl);
CHECK_ERR(ret);
}
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl);
CHECK_ERR(ret);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule1, &rule_hdl1);
CHECK_ERR(ret);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl1);
CHECK_ERR(ret);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl);
CHECK_ERR(ret);
if(sep)
{
ret = ipa_nat_del_ipv4_tbl(tbl_hdl);
CHECK_ERR(ret);
}
return 0;
}

108
data-ipa-cfg-mgr/ipanat/test/ipa_nat_test010.c
View File

@@ -1,108 +0,0 @@
/*
* Copyright (c) 2014, 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_test010.c
@brief
Verify the following scenario:
1. Add ipv4 table
2. add 3 distinct ipv4 rules
3. delete first, second followed by last
4. Delete ipv4 table
*/
/*=========================================================================*/
#include "ipa_nat_test.h"
#include "ipa_nat_drv.h"
int ipa_nat_test010(int total_entries, u32 tbl_hdl, u8 sep)
{
int ret;
u32 rule_hdl, rule_hdl1, rule_hdl2;
ipa_nat_ipv4_rule ipv4_rule, ipv4_rule1, ipv4_rule2;
u32 pub_ip_add = 0x011617c0; /* "192.23.22.1" */
ipv4_rule.target_ip = 0xC1171601; /* 193.23.22.1 */
ipv4_rule.target_port = 1234;
ipv4_rule.private_ip = 0xC2171601; /* 194.23.22.1 */
ipv4_rule.private_port = 5678;
ipv4_rule.protocol = IPPROTO_TCP;
ipv4_rule.public_port = 9050;
ipv4_rule1.target_ip = 0xC1171601; /* 193.23.22.1 */
ipv4_rule1.target_port = 1235;
ipv4_rule1.private_ip = 0xC2171601; /* 194.23.22.1 */
ipv4_rule1.private_port = 5679;
ipv4_rule1.protocol = IPPROTO_TCP;
ipv4_rule1.public_port = 9051;
ipv4_rule2.target_ip = 0xC1171602; /* 193.23.22.2 */
ipv4_rule2.target_port = 1235;
ipv4_rule2.private_ip = 0xC2171602; /* 194.23.22.2 */
ipv4_rule2.private_port = 5679;
ipv4_rule2.protocol = IPPROTO_TCP;
ipv4_rule2.public_port = 9051;
IPADBG("%s():\n",__FUNCTION__);
if(sep)
{
ret = ipa_nat_add_ipv4_tbl(pub_ip_add, total_entries, &tbl_hdl);
CHECK_ERR(ret);
}
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl);
CHECK_ERR(ret);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule1, &rule_hdl1);
CHECK_ERR(ret);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule2, &rule_hdl2);
CHECK_ERR(ret);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl);
CHECK_ERR(ret);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl1);
CHECK_ERR(ret);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl2);
CHECK_ERR(ret);
if(sep)
{
ret = ipa_nat_del_ipv4_tbl(tbl_hdl);
CHECK_ERR(ret);
}
return 0;
}

108
data-ipa-cfg-mgr/ipanat/test/ipa_nat_test011.c
View File

@@ -1,108 +0,0 @@
/*
* Copyright (c) 2014, 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_test011.cpp
@brief
Verify the following scenario:
1. Add ipv4 table
2. add 3 distinct ipv4 rules
3. delete second, first followed by last
4. Delete ipv4 table
*/
/*=========================================================================*/
#include "ipa_nat_test.h"
#include "ipa_nat_drv.h"
int ipa_nat_test011(int total_entries, u32 tbl_hdl, u8 sep)
{
int ret;
u32 rule_hdl, rule_hdl1, rule_hdl2;
ipa_nat_ipv4_rule ipv4_rule, ipv4_rule1, ipv4_rule2;
u32 pub_ip_add = 0x011617c0; /* "192.23.22.1" */
ipv4_rule.target_ip = 0xC1171601; /* 193.23.22.1 */
ipv4_rule.target_port = 1234;
ipv4_rule.private_ip = 0xC2171601; /* 194.23.22.1 */
ipv4_rule.private_port = 5678;
ipv4_rule.protocol = IPPROTO_TCP;
ipv4_rule.public_port = 9050;
ipv4_rule1.target_ip = 0xF1181601;
ipv4_rule1.target_port = 1555;
ipv4_rule1.private_ip = 0xF2151601;
ipv4_rule1.private_port = 5999;
ipv4_rule1.protocol = IPPROTO_TCP;
ipv4_rule1.public_port = 9111;
ipv4_rule2.target_ip = 0xC1166602;
ipv4_rule2.target_port = 1555;
ipv4_rule2.private_ip = 0xC2155602;
ipv4_rule2.private_port = 5777;
ipv4_rule2.protocol = IPPROTO_TCP;
ipv4_rule2.public_port = 9000;
IPADBG("%s():\n",__FUNCTION__);
if(sep)
{
ret = ipa_nat_add_ipv4_tbl(pub_ip_add, total_entries, &tbl_hdl);
CHECK_ERR(ret);
}
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl);
CHECK_ERR(ret);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule1, &rule_hdl1);
CHECK_ERR(ret);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule2, &rule_hdl2);
CHECK_ERR(ret);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl1);
CHECK_ERR(ret);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl);
CHECK_ERR(ret);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl2);
CHECK_ERR(ret);
if(sep)
{
ret = ipa_nat_del_ipv4_tbl(tbl_hdl);
CHECK_ERR(ret);
}
return 0;
}

109
data-ipa-cfg-mgr/ipanat/test/ipa_nat_test012.c
View File

@@ -1,109 +0,0 @@
/*
* Copyright (c) 2014, 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_test012.cpp
@brief
Verify the following scenario:
1. Add ipv4 table
2. add 3 distinct ipv4 rules
3. Delete third, second, first
4. Delete ipv4 table
*/
/*=========================================================================*/
#include "ipa_nat_test.h"
#include "ipa_nat_drv.h"
int ipa_nat_test012(int totoal_entries, u32 tbl_hdl, u8 sep)
{
int ret;
u32 rule_hdl, rule_hdl1, rule_hdl2;
ipa_nat_ipv4_rule ipv4_rule, ipv4_rule1, ipv4_rule2;
u32 pub_ip_add = 0x011617c0; /* "192.23.22.1" */
ipv4_rule.target_ip = 0xC1171601; /* 193.23.22.1 */
ipv4_rule.target_port = 1234;
ipv4_rule.private_ip = 0xC2171601; /* 194.23.22.1 */
ipv4_rule.private_port = 5678;
ipv4_rule.protocol = IPPROTO_TCP;
ipv4_rule.public_port = 9050;
ipv4_rule1.target_ip = 0xD1171601;
ipv4_rule1.target_port = 3512;
ipv4_rule1.private_ip = 0xD2471601;
ipv4_rule1.private_port = 9997;
ipv4_rule1.protocol = IPPROTO_TCP;
ipv4_rule1.public_port = 8881;
ipv4_rule2.target_ip = 0xC1172452;
ipv4_rule2.target_port = 1895;
ipv4_rule2.private_ip = 0xC2172452;
ipv4_rule2.private_port = 6668;
ipv4_rule2.protocol = IPPROTO_TCP;
ipv4_rule2.public_port = 5551;
IPADBG("%s():\n",__FUNCTION__);
if(sep)
{
ret = ipa_nat_add_ipv4_tbl(pub_ip_add, totoal_entries, &tbl_hdl);
CHECK_ERR(ret);
}
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl);
CHECK_ERR(ret);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule1, &rule_hdl1);
CHECK_ERR(ret);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule2, &rule_hdl2);
CHECK_ERR(ret);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl2);
CHECK_ERR(ret);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl1);
CHECK_ERR(ret);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl);
CHECK_ERR(ret);
if(sep)
{
ret = ipa_nat_del_ipv4_tbl(tbl_hdl);
CHECK_ERR(ret);
}
return 0;
}

108
data-ipa-cfg-mgr/ipanat/test/ipa_nat_test013.c
View File

@@ -1,108 +0,0 @@
/*
* Copyright (c) 2014, 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_test013.cpp
@brief
Verify the following scenario:
1. Add ipv4 table
2. add 3 distinct ipv4 rules
3. Delete third, first and second
4. Delete ipv4 table
*/
/*=========================================================================*/
#include "ipa_nat_test.h"
#include "ipa_nat_drv.h"
int ipa_nat_test013(int total_entries, u32 tbl_hdl, u8 sep)
{
int ret;
u32 rule_hdl, rule_hdl1, rule_hdl2;
ipa_nat_ipv4_rule ipv4_rule, ipv4_rule1, ipv4_rule2;
u32 pub_ip_add = 0x011617c0; /* "192.23.22.1" */
ipv4_rule.target_ip = 0xC1171601; /* 193.23.22.1 */
ipv4_rule.target_port = 1234;
ipv4_rule.private_ip = 0xC2171601; /* 194.23.22.1 */
ipv4_rule.private_port = 5678;
ipv4_rule.protocol = IPPROTO_TCP;
ipv4_rule.public_port = 9050;
ipv4_rule1.target_ip = 0xC1171609; /* 193.23.22.9 */
ipv4_rule1.target_port = 1235;
ipv4_rule1.private_ip = 0xC2171609; /* 194.23.22.9 */
ipv4_rule1.private_port = 6579;
ipv4_rule1.protocol = IPPROTO_TCP;
ipv4_rule1.public_port = 8951;
ipv4_rule2.target_ip = 0xC1171606; /* 193.23.22.6 */
ipv4_rule2.target_port = 1235;
ipv4_rule2.private_ip = 0xC2171606; /* 194.23.22.6 */
ipv4_rule2.private_port = 7956;
ipv4_rule2.protocol = IPPROTO_TCP;
ipv4_rule2.public_port = 5109;
IPADBG("%s():\n",__FUNCTION__);
if(sep)
{
ret = ipa_nat_add_ipv4_tbl(pub_ip_add, total_entries, &tbl_hdl);
CHECK_ERR(ret);
}
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl);
CHECK_ERR(ret);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule1, &rule_hdl1);
CHECK_ERR(ret);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule2, &rule_hdl2);
CHECK_ERR(ret);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl2);
CHECK_ERR(ret);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl);
CHECK_ERR(ret);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl1);
CHECK_ERR(ret);
if(sep)
{
ret = ipa_nat_del_ipv4_tbl(tbl_hdl);
CHECK_ERR(ret);
}
return 0;
}

95
data-ipa-cfg-mgr/ipanat/test/ipa_nat_test014.c
View File

@@ -1,95 +0,0 @@
/*
* Copyright (c) 2014, 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_test014.cpp
@brief
Verify the following scenario:
1. Add ipv4 table
2. add same 3 ipv rules
3. delete first, second and third
4. Delete ipv4 table
*/
/*=========================================================================*/
#include "ipa_nat_test.h"
#include "ipa_nat_drv.h"
int ipa_nat_test014(int total_entries, u32 tbl_hdl, u8 sep)
{
int ret;
u32 rule_hdl1, rule_hdl2, rule_hdl3;
ipa_nat_ipv4_rule ipv4_rule;
u32 pub_ip_add = 0x011617c0; /* "192.23.22.1" */
ipv4_rule.target_ip = 0xC1171601; /* 193.23.22.1 */
ipv4_rule.target_port = 1234;
ipv4_rule.private_ip = 0xC2171601; /* 194.23.22.1 */
ipv4_rule.private_port = 5678;
ipv4_rule.protocol = IPPROTO_TCP;
ipv4_rule.public_port = 9050;
IPADBG("%s()\n", __FUNCTION__);
if(sep)
{
ret = ipa_nat_add_ipv4_tbl(pub_ip_add, total_entries, &tbl_hdl);
CHECK_ERR(ret);
}
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl1);
CHECK_ERR(ret);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl2);
CHECK_ERR(ret);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl3);
CHECK_ERR(ret);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl1);
CHECK_ERR(ret);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl2);
CHECK_ERR(ret);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl3);
CHECK_ERR(ret);
if(sep)
{
ret = ipa_nat_del_ipv4_tbl(tbl_hdl);
CHECK_ERR(ret);
}
return 0;
}

97
data-ipa-cfg-mgr/ipanat/test/ipa_nat_test015.c
View File

@@ -1,97 +0,0 @@
/*
* Copyright (c) 2014, 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_test015.cpp
@brief
Verify the following scenario:
1. Add ipv4 table
2. add same 3 ipv rules
3. delete first, third and second
4. Delete ipv4 table
*/
/*=========================================================================*/
#include "ipa_nat_test.h"
#include "ipa_nat_drv.h"
int ipa_nat_test015(int total_entries, u32 tbl_hdl, u8 sep)
{
int ret;
u32 rule_hdl1, rule_hdl2, rule_hdl3;
ipa_nat_ipv4_rule ipv4_rule;
u32 pub_ip_add = 0x011617c0; /* "192.23.22.1" */
ipv4_rule.target_ip = 0xC1171601; /* 193.23.22.1 */
ipv4_rule.target_port = 1234;
ipv4_rule.private_ip = 0xC2171601; /* 194.23.22.1 */
ipv4_rule.private_port = 5678;
ipv4_rule.protocol = IPPROTO_TCP;
ipv4_rule.public_port = 9050;
IPADBG("%s():\n",__FUNCTION__);
if(sep)
{
ret = ipa_nat_add_ipv4_tbl(pub_ip_add, total_entries, &tbl_hdl);
CHECK_ERR(ret);
}
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl1);
CHECK_ERR(ret);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl2);
CHECK_ERR(ret);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl3);
CHECK_ERR(ret);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl1);
CHECK_ERR(ret);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl3);
CHECK_ERR(ret);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl2);
CHECK_ERR(ret);
if(sep)
{
ret = ipa_nat_del_ipv4_tbl(tbl_hdl);
CHECK_ERR(ret);
}
return 0;
}

96
data-ipa-cfg-mgr/ipanat/test/ipa_nat_test016.c
View File

@@ -1,96 +0,0 @@
/*
* Copyright (c) 2014, 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_test016.cpp
@brief
Verify the following scenario:
1. Add ipv4 table
2. add same 3 ipv rules
3. delete second, first and third
4. Delete ipv4 table
*/
/*=========================================================================*/
#include "ipa_nat_test.h"
#include "ipa_nat_drv.h"
int ipa_nat_test016(int total_entries, u32 tbl_hdl, u8 sep)
{
int ret;
u32 rule_hdl1, rule_hdl2, rule_hdl3;
ipa_nat_ipv4_rule ipv4_rule;
u32 pub_ip_add = 0x011617c0; /* "192.23.22.1" */
ipv4_rule.target_ip = 0xC1171601; /* 193.23.22.1 */
ipv4_rule.target_port = 1234;
ipv4_rule.private_ip = 0xC2171601; /* 194.23.22.1 */
ipv4_rule.private_port = 5678;
ipv4_rule.protocol = IPPROTO_TCP;
ipv4_rule.public_port = 9050;
IPADBG("%s():\n",__FUNCTION__);
if(sep)
{
ret = ipa_nat_add_ipv4_tbl(pub_ip_add, total_entries, &tbl_hdl);
CHECK_ERR(ret);
}
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl1);
CHECK_ERR(ret);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl2);
CHECK_ERR(ret);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl3);
CHECK_ERR(ret);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl2);
CHECK_ERR(ret);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl1);
CHECK_ERR(ret);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl3);
CHECK_ERR(ret);
if(sep)
{
ret = ipa_nat_del_ipv4_tbl(tbl_hdl);
CHECK_ERR(ret);
}
return 0;
}

96
data-ipa-cfg-mgr/ipanat/test/ipa_nat_test017.c
View File

@@ -1,96 +0,0 @@
/*
* Copyright (c) 2014, 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_test017.cpp
@brief
Verify the following scenario:
1. Add ipv4 table
2. add same 3 ipv rules
3. delete second, third and first
4. Delete ipv4 table
*/
/*=========================================================================*/
#include "ipa_nat_test.h"
#include "ipa_nat_drv.h"
int ipa_nat_test017(int total_entries, u32 tbl_hdl, u8 sep)
{
int ret;
u32 rule_hdl1, rule_hdl2, rule_hdl3;
ipa_nat_ipv4_rule ipv4_rule;
u32 pub_ip_add = 0x011617c0; /* "192.23.22.1" */
ipv4_rule.target_ip = 0xC1171601; /* 193.23.22.1 */
ipv4_rule.target_port = 1234;
ipv4_rule.private_ip = 0xC2171601; /* 194.23.22.1 */
ipv4_rule.private_port = 5678;
ipv4_rule.protocol = IPPROTO_TCP;
ipv4_rule.public_port = 9050;
IPADBG("%s():\n",__FUNCTION__);
if(sep)
{
ret = ipa_nat_add_ipv4_tbl(pub_ip_add, total_entries, &tbl_hdl);
CHECK_ERR(ret);
}
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl1);
CHECK_ERR(ret);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl2);
CHECK_ERR(ret);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl3);
CHECK_ERR(ret);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl2);
CHECK_ERR(ret);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl3);
CHECK_ERR(ret);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl1);
CHECK_ERR(ret);
if(sep)
{
ret = ipa_nat_del_ipv4_tbl(tbl_hdl);
CHECK_ERR(ret);
}
return 0;
}

96
data-ipa-cfg-mgr/ipanat/test/ipa_nat_test018.c
View File

@@ -1,96 +0,0 @@
/*
* Copyright (c) 2014, 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_test018.c
@brief
Verify the following scenario:
1. Add ipv4 table
2. add same 3 ipv rules
3. delete third, second and first
4. Delete ipv4 table
*/
/*=========================================================================*/
#include "ipa_nat_test.h"
#include "ipa_nat_drv.h"
int ipa_nat_test018(int total_entries, u32 tbl_hdl, u8 sep)
{
int ret;
u32 rule_hdl1, rule_hdl2, rule_hdl3;
ipa_nat_ipv4_rule ipv4_rule;
u32 pub_ip_add = 0x011617c0; /* "192.23.22.1" */
ipv4_rule.target_ip = 0xC1171601; /* 193.23.22.1 */
ipv4_rule.target_port = 1234;
ipv4_rule.private_ip = 0xC2171601; /* 194.23.22.1 */
ipv4_rule.private_port = 5678;
ipv4_rule.protocol = IPPROTO_TCP;
ipv4_rule.public_port = 9050;
IPADBG("%s():\n",__FUNCTION__);
if(sep)
{
ret = ipa_nat_add_ipv4_tbl(pub_ip_add, total_entries, &tbl_hdl);
CHECK_ERR(ret);
}
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl1);
CHECK_ERR(ret);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl2);
CHECK_ERR(ret);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl3);
CHECK_ERR(ret);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl3);
CHECK_ERR(ret);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl2);
CHECK_ERR(ret);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl1);
CHECK_ERR(ret);
if(sep)
{
ret = ipa_nat_del_ipv4_tbl(tbl_hdl);
CHECK_ERR(ret);
}
return 0;
}

96
data-ipa-cfg-mgr/ipanat/test/ipa_nat_test019.c
View File

@@ -1,96 +0,0 @@
/*
* Copyright (c) 2014, 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_test019.c
@brief
Verify the following scenario:
1. Add ipv4 table
2. add same 3 ipv rules
3. delete third, first and second
4. Delete ipv4 table
*/
/*=========================================================================*/
#include "ipa_nat_test.h"
#include "ipa_nat_drv.h"
int ipa_nat_test019(int total_entries, u32 tbl_hdl, u8 sep)
{
int ret;
u32 rule_hdl1, rule_hdl2, rule_hdl3;
ipa_nat_ipv4_rule ipv4_rule;
u32 pub_ip_add = 0x011617c0; /* "192.23.22.1" */
ipv4_rule.target_ip = 0xC1171601; /* 193.23.22.1 */
ipv4_rule.target_port = 1234;
ipv4_rule.private_ip = 0xC2171601; /* 194.23.22.1 */
ipv4_rule.private_port = 5678;
ipv4_rule.protocol = IPPROTO_TCP;
ipv4_rule.public_port = 9050;
IPADBG("%s():\n",__FUNCTION__);
if(sep)
{
ret = ipa_nat_add_ipv4_tbl(pub_ip_add, total_entries, &tbl_hdl);
CHECK_ERR(ret);
}
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl1);
CHECK_ERR(ret);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl2);
CHECK_ERR(ret);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl3);
CHECK_ERR(ret);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl3);
CHECK_ERR(ret);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl1);
CHECK_ERR(ret);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl2);
CHECK_ERR(ret);
if(sep)
{
ret = ipa_nat_del_ipv4_tbl(tbl_hdl);
CHECK_ERR(ret);
}
return 0;
}

100
data-ipa-cfg-mgr/ipanat/test/ipa_nat_test020.c
View File

@@ -1,100 +0,0 @@
/*
* Copyright (c) 2014, 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_test020.c
@brief
Verify the following scenario:
1. Add ipv4 table
2. add same 4 ipv rules
3. delete third, second, fourth and first
4. Delete ipv4 table
*/
/*=========================================================================*/
#include "ipa_nat_test.h"
#include "ipa_nat_drv.h"
int ipa_nat_test020(int total_entries, u32 tbl_hdl, u8 sep)
{
int ret;
u32 rule_hdl1, rule_hdl2, rule_hdl3, rule_hdl4;
ipa_nat_ipv4_rule ipv4_rule;
u32 pub_ip_add = 0x011617c0; /* "192.23.22.1" */
ipv4_rule.target_ip = 0xC1171601; /* 193.23.22.1 */
ipv4_rule.target_port = 1234;
ipv4_rule.private_ip = 0xC2171601; /* 194.23.22.1 */
ipv4_rule.private_port = 5678;
ipv4_rule.protocol = IPPROTO_TCP;
ipv4_rule.public_port = 9050;
IPADBG("%s():\n",__FUNCTION__);
if(sep)
{
ret = ipa_nat_add_ipv4_tbl(pub_ip_add, total_entries, &tbl_hdl);
CHECK_ERR(ret);
}
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl1);
CHECK_ERR(ret);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl2);
CHECK_ERR(ret);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl3);
CHECK_ERR(ret);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl4);
CHECK_ERR(ret);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl3);
CHECK_ERR(ret);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl2);
CHECK_ERR(ret);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl4);
CHECK_ERR(ret);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl1);
CHECK_ERR(ret);
if(sep)
{
ret = ipa_nat_del_ipv4_tbl(tbl_hdl);
CHECK_ERR(ret);
}
return 0;
}

81
data-ipa-cfg-mgr/ipanat/test/ipa_nat_test021.c
View File

@@ -1,81 +0,0 @@
/*
* Copyright (c) 2014, 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_test021.c
@brief
Verify the following scenario:
1. Add ipv4 table
2. Delete ipv4 table
*/
/*=========================================================================*/
#include "ipa_nat_test.h"
#include "ipa_nat_drv.h"
int ipa_nat_test021(int total_entries, int reg)
{
int ret, i;
u32 tbl_hdl;
u32 pub_ip_add = 0x011617c0; /* "192.23.22.1" */
IPADBG("%s():\n",__FUNCTION__);
for(i=0; i<reg; i++)
{
IPADBG("executing %d th time:\n",i);
IPADBG("calling ipa_nat_add_ipv4_tbl() \n");
ret = ipa_nat_add_ipv4_tbl(pub_ip_add, total_entries, &tbl_hdl);
if (0 != ret)
{
IPAERR("unable to create ipv4 nat table and returning Error:%d\n", ret);
IPADBG("executed %d times:\n",i);
return -1;
}
IPADBG("create nat ipv4 table successfully() \n");
IPADBG("calling ipa_nat_del_ipv4_tbl() \n");
ret = ipa_nat_del_ipv4_tbl(tbl_hdl);
if (0 != ret)
{
IPAERR("Unable to delete ipv4 nat table %d\n", ret);
IPADBG("executed %d times:\n",i);
return -1;
}
IPADBG("deleted ipv4 nat table successfully. Test passed \n");
}
IPADBG("executed %d times:\n",(i+1));
return 0;
}

118
data-ipa-cfg-mgr/ipanat/test/ipa_nat_test022.c
View File

@@ -1,118 +0,0 @@
/*
* Copyright (c) 2014, 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_test022.cpp
@brief
Verify the following scenario:
1. Add ipv4 table
2. add same 3 ipv rules
3. delete Head and last entry
4. add 2 new same ip4 entries
5. Add head entry again
6. Delete ipv4 table
*/
/*=========================================================================*/
#include "ipa_nat_test.h"
#include "ipa_nat_drv.h"
int ipa_nat_test022(int total_entries, u32 tbl_hdl, u8 sep)
{
int ret;
u32 rule_hdl1, rule_hdl2, rule_hdl3;
ipa_nat_ipv4_rule ipv4_rule, ipv4_rule2;
u32 rule_hdl21, rule_hdl22;
u32 pub_ip_add = 0x011617c0; /* "192.23.22.1" */
/* Rule 1 */
ipv4_rule.target_ip = 0xC1171601; /* 193.23.22.1 */
ipv4_rule.target_port = 1234;
ipv4_rule.private_ip = 0xC2171601; /* 194.23.22.1 */
ipv4_rule.private_port = 5678;
ipv4_rule.protocol = IPPROTO_TCP;
ipv4_rule.public_port = 9050;
/* Rule 2*/
ipv4_rule.target_ip = 0xC1171604; /* 193.23.22.4 */
ipv4_rule.target_port = 1234;
ipv4_rule.private_ip = 0xC2171603; /* 194.23.22.3 */
ipv4_rule.private_port = 5680;
ipv4_rule.protocol = IPPROTO_UDP;
ipv4_rule.public_port = 9066;
IPADBG("%s():\n",__FUNCTION__);
if(sep)
{
ret = ipa_nat_add_ipv4_tbl(pub_ip_add, total_entries, &tbl_hdl);
CHECK_ERR1(ret, tbl_hdl);
}
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl1);
CHECK_ERR1(ret, tbl_hdl);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl2);
CHECK_ERR1(ret, tbl_hdl);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl3);
CHECK_ERR1(ret, tbl_hdl);
/* Delete head entry */
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl1);
CHECK_ERR1(ret, tbl_hdl);
/* Delete Last Entry */
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl3);
CHECK_ERR1(ret, tbl_hdl);
/* Add 2 different Entries */
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule2, &rule_hdl21);
CHECK_ERR1(ret, tbl_hdl);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule2, &rule_hdl22);
CHECK_ERR1(ret, tbl_hdl);
/* Add first entry again */
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl3);
CHECK_ERR1(ret, tbl_hdl);
if(sep)
{
ret = ipa_nat_del_ipv4_tbl(tbl_hdl);
CHECK_ERR1(ret, tbl_hdl);
}
return 0;
}

640
data-ipa-cfg-mgr/ipanat/test/main.c
View File

@@ -1,640 +0,0 @@
/*
* Copyright (c) 2014, 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 <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "ipa_nat_drv.h"
#include "ipa_nat_drvi.h"
#include "ipa_nat_test.h"
extern struct ipa_nat_cache ipv4_nat_cache;
int chk_for_loop(u32 tbl_hdl)
{
struct ipa_nat_rule *tbl_ptr;
struct ipa_nat_indx_tbl_rule *indx_tbl_ptr;
int cnt;
uint16_t cur_entry;
if (IPA_NAT_INVALID_NAT_ENTRY == tbl_hdl ||
tbl_hdl > IPA_NAT_MAX_IP4_TBLS) {
IPAERR("invalid table handle passed \n");
return -EINVAL;
}
IPADBG("checking ipv4 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)) {
if(Read16BitFieldValue(tbl_ptr[cnt].nxt_indx_pub_port,
NEXT_INDEX_FIELD) == cnt)
{
IPAERR("Infinite loop detected, entry\n");
ipa_nati_print_rule(&tbl_ptr[cnt], cnt);
return -EINVAL;
}
}
}
/* Print ipv4 expansion rules */
IPADBG("checking 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)) {
cur_entry =
cnt + ipv4_nat_cache.ip4_tbl[tbl_hdl - 1].table_entries;
if (Read16BitFieldValue(tbl_ptr[cnt].nxt_indx_pub_port,
NEXT_INDEX_FIELD) == cur_entry)
{
IPAERR("Infinite loop detected\n");
ipa_nati_print_rule(&tbl_ptr[cnt],
(cnt + ipv4_nat_cache.ip4_tbl[tbl_hdl - 1].table_entries));
return -EINVAL;
}
}
}
/* Print ipv4 index rules */
IPADBG("checking 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)) {
if (Read16BitFieldValue(indx_tbl_ptr[cnt].tbl_entry_nxt_indx,
INDX_TBL_NEXT_INDEX_FILED) == cnt)
{
IPAERR("Infinite loop detected\n");
ipa_nati_print_index_rule(&indx_tbl_ptr[cnt], cnt, 0);
return -EINVAL;
}
}
}
/* Print ipv4 index expansion rules */
IPADBG("Checking 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)) {
cur_entry =
cnt + ipv4_nat_cache.ip4_tbl[tbl_hdl - 1].table_entries;
if (Read16BitFieldValue(indx_tbl_ptr[cnt].tbl_entry_nxt_indx,
INDX_TBL_NEXT_INDEX_FILED) == cur_entry)
{
IPAERR("Infinite loop detected\n");
ipa_nati_print_index_rule(&indx_tbl_ptr[cnt],
(cnt + ipv4_nat_cache.ip4_tbl[tbl_hdl - 1].table_entries),
ipv4_nat_cache.ip4_tbl[tbl_hdl - 1].index_expn_table_meta[cnt].prev_index);
return -EINVAL;
}
}
}
return 0;
}
uint8_t is_base_entry_valid(u32 tbl_hdl, u16 entry)
{
struct ipa_nat_rule *tbl_ptr;
if (entry >
ipv4_nat_cache.ip4_tbl[tbl_hdl - 1].table_entries)
{
tbl_ptr = (struct ipa_nat_rule *)
ipv4_nat_cache.ip4_tbl[tbl_hdl-1].ipv4_expn_rules_addr;
entry -=
ipv4_nat_cache.ip4_tbl[tbl_hdl - 1].table_entries;
}
else
{
tbl_ptr = (struct ipa_nat_rule *)
ipv4_nat_cache.ip4_tbl[tbl_hdl-1].ipv4_rules_addr;
}
return (Read16BitFieldValue(tbl_ptr[entry].ip_cksm_enbl,
ENABLE_FIELD));
}
uint8_t is_index_entry_valid(u32 tbl_hdl, u16 entry)
{
struct ipa_nat_indx_tbl_rule *tbl_ptr;
if (entry >
ipv4_nat_cache.ip4_tbl[tbl_hdl - 1].table_entries)
{
tbl_ptr = (struct ipa_nat_indx_tbl_rule *)
ipv4_nat_cache.ip4_tbl[tbl_hdl-1].index_table_expn_addr;
entry -=
ipv4_nat_cache.ip4_tbl[tbl_hdl - 1].table_entries;
}
else
{
tbl_ptr = (struct ipa_nat_indx_tbl_rule *)
ipv4_nat_cache.ip4_tbl[tbl_hdl-1].index_table_addr;
}
if (Read16BitFieldValue(tbl_ptr[entry].tbl_entry_nxt_indx,
INDX_TBL_TBL_ENTRY_FIELD)) {
return 1;
}
else
{
return 0;
}
}
int chk_for_validity(u32 tbl_hdl)
{
struct ipa_nat_rule *tbl_ptr;
struct ipa_nat_indx_tbl_rule *indx_tbl_ptr;
uint16_t nxt_index, prv_index;
int cnt;
if (IPA_NAT_INVALID_NAT_ENTRY == tbl_hdl ||
tbl_hdl > IPA_NAT_MAX_IP4_TBLS) {
IPAERR("invalid table handle passed \n");
return -EINVAL;
}
/* Validate base table next_indx and prev_indx values */
IPADBG("Validating 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)) {
nxt_index =
Read16BitFieldValue(tbl_ptr[cnt].nxt_indx_pub_port,
NEXT_INDEX_FIELD);
if (!is_base_entry_valid(tbl_hdl, nxt_index)) {
IPAERR("Invalid next index found, entry:%d\n", cnt);
}
}
}
IPADBG("Validating ipv4 expansion active 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)) {
/* Validate next index */
nxt_index =
Read16BitFieldValue(tbl_ptr[cnt].nxt_indx_pub_port,
NEXT_INDEX_FIELD);
if (!is_base_entry_valid(tbl_hdl, nxt_index)) {
IPAERR("Invalid next index found, entry:%d\n", cnt);
}
/* Validate previous index */
prv_index =
Read16BitFieldValue(tbl_ptr[cnt].sw_spec_params,
SW_SPEC_PARAM_PREV_INDEX_FIELD);
if (!is_base_entry_valid(tbl_hdl, prv_index)) {
IPAERR("Invalid Previous index found, entry:%d\n", cnt);
}
}
}
IPADBG("Validating 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)) {
nxt_index =
Read16BitFieldValue(indx_tbl_ptr[cnt].tbl_entry_nxt_indx,
INDX_TBL_NEXT_INDEX_FILED);
if (!is_index_entry_valid(tbl_hdl, nxt_index)) {
IPAERR("Invalid next index found, entry:%d\n", cnt);
}
}
}
IPADBG("Validating 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)) {
/* Validate next index*/
nxt_index =
Read16BitFieldValue(indx_tbl_ptr[cnt].tbl_entry_nxt_indx,
INDX_TBL_NEXT_INDEX_FILED);
if (!is_index_entry_valid(tbl_hdl, nxt_index)) {
IPAERR("Invalid next index found, entry:%d\n", cnt);
}
/* Validate previous index*/
prv_index =
ipv4_nat_cache.ip4_tbl[tbl_hdl-1].index_expn_table_meta[cnt].prev_index;
if (!is_index_entry_valid(tbl_hdl, prv_index)) {
IPAERR("Invalid Previous index found, entry:%d\n", cnt);
}
}
}
return 0;
}
int ipa_nat_validate_ipv4_table(u32 tbl_hdl)
{
int ret = 0;
ret = chk_for_loop(tbl_hdl);
if (ret)
return ret;
ret = chk_for_validity(tbl_hdl);
return ret;
}
int main(int argc, char* argv[])
{
int exec = 0, pass = 0, ret;
int cnt, nt=1;
int total_entries = 100;
u8 sep = 0;
u32 tbl_hdl = 0;
u32 pub_ip_add = 0x011617c0; /* "192.23.22.1" */
IPADBG("ipa_nat_testing user space nat driver\n");
if (argc == 4)
{
if (!strncmp(argv[1], "reg", 3))
{
nt = atoi(argv[2]);
total_entries = atoi(argv[3]);
IPADBG("Reg: %d, Nat Entries: %d\n", nt, total_entries);
}
else if (!strncmp(argv[1], "sep", 3))
{
sep = 1;
nt = atoi(argv[2]);
total_entries = atoi(argv[3]);
}
}
else if (argc == 3)
{
if (!strncmp(argv[1], "inotify", 7))
{
ipa_nat_test021(total_entries, atoi(argv[2]));
return 0;
}
else if (!strncmp(argv[1], "sep", 3))
{
sep = 1;
total_entries = atoi(argv[2]);
}
}
else if (argc == 2)
{
total_entries = atoi(argv[1]);
IPADBG("Nat Entries: %d\n", total_entries);
}
for (cnt=0; cnt<nt; cnt++)
{
IPADBG("%s():Executing %d time \n",__FUNCTION__, cnt);
if (!sep)
{
ret = ipa_nat_add_ipv4_tbl(pub_ip_add, total_entries, &tbl_hdl);
CHECK_ERR(ret);
}
if (sep)
{
IPADBG("\n\nExecuting ipa_nat_test00%d\n", exec);
ret = ipa_nat_test000(total_entries, tbl_hdl, sep);
if (!ret)
{
pass++;
}
else
{
IPAERR("ipa_nat_test00%d Fail\n", exec);
}
exec++;
IPADBG("\n\nExecuting ipa_nat_test00%d\n", exec);
ret = ipa_nat_test001(total_entries, tbl_hdl, sep);
if (!ret)
{
pass++;
}
else
{
IPAERR("ipa_nat_test00%d Fail\n", exec);
}
exec++;
}
IPADBG("\n\nExecuting ipa_nat_test00%d\n", exec);
ret = ipa_nat_test002(total_entries, tbl_hdl, sep);
if (!ret)
{
pass++;
}
else
{
IPAERR("ipa_nat_test00%d Fail\n", exec);
}
exec++;
if (sep)
{
IPADBG("\n\nExecuting ipa_nat_test00%d\n", exec);
ret = ipa_nat_test003(total_entries, tbl_hdl, sep);
if (!ret)
{
pass++;
}
else
{
IPAERR("ipa_nat_test00%d Fail\n", exec);
}
exec++;
IPADBG("\n\nExecuting ipa_nat_test00%d\n", exec);
ret = ipa_nat_test004(total_entries, tbl_hdl, sep);
if (!ret)
{
pass++;
}
else
{
IPAERR("ipa_nat_test00%d Fail\n", exec);
}
exec++;
IPADBG("\n\nExecuting ipa_nat_test00%d\n", exec);
ret = ipa_nat_test005(total_entries, tbl_hdl, sep);
if (!ret)
{
pass++;
}
else
{
IPAERR("ipa_nat_test00%d Fail\n", exec);
}
exec++;
}
IPADBG("\n\nExecuting ipa_nat_test00%d\n", exec);
ret = ipa_nat_test006(total_entries, tbl_hdl, sep);
if (!ret)
{
pass++;
}
else
{
IPAERR("ipa_nat_test00%d Fail\n", exec);
}
exec++;
IPADBG("\n\nExecuting ipa_nat_test00%d\n", exec);
ret = ipa_nat_test007(total_entries, tbl_hdl, sep);
if (!ret)
{
pass++;
}
else
{
IPAERR("ipa_nat_test00%d Fail\n", exec);
}
exec++;
IPADBG("\n\nExecuting ipa_nat_test00%d\n", exec);
ret = ipa_nat_test008(total_entries, tbl_hdl, sep);
if (!ret)
{
pass++;
}
else
{
IPAERR("ipa_nat_test00%d Fail\n", exec);
}
exec++;
IPADBG("\n\nExecuting ipa_nat_test00%d\n", exec);
ret = ipa_nat_test009(total_entries, tbl_hdl, sep);
if (!ret)
{
pass++;
}
else
{
IPAERR("ipa_nat_test00%d Fail\n", exec);
}
exec++;
if (total_entries >= IPA_NAT_TEST_PRE_COND_TE)
{
IPADBG("\n\nExecuting ipa_nat_test0%d\n", exec);
ret = ipa_nat_test010(total_entries, tbl_hdl, sep);
if (!ret)
{
pass++;
}
else
{
IPAERR("ipa_nat_test0%d Fail\n", exec);
}
exec++;
IPADBG("\n\nExecuting ipa_nat_test0%d\n", exec);
ret = ipa_nat_test011(total_entries, tbl_hdl, sep);
if (!ret)
{
pass++;
}
else
{
IPAERR("ipa_nat_test0%d Fail\n", exec);
}
exec++;
IPADBG("\n\nExecuting ipa_nat_test0%d\n", exec);
ret = ipa_nat_test012(total_entries, tbl_hdl, sep);
if (!ret)
{
pass++;
}
else
{
IPAERR("ipa_nat_test0%d Fail\n", exec);
}
exec++;
IPADBG("\n\nExecuting ipa_nat_test0%d\n", exec);
ret = ipa_nat_test013(total_entries, tbl_hdl, sep);
if (!ret)
{
pass++;
}
else
{
IPAERR("ipa_nat_test0%d Fail\n", exec);
}
exec++;
IPADBG("\n\nExecuting ipa_nat_test0%d\n", exec);
ret = ipa_nat_test014(total_entries, tbl_hdl, sep);
if (!ret)
{
pass++;
}
else
{
IPAERR("ipa_nat_test0%d Fail\n", exec);
}
exec++;
IPADBG("\n\nExecuting ipa_nat_test0%d\n", exec);
ret = ipa_nat_test015(total_entries, tbl_hdl, sep);
if (!ret)
{
pass++;
}
else
{
IPAERR("ipa_nat_test0%d Fail\n", exec);
}
exec++;
IPADBG("\n\nExecuting ipa_nat_test0%d\n", exec);
ret = ipa_nat_test016(total_entries, tbl_hdl, sep);
if (!ret)
{
pass++;
}
else
{
IPAERR("ipa_nat_test0%d Fail\n", exec);
}
exec++;
IPADBG("\n\nExecuting ipa_nat_test0%d\n", exec);
ret = ipa_nat_test017(total_entries, tbl_hdl, sep);
if (!ret)
{
pass++;
}
else
{
IPAERR("ipa_nat_test0%d Fail\n", exec);
}
exec++;
IPADBG("\n\nExecuting ipa_nat_test0%d\n", exec);
ret = ipa_nat_test018(total_entries, tbl_hdl, sep);
if (!ret)
{
pass++;
}
else
{
IPAERR("ipa_nat_test0%d Fail\n", exec);
}
exec++;
IPADBG("\n\nExecuting ipa_nat_test0%d\n", exec);
ret = ipa_nat_test019(total_entries, tbl_hdl, sep);
if (!ret)
{
pass++;
}
else
{
IPAERR("ipa_nat_test0%d Fail\n", exec);
}
exec++;
IPADBG("\n\nExecuting ipa_nat_test0%d\n", exec);
ret = ipa_nat_test020(total_entries, tbl_hdl, sep);
if (!ret)
{
pass++;
}
else
{
IPAERR("ipa_nat_test0%d Fail\n", exec);
}
exec++;
IPADBG("\n\nExecuting ipa_nat_test0%d\n", exec);
ret = ipa_nat_test022(total_entries, tbl_hdl, sep);
if (!ret)
{
pass++;
}
else
{
IPAERR("ipa_nat_test0%d Fail\n", exec);
}
exec++;
}
if (!sep)
{
ret = ipa_nat_del_ipv4_tbl(tbl_hdl);
CHECK_ERR(ret);
}
}
/*======= Printing Results ==========*/
IPADBG("Total ipa_nat Tests Run:%d, Pass:%d, Fail:%d\n",exec, pass, exec-pass);
return 0;
}