| /* |
| ************************************************************************** |
| * Copyright (c) 2014-2018 The Linux Foundation. All rights reserved. |
| * Permission to use, copy, modify, and/or distribute this software for |
| * any purpose with or without fee is hereby granted, provided that the |
| * above copyright notice and this permission notice appear in all copies. |
| * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES |
| * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
| * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR |
| * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
| * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN |
| * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT |
| * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
| ************************************************************************** |
| */ |
| |
| #include <linux/version.h> |
| #include <linux/types.h> |
| #include <linux/ip.h> |
| #include <linux/tcp.h> |
| #include <linux/module.h> |
| #include <linux/skbuff.h> |
| #include <linux/icmp.h> |
| #include <linux/kthread.h> |
| #include <linux/pkt_sched.h> |
| #include <linux/string.h> |
| #include <net/ip6_route.h> |
| #include <net/ip6_fib.h> |
| #include <net/ipv6.h> |
| #include <net/route.h> |
| #include <net/ip_fib.h> |
| #include <net/ip.h> |
| #include <net/tcp.h> |
| #include <asm/unaligned.h> |
| #include <asm/uaccess.h> /* for put_user */ |
| #include <linux/inet.h> |
| #include <linux/in6.h> |
| #include <linux/in.h> |
| #include <linux/udp.h> |
| #include <linux/tcp.h> |
| #include <linux/kernel.h> |
| #include <linux/netlink.h> |
| #include <linux/rtnetlink.h> |
| #include <linux/socket.h> |
| #include <linux/wireless.h> |
| |
| #if defined(ECM_DB_XREF_ENABLE) && defined(ECM_BAND_STEERING_ENABLE) |
| #include <linux/if_bridge.h> |
| #endif |
| #include <linux/inetdevice.h> |
| #if defined(ECM_INTERFACE_TUNIPIP6_ENABLE) || defined(ECM_INTERFACE_SIT_ENABLE) |
| #if (LINUX_VERSION_CODE <= KERNEL_VERSION(3, 9, 0)) |
| #include <net/ipip.h> |
| #else |
| #include <net/ip_tunnels.h> |
| #endif |
| #endif |
| #include <net/ip6_tunnel.h> |
| #include <net/addrconf.h> |
| #include <linux/if_arp.h> |
| #include <linux/netfilter_ipv4.h> |
| #include <linux/netfilter_bridge.h> |
| #include <linux/if_bridge.h> |
| #include <net/arp.h> |
| #include <net/netfilter/nf_conntrack.h> |
| #include <net/netfilter/nf_conntrack_acct.h> |
| #include <net/netfilter/nf_conntrack_helper.h> |
| #include <net/netfilter/nf_conntrack_l4proto.h> |
| #include <net/netfilter/nf_conntrack_l3proto.h> |
| #include <net/netfilter/nf_conntrack_zones.h> |
| #include <net/netfilter/nf_conntrack_core.h> |
| #include <linux/netfilter_ipv6/ip6_tables.h> |
| #include <net/netfilter/ipv4/nf_conntrack_ipv4.h> |
| #include <net/netfilter/ipv4/nf_defrag_ipv4.h> |
| #ifdef ECM_INTERFACE_VLAN_ENABLE |
| #include <linux/../../net/8021q/vlan.h> |
| #include <linux/if_vlan.h> |
| #endif |
| #ifdef ECM_INTERFACE_PPP_ENABLE |
| #include <linux/if_pppox.h> |
| #ifdef ECM_INTERFACE_L2TPV2_ENABLE |
| #include <linux/if_pppol2tp.h> |
| #endif |
| #ifdef ECM_INTERFACE_PPTP_ENABLE |
| #include <linux/netfilter/nf_conntrack_proto_gre.h> |
| #endif |
| #endif |
| #ifdef ECM_INTERFACE_MAP_T_ENABLE |
| #include <nat46-core.h> |
| #endif |
| |
| /* |
| * Debug output levels |
| * 0 = OFF |
| * 1 = ASSERTS / ERRORS |
| * 2 = 1 + WARN |
| * 3 = 2 + INFO |
| * 4 = 3 + TRACE |
| */ |
| #define DEBUG_LEVEL ECM_INTERFACE_DEBUG_LEVEL |
| |
| #ifdef ECM_MULTICAST_ENABLE |
| #include <mc_ecm.h> |
| #endif |
| |
| #include "ecm_types.h" |
| #include "ecm_db_types.h" |
| #include "ecm_state.h" |
| #include "ecm_tracker.h" |
| #include "ecm_classifier.h" |
| #include "ecm_front_end_types.h" |
| #include "ecm_tracker_datagram.h" |
| #include "ecm_tracker_udp.h" |
| #include "ecm_tracker_tcp.h" |
| #include "ecm_db.h" |
| #include "ecm_interface.h" |
| |
| /* |
| * Wifi event handler structure. |
| */ |
| struct ecm_interface_wifi_event { |
| struct task_struct *thread; |
| struct socket *sock; |
| }; |
| |
| static struct ecm_interface_wifi_event __ewn; |
| |
| #ifdef ECM_IPV6_ENABLE |
| /* |
| * TODO: Remove once the Linux image and headers get propogated. |
| */ |
| struct net_device *ipv6_dev_find(struct net *net, struct in6_addr *addr, int strict); |
| #endif |
| |
| /* |
| * Locking - concurrency control |
| */ |
| static DEFINE_SPINLOCK(ecm_interface_lock); /* Protect against SMP access between netfilter, events and private threaded function. */ |
| |
| /* |
| * Management thread control |
| */ |
| static bool ecm_interface_terminate_pending = false; /* True when the user has signalled we should quit */ |
| |
| /* |
| * Source interface check flag. |
| * If it is enabled, the acceleration engine will check the flow's interface to see |
| * whether it matches with the rule's source interface or not. |
| */ |
| int ecm_interface_src_check; |
| |
| static struct ctl_table_header *ecm_interface_ctl_table_header; /* Sysctl table header */ |
| |
| /* |
| * ecm_interface_get_and_hold_dev_master() |
| * Returns the master device of a net device if any. |
| */ |
| struct net_device *ecm_interface_get_and_hold_dev_master(struct net_device *dev) |
| { |
| struct net_device *master; |
| #if (LINUX_VERSION_CODE > KERNEL_VERSION(3,6,0)) |
| rcu_read_lock(); |
| master = netdev_master_upper_dev_get_rcu(dev); |
| if (!master) { |
| rcu_read_unlock(); |
| return NULL; |
| } |
| dev_hold(master); |
| rcu_read_unlock(); |
| #else |
| master = dev->master; |
| if (!master) { |
| return NULL; |
| } |
| dev_hold(master); |
| #endif |
| return master; |
| } |
| EXPORT_SYMBOL(ecm_interface_get_and_hold_dev_master); |
| |
| /* |
| * ecm_interface_vlan_real_dev() |
| * Return immediate VLAN net device or Physical device pointer |
| */ |
| static inline struct net_device *ecm_interface_vlan_real_dev(struct net_device *vlan_dev) |
| { |
| #if (LINUX_VERSION_CODE > KERNEL_VERSION(3, 6, 0)) |
| return vlan_dev_next_dev(vlan_dev); |
| #else |
| return vlan_dev_real_dev(vlan_dev); |
| #endif |
| } |
| |
| /* |
| * ecm_interface_dev_find_by_local_addr_ipv4() |
| * Return a hold to the device for the given local IP address. Returns NULL on failure. |
| */ |
| static struct net_device *ecm_interface_dev_find_by_local_addr_ipv4(ip_addr_t addr) |
| { |
| __be32 be_addr; |
| struct net_device *dev; |
| |
| ECM_IP_ADDR_TO_NIN4_ADDR(be_addr, addr); |
| dev = ip_dev_find(&init_net, be_addr); |
| return dev; |
| } |
| |
| #ifdef ECM_IPV6_ENABLE |
| /* |
| * ecm_interface_dev_find_by_local_addr_ipv6() |
| * Return a hold to the device for the given local IP address. Returns NULL on failure. |
| */ |
| static struct net_device *ecm_interface_dev_find_by_local_addr_ipv6(ip_addr_t addr) |
| { |
| struct in6_addr addr6; |
| struct net_device *dev; |
| |
| ECM_IP_ADDR_TO_NIN6_ADDR(addr6, addr); |
| dev = (struct net_device *)ipv6_dev_find(&init_net, &addr6, 1); |
| return dev; |
| } |
| #endif |
| |
| /* |
| * ecm_interface_dev_find_by_local_addr() |
| * Return the device on which the local address resides. |
| * |
| * Returns a hold to the device or NULL on failure. |
| */ |
| struct net_device *ecm_interface_dev_find_by_local_addr(ip_addr_t addr) |
| { |
| char __attribute__((unused)) addr_str[40]; |
| |
| DEBUG_ECM_IP_ADDR_TO_STRING(addr_str, addr); |
| DEBUG_TRACE("Locate dev for: %s\n", addr_str); |
| |
| if (ECM_IP_ADDR_IS_V4(addr)) { |
| return ecm_interface_dev_find_by_local_addr_ipv4(addr); |
| } |
| |
| #ifdef ECM_IPV6_ENABLE |
| return ecm_interface_dev_find_by_local_addr_ipv6(addr); |
| #else |
| return NULL; |
| #endif |
| } |
| EXPORT_SYMBOL(ecm_interface_dev_find_by_local_addr); |
| |
| /* |
| * ecm_interface_dev_find_by_addr() |
| * Return the net device on which the given IP address resides. Returns NULL on faiure. |
| * |
| * NOTE: The device may be the device upon which has a default gateway to reach the address. |
| * from_local_addr is true when the device was found by a local address search. |
| */ |
| struct net_device *ecm_interface_dev_find_by_addr(ip_addr_t addr, bool *from_local_addr) |
| { |
| char __attribute__((unused)) addr_str[40]; |
| struct ecm_interface_route ecm_rt; |
| struct net_device *dev; |
| struct dst_entry *dst; |
| |
| DEBUG_ECM_IP_ADDR_TO_STRING(addr_str, addr); |
| |
| /* |
| * Is the address a local IP? |
| */ |
| DEBUG_TRACE("find net device for address: %s\n", addr_str); |
| dev = ecm_interface_dev_find_by_local_addr(addr); |
| if (dev) { |
| *from_local_addr = true; |
| DEBUG_TRACE("addr: %s is local: %p (%s)\n", addr_str, dev, dev->name); |
| return dev; |
| } |
| |
| DEBUG_TRACE("addr: %s is not local\n", addr_str); |
| |
| /* |
| * Try a route to the address instead |
| * NOTE: This will locate a route entry in the route destination *cache*. |
| */ |
| if (!ecm_interface_find_route_by_addr(addr, &ecm_rt)) { |
| DEBUG_WARN("addr: %s - no dev locatable\n", addr_str); |
| return NULL; |
| } |
| |
| *from_local_addr = false; |
| dst = ecm_rt.dst; |
| dev = dst->dev; |
| dev_hold(dev); |
| ecm_interface_route_release(&ecm_rt); |
| DEBUG_TRACE("dest_addr: %s uses dev: %p(%s)\n", addr_str, dev, dev->name); |
| return dev; |
| } |
| EXPORT_SYMBOL(ecm_interface_dev_find_by_addr); |
| |
| #ifdef ECM_IPV6_ENABLE |
| /* |
| * ecm_interface_mac_addr_get_ipv6() |
| * Return mac for an IPv6 address |
| * |
| * GGG TODO Need to make sure this also works for local IP addresses too. |
| */ |
| static bool ecm_interface_mac_addr_get_ipv6(ip_addr_t addr, uint8_t *mac_addr, bool *on_link, ip_addr_t gw_addr) |
| { |
| struct in6_addr daddr; |
| struct ecm_interface_route ecm_rt; |
| struct neighbour *neigh; |
| struct rt6_info *rt; |
| struct dst_entry *dst; |
| |
| /* |
| * Get the MAC address that corresponds to IP address given. |
| * We look up the rt6_info entries and, from its neighbour structure, obtain the hardware address. |
| * This means we will also work if the neighbours are routers too. |
| */ |
| ECM_IP_ADDR_TO_NIN6_ADDR(daddr, addr); |
| if (!ecm_interface_find_route_by_addr(addr, &ecm_rt)) { |
| *on_link = false; |
| return false; |
| } |
| DEBUG_ASSERT(!ecm_rt.v4_route, "Did not locate a v6 route!\n"); |
| |
| /* |
| * Is this destination on link or off-link via a gateway? |
| */ |
| rt = ecm_rt.rt.rtv6; |
| if (!ECM_IP_ADDR_MATCH(rt->rt6i_dst.addr.in6_u.u6_addr32, rt->rt6i_gateway.in6_u.u6_addr32) || (rt->rt6i_flags & RTF_GATEWAY)) { |
| *on_link = false; |
| ECM_NIN6_ADDR_TO_IP_ADDR(gw_addr, rt->rt6i_gateway) |
| } else { |
| *on_link = true; |
| } |
| |
| rcu_read_lock(); |
| dst = ecm_rt.dst; |
| #if (LINUX_VERSION_CODE <= KERNEL_VERSION(3,6,0)) |
| neigh = dst_get_neighbour_noref(dst); |
| if (neigh) { |
| neigh_hold(neigh); |
| } |
| #else |
| neigh = dst_neigh_lookup(dst, &daddr); |
| #endif |
| if (!neigh) { |
| neigh = neigh_lookup(&nd_tbl, &daddr, dst->dev); |
| } |
| |
| if (!neigh) { |
| rcu_read_unlock(); |
| ecm_interface_route_release(&ecm_rt); |
| DEBUG_WARN("No neigh reference\n"); |
| return false; |
| } |
| if (!(neigh->nud_state & NUD_VALID)) { |
| rcu_read_unlock(); |
| neigh_release(neigh); |
| ecm_interface_route_release(&ecm_rt); |
| DEBUG_WARN("NUD invalid\n"); |
| return false; |
| } |
| if (!neigh->dev) { |
| rcu_read_unlock(); |
| neigh_release(neigh); |
| ecm_interface_route_release(&ecm_rt); |
| DEBUG_WARN("Neigh dev invalid\n"); |
| return false; |
| } |
| |
| /* |
| * If neigh->dev is a loopback then addr is a local address in which case we take the MAC from given device |
| */ |
| if (neigh->dev->flags & IFF_LOOPBACK) { |
| // GGG TODO Create an equivalent logic to that for ipv4, maybe need to create an ip6_dev_find()? |
| DEBUG_TRACE("local address " ECM_IP_ADDR_OCTAL_FMT " (found loopback)\n", ECM_IP_ADDR_TO_OCTAL(addr)); |
| memset(mac_addr, 0, 6); |
| } else { |
| memcpy(mac_addr, neigh->ha, 6); |
| } |
| rcu_read_unlock(); |
| neigh_release(neigh); |
| ecm_interface_route_release(&ecm_rt); |
| |
| DEBUG_TRACE(ECM_IP_ADDR_OCTAL_FMT " maps to %pM\n", ECM_IP_ADDR_TO_OCTAL(addr), mac_addr); |
| return true; |
| } |
| |
| /* |
| * ecm_interface_find_gateway_ipv6() |
| * Finds the ipv6 gateway ip address of a given ipv6 address. |
| */ |
| static bool ecm_interface_find_gateway_ipv6(ip_addr_t addr, ip_addr_t gw_addr) |
| { |
| struct ecm_interface_route ecm_rt; |
| struct rt6_info *rt; |
| |
| /* |
| * Find the ipv6 route of the given ip address to look up |
| * whether we have a gateway to reach to that ip address or not. |
| */ |
| if (!ecm_interface_find_route_by_addr(addr, &ecm_rt)) { |
| return false; |
| } |
| DEBUG_ASSERT(!ecm_rt.v4_route, "Did not locate a v6 route!\n"); |
| DEBUG_TRACE("Found route\n"); |
| |
| /* |
| * Is this destination reachable via a gateway? |
| */ |
| rt = ecm_rt.rt.rtv6; |
| if (ECM_IP_ADDR_MATCH(rt->rt6i_dst.addr.in6_u.u6_addr32, rt->rt6i_gateway.in6_u.u6_addr32) && !(rt->rt6i_flags & RTF_GATEWAY)) { |
| ecm_interface_route_release(&ecm_rt); |
| return false; |
| } |
| |
| ECM_NIN6_ADDR_TO_IP_ADDR(gw_addr, rt->rt6i_gateway) |
| ecm_interface_route_release(&ecm_rt); |
| return true; |
| } |
| #endif |
| |
| /* |
| * ecm_interface_find_gateway_ipv4() |
| * Finds the ipv4 gateway address of a given ipv4 address. |
| */ |
| static bool ecm_interface_find_gateway_ipv4(ip_addr_t addr, ip_addr_t gw_addr) |
| { |
| struct ecm_interface_route ecm_rt; |
| struct rtable *rt; |
| |
| /* |
| * Find the ipv4 route of the given ip address to look up |
| * whether we have a gateway to reach to that ip address or not. |
| */ |
| if (!ecm_interface_find_route_by_addr(addr, &ecm_rt)) { |
| return false; |
| } |
| DEBUG_ASSERT(ecm_rt.v4_route, "Did not locate a v4 route!\n"); |
| DEBUG_TRACE("Found route\n"); |
| |
| /* |
| * Is this destination reachable via a gateway? |
| */ |
| rt = ecm_rt.rt.rtv4; |
| #if (LINUX_VERSION_CODE <= KERNEL_VERSION(3, 6, 0)) |
| if (!(rt->rt_dst != rt->rt_gateway) && !(rt->rt_flags & RTF_GATEWAY)) { |
| #else |
| if (!rt->rt_uses_gateway && !(rt->rt_flags & RTF_GATEWAY)) { |
| #endif |
| ecm_interface_route_release(&ecm_rt); |
| return false; |
| } |
| |
| ECM_NIN4_ADDR_TO_IP_ADDR(gw_addr, rt->rt_gateway) |
| ecm_interface_route_release(&ecm_rt); |
| return true; |
| } |
| |
| /* |
| * ecm_interface_find_gateway() |
| * Finds the gateway ip address of a given ECM ip address type. |
| */ |
| bool ecm_interface_find_gateway(ip_addr_t addr, ip_addr_t gw_addr) |
| { |
| if (ECM_IP_ADDR_IS_V4(addr)) { |
| return ecm_interface_find_gateway_ipv4(addr, gw_addr); |
| } |
| |
| #ifdef ECM_IPV6_ENABLE |
| return ecm_interface_find_gateway_ipv6(addr, gw_addr); |
| #else |
| return false; |
| #endif |
| } |
| EXPORT_SYMBOL(ecm_interface_find_gateway); |
| |
| /* |
| * ecm_interface_mac_addr_get_ipv4() |
| * Return mac for an IPv4 address |
| */ |
| static bool ecm_interface_mac_addr_get_ipv4(ip_addr_t addr, uint8_t *mac_addr, bool *on_link, ip_addr_t gw_addr) |
| { |
| struct neighbour *neigh; |
| struct ecm_interface_route ecm_rt; |
| struct rtable *rt; |
| struct dst_entry *dst; |
| __be32 ipv4_addr; |
| |
| /* |
| * Get the MAC address that corresponds to IP address given. |
| * We look up the rtable entries and, from its neighbour structure, obtain the hardware address. |
| * This means we will also work if the neighbours are routers too. |
| * We also locate the MAC if the address is a local host address. |
| */ |
| ECM_IP_ADDR_TO_NIN4_ADDR(ipv4_addr, addr); |
| if (!ecm_interface_find_route_by_addr(addr, &ecm_rt)) { |
| *on_link = false; |
| return false; |
| } |
| DEBUG_ASSERT(ecm_rt.v4_route, "Did not locate a v4 route!\n"); |
| DEBUG_TRACE("Found route\n"); |
| |
| /* |
| * Is this destination on link or off-link via a gateway? |
| */ |
| rt = ecm_rt.rt.rtv4; |
| #if (LINUX_VERSION_CODE <= KERNEL_VERSION(3,6,0)) |
| if ((rt->rt_dst != rt->rt_gateway) || (rt->rt_flags & RTF_GATEWAY)) { |
| #else |
| if (rt->rt_uses_gateway || (rt->rt_flags & RTF_GATEWAY)) { |
| #endif |
| *on_link = false; |
| ECM_NIN4_ADDR_TO_IP_ADDR(gw_addr, rt->rt_gateway) |
| } else { |
| *on_link = true; |
| } |
| |
| /* |
| * Get the neighbour entry for the address |
| */ |
| rcu_read_lock(); |
| dst = ecm_rt.dst; |
| #if (LINUX_VERSION_CODE <= KERNEL_VERSION(3,6,0)) |
| neigh = dst_get_neighbour_noref(dst); |
| if (neigh) { |
| neigh_hold(neigh); |
| } |
| #else |
| neigh = dst_neigh_lookup(dst, &ipv4_addr); |
| #endif |
| if (!neigh) { |
| neigh = neigh_lookup(&arp_tbl, &ipv4_addr, dst->dev); |
| } |
| if (!neigh) { |
| rcu_read_unlock(); |
| ecm_interface_route_release(&ecm_rt); |
| DEBUG_WARN("no neigh\n"); |
| return false; |
| } |
| if (!(neigh->nud_state & NUD_VALID)) { |
| rcu_read_unlock(); |
| neigh_release(neigh); |
| ecm_interface_route_release(&ecm_rt); |
| DEBUG_WARN("neigh nud state is not valid\n"); |
| return false; |
| } |
| if (!neigh->dev) { |
| rcu_read_unlock(); |
| neigh_release(neigh); |
| ecm_interface_route_release(&ecm_rt); |
| DEBUG_WARN("neigh has no device\n"); |
| return false; |
| } |
| |
| /* |
| * If the device is loopback this will be because the address is a local address |
| * In this case locate the device that has this local address and get its mac. |
| */ |
| if (neigh->dev->type == ARPHRD_LOOPBACK) { |
| struct net_device *dev; |
| |
| DEBUG_TRACE("%pI4 finds loopback device, dev: %p (%s)\n", &ipv4_addr, neigh->dev, neigh->dev->name); |
| rcu_read_unlock(); |
| neigh_release(neigh); |
| ecm_interface_route_release(&ecm_rt); |
| |
| /* |
| * Lookup the device that has this IP address assigned |
| */ |
| dev = ip_dev_find(&init_net, ipv4_addr); |
| if (!dev) { |
| DEBUG_WARN("Unable to locate dev for: %pI4\n", &ipv4_addr); |
| return false; |
| } |
| memcpy(mac_addr, dev->dev_addr, (size_t)dev->addr_len); |
| DEBUG_TRACE("is local addr: %pI4, mac: %pM, dev ifindex: %d, dev: %p (%s), dev_type: %d\n", |
| &ipv4_addr, mac_addr, dev->ifindex, dev, dev->name, dev->type); |
| dev_put(dev); |
| return true; |
| } |
| |
| if (!(neigh->dev->flags & IFF_NOARP)) { |
| memcpy(mac_addr, neigh->ha, (size_t)neigh->dev->addr_len); |
| } else { |
| DEBUG_TRACE("non-arp device: %p (%s, type: %d) to reach %pI4\n", neigh->dev, neigh->dev->name, neigh->dev->type, &ipv4_addr); |
| memset(mac_addr, 0, 6); |
| } |
| DEBUG_TRACE("addr: %pI4, mac: %pM, iif: %d, neigh dev ifindex: %d, dev: %p (%s), dev_type: %d\n", |
| &ipv4_addr, mac_addr, rt->rt_iif, neigh->dev->ifindex, neigh->dev, neigh->dev->name, neigh->dev->type); |
| |
| rcu_read_unlock(); |
| neigh_release(neigh); |
| ecm_interface_route_release(&ecm_rt); |
| return true; |
| } |
| |
| /* |
| * ecm_interface_mac_addr_get() |
| * Return the mac address for the given IP address. Returns false on failure. |
| */ |
| bool ecm_interface_mac_addr_get(ip_addr_t addr, uint8_t *mac_addr, bool *on_link, ip_addr_t gw_addr) |
| { |
| if (ECM_IP_ADDR_IS_V4(addr)) { |
| return ecm_interface_mac_addr_get_ipv4(addr, mac_addr, on_link, gw_addr); |
| } |
| |
| #ifdef ECM_IPV6_ENABLE |
| return ecm_interface_mac_addr_get_ipv6(addr, mac_addr, on_link, gw_addr); |
| #else |
| return false; |
| #endif |
| } |
| EXPORT_SYMBOL(ecm_interface_mac_addr_get); |
| |
| #ifdef ECM_IPV6_ENABLE |
| /* |
| * ecm_interface_mac_addr_get_ipv6_no_route() |
| * Finds the mac address of a node from its ip address reachable via |
| * the given device. It looks up the mac address in the neighbour entries. |
| * It doesn't do any route lookup to find the dst entry. |
| */ |
| static bool ecm_interface_mac_addr_get_ipv6_no_route(struct net_device *dev, ip_addr_t addr, uint8_t *mac_addr) |
| { |
| struct in6_addr daddr; |
| struct neighbour *neigh; |
| struct net_device *local_dev; |
| |
| memset(mac_addr, 0, ETH_ALEN); |
| |
| /* |
| * Get the MAC address that corresponds to IP address given. |
| */ |
| ECM_IP_ADDR_TO_NIN6_ADDR(daddr, addr); |
| local_dev = ipv6_dev_find(&init_net, &daddr, 1); |
| if (local_dev) { |
| DEBUG_TRACE("%pi6 is a local address\n", &daddr); |
| memcpy(mac_addr, dev->dev_addr, ETH_ALEN); |
| dev_put(local_dev); |
| return true; |
| } |
| |
| rcu_read_lock(); |
| neigh = neigh_lookup(&nd_tbl, &daddr, dev); |
| if (!neigh) { |
| rcu_read_unlock(); |
| DEBUG_WARN("No neigh reference\n"); |
| return false; |
| } |
| if (!(neigh->nud_state & NUD_VALID)) { |
| neigh_release(neigh); |
| rcu_read_unlock(); |
| DEBUG_WARN("NUD invalid\n"); |
| return false; |
| } |
| if (!neigh->dev) { |
| neigh_release(neigh); |
| rcu_read_unlock(); |
| DEBUG_WARN("Neigh dev invalid\n"); |
| return false; |
| } |
| |
| if (neigh->dev->flags & IFF_NOARP) { |
| neigh_release(neigh); |
| rcu_read_unlock(); |
| DEBUG_TRACE("dest MAC is zero: %pM\n", mac_addr); |
| return true; |
| } |
| |
| memcpy(mac_addr, neigh->ha, (size_t)neigh->dev->addr_len); |
| neigh_release(neigh); |
| rcu_read_unlock(); |
| DEBUG_TRACE(ECM_IP_ADDR_OCTAL_FMT " maps to %pM\n", ECM_IP_ADDR_TO_OCTAL(addr), mac_addr); |
| return true; |
| } |
| #endif |
| |
| /* |
| * ecm_interface_mac_addr_get_ipv4_no_route() |
| * Finds the mac address of a node from its ip address reachable via |
| * the given device. It looks up the mac address in the neighbour entries. |
| * It doesn't do any route lookup to find the dst entry. |
| */ |
| static bool ecm_interface_mac_addr_get_ipv4_no_route(struct net_device *dev, ip_addr_t ip_addr, uint8_t *mac_addr) |
| { |
| struct neighbour *neigh; |
| __be32 be_addr; |
| struct net_device *local_dev; |
| |
| memset(mac_addr, 0, ETH_ALEN); |
| |
| ECM_IP_ADDR_TO_NIN4_ADDR(be_addr, ip_addr); |
| local_dev = ip_dev_find(&init_net, be_addr); |
| if (local_dev) { |
| DEBUG_TRACE("%pI4n is a local address\n", &be_addr); |
| memcpy(mac_addr, dev->dev_addr, ETH_ALEN); |
| dev_put(local_dev); |
| return true; |
| } |
| |
| rcu_read_lock(); |
| neigh = neigh_lookup(&arp_tbl, &be_addr, dev); |
| if (!neigh) { |
| rcu_read_unlock(); |
| DEBUG_WARN("no neigh\n"); |
| return false; |
| } |
| if (!(neigh->nud_state & NUD_VALID)) { |
| neigh_release(neigh); |
| rcu_read_unlock(); |
| DEBUG_WARN("neigh nud state is not valid\n"); |
| return false; |
| } |
| if (!neigh->dev) { |
| neigh_release(neigh); |
| rcu_read_unlock(); |
| DEBUG_WARN("neigh has no device\n"); |
| return false; |
| } |
| |
| if (neigh->dev->flags & IFF_NOARP) { |
| neigh_release(neigh); |
| rcu_read_unlock(); |
| DEBUG_TRACE("dest MAC is zero: %pM\n", mac_addr); |
| return true; |
| } |
| |
| memcpy(mac_addr, neigh->ha, (size_t)neigh->dev->addr_len); |
| neigh_release(neigh); |
| rcu_read_unlock(); |
| DEBUG_TRACE("dest MAC: %pM\n", mac_addr); |
| return true; |
| |
| } |
| |
| /* |
| * ecm_interface_mac_addr_get_no_route() |
| * Return the mac address for the given IP address reacahble via the given device. |
| * Return false on failure, true on success. |
| */ |
| bool ecm_interface_mac_addr_get_no_route(struct net_device *dev, ip_addr_t addr, uint8_t *mac_addr) |
| { |
| if (ECM_IP_ADDR_IS_V4(addr)) { |
| return ecm_interface_mac_addr_get_ipv4_no_route(dev, addr, mac_addr); |
| } |
| |
| #ifdef ECM_IPV6_ENABLE |
| return ecm_interface_mac_addr_get_ipv6_no_route(dev, addr, mac_addr); |
| #else |
| return false; |
| #endif |
| } |
| EXPORT_SYMBOL(ecm_interface_mac_addr_get_no_route); |
| |
| #ifdef ECM_MULTICAST_ENABLE |
| /* |
| * ecm_interface_multicast_check_for_br_dev() |
| * Find a bridge dev is present or not in an |
| * array of Ifindexs |
| */ |
| bool ecm_interface_multicast_check_for_br_dev(uint32_t dest_if[], uint8_t max_if) |
| { |
| struct net_device *br_dev; |
| int i; |
| |
| for (i = 0; i < max_if; i++) { |
| br_dev = dev_get_by_index(&init_net, dest_if[i]); |
| if (!br_dev) { |
| DEBUG_ASSERT(NULL, "expected only valid netdev here\n"); |
| continue; |
| } |
| |
| if (ecm_front_end_is_bridge_device(br_dev)) { |
| dev_put(br_dev); |
| return true; |
| } |
| dev_put(br_dev); |
| } |
| return false; |
| } |
| EXPORT_SYMBOL(ecm_interface_multicast_check_for_br_dev); |
| |
| /* |
| * ecm_interface_multicast_check_for_src_if_index() |
| * Find if a source netdev ifindex is matching with list of |
| * multicast destination netdev ifindex. If find a match then |
| * returns a new list of destination netdev ifindex excluding |
| * the ifindex of source netdev. |
| */ |
| int32_t ecm_interface_multicast_check_for_src_ifindex(int32_t mc_if_index[], int32_t max_if_index, int32_t if_num) |
| { |
| int32_t i; |
| int32_t valid_index; |
| |
| for (i = 0, valid_index = 0; i < max_if_index; i++) { |
| if (mc_if_index[i] == 0) { |
| break; |
| } |
| |
| if (mc_if_index[i] != if_num) { |
| mc_if_index[valid_index] = mc_if_index[i]; |
| valid_index++; |
| continue; |
| } |
| } |
| |
| return valid_index; |
| } |
| EXPORT_SYMBOL(ecm_interface_multicast_check_for_src_ifindex); |
| #endif |
| |
| /* |
| * ecm_interface_addr_find_route_by_addr_ipv4() |
| * Return the route for the given IP address. Returns NULL on failure. |
| */ |
| static bool ecm_interface_find_route_by_addr_ipv4(ip_addr_t addr, struct ecm_interface_route *ecm_rt) |
| { |
| __be32 be_addr; |
| |
| /* |
| * Get a route to the given IP address, this will allow us to also find the interface |
| * it is using to communicate with that IP address. |
| */ |
| ECM_IP_ADDR_TO_NIN4_ADDR(be_addr, addr); |
| ecm_rt->rt.rtv4 = ip_route_output(&init_net, be_addr, 0, 0, 0); |
| if (IS_ERR(ecm_rt->rt.rtv4)) { |
| DEBUG_TRACE("No output route to: %pI4n\n", &be_addr); |
| return false; |
| } |
| DEBUG_TRACE("Output route to: %pI4n is: %p\n", &be_addr, ecm_rt->rt.rtv4); |
| ecm_rt->dst = (struct dst_entry *)ecm_rt->rt.rtv4; |
| ecm_rt->v4_route = true; |
| return true; |
| } |
| |
| #ifdef ECM_IPV6_ENABLE |
| /* |
| * ecm_interface_addr_find_route_by_addr_ipv6() |
| * Return the route for the given IP address. Returns NULL on failure. |
| */ |
| static bool ecm_interface_find_route_by_addr_ipv6(ip_addr_t addr, struct ecm_interface_route *ecm_rt) |
| { |
| struct in6_addr naddr; |
| |
| ECM_IP_ADDR_TO_NIN6_ADDR(naddr, addr); |
| |
| /* |
| * Get a route to the given IP address, this will allow us to also find the interface |
| * it is using to communicate with that IP address. |
| */ |
| ecm_rt->rt.rtv6 = rt6_lookup(&init_net, &naddr, NULL, 0, 0); |
| if (!ecm_rt->rt.rtv6) { |
| DEBUG_TRACE("No output route to: " ECM_IP_ADDR_OCTAL_FMT "\n", ECM_IP_ADDR_TO_OCTAL(addr)); |
| return NULL; |
| } |
| DEBUG_TRACE("Output route to: " ECM_IP_ADDR_OCTAL_FMT " is: %p\n", ECM_IP_ADDR_TO_OCTAL(addr), ecm_rt->rt.rtv6); |
| ecm_rt->dst = (struct dst_entry *)ecm_rt->rt.rtv6; |
| ecm_rt->v4_route = false; |
| return true; |
| } |
| #endif |
| |
| /* |
| * ecm_interface_addr_find_route_by_addr() |
| * Return the route (in the given parameter) for the given IP address. Returns false on failure. |
| * |
| * Route is the device on which the addr is reachable, which may be loopback for local addresses. |
| * |
| * Returns true if the route was able to be located. The route must be released using ecm_interface_route_release(). |
| */ |
| bool ecm_interface_find_route_by_addr(ip_addr_t addr, struct ecm_interface_route *ecm_rt) |
| { |
| char __attribute__((unused)) addr_str[40]; |
| |
| DEBUG_ECM_IP_ADDR_TO_STRING(addr_str, addr); |
| DEBUG_TRACE("Locate route to: %s\n", addr_str); |
| |
| if (ECM_IP_ADDR_IS_V4(addr)) { |
| return ecm_interface_find_route_by_addr_ipv4(addr, ecm_rt); |
| } |
| |
| #ifdef ECM_IPV6_ENABLE |
| return ecm_interface_find_route_by_addr_ipv6(addr, ecm_rt); |
| #else |
| return false; |
| #endif |
| } |
| EXPORT_SYMBOL(ecm_interface_find_route_by_addr); |
| |
| /* |
| * ecm_interface_route_release() |
| * Release an ecm route |
| */ |
| void ecm_interface_route_release(struct ecm_interface_route *rt) |
| { |
| dst_release(rt->dst); |
| } |
| EXPORT_SYMBOL(ecm_interface_route_release); |
| |
| #ifdef ECM_IPV6_ENABLE |
| /* |
| * ecm_interface_send_neighbour_solicitation() |
| * Issue an IPv6 Neighbour soliciation request. |
| */ |
| void ecm_interface_send_neighbour_solicitation(struct net_device *dev, ip_addr_t addr) |
| { |
| struct in6_addr dst_addr, src_addr; |
| struct in6_addr mc_dst_addr; |
| struct rt6_info *rt6i; |
| struct neighbour *neigh; |
| struct net *netf = dev_net(dev); |
| int ret; |
| |
| /* |
| * Find source and destination addresses in Linux format. We need |
| * mcast destination address as well. |
| */ |
| ECM_IP_ADDR_TO_NIN6_ADDR(dst_addr, addr); |
| addrconf_addr_solict_mult(&dst_addr, &mc_dst_addr); |
| ret = ipv6_dev_get_saddr(netf, dev, &mc_dst_addr, 0, &src_addr); |
| |
| /* |
| * Find the route entry |
| */ |
| rt6i = rt6_lookup(netf, &dst_addr, NULL, 0, 0); |
| if (!rt6i) { |
| DEBUG_TRACE("IPv6 Route lookup failure for destination IPv6 address " ECM_IP_ADDR_OCTAL_FMT "\n", ECM_IP_ADDR_TO_OCTAL(addr)); |
| return; |
| } |
| |
| /* |
| * Find the neighbor entry |
| */ |
| #if (LINUX_VERSION_CODE <= KERNEL_VERSION(3,6,0)) |
| neigh = rt6i->dst.ops->neigh_lookup(&rt6i->dst, &dst_addr); |
| #else |
| neigh = rt6i->dst.ops->neigh_lookup(&rt6i->dst, NULL, &dst_addr); |
| #endif |
| if (neigh == NULL) { |
| DEBUG_TRACE("Neighbour lookup failure for destination IPv6 address " ECM_IP_ADDR_OCTAL_FMT "\n", ECM_IP_ADDR_TO_OCTAL(addr)); |
| dst_release(&rt6i->dst); |
| return; |
| } |
| |
| /* |
| * Issue a Neighbour soliciation request |
| */ |
| DEBUG_TRACE("Issue Neighbour solicitation request\n"); |
| #if (LINUX_VERSION_CODE < KERNEL_VERSION(4, 4, 0)) |
| ndisc_send_ns(dev, neigh, &dst_addr, &mc_dst_addr, &src_addr); |
| #else |
| ndisc_send_ns(dev, &dst_addr, &mc_dst_addr, &src_addr); |
| #endif |
| neigh_release(neigh); |
| dst_release(&rt6i->dst); |
| } |
| EXPORT_SYMBOL(ecm_interface_send_neighbour_solicitation); |
| #endif |
| |
| /* |
| * ecm_interface_send_arp_request() |
| * Issue and ARP request. |
| */ |
| void ecm_interface_send_arp_request(struct net_device *dest_dev, ip_addr_t dest_addr, bool on_link, ip_addr_t gw_addr) |
| { |
| /* |
| * Possible ARP does not know the address yet |
| */ |
| struct neighbour *neigh; |
| __be32 ipv4_addr; |
| |
| /* |
| * Convert the ECM IP address type to network order IPv4 address. |
| */ |
| ECM_IP_ADDR_TO_NIN4_ADDR(ipv4_addr, dest_addr); |
| |
| /* |
| * If we have a GW for this address, then we have to send ARP request to the GW |
| */ |
| if (!on_link && !ECM_IP_ADDR_IS_NULL(gw_addr)) { |
| ECM_IP_ADDR_TO_NIN4_ADDR(ipv4_addr, gw_addr); |
| } |
| |
| /* |
| * If we don't have this neighbor, create it before sending the arp request, |
| * so that when we receive the arp reply we update the neigh entry. |
| */ |
| neigh = neigh_lookup(&arp_tbl, &ipv4_addr, dest_dev); |
| if (!neigh) { |
| neigh = neigh_create(&arp_tbl, &ipv4_addr, dest_dev); |
| if (IS_ERR(neigh)) { |
| DEBUG_WARN("Unable to create ARP request neigh for %pI4\n", &ipv4_addr); |
| return; |
| } |
| } |
| |
| DEBUG_TRACE("Send ARP for %pI4\n", &ipv4_addr); |
| neigh_event_send(neigh, NULL); |
| neigh_release(neigh); |
| } |
| EXPORT_SYMBOL(ecm_interface_send_arp_request); |
| |
| /* |
| * ecm_interface_ipv4_neigh_get() |
| * Returns neighbour reference for a given IP address which must be released when you are done with it. |
| * |
| * Returns NULL on fail. |
| */ |
| struct neighbour *ecm_interface_ipv4_neigh_get(ip_addr_t addr) |
| { |
| struct neighbour *neigh; |
| struct rtable *rt; |
| struct dst_entry *dst; |
| __be32 ipv4_addr; |
| |
| ECM_IP_ADDR_TO_NIN4_ADDR(ipv4_addr, addr); |
| rt = ip_route_output(&init_net, ipv4_addr, 0, 0, 0); |
| if (IS_ERR(rt)) { |
| return NULL; |
| } |
| dst = (struct dst_entry *)rt; |
| neigh = dst_neigh_lookup(dst, &ipv4_addr); |
| ip_rt_put(rt); |
| return neigh; |
| } |
| |
| #ifdef ECM_IPV6_ENABLE |
| /* |
| * ecm_interface_ipv6_neigh_get() |
| * Returns neighbour reference for a given IP address which must be released when you are done with it. |
| * |
| * Returns NULL on fail. |
| */ |
| struct neighbour *ecm_interface_ipv6_neigh_get(ip_addr_t addr) |
| { |
| struct neighbour *neigh; |
| struct rt6_info *rt; |
| struct dst_entry *dst; |
| struct in6_addr ipv6_addr; |
| |
| ECM_IP_ADDR_TO_NIN6_ADDR(ipv6_addr, addr); |
| rt = rt6_lookup(&init_net, &ipv6_addr, NULL, 0, 0); |
| if (!rt) { |
| return NULL; |
| } |
| dst = (struct dst_entry *)rt; |
| neigh = dst_neigh_lookup(dst, &ipv6_addr); |
| dst_release(dst); |
| return neigh; |
| } |
| #endif |
| |
| /* |
| * ecm_interface_is_pptp() |
| * skip pptp tunnel encapsulated traffic |
| * |
| * ECM does not handle PPTP, |
| * this function detects packets of that type so they can be skipped over to improve their throughput. |
| */ |
| bool ecm_interface_is_pptp(struct sk_buff *skb, const struct net_device *out) |
| { |
| struct net_device *in; |
| |
| /* |
| * skip first pass of l2tp/pptp tunnel encapsulated traffic |
| */ |
| if (out->type == ARPHRD_PPP) { |
| if (out->priv_flags & IFF_PPP_PPTP) { |
| return true; |
| } |
| } |
| |
| in = dev_get_by_index(&init_net, skb->skb_iif); |
| if (!in) { |
| return true; |
| } |
| |
| if (in->type == ARPHRD_PPP) { |
| if (in->priv_flags & IFF_PPP_PPTP) { |
| dev_put(in); |
| return true; |
| } |
| } |
| |
| dev_put(in); |
| return false; |
| } |
| |
| #ifdef ECM_INTERFACE_PPP_ENABLE |
| /* |
| * ecm_interface_is_l2tp_packet_by_version() |
| * Check version of l2tp tunnel encapsulated traffic |
| * |
| * ECM does not handle l2tp, |
| * this function detects packets of that type so they can be skipped over to improve their throughput. |
| */ |
| bool ecm_interface_is_l2tp_packet_by_version(struct sk_buff *skb, const struct net_device *out, int ver) |
| { |
| uint32_t flag = 0; |
| struct net_device *in; |
| |
| switch (ver) { |
| case 2: |
| flag = IFF_PPP_L2TPV2; |
| break; |
| case 3: |
| flag = IFF_PPP_L2TPV3; |
| break; |
| default: |
| break; |
| } |
| |
| /* |
| * skip first pass of l2tp/pptp tunnel encapsulated traffic |
| */ |
| if (out->type == ARPHRD_PPP) { |
| if (out->priv_flags & flag) { |
| return true; |
| } |
| } |
| |
| in = dev_get_by_index(&init_net, skb->skb_iif); |
| if (!in) { |
| return true; |
| } |
| |
| if (in->type == ARPHRD_PPP) { |
| if (in->priv_flags & flag) { |
| dev_put(in); |
| return true; |
| } |
| } |
| |
| dev_put(in); |
| return false; |
| } |
| |
| /* |
| * ecm_interface_is_l2tp_pptp() |
| * skip l2tp/pptp tunnel encapsulated traffic |
| * |
| * ECM does not handle L2TP or PPTP encapsulated packets, |
| * this function detects packets of that type so they can be skipped over to improve their throughput. |
| */ |
| bool ecm_interface_is_l2tp_pptp(struct sk_buff *skb, const struct net_device *out) |
| { |
| struct net_device *in; |
| |
| /* |
| * skip first pass of l2tp/pptp tunnel encapsulated traffic |
| */ |
| if (out->type == ARPHRD_PPP) { |
| if (out->priv_flags & (IFF_PPP_L2TPV2 | IFF_PPP_L2TPV3 | |
| IFF_PPP_PPTP)) { |
| return true; |
| } |
| } |
| |
| in = dev_get_by_index(&init_net, skb->skb_iif); |
| if (!in) { |
| return true; |
| } |
| |
| if (in->type == ARPHRD_PPP) { |
| if (in->priv_flags & (IFF_PPP_L2TPV2 | IFF_PPP_L2TPV3 | |
| IFF_PPP_PPTP)) { |
| dev_put(in); |
| return true; |
| } |
| } |
| |
| dev_put(in); |
| return false; |
| |
| } |
| #endif |
| |
| #ifdef ECM_INTERFACE_VLAN_ENABLE |
| /* |
| * ecm_interface_vlan_interface_establish() |
| * Returns a reference to a iface of the VLAN type, possibly creating one if necessary. |
| * Returns NULL on failure or a reference to interface. |
| */ |
| static struct ecm_db_iface_instance *ecm_interface_vlan_interface_establish(struct ecm_db_interface_info_vlan *type_info, |
| char *dev_name, int32_t dev_interface_num, int32_t ae_interface_num, int32_t mtu) |
| { |
| struct ecm_db_iface_instance *nii; |
| struct ecm_db_iface_instance *ii; |
| |
| DEBUG_INFO("Establish VLAN iface: %s with address: %pM, vlan tag: %u, vlan_tpid: %x MTU: %d, if num: %d, accel engine if id: %d\n", |
| dev_name, type_info->address, type_info->vlan_tag, type_info->vlan_tpid, mtu, dev_interface_num, ae_interface_num); |
| |
| /* |
| * Locate the iface |
| */ |
| ii = ecm_db_iface_find_and_ref_vlan(type_info->address, type_info->vlan_tag, type_info->vlan_tpid); |
| if (ii) { |
| DEBUG_TRACE("%p: iface established\n", ii); |
| return ii; |
| } |
| |
| /* |
| * No iface - create one |
| */ |
| nii = ecm_db_iface_alloc(); |
| if (!nii) { |
| DEBUG_WARN("Failed to establish iface\n"); |
| return NULL; |
| } |
| |
| /* |
| * Add iface into the database, atomically to avoid races creating the same thing |
| */ |
| spin_lock_bh(&ecm_interface_lock); |
| ii = ecm_db_iface_find_and_ref_vlan(type_info->address, type_info->vlan_tag, type_info->vlan_tpid); |
| if (ii) { |
| spin_unlock_bh(&ecm_interface_lock); |
| ecm_db_iface_deref(nii); |
| return ii; |
| } |
| ecm_db_iface_add_vlan(nii, type_info->address, type_info->vlan_tag, type_info->vlan_tpid, dev_name, |
| mtu, dev_interface_num, ae_interface_num, NULL, nii); |
| spin_unlock_bh(&ecm_interface_lock); |
| |
| DEBUG_TRACE("%p: vlan iface established\n", nii); |
| return nii; |
| } |
| #endif |
| |
| /* |
| * ecm_interface_bridge_interface_establish() |
| * Returns a reference to a iface of the BRIDGE type, possibly creating one if necessary. |
| * Returns NULL on failure or a reference to interface. |
| */ |
| static struct ecm_db_iface_instance *ecm_interface_bridge_interface_establish(struct ecm_db_interface_info_bridge *type_info, |
| char *dev_name, int32_t dev_interface_num, int32_t ae_interface_num, int32_t mtu) |
| { |
| struct ecm_db_iface_instance *nii; |
| struct ecm_db_iface_instance *ii; |
| |
| DEBUG_INFO("Establish BRIDGE iface: %s with address: %pM, MTU: %d, if num: %d, accel engine if id: %d\n", |
| dev_name, type_info->address, mtu, dev_interface_num, ae_interface_num); |
| |
| /* |
| * Locate the iface |
| */ |
| ii = ecm_db_iface_find_and_ref_bridge(type_info->address); |
| if (ii) { |
| DEBUG_TRACE("%p: iface established\n", ii); |
| return ii; |
| } |
| |
| /* |
| * No iface - create one |
| */ |
| nii = ecm_db_iface_alloc(); |
| if (!nii) { |
| DEBUG_WARN("Failed to establish iface\n"); |
| return NULL; |
| } |
| |
| /* |
| * Add iface into the database, atomically to avoid races creating the same thing |
| */ |
| spin_lock_bh(&ecm_interface_lock); |
| ii = ecm_db_iface_find_and_ref_bridge(type_info->address); |
| if (ii) { |
| spin_unlock_bh(&ecm_interface_lock); |
| ecm_db_iface_deref(nii); |
| return ii; |
| } |
| ecm_db_iface_add_bridge(nii, type_info->address, dev_name, |
| mtu, dev_interface_num, ae_interface_num, NULL, nii); |
| spin_unlock_bh(&ecm_interface_lock); |
| |
| DEBUG_TRACE("%p: bridge iface established\n", nii); |
| return nii; |
| } |
| |
| #ifdef ECM_INTERFACE_BOND_ENABLE |
| /* |
| * ecm_interface_lag_interface_establish() |
| * Returns a reference to a iface of the LAG type, possibly creating one if necessary. |
| * Returns NULL on failure or a reference to interface. |
| */ |
| static struct ecm_db_iface_instance *ecm_interface_lag_interface_establish(struct ecm_db_interface_info_lag *type_info, |
| char *dev_name, int32_t dev_interface_num, int32_t ae_interface_num, int32_t mtu) |
| { |
| struct ecm_db_iface_instance *nii; |
| struct ecm_db_iface_instance *ii; |
| |
| DEBUG_INFO("Establish LAG iface: %s with address: %pM, MTU: %d, if num: %d, accel engine if id: %d\n", |
| dev_name, type_info->address, mtu, dev_interface_num, ae_interface_num); |
| |
| /* |
| * Locate the iface |
| */ |
| ii = ecm_db_iface_find_and_ref_lag(type_info->address); |
| if (ii) { |
| DEBUG_TRACE("%p: iface established\n", ii); |
| return ii; |
| } |
| |
| /* |
| * No iface - create one |
| */ |
| nii = ecm_db_iface_alloc(); |
| if (!nii) { |
| DEBUG_WARN("Failed to establish iface\n"); |
| return NULL; |
| } |
| |
| /* |
| * Add iface into the database, atomically to avoid races creating the same thing |
| */ |
| spin_lock_bh(&ecm_interface_lock); |
| ii = ecm_db_iface_find_and_ref_lag(type_info->address); |
| if (ii) { |
| spin_unlock_bh(&ecm_interface_lock); |
| ecm_db_iface_deref(nii); |
| return ii; |
| } |
| ecm_db_iface_add_lag(nii, type_info->address, dev_name, |
| mtu, dev_interface_num, ae_interface_num, NULL, nii); |
| spin_unlock_bh(&ecm_interface_lock); |
| |
| DEBUG_TRACE("%p: lag iface established\n", nii); |
| return nii; |
| } |
| #endif |
| |
| /* |
| * ecm_interface_ethernet_interface_establish() |
| * Returns a reference to a iface of the ETHERNET type, possibly creating one if necessary. |
| * Returns NULL on failure or a reference to interface. |
| */ |
| static struct ecm_db_iface_instance *ecm_interface_ethernet_interface_establish(struct ecm_db_interface_info_ethernet *type_info, |
| char *dev_name, int32_t dev_interface_num, int32_t ae_interface_num, int32_t mtu) |
| { |
| struct ecm_db_iface_instance *nii; |
| struct ecm_db_iface_instance *ii; |
| |
| DEBUG_INFO("Establish ETHERNET iface: %s with address: %pM, MTU: %d, if num: %d, accel engine if id: %d\n", |
| dev_name, type_info->address, mtu, dev_interface_num, ae_interface_num); |
| |
| /* |
| * Locate the iface |
| */ |
| ii = ecm_db_iface_ifidx_find_and_ref_ethernet(type_info->address, dev_interface_num); |
| |
| if (ii) { |
| DEBUG_TRACE("%p: iface established\n", ii); |
| /* |
| * Update the accel engine interface identifier, just in case it was changed. |
| */ |
| ecm_db_iface_ae_interface_identifier_set(ii, ae_interface_num); |
| return ii; |
| } |
| |
| /* |
| * No iface - create one |
| */ |
| nii = ecm_db_iface_alloc(); |
| if (!nii) { |
| DEBUG_WARN("Failed to establish iface\n"); |
| return NULL; |
| } |
| |
| /* |
| * Add iface into the database, atomically to avoid races creating the same thing |
| */ |
| spin_lock_bh(&ecm_interface_lock); |
| ii = ecm_db_iface_ifidx_find_and_ref_ethernet(type_info->address, dev_interface_num); |
| if (ii) { |
| spin_unlock_bh(&ecm_interface_lock); |
| ecm_db_iface_deref(nii); |
| return ii; |
| } |
| ecm_db_iface_add_ethernet(nii, type_info->address, dev_name, |
| mtu, dev_interface_num, ae_interface_num, NULL, nii); |
| spin_unlock_bh(&ecm_interface_lock); |
| |
| DEBUG_TRACE("%p: ethernet iface established\n", nii); |
| return nii; |
| } |
| |
| #ifdef ECM_INTERFACE_PPPOE_ENABLE |
| /* |
| * ecm_interface_pppoe_interface_establish() |
| * Returns a reference to a iface of the PPPoE type, possibly creating one if necessary. |
| * Returns NULL on failure or a reference to interface. |
| */ |
| static struct ecm_db_iface_instance *ecm_interface_pppoe_interface_establish(struct ecm_db_interface_info_pppoe *type_info, |
| char *dev_name, int32_t dev_interface_num, int32_t ae_interface_num, int32_t mtu) |
| { |
| struct ecm_db_iface_instance *nii; |
| struct ecm_db_iface_instance *ii; |
| |
| DEBUG_INFO("Establish PPPoE iface: %s with session id: %u, remote mac: %pM, MTU: %d, if num: %d, accel engine if id: %d\n", |
| dev_name, type_info->pppoe_session_id, type_info->remote_mac, mtu, dev_interface_num, ae_interface_num); |
| |
| /* |
| * Locate the iface |
| */ |
| ii = ecm_db_iface_find_and_ref_pppoe(type_info->pppoe_session_id, type_info->remote_mac); |
| if (ii) { |
| DEBUG_TRACE("%p: iface established\n", ii); |
| return ii; |
| } |
| |
| /* |
| * No iface - create one |
| */ |
| nii = ecm_db_iface_alloc(); |
| if (!nii) { |
| DEBUG_WARN("Failed to establish iface\n"); |
| return NULL; |
| } |
| |
| /* |
| * Add iface into the database, atomically to avoid races creating the same thing |
| */ |
| spin_lock_bh(&ecm_interface_lock); |
| ii = ecm_db_iface_find_and_ref_pppoe(type_info->pppoe_session_id, type_info->remote_mac); |
| if (ii) { |
| spin_unlock_bh(&ecm_interface_lock); |
| ecm_db_iface_deref(nii); |
| return ii; |
| } |
| ecm_db_iface_add_pppoe(nii, type_info->pppoe_session_id, type_info->remote_mac, dev_name, |
| mtu, dev_interface_num, ae_interface_num, NULL, nii); |
| spin_unlock_bh(&ecm_interface_lock); |
| |
| DEBUG_TRACE("%p: pppoe iface established\n", nii); |
| return nii; |
| } |
| #endif |
| |
| #ifdef ECM_INTERFACE_MAP_T_ENABLE |
| /* |
| * ecm_interface_map_t_interface_establish() |
| * Returns a reference to a iface of the PPPoE type, possibly creating one if necessary. |
| * Returns NULL on failure or a reference to interface. |
| */ |
| static struct ecm_db_iface_instance *ecm_interface_map_t_interface_establish(struct ecm_db_interface_info_map_t *type_info, |
| char *dev_name, int32_t dev_interface_num, int32_t ae_interface_num, int32_t mtu) |
| { |
| struct ecm_db_iface_instance *nii; |
| struct ecm_db_iface_instance *ii; |
| |
| DEBUG_TRACE("Establish MAP-T iface: %s MTU: %d, if num: %d, accel engine if id: %d\n", |
| dev_name, mtu, dev_interface_num, ae_interface_num); |
| |
| /* |
| * Locate the iface |
| */ |
| ii = ecm_db_iface_find_and_ref_map_t(type_info->if_index); |
| if (ii) { |
| DEBUG_TRACE("%p: iface established\n", ii); |
| ecm_db_iface_update_ae_interface_identifier(ii, ae_interface_num); |
| return ii; |
| } |
| |
| /* |
| * No iface - create one |
| */ |
| nii = ecm_db_iface_alloc(); |
| if (!nii) { |
| DEBUG_WARN("Failed to establish iface\n"); |
| return NULL; |
| } |
| |
| /* |
| * Add iface into the database, atomically to avoid races creating the same thing |
| */ |
| spin_lock_bh(&ecm_interface_lock); |
| ii = ecm_db_iface_find_and_ref_map_t(type_info->if_index); |
| if (ii) { |
| spin_unlock_bh(&ecm_interface_lock); |
| ecm_db_iface_deref(nii); |
| ecm_db_iface_update_ae_interface_identifier(ii, ae_interface_num); |
| return ii; |
| } |
| ecm_db_iface_add_map_t(nii, type_info, dev_name, |
| mtu, dev_interface_num, ae_interface_num, NULL, nii); |
| spin_unlock_bh(&ecm_interface_lock); |
| |
| DEBUG_TRACE("%p: map_t iface established\n", nii); |
| return nii; |
| } |
| #endif |
| |
| #ifdef ECM_INTERFACE_L2TPV2_ENABLE |
| /* |
| * ecm_interface_pppol2tpv2_interface_establish() |
| * Returns a reference to a iface of the PPPoL2TPV2 type, possibly creating one if necessary. |
| * Returns NULL on failure or a reference to interface. |
| */ |
| static struct ecm_db_iface_instance *ecm_interface_pppol2tpv2_interface_establish(struct ecm_db_interface_info_pppol2tpv2 *type_info, |
| char *dev_name, int32_t dev_interface_num, int32_t ae_interface_num, int32_t mtu) |
| { |
| struct ecm_db_iface_instance *nii; |
| struct ecm_db_iface_instance *ii; |
| |
| DEBUG_INFO("Establish PPPol2tp iface: %s with tunnel id=%u session id %u\n", dev_name, type_info->l2tp.tunnel.tunnel_id, |
| type_info->l2tp.session.session_id); |
| /* |
| * Locate the iface |
| */ |
| ii = ecm_db_iface_find_and_ref_pppol2tpv2(type_info->l2tp.tunnel.tunnel_id, type_info->l2tp.session.session_id); |
| if (ii) { |
| DEBUG_TRACE("%p: iface established\n", ii); |
| ecm_db_iface_update_ae_interface_identifier(ii, ae_interface_num); |
| return ii; |
| } |
| |
| /* |
| * No iface - create one |
| */ |
| nii = ecm_db_iface_alloc(); |
| if (!nii) { |
| DEBUG_WARN("Failed to establish iface\n"); |
| return NULL; |
| } |
| |
| /* |
| * Add iface into the database, atomically to avoid races creating the same thing |
| */ |
| spin_lock_bh(&ecm_interface_lock); |
| ii = ecm_db_iface_find_and_ref_pppol2tpv2(type_info->l2tp.tunnel.tunnel_id, type_info->l2tp.session.session_id); |
| if (ii) { |
| spin_unlock_bh(&ecm_interface_lock); |
| ecm_db_iface_deref(nii); |
| ecm_db_iface_update_ae_interface_identifier(ii, ae_interface_num); |
| return ii; |
| } |
| |
| ecm_db_iface_add_pppol2tpv2(nii, type_info, dev_name, mtu, dev_interface_num, ae_interface_num, NULL, nii); |
| spin_unlock_bh(&ecm_interface_lock); |
| |
| DEBUG_TRACE("%p: pppol2tpv2 iface established\n", nii); |
| return nii; |
| } |
| |
| #endif |
| |
| #ifdef ECM_INTERFACE_PPTP_ENABLE |
| /* |
| * ecm_interface_pptp_interface_establish() |
| * Returns a reference to a iface of the PPTP type, possibly creating one if necessary. |
| * Returns NULL on failure or a reference to interface. |
| */ |
| static struct ecm_db_iface_instance *ecm_interface_pptp_interface_establish(struct ecm_db_interface_info_pptp *type_info, |
| char *dev_name, int32_t dev_interface_num, int32_t ae_interface_num, int32_t mtu) |
| { |
| struct ecm_db_iface_instance *nii; |
| struct ecm_db_iface_instance *ii; |
| |
| DEBUG_INFO("Establish PPTP iface: %s with local call id %u peer call id %u\n", dev_name, type_info->src_call_id, |
| type_info->dst_call_id); |
| /* |
| * Locate the iface |
| */ |
| ii = ecm_db_iface_find_and_ref_pptp(type_info->src_call_id, type_info->dst_call_id); |
| if (ii) { |
| DEBUG_TRACE("%p: iface established\n", ii); |
| ecm_db_iface_update_ae_interface_identifier(ii, ae_interface_num); |
| return ii; |
| } |
| |
| /* |
| * No iface - create one |
| */ |
| nii = ecm_db_iface_alloc(); |
| if (!nii) { |
| DEBUG_WARN("Failed to establish iface\n"); |
| return NULL; |
| } |
| |
| /* |
| * Add iface into the database, atomically to avoid races creating the same thing |
| */ |
| spin_lock_bh(&ecm_interface_lock); |
| ii = ecm_db_iface_find_and_ref_pptp(type_info->src_call_id, type_info->dst_call_id); |
| if (ii) { |
| spin_unlock_bh(&ecm_interface_lock); |
| ecm_db_iface_deref(nii); |
| ecm_db_iface_update_ae_interface_identifier(ii, ae_interface_num); |
| return ii; |
| } |
| |
| ecm_db_iface_add_pptp(nii, type_info, dev_name, mtu, dev_interface_num, ae_interface_num, NULL, nii); |
| spin_unlock_bh(&ecm_interface_lock); |
| |
| DEBUG_TRACE("%p: pptp iface established\n", nii); |
| return nii; |
| } |
| #endif |
| |
| /* |
| * ecm_interface_unknown_interface_establish() |
| * Returns a reference to a iface of the UNKNOWN type, possibly creating one if necessary. |
| * Returns NULL on failure or a reference to interface. |
| */ |
| static struct ecm_db_iface_instance *ecm_interface_unknown_interface_establish(struct ecm_db_interface_info_unknown *type_info, |
| char *dev_name, int32_t dev_interface_num, int32_t ae_interface_num, int32_t mtu) |
| { |
| struct ecm_db_iface_instance *nii; |
| struct ecm_db_iface_instance *ii; |
| |
| DEBUG_INFO("Establish UNKNOWN iface: %s with os_specific_ident: %u, MTU: %d, if num: %d, accel engine if id: %d\n", |
| dev_name, type_info->os_specific_ident, mtu, dev_interface_num, ae_interface_num); |
| |
| /* |
| * Locate the iface |
| */ |
| ii = ecm_db_iface_find_and_ref_unknown(type_info->os_specific_ident); |
| if (ii) { |
| DEBUG_TRACE("%p: iface established\n", ii); |
| return ii; |
| } |
| |
| /* |
| * No iface - create one |
| */ |
| nii = ecm_db_iface_alloc(); |
| if (!nii) { |
| DEBUG_WARN("Failed to establish iface\n"); |
| return NULL; |
| } |
| |
| /* |
| * Add iface into the database, atomically to avoid races creating the same thing |
| */ |
| spin_lock_bh(&ecm_interface_lock); |
| ii = ecm_db_iface_find_and_ref_unknown(type_info->os_specific_ident); |
| if (ii) { |
| spin_unlock_bh(&ecm_interface_lock); |
| ecm_db_iface_deref(nii); |
| return ii; |
| } |
| ecm_db_iface_add_unknown(nii, type_info->os_specific_ident, dev_name, |
| mtu, dev_interface_num, ae_interface_num, NULL, nii); |
| spin_unlock_bh(&ecm_interface_lock); |
| |
| DEBUG_TRACE("%p: unknown iface established\n", nii); |
| return nii; |
| } |
| |
| /* |
| * ecm_interface_loopback_interface_establish() |
| * Returns a reference to a iface of the LOOPBACK type, possibly creating one if necessary. |
| * Returns NULL on failure or a reference to interface. |
| */ |
| static struct ecm_db_iface_instance *ecm_interface_loopback_interface_establish(struct ecm_db_interface_info_loopback *type_info, |
| char *dev_name, int32_t dev_interface_num, int32_t ae_interface_num, int32_t mtu) |
| { |
| struct ecm_db_iface_instance *nii; |
| struct ecm_db_iface_instance *ii; |
| |
| DEBUG_INFO("Establish LOOPBACK iface: %s with os_specific_ident: %u, MTU: %d, if num: %d, accel engine if id: %d\n", |
| dev_name, type_info->os_specific_ident, mtu, dev_interface_num, ae_interface_num); |
| |
| /* |
| * Locate the iface |
| */ |
| ii = ecm_db_iface_find_and_ref_loopback(type_info->os_specific_ident); |
| if (ii) { |
| DEBUG_TRACE("%p: iface established\n", ii); |
| return ii; |
| } |
| |
| /* |
| * No iface - create one |
| */ |
| nii = ecm_db_iface_alloc(); |
| if (!nii) { |
| DEBUG_WARN("Failed to establish iface\n"); |
| return NULL; |
| } |
| |
| /* |
| * Add iface into the database, atomically to avoid races creating the same thing |
| */ |
| spin_lock_bh(&ecm_interface_lock); |
| ii = ecm_db_iface_find_and_ref_loopback(type_info->os_specific_ident); |
| if (ii) { |
| spin_unlock_bh(&ecm_interface_lock); |
| ecm_db_iface_deref(nii); |
| return ii; |
| } |
| ecm_db_iface_add_loopback(nii, type_info->os_specific_ident, dev_name, |
| mtu, dev_interface_num, ae_interface_num, NULL, nii); |
| spin_unlock_bh(&ecm_interface_lock); |
| |
| DEBUG_TRACE("%p: loopback iface established\n", nii); |
| return nii; |
| } |
| |
| #ifdef ECM_INTERFACE_IPSEC_ENABLE |
| /* |
| * ecm_interface_ipsec_tunnel_interface_establish() |
| * Returns a reference to a iface of the IPSEC_TUNNEL type, possibly creating one if necessary. |
| * Returns NULL on failure or a reference to interface. |
| * |
| * NOTE: GGG TODO THIS NEEDS TO TAKE A PROPER APPROACH TO IPSEC TUNNELS USING ENDPOINT ADDRESSING AS THE TYPE INFO KEYS |
| */ |
| static struct ecm_db_iface_instance *ecm_interface_ipsec_tunnel_interface_establish(struct ecm_db_interface_info_ipsec_tunnel *type_info, |
| char *dev_name, int32_t dev_interface_num, int32_t ae_interface_num, int32_t mtu) |
| { |
| struct ecm_db_iface_instance *nii; |
| struct ecm_db_iface_instance *ii; |
| |
| DEBUG_INFO("Establish IPSEC_TUNNEL iface: %s with os_specific_ident: %u, MTU: %d, if num: %d, accel engine if id: %d\n", |
| dev_name, type_info->os_specific_ident, mtu, dev_interface_num, ae_interface_num); |
| |
| /* |
| * Locate the iface |
| */ |
| ii = ecm_db_iface_find_and_ref_ipsec_tunnel(type_info->os_specific_ident); |
| if (ii) { |
| DEBUG_TRACE("%p: iface established\n", ii); |
| return ii; |
| } |
| |
| /* |
| * No iface - create one |
| */ |
| nii = ecm_db_iface_alloc(); |
| if (!nii) { |
| DEBUG_WARN("Failed to establish iface\n"); |
| return NULL; |
| } |
| |
| /* |
| * Add iface into the database, atomically to avoid races creating the same thing |
| */ |
| spin_lock_bh(&ecm_interface_lock); |
| ii = ecm_db_iface_find_and_ref_ipsec_tunnel(type_info->os_specific_ident); |
| if (ii) { |
| spin_unlock_bh(&ecm_interface_lock); |
| ecm_db_iface_deref(nii); |
| return ii; |
| } |
| ecm_db_iface_add_ipsec_tunnel(nii, type_info->os_specific_ident, dev_name, |
| mtu, dev_interface_num, ae_interface_num, NULL, nii); |
| spin_unlock_bh(&ecm_interface_lock); |
| |
| DEBUG_TRACE("%p: ipsec_tunnel iface established\n", nii); |
| return nii; |
| } |
| #endif |
| |
| #ifdef ECM_INTERFACE_SIT_ENABLE |
| #ifdef CONFIG_IPV6_SIT_6RD |
| /* |
| * ecm_interface_sit_interface_establish() |
| * Returns a reference to a iface of the SIT type, possibly creating one if necessary. |
| * Returns NULL on failure or a reference to interface. |
| */ |
| static struct ecm_db_iface_instance *ecm_interface_sit_interface_establish(struct ecm_db_interface_info_sit *type_info, |
| char *dev_name, int32_t dev_interface_num, int32_t ae_interface_num, int32_t mtu) |
| { |
| struct ecm_db_iface_instance *nii; |
| struct ecm_db_iface_instance *ii; |
| |
| DEBUG_INFO("Establish SIT iface: %s with saddr: " ECM_IP_ADDR_OCTAL_FMT ", daddr: " ECM_IP_ADDR_OCTAL_FMT ", MTU: %d, if num: %d, accel engine if id: %d\n", |
| dev_name, ECM_IP_ADDR_TO_OCTAL(type_info->saddr), ECM_IP_ADDR_TO_OCTAL(type_info->daddr), mtu, dev_interface_num, ae_interface_num); |
| |
| /* |
| * Locate the iface |
| */ |
| ii = ecm_db_iface_find_and_ref_sit(type_info->saddr, type_info->daddr, ae_interface_num); |
| if (ii) { |
| DEBUG_TRACE("%p: iface established\n", ii); |
| return ii; |
| } |
| |
| /* |
| * No iface - create one |
| */ |
| nii = ecm_db_iface_alloc(); |
| if (!nii) { |
| DEBUG_WARN("Failed to establish iface\n"); |
| return NULL; |
| } |
| |
| /* |
| * Add iface into the database, atomically to avoid races creating the same thing |
| */ |
| spin_lock_bh(&ecm_interface_lock); |
| ii = ecm_db_iface_find_and_ref_sit(type_info->saddr, type_info->daddr, ae_interface_num); |
| if (ii) { |
| spin_unlock_bh(&ecm_interface_lock); |
| ecm_db_iface_deref(nii); |
| return ii; |
| } |
| ecm_db_iface_add_sit(nii, type_info, dev_name, mtu, dev_interface_num, |
| ae_interface_num, NULL, nii); |
| spin_unlock_bh(&ecm_interface_lock); |
| |
| DEBUG_TRACE("%p: sit iface established\n", nii); |
| return nii; |
| } |
| #endif |
| #endif |
| |
| #ifdef ECM_INTERFACE_TUNIPIP6_ENABLE |
| #ifdef ECM_IPV6_ENABLE |
| /* |
| * ecm_interface_tunipip6_interface_establish() |
| * Returns a reference to a iface of the TUNIPIP6 type, possibly creating one if necessary. |
| * Returns NULL on failure or a reference to interface. |
| */ |
| static struct ecm_db_iface_instance *ecm_interface_tunipip6_interface_establish(struct ecm_db_interface_info_tunipip6 *type_info, |
| char *dev_name, int32_t dev_interface_num, int32_t ae_interface_num, int32_t mtu) |
| { |
| struct ecm_db_iface_instance *nii; |
| struct ecm_db_iface_instance *ii; |
| |
| DEBUG_INFO("Establish TUNIPIP6 iface: %s with saddr: " ECM_IP_ADDR_OCTAL_FMT ", daddr: " ECM_IP_ADDR_OCTAL_FMT ", MTU: %d, if num: %d, accel engine if id: %d\n", |
| dev_name, ECM_IP_ADDR_TO_OCTAL(type_info->saddr), ECM_IP_ADDR_TO_OCTAL(type_info->daddr), mtu, dev_interface_num, ae_interface_num); |
| |
| /* |
| * Locate the iface |
| */ |
| ii = ecm_db_iface_find_and_ref_tunipip6(type_info->saddr, type_info->daddr); |
| if (ii) { |
| DEBUG_TRACE("%p: iface established\n", ii); |
| return ii; |
| } |
| |
| /* |
| * No iface - create one |
| */ |
| nii = ecm_db_iface_alloc(); |
| if (!nii) { |
| DEBUG_WARN("Failed to establish iface\n"); |
| return NULL; |
| } |
| |
| /* |
| * Add iface into the database, atomically to avoid races creating the same thing |
| */ |
| spin_lock_bh(&ecm_interface_lock); |
| ii = ecm_db_iface_find_and_ref_tunipip6(type_info->saddr, type_info->daddr); |
| if (ii) { |
| spin_unlock_bh(&ecm_interface_lock); |
| ecm_db_iface_deref(nii); |
| return ii; |
| } |
| ecm_db_iface_add_tunipip6(nii, type_info, dev_name, mtu, dev_interface_num, |
| ae_interface_num, NULL, nii); |
| spin_unlock_bh(&ecm_interface_lock); |
| |
| DEBUG_TRACE("%p: tunipip6 iface established\n", nii); |
| return nii; |
| } |
| #endif |
| #endif |
| |
| /* |
| * ecm_interface_establish_and_ref() |
| * Establish an interface instance for the given interface detail. |
| */ |
| struct ecm_db_iface_instance *ecm_interface_establish_and_ref(struct ecm_front_end_connection_instance *feci, |
| struct net_device *dev, struct sk_buff *skb) |
| { |
| int32_t dev_interface_num; |
| char *dev_name; |
| int32_t dev_type; |
| int32_t dev_mtu; |
| int32_t ae_interface_num; |
| struct ecm_db_iface_instance *ii; |
| union { |
| struct ecm_db_interface_info_ethernet ethernet; /* type == ECM_DB_IFACE_TYPE_ETHERNET */ |
| #ifdef ECM_INTERFACE_VLAN_ENABLE |
| struct ecm_db_interface_info_vlan vlan; /* type == ECM_DB_IFACE_TYPE_VLAN */ |
| #endif |
| #ifdef ECM_INTERFACE_BOND_ENABLE |
| struct ecm_db_interface_info_lag lag; /* type == ECM_DB_IFACE_TYPE_LAG */ |
| #endif |
| struct ecm_db_interface_info_bridge bridge; /* type == ECM_DB_IFACE_TYPE_BRIDGE */ |
| #ifdef ECM_INTERFACE_PPPOE_ENABLE |
| struct ecm_db_interface_info_pppoe pppoe; /* type == ECM_DB_IFACE_TYPE_PPPOE */ |
| #endif |
| #ifdef ECM_INTERFACE_L2TPV2_ENABLE |
| struct ecm_db_interface_info_pppol2tpv2 pppol2tpv2; /* type == ECM_DB_IFACE_TYPE_PPPOL2TPV2 */ |
| #endif |
| #ifdef ECM_INTERFACE_PPTP_ENABLE |
| struct ecm_db_interface_info_pptp pptp; /* type == ECM_DB_IFACE_TYPE_PPTP */ |
| #endif |
| #ifdef ECM_INTERFACE_MAP_T_ENABLE |
| struct ecm_db_interface_info_map_t map_t; /* type == ECM_DB_IFACE_TYPE_MAP_T */ |
| #endif |
| struct ecm_db_interface_info_unknown unknown; /* type == ECM_DB_IFACE_TYPE_UNKNOWN */ |
| struct ecm_db_interface_info_loopback loopback; /* type == ECM_DB_IFACE_TYPE_LOOPBACK */ |
| #ifdef ECM_INTERFACE_IPSEC_ENABLE |
| struct ecm_db_interface_info_ipsec_tunnel ipsec_tunnel; /* type == ECM_DB_IFACE_TYPE_IPSEC_TUNNEL */ |
| #endif |
| #ifdef ECM_INTERFACE_SIT_ENABLE |
| struct ecm_db_interface_info_sit sit; /* type == ECM_DB_IFACE_TYPE_SIT */ |
| #endif |
| #ifdef ECM_INTERFACE_TUNIPIP6_ENABLE |
| #ifdef ECM_IPV6_ENABLE |
| struct ecm_db_interface_info_tunipip6 tunipip6; /* type == ECM_DB_IFACE_TYPE_TUNIPIP6 */ |
| #endif |
| #endif |
| } type_info; |
| |
| #ifdef ECM_INTERFACE_PPP_ENABLE |
| int channel_count; |
| struct ppp_channel *ppp_chan[1]; |
| int channel_protocol; |
| #ifdef ECM_INTERFACE_PPPOE_ENABLE |
| struct pppoe_opt addressing; |
| #endif |
| #ifdef ECM_INTERFACE_PPTP_ENABLE |
| int protocol = IPPROTO_IP; |
| struct pptp_opt opt; |
| struct iphdr *v4_hdr = NULL; |
| if (skb) { |
| v4_hdr = ip_hdr(skb); |
| protocol = v4_hdr->protocol; |
| } |
| #endif |
| #endif |
| /* |
| * Get basic information about the given device |
| */ |
| dev_interface_num = dev->ifindex; |
| dev_name = dev->name; |
| dev_type = dev->type; |
| dev_mtu = dev->mtu; |
| |
| /* |
| * Does the accel engine recognise this interface? |
| */ |
| ae_interface_num = feci->ae_interface_number_by_dev_get(dev); |
| |
| DEBUG_TRACE("Establish interface instance for device: %p is type: %d, name: %s, ifindex: %d, ae_if: %d, mtu: %d\n", |
| dev, dev_type, dev_name, dev_interface_num, ae_interface_num, dev_mtu); |
| |
| /* |
| * Extract from the device more type-specific information |
| */ |
| if (dev_type == ARPHRD_ETHER) { |
| |
| /* |
| * Ethernet - but what sub type? |
| */ |
| |
| #ifdef ECM_INTERFACE_VLAN_ENABLE |
| /* |
| * VLAN? |
| */ |
| if (is_vlan_dev(dev)) { |
| /* |
| * VLAN master |
| * GGG No locking needed here, ASSUMPTION is that real_dev is held for as long as we have dev. |
| */ |
| memcpy(type_info.vlan.address, dev->dev_addr, 6); |
| type_info.vlan.vlan_tag = vlan_dev_vlan_id(dev); |
| #if (LINUX_VERSION_CODE < KERNEL_VERSION(3, 15, 0)) |
| type_info.vlan.vlan_tpid = ETH_P_8021Q; |
| #else |
| type_info.vlan.vlan_tpid = ntohs(vlan_dev_vlan_proto(dev)); |
| #endif |
| DEBUG_TRACE("Net device: %p is VLAN, mac: %pM, vlan_id: %x vlan_tpid: %x\n", |
| dev, type_info.vlan.address, type_info.vlan.vlan_tag, type_info.vlan.vlan_tpid); |
| |
| /* |
| * Establish this type of interface |
| */ |
| ii = ecm_interface_vlan_interface_establish(&type_info.vlan, dev_name, dev_interface_num, ae_interface_num, dev_mtu); |
| goto identifier_update; |
| } |
| #endif |
| |
| /* |
| * BRIDGE? |
| */ |
| if (ecm_front_end_is_bridge_device(dev)) { |
| /* |
| * Bridge |
| */ |
| memcpy(type_info.bridge.address, dev->dev_addr, 6); |
| |
| DEBUG_TRACE("Net device: %p is BRIDGE, mac: %pM\n", |
| dev, type_info.bridge.address); |
| |
| /* |
| * Establish this type of interface |
| */ |
| ii = ecm_interface_bridge_interface_establish(&type_info.bridge, dev_name, dev_interface_num, ae_interface_num, dev_mtu); |
| goto identifier_update; |
| } |
| |
| #ifdef ECM_INTERFACE_BOND_ENABLE |
| /* |
| * LAG? |
| */ |
| if (ecm_front_end_is_lag_master(dev)) { |
| /* |
| * Link aggregation |
| */ |
| memcpy(type_info.lag.address, dev->dev_addr, 6); |
| |
| DEBUG_TRACE("Net device: %p is LAG, mac: %pM\n", |
| dev, type_info.lag.address); |
| |
| /* |
| * Establish this type of interface |
| */ |
| ii = ecm_interface_lag_interface_establish(&type_info.lag, dev_name, dev_interface_num, ae_interface_num, dev_mtu); |
| goto identifier_update; |
| } |
| #endif |
| |
| #ifdef ECM_INTERFACE_GRE_ENABLE |
| /* |
| * GRE TAP? |
| */ |
| if (dev->priv_flags & (IFF_GRE_V4_TAP | IFF_GRE_V6_TAP)) { |
| /* |
| * GRE TAP interface is handled as ethernet interface, however it is possible |
| * that the acceleration engine may not be ready yet to handle the connection. |
| * In this case the acceleration engine interface is not found for this type and |
| * we should wait until it is ready. |
| */ |
| if (ae_interface_num < 0) { |
| DEBUG_TRACE("GRE interface is not ready yet\n"); |
| return NULL; |
| } |
| } |
| #endif |
| /* |
| * ETHERNET! |
| * Just plain ethernet it seems |
| */ |
| memcpy(type_info.ethernet.address, dev->dev_addr, 6); |
| DEBUG_TRACE("Net device: %p is ETHERNET, mac: %pM\n", |
| dev, type_info.ethernet.address); |
| |
| /* |
| * Establish this type of interface |
| */ |
| ii = ecm_interface_ethernet_interface_establish(&type_info.ethernet, dev_name, dev_interface_num, ae_interface_num, dev_mtu); |
| |
| identifier_update: |
| if (ii) { |
| /* |
| * An interface identifier/ifindex can be change after network restart. Below |
| * functtion will check interface_identifier present in 'ii' with new dev_interface_num. |
| * If differ then update new ifindex and update the interface identifier hash table. |
| */ |
| ecm_db_iface_identifier_hash_table_entry_check_and_update(ii, dev_interface_num); |
| } |
| |
| return ii; |
| } |
| |
| /* |
| * LOOPBACK? |
| */ |
| if (dev_type == ARPHRD_LOOPBACK) { |
| DEBUG_TRACE("Net device: %p is LOOPBACK type: %d\n", dev, dev_type); |
| type_info.loopback.os_specific_ident = dev_interface_num; |
| ii = ecm_interface_loopback_interface_establish(&type_info.loopback, dev_name, dev_interface_num, ae_interface_num, dev_mtu); |
| return ii; |
| } |
| |
| #ifdef ECM_INTERFACE_IPSEC_ENABLE |
| /* |
| * IPSEC? |
| */ |
| if (dev_type == ECM_ARPHRD_IPSEC_TUNNEL_TYPE) { |
| DEBUG_TRACE("Net device: %p is IPSec tunnel type: %d\n", dev, dev_type); |
| type_info.ipsec_tunnel.os_specific_ident = dev_interface_num; |
| |
| // GGG TODO Flesh this out with tunnel endpoint addressing detail |
| ii = ecm_interface_ipsec_tunnel_interface_establish(&type_info.ipsec_tunnel, dev_name, dev_interface_num, ae_interface_num, dev_mtu); |
| return ii; |
| } |
| #endif |
| |
| #ifdef ECM_INTERFACE_MAP_T_ENABLE |
| if (dev_type == ARPHRD_NONE) { |
| if (is_map_t_dev(dev)) { |
| type_info.map_t.if_index = dev_interface_num; |
| ii = ecm_interface_map_t_interface_establish(&type_info.map_t, dev_name, dev_interface_num, ae_interface_num, dev_mtu); |
| return ii; |
| } |
| |
| } |
| #endif |
| |
| #ifdef ECM_INTERFACE_SIT_ENABLE |
| #ifdef CONFIG_IPV6_SIT_6RD |
| /* |
| * SIT (6-in-4)? |
| */ |
| if (dev_type == ARPHRD_SIT) { |
| struct ip_tunnel *tunnel; |
| struct ip_tunnel_6rd_parm *ip6rd; |
| const struct iphdr *tiph; |
| int interface_type; |
| |
| DEBUG_TRACE("Net device: %p is SIT (6-in-4) type: %d\n", dev, dev_type); |
| |
| tunnel = (struct ip_tunnel*)netdev_priv(dev); |
| ip6rd = &tunnel->ip6rd; |
| |
| /* |
| * Get the Tunnel device IP header info |
| */ |
| tiph = &tunnel->parms.iph ; |
| |
| type_info.sit.prefixlen = ip6rd->prefixlen; |
| type_info.sit.relay_prefix = ip6rd->relay_prefix; |
| type_info.sit.relay_prefixlen = ip6rd->relay_prefixlen; |
| ECM_NIN4_ADDR_TO_IP_ADDR(type_info.sit.saddr, tiph->saddr); |
| ECM_NIN4_ADDR_TO_IP_ADDR(type_info.sit.daddr, tiph->daddr); |
| type_info.sit.prefix[0] = ntohl(ip6rd->prefix.s6_addr32[0]); |
| type_info.sit.prefix[1] = ntohl(ip6rd->prefix.s6_addr32[1]); |
| type_info.sit.prefix[2] = ntohl(ip6rd->prefix.s6_addr32[2]); |
| type_info.sit.prefix[3] = ntohl(ip6rd->prefix.s6_addr32[3]); |
| type_info.sit.ttl = tiph->ttl; |
| type_info.sit.tos = tiph->tos; |
| |
| interface_type = feci->ae_interface_type_get(feci, dev_type); |
| ae_interface_num = feci->ae_interface_number_by_dev_type_get(dev, interface_type); |
| |
| ii = ecm_interface_sit_interface_establish(&type_info.sit, dev_name, dev_interface_num, ae_interface_num, dev_mtu); |
| return ii; |
| } |
| #endif |
| #endif |
| |
| #ifdef ECM_INTERFACE_TUNIPIP6_ENABLE |
| #ifdef ECM_IPV6_ENABLE |
| /* |
| * IPIP6 Tunnel? |
| */ |
| if (dev_type == ARPHRD_TUNNEL6) { |
| struct ip6_tnl *tunnel; |
| struct flowi6 *fl6; |
| |
| DEBUG_TRACE("Net device: %p is TUNIPIP6 type: %d\n", dev, dev_type); |
| |
| /* |
| * Get the tunnel device flow information (discover the output path of the tunnel) |
| */ |
| tunnel = (struct ip6_tnl *)netdev_priv(dev); |
| fl6 = &tunnel->fl.u.ip6; |
| |
| ECM_NIN6_ADDR_TO_IP_ADDR(type_info.tunipip6.saddr, fl6->saddr); |
| ECM_NIN6_ADDR_TO_IP_ADDR(type_info.tunipip6.daddr, fl6->daddr); |
| type_info.tunipip6.hop_limit = tunnel->parms.hop_limit; |
| type_info.tunipip6.flags = ntohl(tunnel->parms.flags); |
| type_info.tunipip6.flowlabel = fl6->flowlabel; /* flow Label In kernel is stored in big endian format */ |
| |
| ii = ecm_interface_tunipip6_interface_establish(&type_info.tunipip6, dev_name, dev_interface_num, ae_interface_num, dev_mtu); |
| return ii; |
| } |
| #endif |
| #endif |
| |
| /* |
| * If this is NOT PPP then it is unknown to the ecm |
| */ |
| if (dev_type != ARPHRD_PPP) { |
| DEBUG_TRACE("Net device: %p is UNKNOWN type: %d\n", dev, dev_type); |
| type_info.unknown.os_specific_ident = dev_interface_num; |
| |
| /* |
| * Establish this type of interface |
| */ |
| ii = ecm_interface_unknown_interface_establish(&type_info.unknown, dev_name, dev_interface_num, ae_interface_num, dev_mtu); |
| return ii; |
| } |
| |
| #ifndef ECM_INTERFACE_PPP_ENABLE |
| /* |
| * PPP Support is NOT provided for. |
| * Interface is therefore unknown |
| */ |
| DEBUG_TRACE("Net device: %p is UNKNOWN (PPP Unsupported) type: %d\n", dev, dev_type); |
| type_info.unknown.os_specific_ident = dev_interface_num; |
| |
| /* |
| * Establish this type of interface |
| */ |
| ii = ecm_interface_unknown_interface_establish(&type_info.unknown, dev_name, dev_interface_num, ae_interface_num, dev_mtu); |
| return ii; |
| #else |
| |
| #ifdef ECM_INTERFACE_L2TPV2_ENABLE |
| /* |
| * ppp_xmit lock is held by linux kernel for l2tp packet in transmit |
| * direction. we need to check for l2tp packet and avoid calls to |
| * ppp_is_multilink() and ppp_hold_channels() which acquire same lock |
| */ |
| |
| if ((dev->priv_flags & IFF_PPP_L2TPV2) && ppp_is_xmit_locked(dev)) { |
| if (skb && (skb->skb_iif == dev->ifindex)) { |
| struct pppol2tp_common_addr info; |
| |
| if (__ppp_is_multilink(dev) > 0) { |
| DEBUG_TRACE("Net device: %p is MULTILINK PPP - Unknown to the ECM\n", dev); |
| type_info.unknown.os_specific_ident = dev_interface_num; |
| |
| /* |
| * Establish this type of interface |
| */ |
| ii = ecm_interface_unknown_interface_establish(&type_info.unknown, dev_name, dev_interface_num, ae_interface_num, dev_mtu); |
| return ii; |
| } |
| channel_count = __ppp_hold_channels(dev, ppp_chan, 1); |
| if (channel_count != 1) { |
| DEBUG_TRACE("Net device: %p PPP has %d channels - ECM cannot handle this (interface becomes Unknown type)\n", |
| dev, channel_count); |
| type_info.unknown.os_specific_ident = dev_interface_num; |
| |
| /* |
| * Establish this type of interface |
| */ |
| ii = ecm_interface_unknown_interface_establish(&type_info.unknown, dev_name, dev_interface_num, ae_interface_num, dev_mtu); |
| return ii; |
| } |
| |
| if (pppol2tp_channel_addressing_get(ppp_chan[0], &info)) { |
| ppp_release_channels(ppp_chan, 1); |
| return NULL; |
| } |
| |
| type_info.pppol2tpv2.l2tp.tunnel.tunnel_id = info.local_tunnel_id; |
| type_info.pppol2tpv2.l2tp.tunnel.peer_tunnel_id = info.remote_tunnel_id; |
| type_info.pppol2tpv2.l2tp.session.session_id = info.local_session_id; |
| type_info.pppol2tpv2.l2tp.session.peer_session_id = info.remote_session_id; |
| type_info.pppol2tpv2.udp.sport = ntohs(info.local_addr.sin_port); |
| type_info.pppol2tpv2.udp.dport = ntohs(info.remote_addr.sin_port); |
| type_info.pppol2tpv2.ip.saddr = ntohl(info.local_addr.sin_addr.s_addr); |
| type_info.pppol2tpv2.ip.daddr = ntohl(info.remote_addr.sin_addr.s_addr); |
| |
| /* |
| * Release the channel. Note that next_dev is still (correctly) held. |
| */ |
| ppp_release_channels(ppp_chan, 1); |
| |
| DEBUG_TRACE("Net device: %p PPPo2L2TP session: %d,n", dev, type_info.pppol2tpv2.l2tp.session.peer_session_id); |
| |
| /* |
| * Establish this type of interface |
| */ |
| ii = ecm_interface_pppol2tpv2_interface_establish(&type_info.pppol2tpv2, dev_name, dev_interface_num, ae_interface_num, dev_mtu); |
| return ii; |
| } |
| } |
| #endif |
| |
| #ifdef ECM_INTERFACE_PPTP_ENABLE |
| if ((protocol == IPPROTO_GRE) && skb && v4_hdr) { |
| struct gre_hdr_pptp *gre_hdr; |
| uint16_t proto; |
| int ret; |
| |
| skb_pull(skb, sizeof(struct iphdr)); |
| gre_hdr = (struct gre_hdr_pptp *)(skb->data); |
| proto = ntohs(gre_hdr->protocol); |
| if ((gre_hdr->version == GRE_VERSION_PPTP) && (proto == GRE_PROTOCOL_PPTP)) { |
| ret = pptp_session_find(&opt, gre_hdr->call_id, v4_hdr->daddr); |
| if (ret < 0) { |
| skb_push(skb, sizeof(struct iphdr)); |
| DEBUG_WARN("PPTP session info not found\n"); |
| return NULL; |
| } |
| |
| /* |
| * Get PPTP session info |
| */ |
| type_info.pptp.src_call_id = ntohs(opt.src_addr.call_id); |
| type_info.pptp.dst_call_id = ntohs(opt.dst_addr.call_id); |
| type_info.pptp.src_ip = ntohl(opt.src_addr.sin_addr.s_addr); |
| type_info.pptp.dst_ip = ntohl(opt.dst_addr.sin_addr.s_addr); |
| |
| skb_push(skb, sizeof(struct iphdr)); |
| |
| /* |
| * Establish this type of interface |
| */ |
| ii = ecm_interface_pptp_interface_establish(&type_info.pptp, dev_name, dev_interface_num, ae_interface_num, dev_mtu); |
| if (ii) { |
| /* |
| * The ifindex of a virtual netdevice like a PPTP session can change if it is destroyed |
| * and comes up again. Detect if the ifindex has changed and update it if required |
| */ |
| ecm_db_iface_identifier_hash_table_entry_check_and_update(ii, dev_interface_num); |
| } |
| return ii; |
| } |
| |
| skb_push(skb, sizeof(struct iphdr)); |
| |
| DEBUG_TRACE("Unknown GRE protocol \n"); |
| type_info.unknown.os_specific_ident = dev_interface_num; |
| |
| /* |
| * Establish this type of interface |
| */ |
| ii = ecm_interface_unknown_interface_establish(&type_info.unknown, dev_name, dev_interface_num, ae_interface_num, dev_mtu); |
| return ii; |
| } |
| #endif |
| |
| /* |
| * PPP - but what is the channel type? |
| * First: If this is multi-link then we do not support it |
| */ |
| if (ppp_is_multilink(dev) > 0) { |
| DEBUG_TRACE("Net device: %p is MULTILINK PPP - Unknown to the ECM\n", dev); |
| type_info.unknown.os_specific_ident = dev_interface_num; |
| |
| /* |
| * Establish this type of interface |
| */ |
| ii = ecm_interface_unknown_interface_establish(&type_info.unknown, dev_name, dev_interface_num, ae_interface_num, dev_mtu); |
| return ii; |
| } |
| |
| DEBUG_TRACE("Net device: %p is PPP\n", dev); |
| |
| /* |
| * Get the PPP channel and then enquire what kind of channel it is |
| * NOTE: Not multilink so only one channel to get. |
| */ |
| channel_count = ppp_hold_channels(dev, ppp_chan, 1); |
| if (channel_count != 1) { |
| DEBUG_TRACE("Net device: %p PPP has %d channels - ECM cannot handle this (interface becomes Unknown type)\n", |
| dev, channel_count); |
| type_info.unknown.os_specific_ident = dev_interface_num; |
| |
| /* |
| * Establish this type of interface |
| */ |
| ii = ecm_interface_unknown_interface_establish(&type_info.unknown, dev_name, dev_interface_num, ae_interface_num, dev_mtu); |
| return ii; |
| } |
| |
| /* |
| * Get channel protocol type |
| * NOTE: Not all PPP channels support channel specific methods. |
| */ |
| channel_protocol = ppp_channel_get_protocol(ppp_chan[0]); |
| |
| #ifdef ECM_INTERFACE_L2TPV2_ENABLE |
| if (channel_protocol == PX_PROTO_OL2TP) { |
| struct pppol2tp_common_addr info; |
| |
| if (pppol2tp_channel_addressing_get(ppp_chan[0], &info)) { |
| ppp_release_channels(ppp_chan, 1); |
| return NULL; |
| } |
| |
| type_info.pppol2tpv2.l2tp.tunnel.tunnel_id = info.local_tunnel_id; |
| type_info.pppol2tpv2.l2tp.tunnel.peer_tunnel_id = info.remote_tunnel_id; |
| type_info.pppol2tpv2.l2tp.session.session_id = info.local_session_id; |
| type_info.pppol2tpv2.l2tp.session.peer_session_id = info.remote_session_id; |
| type_info.pppol2tpv2.udp.sport = ntohs(info.local_addr.sin_port); |
| type_info.pppol2tpv2.udp.dport = ntohs(info.remote_addr.sin_port); |
| type_info.pppol2tpv2.ip.saddr = ntohl(info.local_addr.sin_addr.s_addr); |
| type_info.pppol2tpv2.ip.daddr = ntohl(info.remote_addr.sin_addr.s_addr); |
| |
| /* |
| * Release the channel. Note that next_dev is still (correctly) held. |
| */ |
| ppp_release_channels(ppp_chan, 1); |
| |
| DEBUG_TRACE("Net device: %p PPPo2L2TP session: %d,n", dev, type_info.pppol2tpv2.l2tp.session.peer_session_id); |
| |
| /* |
| * Establish this type of interface |
| */ |
| ii = ecm_interface_pppol2tpv2_interface_establish(&type_info.pppol2tpv2, dev_name, dev_interface_num, ae_interface_num, dev_mtu); |
| return ii; |
| } |
| #endif |
| #ifdef ECM_INTERFACE_PPPOE_ENABLE |
| if (channel_protocol == PX_PROTO_OE) { |
| |
| /* |
| * PPPoE channel |
| */ |
| DEBUG_TRACE("Net device: %p PPP channel is PPPoE\n", dev); |
| |
| /* |
| * Get PPPoE session information and the underlying device it is using. |
| */ |
| pppoe_channel_addressing_get(ppp_chan[0], &addressing); |
| type_info.pppoe.pppoe_session_id = (uint16_t)ntohs((uint16_t)addressing.pa.sid); |
| memcpy(type_info.pppoe.remote_mac, addressing.pa.remote, ETH_ALEN); |
| dev_put(addressing.dev); |
| |
| /* |
| * Release the channel. Note that next_dev is still (correctly) held. |
| */ |
| ppp_release_channels(ppp_chan, 1); |
| |
| DEBUG_TRACE("Net device: %p PPPoE session: %x, remote mac: %pM\n", |
| dev, type_info.pppoe.pppoe_session_id, type_info.pppoe.remote_mac); |
| |
| /* |
| * Establish this type of interface |
| */ |
| ii = ecm_interface_pppoe_interface_establish(&type_info.pppoe, dev_name, dev_interface_num, ae_interface_num, dev_mtu); |
| return ii; |
| } |
| #endif |
| |
| #ifdef ECM_INTERFACE_PPTP_ENABLE |
| if (channel_protocol == PX_PROTO_PPTP) { |
| pptp_channel_addressing_get(&opt, ppp_chan[0]); |
| |
| /* |
| * Get PPTP session info |
| */ |
| type_info.pptp.src_call_id = ntohs(opt.src_addr.call_id); |
| type_info.pptp.dst_call_id = ntohs(opt.dst_addr.call_id); |
| type_info.pptp.src_ip = ntohl(opt.src_addr.sin_addr.s_addr); |
| type_info.pptp.dst_ip = ntohl(opt.dst_addr.sin_addr.s_addr); |
| |
| DEBUG_TRACE("Net device: %p PPTP source call id: %d,n", dev, type_info.pptp.src_call_id); |
| ppp_release_channels(ppp_chan, 1); |
| |
| /* |
| * Establish this type of interface |
| */ |
| ii = ecm_interface_pptp_interface_establish(&type_info.pptp, dev_name, dev_interface_num, ae_interface_num, dev_mtu); |
| if (ii) { |
| /* |
| * The ifindex of a virtual netdevice like a PPTP session can change if it is destroyed |
| * and comes up again. Detect if the ifindex has changed and update it if required |
| */ |
| ecm_db_iface_identifier_hash_table_entry_check_and_update(ii, dev_interface_num); |
| } |
| return ii; |
| } |
| #endif |
| DEBUG_TRACE("Net device: %p PPP channel protocol: %d - Unknown to the ECM\n", dev, channel_protocol); |
| type_info.unknown.os_specific_ident = dev_interface_num; |
| |
| /* |
| * Release the channel |
| */ |
| ppp_release_channels(ppp_chan, 1); |
| |
| /* |
| * Establish this type of interface |
| */ |
| ii = ecm_interface_unknown_interface_establish(&type_info.unknown, dev_name, dev_interface_num, ae_interface_num, dev_mtu); |
| return ii; |
| #endif |
| } |
| EXPORT_SYMBOL(ecm_interface_establish_and_ref); |
| |
| #ifdef ECM_MULTICAST_ENABLE |
| /* |
| * ecm_interface_multicast_heirarchy_construct_single() |
| * Create and return an interface heirarchy for a single interface for a multicast connection |
| * |
| * src_addr IP source address |
| * dest_addr IP Destination address/Group Address |
| * interface Pointer to a single multicast interface heirarchy |
| * given_dest_dev Netdev pointer for destination interface |
| * br_slave_dev Netdev pointer to a bridge slave device. It could be NULL in case of pure |
| * routed flow without any bridge interface in destination dev list. |
| * skb sk_buff |
| */ |
| static uint32_t ecm_interface_multicast_heirarchy_construct_single(struct ecm_front_end_connection_instance *feci, ip_addr_t src_addr, |
| ip_addr_t dest_addr, struct ecm_db_iface_instance *interface, |
| struct net_device *given_dest_dev, struct net_device *br_slave_dev, |
| uint8_t *src_node_addr, bool is_routed, __be16 *layer4hdr, struct sk_buff *skb) |
| { |
| struct ecm_db_iface_instance *to_list_single[ECM_DB_IFACE_HEIRARCHY_MAX]; |
| struct ecm_db_iface_instance **ifaces; |
| struct ecm_db_iface_instance *ii_temp; |
| struct net_device *dest_dev; |
| int32_t current_interface_index; |
| int32_t interfaces_cnt = 0; |
| int32_t dest_dev_type; |
| |
| dest_dev = given_dest_dev; |
| dev_hold(dest_dev); |
| dest_dev_type = dest_dev->type; |
| current_interface_index = ECM_DB_IFACE_HEIRARCHY_MAX; |
| |
| while (current_interface_index > 0) { |
| struct ecm_db_iface_instance *ii; |
| struct net_device *next_dev; |
| |
| /* |
| * Get the ecm db interface instance for the device at hand |
| */ |
| ii = ecm_interface_establish_and_ref(feci, dest_dev, skb); |
| interfaces_cnt++; |
| |
| /* |
| * If the interface could not be established then we abort |
| */ |
| if (!ii) { |
| DEBUG_WARN("Failed to establish interface: %p, name: %s\n", dest_dev, dest_dev->name); |
| dev_put(dest_dev); |
| |
| /* |
| * Release the interfaces heirarchy we constructed to this point. |
| */ |
| ecm_db_multicast_copy_if_heirarchy(to_list_single, interface); |
| ecm_db_connection_interfaces_deref(to_list_single, current_interface_index); |
| return ECM_DB_IFACE_HEIRARCHY_MAX; |
| } |
| |
| /* |
| * Record the interface instance into the *ifaces |
| */ |
| current_interface_index--; |
| ii_temp = ecm_db_multicast_if_instance_get_at_index(interface, current_interface_index); |
| ifaces = (struct ecm_db_iface_instance **)ii_temp; |
| *ifaces = ii; |
| |
| /* |
| * Now we have to figure out what the next device will be (in the transmission path) |
| */ |
| do { |
| #ifdef ECM_INTERFACE_PPP_ENABLE |
| int channel_count; |
| struct ppp_channel *ppp_chan[1]; |
| int channel_protocol; |
| struct pppoe_opt addressing; |
| #endif |
| DEBUG_TRACE("Net device: %p is type: %d, name: %s\n", dest_dev, dest_dev_type, dest_dev->name); |
| next_dev = NULL; |
| |
| if (dest_dev_type == ARPHRD_ETHER) { |
| /* |
| * Ethernet - but what sub type? |
| */ |
| |
| /* |
| * VLAN? |
| */ |
| if (is_vlan_dev(dest_dev)) { |
| /* |
| * VLAN master |
| * No locking needed here, ASSUMPTION is that real_dev is held for as long as we have dev. |
| */ |
| next_dev = ecm_interface_vlan_real_dev(dest_dev); |
| dev_hold(next_dev); |
| DEBUG_TRACE("Net device: %p is VLAN, slave dev: %p (%s)\n", |
| dest_dev, next_dev, next_dev->name); |
| break; |
| } |
| |
| /* |
| * BRIDGE? |
| */ |
| if (ecm_front_end_is_bridge_device(dest_dev)) { |
| if (!ecm_front_end_is_bridge_port(br_slave_dev)) { |
| DEBUG_ASSERT(NULL, "%p: expected only bridge slave here\n", interface); |
| |
| /* |
| * Release the interfaces heirarchy we constructed to this point. |
| */ |
| ecm_db_multicast_copy_if_heirarchy(to_list_single, interface); |
| ecm_db_connection_interfaces_deref(to_list_single, current_interface_index); |
| dev_put(dest_dev); |
| return ECM_DB_IFACE_HEIRARCHY_MAX; |
| } |
| |
| next_dev = br_slave_dev; |
| if (!next_dev) { |
| DEBUG_WARN("Unable to obtain output port \n"); |
| |
| /* |
| * Release the interfaces heirarchy we constructed to this point. |
| */ |
| ecm_db_multicast_copy_if_heirarchy(to_list_single, interface); |
| ecm_db_connection_interfaces_deref(to_list_single, current_interface_index); |
| dev_put(dest_dev); |
| return ECM_DB_IFACE_HEIRARCHY_MAX; |
| } |
| DEBUG_TRACE("Net device: %p is BRIDGE, next_dev: %p (%s)\n", dest_dev, next_dev, next_dev->name); |
| dev_hold(next_dev); |
| break; |
| } |
| |
| #ifdef ECM_INTERFACE_BOND_ENABLE |
| /* |
| * LAG? |
| */ |
| if (ecm_front_end_is_lag_master(dest_dev)) { |
| /* |
| * Link aggregation |
| * Figure out which slave device of the link aggregation will be used to reach the destination. |
| */ |
| uint32_t src_addr_32 = 0; |
| uint32_t dest_addr_32 = 0; |
| struct in6_addr src_addr6; |
| struct in6_addr dest_addr6; |
| uint8_t src_mac_addr[ETH_ALEN]; |
| uint8_t dest_mac_addr[ETH_ALEN]; |
| |
| memset(src_mac_addr, 0, ETH_ALEN); |
| memset(dest_mac_addr, 0, ETH_ALEN); |
| |
| if (ECM_IP_ADDR_IS_V4(src_addr)) { |
| ECM_IP_ADDR_TO_NIN4_ADDR(src_addr_32, src_addr); |
| ECM_IP_ADDR_TO_NIN4_ADDR(dest_addr_32, dest_addr); |
| } |
| |
| if (!is_routed) { |
| memcpy(src_mac_addr, src_node_addr, ETH_ALEN); |
| } else { |
| struct net_device *dest_dev_master; |
| |
| /* |
| * Use appropriate source MAC address for routed packets |
| */ |
| dest_dev_master = ecm_interface_get_and_hold_dev_master(dest_dev); |
| if (dest_dev_master) { |
| memcpy(src_mac_addr, dest_dev_master->dev_addr, ETH_ALEN); |
| dev_put(dest_dev_master); |
| } else { |
| memcpy(src_mac_addr, dest_dev->dev_addr, ETH_ALEN); |
| } |
| } |
| |
| /* |
| * Create Destination MAC address using IP multicast destination address |
| */ |
| ecm_translate_multicast_mac(dest_addr, dest_mac_addr); |
| |
| if (ECM_IP_ADDR_IS_V4(src_addr)) { |
| next_dev = bond_get_tx_dev(NULL, src_mac_addr, dest_mac_addr, |
| &src_addr_32, &dest_addr_32, |
| htons((uint16_t)ETH_P_IP), dest_dev, layer4hdr); |
| } else { |
| ECM_IP_ADDR_TO_NIN6_ADDR(src_addr6, src_addr); |
| ECM_IP_ADDR_TO_NIN6_ADDR(dest_addr6, dest_addr); |
| next_dev = bond_get_tx_dev(NULL, src_mac_addr, dest_mac_addr, |
| src_addr6.s6_addr, dest_addr6.s6_addr, |
| htons((uint16_t)ETH_P_IPV6), dest_dev, layer4hdr); |
| } |
| |
| if (!(next_dev && netif_carrier_ok(next_dev))) { |
| DEBUG_WARN("Unable to obtain LAG output slave device\n"); |
| dev_put(dest_dev); |
| |
| /* |
| * Release the interfaces heirarchy we constructed to this point. |
| */ |
| ecm_db_multicast_copy_if_heirarchy(to_list_single, interface); |
| ecm_db_connection_interfaces_deref(to_list_single, current_interface_index); |
| return ECM_DB_IFACE_HEIRARCHY_MAX; |
| } |
| |
| dev_hold(next_dev); |
| DEBUG_TRACE("Net device: %p is LAG, slave dev: %p (%s)\n", dest_dev, next_dev, next_dev->name); |
| break; |
| } |
| #endif |
| |
| /* |
| * ETHERNET! |
| * Just plain ethernet it seems. |
| */ |
| DEBUG_TRACE("Net device: %p is ETHERNET\n", dest_dev); |
| break; |
| } |
| |
| /* |
| * LOOPBACK? |
| */ |
| if (dest_dev_type == ARPHRD_LOOPBACK) { |
| DEBUG_TRACE("Net device: %p is LOOPBACK type: %d\n", dest_dev, dest_dev_type); |
| break; |
| } |
| |
| /* |
| * IPSEC? |
| */ |
| if (dest_dev_type == ECM_ARPHRD_IPSEC_TUNNEL_TYPE) { |
| DEBUG_TRACE("Net device: %p is IPSec tunnel type: %d\n", dest_dev, dest_dev_type); |
| /* |
| * TODO Figure out the next device the tunnel is using... |
| */ |
| break; |
| } |
| |
| /* |
| * SIT (6-in-4)? |
| */ |
| if (dest_dev_type == ARPHRD_SIT) { |
| DEBUG_TRACE("Net device: %p is SIT (6-in-4) type: %d\n", dest_dev, dest_dev_type); |
| /* |
| * TODO Figure out the next device the tunnel is using... |
| */ |
| break; |
| } |
| |
| /* |
| * IPIP6 Tunnel? |
| */ |
| if (dest_dev_type == ARPHRD_TUNNEL6) { |
| DEBUG_TRACE("Net device: %p is TUNIPIP6 type: %d\n", dest_dev, dest_dev_type); |
| /* |
| * TODO Figure out the next device the tunnel is using... |
| */ |
| break; |
| } |
| |
| /* |
| * If this is NOT PPP then it is unknown to the ecm and we cannot figure out it's next device. |
| */ |
| if (dest_dev_type != ARPHRD_PPP) { |
| DEBUG_TRACE("Net device: %p is UNKNOWN type: %d\n", dest_dev, dest_dev_type); |
| break; |
| } |
| |
| #ifndef ECM_INTERFACE_PPP_ENABLE |
| DEBUG_TRACE("Net device: %p is UNKNOWN (PPP Unsupported) type: %d\n", dest_dev, dest_dev_type); |
| #else |
| /* |
| * PPP - but what is the channel type? |
| * First: If this is multi-link then we do not support it |
| */ |
| if (ppp_is_multilink(dest_dev) > 0) { |
| DEBUG_TRACE("Net device: %p is MULTILINK PPP - Unknown to the ECM\n", dest_dev); |
| break; |
| } |
| |
| DEBUG_TRACE("Net device: %p is PPP\n", dest_dev); |
| |
| /* |
| * Get the PPP channel and then enquire what kind of channel it is |
| * NOTE: Not multilink so only one channel to get. |
| */ |
| channel_count = ppp_hold_channels(dest_dev, ppp_chan, 1); |
| if (channel_count != 1) { |
| DEBUG_TRACE("Net device: %p PPP has %d channels - Unknown to the ECM\n", |
| dest_dev, channel_count); |
| break; |
| } |
| |
| /* |
| * Get channel protocol type |
| * NOTE: Not all PPP channels support channel specific methods. |
| */ |
| channel_protocol = ppp_channel_get_protocol(ppp_chan[0]); |
| if (channel_protocol != PX_PROTO_OE) { |
| DEBUG_TRACE("Net device: %p PPP channel protocol: %d - Unknown to the ECM\n", |
| dest_dev, channel_protocol); |
| |
| /* |
| * Release the channel |
| */ |
| ppp_release_channels(ppp_chan, 1); |
| |
| break; |
| } |
| |
| /* |
| * PPPoE channel |
| */ |
| DEBUG_TRACE("Net device: %p PPP channel is PPPoE\n", dest_dev); |
| |
| /* |
| * Get PPPoE session information and the underlying device it is using. |
| */ |
| pppoe_channel_addressing_get(ppp_chan[0], &addressing); |
| |
| /* |
| * Copy the dev hold into this, we will release the hold later |
| */ |
| next_dev = addressing.dev; |
| |
| /* |
| * Release the channel. Note that next_dev is still (correctly) held. |
| */ |
| ppp_release_channels(ppp_chan, 1); |
| #endif |
| } while (false); |
| |
| /* |
| * No longer need dest_dev as it may become next_dev |
| */ |
| dev_put(dest_dev); |
| |
| /* |
| * Check out the next_dev, if any |
| */ |
| if (!next_dev) { |
| int32_t i __attribute__((unused)); |
| DEBUG_INFO("Completed interface heirarchy construct with first interface @: %d\n", current_interface_index); |
| #if DEBUG_LEVEL > 1 |
| ecm_db_multicast_copy_if_heirarchy(to_list_single, interface); |
| for (i = current_interface_index; i < ECM_DB_IFACE_HEIRARCHY_MAX; ++i) { |
| DEBUG_TRACE("\tInterface @ %d: %p, type: %d, name: %s\n", \ |
| i, to_list_single[i], ecm_db_connection_iface_type_get(to_list_single[i]), \ |
| ecm_db_interface_type_to_string(ecm_db_connection_iface_type_get(to_list_single[i]))); |
| } |
| #endif |
| return current_interface_index; |
| } |
| |
| /* |
| * dest_dev becomes next_dev |
| */ |
| dest_dev = next_dev; |
| dest_dev_type = dest_dev->type; |
| } |
| |
| dev_put(dest_dev); |
| |
| ecm_db_multicast_copy_if_heirarchy(to_list_single, interface); |
| ecm_db_connection_interfaces_deref(to_list_single, current_interface_index); |
| return ECM_DB_IFACE_HEIRARCHY_MAX; |
| } |
| |
| /* |
| * ecm_interface_multicast_heirarchy_construct_routed() |
| * Create destination interface heirarchy for a routed multicast connectiona |
| * |
| * interfaces Pointer to the 2-D array of multicast interface heirarchies |
| * in_dev Pointer to the source netdev |
| * packet_src_addr Source IP of the multicast flow |
| * packet_dest_addr Group(dest) IP of the multicast flow |
| * max_dst Maximum number of netdev joined the multicast group |
| * dst_if_index_base An array of if index joined the multicast group |
| * interface_first_base An array of the index of the first interface in the list |
| */ |
| int32_t ecm_interface_multicast_heirarchy_construct_routed(struct ecm_front_end_connection_instance *feci, |
| struct ecm_db_iface_instance *interfaces, |
| struct net_device *in_dev, |
| ip_addr_t packet_src_addr, |
| ip_addr_t packet_dest_addr, uint8_t max_if, |
| uint32_t *dst_if_index_base, |
| uint32_t *interface_first_base, bool mfc_update, |
| __be16 *layer4hdr, struct sk_buff *skb) |
| { |
| struct ecm_db_iface_instance *to_list_single[ECM_DB_IFACE_HEIRARCHY_MAX]; |
| struct ecm_db_iface_instance *ifaces; |
| struct net_device *dest_dev = NULL; |
| struct net_device *br_dev_src = NULL; |
| uint32_t *dst_if_index; |
| uint32_t *interface_first; |
| uint32_t br_if; |
| uint32_t valid_if; |
| int32_t if_num; |
| int32_t dest_dev_type; |
| int if_index; |
| int ii_cnt; |
| int total_ii_count = 0; |
| bool src_dev_is_bridge = false; |
| |
| DEBUG_TRACE("Construct interface heirarchy for dest_addr: " ECM_IP_ADDR_DOT_FMT " src_addr: " ECM_IP_ADDR_DOT_FMT "total destination ifs %d\n", |
| ECM_IP_ADDR_TO_DOT(packet_dest_addr), ECM_IP_ADDR_TO_DOT(packet_src_addr), max_if); |
| |
| /* |
| * Check if the source net_dev is a bridge slave. |
| */ |
| if (in_dev && !mfc_update) { |
| if (ecm_front_end_is_bridge_port(in_dev)) { |
| src_dev_is_bridge = true; |
| br_dev_src = ecm_interface_get_and_hold_dev_master(in_dev); |
| DEBUG_ASSERT(br_dev_src, "Expected a master\n"); |
| |
| /* |
| * The source net_dev found as bridge slave. In case of routed interface |
| * heirarchy MFC is not aware of any other bridge slave has joined the same |
| * multicast group as a destination interface. Therfore we assume there |
| * are bridge slaves present in multicast destination interface list |
| * and increase the max_if by one. |
| */ |
| max_if++; |
| } |
| } |
| |
| ii_cnt = 0; |
| br_if = if_num = 0; |
| |
| /* |
| * This loop is for creating the destination interface hierarchy list. |
| * We take the destination interface array we got from MFC (in form of ifindex array) |
| * as input for this. |
| */ |
| for (if_index = 0, valid_if = 0; if_index < max_if; if_index++) { |
| dst_if_index = ecm_db_multicast_if_first_get_at_index(dst_if_index_base, if_index); |
| |
| if (*dst_if_index == ECM_INTERFACE_LOOPBACK_DEV_INDEX) { |
| continue; |
| } |
| |
| dest_dev = dev_get_by_index(&init_net, *dst_if_index); |
| if (!dest_dev) { |
| if (!src_dev_is_bridge) { |
| int i; |
| |
| /* |
| * If already constructed any interface heirarchies before hitting |
| * this error condition then Deref all interface heirarchies. |
| */ |
| if (valid_if > 0) { |
| for (i = 0; i < valid_if; i++) { |
| ifaces = ecm_db_multicast_if_heirarchy_get(interfaces, i); |
| ecm_db_multicast_copy_if_heirarchy(to_list_single, ifaces); |
| ecm_db_connection_interfaces_deref(to_list_single, interface_first_base[i]); |
| } |
| } |
| |
| /* |
| * If valid netdev not found, Return 0 |
| */ |
| return 0; |
| } |
| |
| dest_dev = br_dev_src; |
| |
| } |
| |
| dest_dev_type = dest_dev->type; |
| |
| if (ecm_front_end_is_bridge_device(dest_dev)) { |
| struct net_device *mc_br_slave_dev = NULL; |
| uint32_t mc_max_dst = ECM_DB_MULTICAST_IF_MAX; |
| uint32_t mc_dst_if_index[ECM_DB_MULTICAST_IF_MAX]; |
| |
| if (ECM_IP_ADDR_IS_V4(packet_src_addr)) { |
| if_num = mc_bridge_ipv4_get_if(dest_dev, htonl((packet_src_addr[0])), htonl(packet_dest_addr[0]), mc_max_dst, mc_dst_if_index); |
| } else { |
| struct in6_addr origin6; |
| struct in6_addr group6; |
| ECM_IP_ADDR_TO_NIN6_ADDR(origin6, packet_src_addr); |
| ECM_IP_ADDR_TO_NIN6_ADDR(group6, packet_dest_addr); |
| if_num = mc_bridge_ipv6_get_if(dest_dev, &origin6, &group6, mc_max_dst, mc_dst_if_index); |
| } |
| |
| if ((if_num < 0) || (if_num > ECM_DB_MULTICAST_IF_MAX)) { |
| int i; |
| DEBUG_WARN("MCS is not ready\n"); |
| |
| /* |
| * If already constructed any interface heirarchies before hitting |
| * this error condition then Deref all interface heirarchies. |
| */ |
| if (valid_if > 0) { |
| for (i = 0; i < valid_if; i++) { |
| ifaces = ecm_db_multicast_if_heirarchy_get(interfaces, i); |
| ecm_db_multicast_copy_if_heirarchy(to_list_single, ifaces); |
| ecm_db_connection_interfaces_deref(to_list_single, interface_first_base[i]); |
| } |
| } |
| |
| dev_put(dest_dev); |
| return 0; |
| } |
| |
| if (in_dev && !mfc_update) { |
| if_num = ecm_interface_multicast_check_for_src_ifindex(mc_dst_if_index, if_num, in_dev->ifindex); |
| } |
| |
| for (br_if = 0; br_if < if_num; br_if++) { |
| mc_br_slave_dev = dev_get_by_index(&init_net, mc_dst_if_index[br_if]); |
| if (!mc_br_slave_dev) { |
| continue; |
| } |
| |
| if ((valid_if + br_if) > ECM_DB_MULTICAST_IF_MAX) { |
| int i; |
| |
| /* |
| * If already constructed any interface heirarchies before hitting |
| * this error condition then Deref all interface heirarchies. |
| */ |
| for (i = 0; i < (valid_if + br_if); i++) { |
| ifaces = ecm_db_multicast_if_heirarchy_get(interfaces, i); |
| ecm_db_multicast_copy_if_heirarchy(to_list_single, ifaces); |
| ecm_db_connection_interfaces_deref(to_list_single, interface_first_base[i]); |
| } |
| |
| dev_put(dest_dev); |
| dev_put(mc_br_slave_dev); |
| return 0; |
| } |
| |
| ifaces = ecm_db_multicast_if_heirarchy_get(interfaces, valid_if + br_if); |
| /* |
| * Construct a single interface heirarchy of a multicast dev. |
| */ |
| ii_cnt = ecm_interface_multicast_heirarchy_construct_single(feci, packet_src_addr, packet_dest_addr, ifaces, dest_dev, mc_br_slave_dev, NULL, true, layer4hdr, skb); |
| if (ii_cnt == ECM_DB_IFACE_HEIRARCHY_MAX) { |
| |
| /* |
| * If already constructed any interface heirarchies before hitting |
| * this error condition then Deref all interface heirarchies. |
| */ |
| if ((valid_if + br_if) > 0) { |
| int i; |
| for (i = 0; i < (valid_if + br_if); i++) { |
| ifaces = ecm_db_multicast_if_heirarchy_get(interfaces, i); |
| ecm_db_multicast_copy_if_heirarchy(to_list_single, ifaces); |
| ecm_db_connection_interfaces_deref(to_list_single, interface_first_base[i]); |
| } |
| } |
| |
| dev_put(dest_dev); |
| dev_put(mc_br_slave_dev); |
| return 0; |
| } |
| |
| interface_first = ecm_db_multicast_if_first_get_at_index(interface_first_base, (valid_if + br_if)); |
| *interface_first = ii_cnt; |
| total_ii_count += ii_cnt; |
| dev_put(mc_br_slave_dev); |
| } |
| |
| valid_if += br_if; |
| |
| } else { |
| |
| DEBUG_ASSERT(valid_if < ECM_DB_MULTICAST_IF_MAX, "Bad array index size %d\n", valid_if); |
| ifaces = ecm_db_multicast_if_heirarchy_get(interfaces, valid_if); |
| /* |
| * Construct a single interface heirarchy of a multicast dev. |
| */ |
| ii_cnt = ecm_interface_multicast_heirarchy_construct_single(feci, packet_src_addr, packet_dest_addr, ifaces, dest_dev, NULL, NULL, true, layer4hdr, skb); |
| if (ii_cnt == ECM_DB_IFACE_HEIRARCHY_MAX) { |
| |
| /* |
| * If already constructed any interface heirarchies before hitting |
| * this error condition then Deref all interface heirarchies. |
| */ |
| if (valid_if > 0) { |
| int i; |
| for (i = 0; i < valid_if; i++) { |
| ifaces = ecm_db_multicast_if_heirarchy_get(interfaces, i); |
| ecm_db_multicast_copy_if_heirarchy(to_list_single, ifaces); |
| ecm_db_connection_interfaces_deref(to_list_single, interface_first_base[i]); |
| } |
| } |
| |
| dev_put(dest_dev); |
| return 0; |
| } |
| |
| interface_first = ecm_db_multicast_if_first_get_at_index(interface_first_base, valid_if); |
| *interface_first = ii_cnt; |
| total_ii_count += ii_cnt; |
| valid_if++; |
| } |
| |
| dev_put(dest_dev); |
| } |
| return total_ii_count; |
| } |
| EXPORT_SYMBOL(ecm_interface_multicast_heirarchy_construct_routed); |
| |
| /* |
| * ecm_interface_multicast_heirarchy_construct_bridged() |
| * This function called when the Hyfi bridge snooper has IGMP/IMLD updates, this function |
| * creates destination interface heirarchy for a bridged multicast connection. |
| * |
| * interfaces Pointer to the 2-D array of multicast interface heirarchies |
| * dest_dev Pointer to the destination dev, here dest_dev is always a bridge type |
| * packet_src_addr Source IP of the multicast flow |
| * packet_dest_addr Group(dest) IP of the multicast flow |
| * mc_max_dst Maximum number of bridge slaves joined the multicast group |
| * mc_dst_if_index_base An array of if index joined the multicast group |
| * interface_first_base An array of the index of the first interface in the list |
| */ |
| int32_t ecm_interface_multicast_heirarchy_construct_bridged(struct ecm_front_end_connection_instance *feci, |
| struct ecm_db_iface_instance *interfaces, struct net_device *dest_dev, |
| ip_addr_t packet_src_addr, ip_addr_t packet_dest_addr, uint8_t mc_max_dst, |
| int *mc_dst_if_index_base, uint32_t *interface_first_base, uint8_t *src_node_addr, |
| __be16 *layer4hdr, struct sk_buff *skb) |
| { |
| struct ecm_db_iface_instance *to_list_single[ECM_DB_IFACE_HEIRARCHY_MAX]; |
| struct ecm_db_iface_instance *ifaces; |
| struct net_device *mc_br_slave_dev = NULL; |
| uint32_t *interface_first; |
| int *mc_dst_if_index; |
| int valid_if; |
| int ii_cnt = 0; |
| int br_if; |
| int total_ii_cnt = 0; |
| |
| /* |
| * Go through the newly joined interface index one by one and |
| * create an interface heirarchy for each valid interface. |
| */ |
| for (br_if = 0, valid_if = 0; br_if < mc_max_dst; br_if++) { |
| mc_dst_if_index = (int *)ecm_db_multicast_if_num_get_at_index(mc_dst_if_index_base, br_if); |
| mc_br_slave_dev = dev_get_by_index(&init_net, *mc_dst_if_index); |
| if (!mc_br_slave_dev) { |
| |
| /* |
| * If already constructed any interface heirarchies before hitting |
| * this error condition then Deref all interface heirarchies. |
| */ |
| if (valid_if > 0) { |
| int i; |
| for (i = 0; i < valid_if; i++) { |
| ifaces = ecm_db_multicast_if_heirarchy_get(interfaces, i); |
| ecm_db_multicast_copy_if_heirarchy(to_list_single, ifaces); |
| ecm_db_connection_interfaces_deref(to_list_single, interface_first_base[i]); |
| } |
| } |
| |
| /* |
| * If valid netdev not found, Return 0 |
| */ |
| return 0; |
| } |
| |
| if (valid_if > ECM_DB_MULTICAST_IF_MAX) { |
| int i; |
| |
| /* |
| * If already constructed any interface heirarchies before hitting |
| * this error condition then Deref all interface heirarchies. |
| */ |
| for (i = 0; i < valid_if; i++) { |
| ifaces = ecm_db_multicast_if_heirarchy_get(interfaces, i); |
| ecm_db_multicast_copy_if_heirarchy(to_list_single, ifaces); |
| ecm_db_connection_interfaces_deref(to_list_single, interface_first_base[i]); |
| } |
| |
| dev_put(mc_br_slave_dev); |
| return 0; |
| } |
| |
| ifaces = ecm_db_multicast_if_heirarchy_get(interfaces, valid_if); |
| |
| /* |
| * Construct a single interface heirarchy of a multicast dev. |
| */ |
| ii_cnt = ecm_interface_multicast_heirarchy_construct_single(feci, packet_src_addr, packet_dest_addr, ifaces, dest_dev, mc_br_slave_dev, src_node_addr, false, layer4hdr, skb); |
| if (ii_cnt == ECM_DB_IFACE_HEIRARCHY_MAX) { |
| |
| /* |
| * If already constructed any interface heirarchies before hitting |
| * this error condition then Deref all interface heirarchies. |
| */ |
| if (valid_if > 0) { |
| int i; |
| for (i = 0; i < valid_if; i++) { |
| ifaces = ecm_db_multicast_if_heirarchy_get(interfaces, i); |
| ecm_db_multicast_copy_if_heirarchy(to_list_single, ifaces); |
| ecm_db_connection_interfaces_deref(to_list_single, interface_first_base[i]); |
| } |
| } |
| |
| dev_put(mc_br_slave_dev); |
| return 0; |
| } |
| |
| interface_first = ecm_db_multicast_if_first_get_at_index(interface_first_base, valid_if); |
| *interface_first = ii_cnt; |
| total_ii_cnt += ii_cnt; |
| valid_if++; |
| dev_put(mc_br_slave_dev); |
| } |
| |
| return valid_if; |
| } |
| EXPORT_SYMBOL(ecm_interface_multicast_heirarchy_construct_bridged); |
| |
| /* |
| * ecm_interface_multicast_get_next_node_mac_address() |
| * Get the MAC address of the next node for multicast flows |
| * |
| * TODO: This function will be removed when the multicast flow code |
| * is fixed to use the new interface hierarchy construction model. |
| * |
| */ |
| static bool ecm_interface_multicast_get_next_node_mac_address( |
| ip_addr_t dest_addr, struct net_device *dest_dev, int ip_version, |
| uint8_t *mac_addr) |
| { |
| bool on_link; |
| ip_addr_t gw_addr = ECM_IP_ADDR_NULL; |
| |
| if (!ecm_interface_mac_addr_get(dest_addr, mac_addr, &on_link, gw_addr)) { |
| if (ip_version == 4) { |
| DEBUG_WARN("Unable to obtain MAC address for " ECM_IP_ADDR_DOT_FMT "\n", |
| ECM_IP_ADDR_TO_DOT(dest_addr)); |
| ecm_interface_send_arp_request(dest_dev, dest_addr, on_link, gw_addr); |
| } |
| #ifdef ECM_IPV6_ENABLE |
| if (ip_version == 6) { |
| DEBUG_WARN("Unable to obtain MAC address for " ECM_IP_ADDR_OCTAL_FMT "\n", |
| ECM_IP_ADDR_TO_OCTAL(dest_addr)); |
| ecm_interface_send_neighbour_solicitation(dest_dev, dest_addr); |
| } |
| #endif |
| return false; |
| } |
| |
| return true; |
| } |
| #endif |
| |
| /* |
| * ecm_interface_get_next_node_mac_address() |
| * Get the MAC address of the next node |
| */ |
| static bool ecm_interface_get_next_node_mac_address( |
| ip_addr_t dest_addr, struct net_device *dest_dev, int ip_version, |
| uint8_t *mac_addr) |
| { |
| if (!ecm_interface_mac_addr_get_no_route(dest_dev, dest_addr, mac_addr)) { |
| /* |
| * MAC address look up failed. The host IP address may not be in the |
| * neighbour table. So, let's send an ARP or neighbour solicitation |
| * request to this host IP address, so in the subsequent lookups it can be |
| * found. |
| */ |
| if (ip_version == 4) { |
| ip_addr_t gw_addr = ECM_IP_ADDR_NULL; |
| bool on_link = true; |
| |
| DEBUG_WARN("Unable to obtain MAC address for " ECM_IP_ADDR_DOT_FMT " send ARP request\n", |
| ECM_IP_ADDR_TO_DOT(dest_addr)); |
| |
| if (ecm_interface_find_gateway(dest_addr, gw_addr)) { |
| on_link = false; |
| } |
| |
| if (ecm_interface_mac_addr_get_no_route(dest_dev, gw_addr, mac_addr)) { |
| DEBUG_TRACE("Found the mac address for gateway\n"); |
| return true; |
| } |
| |
| ecm_interface_send_arp_request(dest_dev, dest_addr, on_link, gw_addr); |
| } |
| #ifdef ECM_IPV6_ENABLE |
| if (ip_version == 6) { |
| DEBUG_WARN("Unable to obtain MAC address for " ECM_IP_ADDR_OCTAL_FMT " send neighbour solicitation request\n", |
| ECM_IP_ADDR_TO_OCTAL(dest_addr)); |
| ecm_interface_send_neighbour_solicitation(dest_dev, dest_addr); |
| } |
| #endif |
| return false; |
| } |
| |
| return true; |
| } |
| |
| /* |
| * ecm_interface_should_update_egress_device_bridged() |
| * Determine if the egress port should be re-evaluated in the bridged case |
| * |
| * This will be done if: |
| * - The egress port is the one provided from the front-end |
| * - The egress port is not a bridge, but is a slave of the bridge |
| * - Not routed |
| * |
| * If these conditions hold, this function will hold a reference to the bridge |
| * port and return it to the caller. Otherwise no reference will be held and |
| * it will return NULL. |
| */ |
| static struct net_device *ecm_interface_should_update_egress_device_bridged( |
| struct net_device *given_dest_dev, struct net_device *dest_dev, |
| bool is_routed) |
| { |
| struct net_device *bridge; |
| |
| /* |
| * Determine if we should attempt to fetch the bridge device |
| */ |
| if (!given_dest_dev || is_routed || (dest_dev != given_dest_dev) || |
| ecm_front_end_is_bridge_device(given_dest_dev)) |
| return NULL; |
| |
| bridge = ecm_interface_get_and_hold_dev_master(given_dest_dev); |
| |
| if (!bridge) |
| return NULL; |
| |
| if (!ecm_front_end_is_bridge_device(bridge)) { |
| /* |
| * Master is not a bridge - free the reference and return |
| */ |
| dev_put(bridge); |
| return NULL; |
| } |
| |
| /* |
| * Reference is held to bridge and must be freed by caller |
| */ |
| return bridge; |
| } |
| |
| /* |
| * ecm_interface_heirarchy_construct() |
| * Construct an interface heirarchy. |
| * |
| * Using the given addressing, locate the interface heirarchy used to emit packets to that destination. |
| * This is the heirarchy of interfaces a packet would transit to emit from the device. |
| * |
| * We will use the given src/dest devices when is_routed is false. |
| * When is_routed is true we will use the construct and the other devices (which is the src device of the |
| * construct device) whcih were obtained from the skb's route field and passed to this function.. |
| * |
| * For example, with this network arrangement: |
| * |
| * PPPoE--VLAN--BRIDGE--BRIDGE_PORT(LAG_MASTER)--LAG_SLAVE_0--10.22.33.11 |
| * |
| * Given the packet_dest_addr IP address 10.22.33.11 this will create an interface heirarchy (in interracfes[]) of: |
| * LAG_SLAVE_0 @ [ECM_DB_IFACE_HEIRARCHY_MAX - 5] |
| * LAG_MASTER @ [ECM_DB_IFACE_HEIRARCHY_MAX - 4] |
| * BRIDGE @ [ECM_DB_IFACE_HEIRARCHY_MAX - 3] |
| * VLAN @ [ECM_DB_IFACE_HEIRARCHY_MAX - 2] |
| * PPPOE @ [ECM_DB_IFACE_HEIRARCHY_MAX - 1] |
| * The value returned is (ECM_DB_IFACE_HEIRARCHY_MAX - 5) |
| * |
| * IMPORTANT: This function will return any known interfaces in the database, when interfaces do not exist in the database |
| * they will be created and added automatically to the database. |
| */ |
| int32_t ecm_interface_heirarchy_construct(struct ecm_front_end_connection_instance *feci, |
| struct ecm_db_iface_instance *interfaces[], |
| struct net_device *const_if, struct net_device *other_if, |
| ip_addr_t lookup_src_addr, |
| ip_addr_t lookup_dest_addr, |
| ip_addr_t real_dest_addr, |
| int ip_version, int packet_protocol, |
| struct net_device *given_dest_dev, |
| bool is_routed, struct net_device *given_src_dev, |
| uint8_t *dest_node_addr, uint8_t *src_node_addr, |
| __be16 *layer4hdr, struct sk_buff *skb) |
| { |
| int protocol; |
| ip_addr_t src_addr; |
| ip_addr_t dest_addr; |
| struct net_device *dest_dev; |
| char *dest_dev_name; |
| int32_t dest_dev_type; |
| struct net_device *src_dev; |
| char *src_dev_name; |
| int32_t src_dev_type; |
| int32_t current_interface_index; |
| bool from_local_addr; |
| bool next_dest_addr_valid; |
| bool next_dest_node_addr_valid = false; |
| ip_addr_t next_dest_addr; |
| uint8_t next_dest_node_addr[ETH_ALEN] = {0}; |
| struct net_device *bridge; |
| struct net_device *top_dev_vlan = NULL; |
| uint32_t serial = ecm_db_connection_serial_get(feci->ci); |
| |
| /* |
| * Get a big endian of the IPv4 address we have been given as our starting point. |
| */ |
| protocol = packet_protocol; |
| ECM_IP_ADDR_COPY(src_addr, lookup_src_addr); |
| ECM_IP_ADDR_COPY(dest_addr, lookup_dest_addr); |
| |
| if (ip_version == 4) { |
| DEBUG_TRACE("Construct interface heirarchy for from src_addr: " ECM_IP_ADDR_DOT_FMT " to dest_addr: " ECM_IP_ADDR_DOT_FMT ", protocol: %d (serial %u)\n", |
| ECM_IP_ADDR_TO_DOT(src_addr), ECM_IP_ADDR_TO_DOT(dest_addr), protocol, |
| serial); |
| #ifdef ECM_IPV6_ENABLE |
| } else if (ip_version == 6) { |
| DEBUG_TRACE("Construct interface heirarchy for from src_addr: " ECM_IP_ADDR_OCTAL_FMT " to dest_addr: " ECM_IP_ADDR_OCTAL_FMT ", protocol: %d (serial %u)\n", |
| ECM_IP_ADDR_TO_OCTAL(src_addr), ECM_IP_ADDR_TO_OCTAL(dest_addr), protocol, |
| serial); |
| #endif |
| } else { |
| DEBUG_WARN("Wrong IP protocol: %d\n", ip_version); |
| return ECM_DB_IFACE_HEIRARCHY_MAX; |
| } |
| |
| /* |
| * Get device to reach the given destination address. |
| * If the heirarchy is for a routed connection we must use the devices obtained from the skb's route information.. |
| * If the heirarchy is NOT for a routed connection we try the given_dest_dev. |
| */ |
| from_local_addr = false; |
| if (!is_routed) { |
| dest_dev = given_dest_dev; |
| dev_hold(dest_dev); |
| } else { |
| dest_dev = ecm_interface_dev_find_by_local_addr(dest_addr); |
| if (dest_dev) { |
| from_local_addr = true; |
| } else { |
| dest_dev = const_if; |
| dev_hold(dest_dev); |
| } |
| } |
| |
| /* |
| * If the address is a local address and protocol is an IP tunnel |
| * then this connection is a tunnel endpoint made to this device. |
| * In which case we circumvent all proper procedure and just hack the devices to make stuff work. |
| * |
| * TODO THIS MUST BE FIXED - WE MUST USE THE INTERFACE HIERARCHY FOR ITS INTENDED PURPOSE TO |
| * PARSE THE DEVICES AND WORK OUT THE PROPER INTERFACES INVOLVED. |
| * E.G. IF WE TRIED TO RUN A TUNNEL OVER A VLAN OR QINQ THIS WILL BREAK AS WE DON'T DISCOVER THAT HIERARCHY |
| */ |
| if (dest_dev && from_local_addr) { |
| if (((ip_version == 4) && (protocol == IPPROTO_IPV6)) || |
| ((ip_version == 6) && (protocol == IPPROTO_IPIP)) |
| #ifdef ECM_INTERFACE_GRE_ENABLE |
| || ((protocol == IPPROTO_GRE) && (given_dest_dev->priv_flags & (IFF_GRE_V4_TAP | IFF_GRE_V6_TAP)))) { |
| #else |
| { |
| #endif |
| dev_put(dest_dev); |
| dest_dev = given_dest_dev; |
| if (dest_dev) { |
| dev_hold(dest_dev); |
| if (ip_version == 4) { |
| DEBUG_TRACE("HACK: %s tunnel packet with dest_addr: " ECM_IP_ADDR_DOT_FMT " uses dev: %p(%s)\n", "IPV6", ECM_IP_ADDR_TO_DOT(dest_addr), dest_dev, dest_dev->name); |
| } else { |
| DEBUG_TRACE("HACK: %s tunnel packet with dest_addr: " ECM_IP_ADDR_OCTAL_FMT " uses dev: %p(%s)\n", "IPIP", ECM_IP_ADDR_TO_OCTAL(dest_addr), dest_dev, dest_dev->name); |
| } |
| } |
| } |
| } |
| |
| #ifdef ECM_INTERFACE_L2TPV2_ENABLE |
| |
| /* |
| * if the address is a local address and indev=l2tp. |
| */ |
| if ((given_src_dev->type == ARPHRD_PPP) && (given_src_dev->priv_flags & IFF_PPP_L2TPV2) && ppp_is_xmit_locked(given_src_dev)) { |
| dev_put(dest_dev); |
| dest_dev = given_dest_dev; |
| if (dest_dev) { |
| dev_hold(dest_dev); |
| DEBUG_TRACE("l2tp packet tunnel packet with dest_addr: " ECM_IP_ADDR_OCTAL_FMT " uses dev: %p(%s)\n", ECM_IP_ADDR_TO_OCTAL(dest_addr), dest_dev, dest_dev->name); |
| } |
| } |
| #endif |
| |
| #ifdef ECM_INTERFACE_PPTP_ENABLE |
| /* |
| * if the address is a local address and indev=PPTP. |
| */ |
| if (protocol == IPPROTO_GRE && given_dest_dev && given_dest_dev->type == ARPHRD_PPP) { |
| dev_put(dest_dev); |
| dest_dev = given_dest_dev; |
| if (dest_dev) { |
| dev_hold(dest_dev); |
| DEBUG_TRACE("PPTP packet tunnel packet with dest_addr: " ECM_IP_ADDR_OCTAL_FMT " uses dev: %p(%s)\n", ECM_IP_ADDR_TO_OCTAL(dest_addr), dest_dev, dest_dev->name); |
| } |
| } |
| #endif |
| |
| if (!dest_dev) { |
| DEBUG_WARN("dest_addr: " ECM_IP_ADDR_OCTAL_FMT " - cannot locate device\n", ECM_IP_ADDR_TO_OCTAL(dest_addr)); |
| return ECM_DB_IFACE_HEIRARCHY_MAX; |
| } |
| dest_dev_name = dest_dev->name; |
| dest_dev_type = dest_dev->type; |
| |
| /* |
| * Get device to reach the given source address. |
| * If the heirarchy is for a routed connection we must use the devices obtained from the skb's route information.. |
| * If the heirarchy is NOT for a routed connection we try the given_src_dev. |
| */ |
| from_local_addr = false; |
| if (!is_routed) { |
| src_dev = given_src_dev; |
| dev_hold(src_dev); |
| } else { |
| src_dev = ecm_interface_dev_find_by_local_addr(src_addr); |
| if (src_dev) { |
| from_local_addr = true; |
| } else { |
| src_dev = other_if; |
| dev_hold(src_dev); |
| } |
| } |
| |
| /* |
| * If the address is a local address and protocol is an IP tunnel |
| * then this connection is a tunnel endpoint made to this device. |
| * In which case we circumvent all proper procedure and just hack the devices to make stuff work. |
| * |
| * TODO THIS MUST BE FIXED - WE MUST USE THE INTERFACE HIERARCHY FOR ITS INTENDED PURPOSE TO |
| * PARSE THE DEVICES AND WORK OUT THE PROPER INTERFACES INVOLVED. |
| * E.G. IF WE TRIED TO RUN A TUNNEL OVER A VLAN OR QINQ THIS WILL BREAK AS WE DON'T DISCOVER THAT HIERARCHY |
| */ |
| if (src_dev && from_local_addr) { |
| if (((ip_version == 4) && (protocol == IPPROTO_IPV6)) || |
| ((ip_version == 6) && (protocol == IPPROTO_IPIP)) |
| #ifdef ECM_INTERFACE_GRE_ENABLE |
| || ((protocol == IPPROTO_GRE) && (given_src_dev->priv_flags & (IFF_GRE_V4_TAP | IFF_GRE_V6_TAP)))) { |
| #else |
| { |
| #endif |
| dev_put(src_dev); |
| src_dev = given_src_dev; |
| if (src_dev) { |
| dev_hold(src_dev); |
| if (ip_version == 4) { |
| DEBUG_TRACE("HACK: %s tunnel packet with src_addr: " ECM_IP_ADDR_DOT_FMT " uses dev: %p(%s)\n", "IPV6", ECM_IP_ADDR_TO_DOT(src_addr), src_dev, src_dev->name); |
| } else { |
| DEBUG_TRACE("HACK: %s tunnel packet with src_addr: " ECM_IP_ADDR_OCTAL_FMT " uses dev: %p(%s)\n", "IPIP", ECM_IP_ADDR_TO_OCTAL(src_addr), src_dev, src_dev->name); |
| } |
| } |
| } |
| } |
| |
| if (!src_dev) { |
| DEBUG_WARN("src_addr: " ECM_IP_ADDR_OCTAL_FMT " - cannot locate device\n", ECM_IP_ADDR_TO_OCTAL(src_addr)); |
| dev_put(dest_dev); |
| return ECM_DB_IFACE_HEIRARCHY_MAX; |
| } |
| src_dev_name = src_dev->name; |
| src_dev_type = src_dev->type; |
| |
| /* |
| * Check if source and dest dev are same. |
| */ |
| if (src_dev == dest_dev) { |
| bool skip = false; |
| |
| DEBUG_TRACE("Protocol is :%d source dev and dest dev are same\n", protocol); |
| |
| switch (ip_version) { |
| case 4: |
| if ((protocol == IPPROTO_IPV6) || (protocol == IPPROTO_ESP)) { |
| skip = true; |
| break; |
| } |
| |
| if ((protocol == IPPROTO_UDP) && (udp_hdr(skb)->dest == htons(4500))) { |
| skip = true; |
| break; |
| } |
| |
| break; |
| |
| case 6: |
| if ((protocol == IPPROTO_IPIP) || (protocol == IPPROTO_ESP)) { |
| skip = true; |
| break; |
| } |
| |
| break; |
| |
| default: |
| DEBUG_WARN("IP version = %d, Protocol = %d: Corrupted packet entered ecm\n", ip_version, protocol); |
| skip = true; |
| break; |
| } |
| |
| if (skip) { |
| /* |
| * This happens from the input hook |
| * We do not want to create a connection entry for this |
| * TODO YES WE DO. |
| * TODO THIS CONCERNS ME AS THIS SHOULD BE CAUGHT MUCH |
| * EARLIER IN THE FRONT END IF POSSIBLE TO AVOID PERFORMANCE PENALTIES. |
| * WE HAVE DONE A TREMENDOUS AMOUT OF WORK TO GET TO THIS POINT. |
| * WE WILL ABORT HERE AND THIS WILL BE REPEATED FOR EVERY PACKET. |
| * IN KEEPING WITH THE ECM DESIGN IT IS BETTER TO CREATE A CONNECTION AND RECORD IN THE HIERARCHY |
| * ENOUGH INFORMATION TO ENSURE THAT ACCELERATION IS NOT BROKEN / DOES NOT OCCUR AT ALL. |
| * THAT WAY WE DO A HEAVYWEIGHT ESTABLISHING OF A CONNECTION ONCE AND NEVER AGAIN... |
| */ |
| dev_put(src_dev); |
| dev_put(dest_dev); |
| return ECM_DB_IFACE_HEIRARCHY_MAX; |
| } |
| } |
| |
| bridge = ecm_interface_should_update_egress_device_bridged( |
| given_dest_dev, dest_dev, is_routed); |
| |
| if (bridge) { |
| struct net_device *new_dest_dev; |
| new_dest_dev = br_port_dev_get(bridge, dest_node_addr, skb, serial); |
| if (new_dest_dev) { |
| dev_put(dest_dev); |
| if (new_dest_dev != given_dest_dev) { |
| DEBUG_INFO("Adjusted port for %pM is %s (given was %s)\n", |
| dest_node_addr, new_dest_dev->name, |
| given_dest_dev->name); |
| |
| dest_dev = new_dest_dev; |
| dest_dev_name = dest_dev->name; |
| dest_dev_type = dest_dev->type; |
| } |
| } |
| dev_put(bridge); |
| } |
| |
| next_dest_addr_valid = true; |
| ECM_IP_ADDR_COPY(next_dest_addr, dest_addr); |
| |
| /* |
| * Iterate until we are done or get to the max number of interfaces we can record. |
| * NOTE: current_interface_index tracks the position of the first interface position in interfaces[] |
| * because we add from the end first_interface grows downwards. |
| */ |
| current_interface_index = ECM_DB_IFACE_HEIRARCHY_MAX; |
| while (current_interface_index > 0) { |
| struct ecm_db_iface_instance *ii; |
| struct net_device *next_dev; |
| /* |
| * Get the ecm db interface instance for the device at hand |
| */ |
| ii = ecm_interface_establish_and_ref(feci, dest_dev, skb); |
| |
| /* |
| * If the interface could not be established then we abort |
| */ |
| if (!ii) { |
| DEBUG_WARN("Failed to establish interface: %p, name: %s\n", dest_dev, dest_dev_name); |
| dev_put(src_dev); |
| dev_put(dest_dev); |
| |
| /* |
| * Release the interfaces heirarchy we constructed to this point. |
| */ |
| ecm_db_connection_interfaces_deref(interfaces, current_interface_index); |
| return ECM_DB_IFACE_HEIRARCHY_MAX; |
| } |
| |
| /* |
| * Record the interface instance into the interfaces[] |
| */ |
| current_interface_index--; |
| interfaces[current_interface_index] = ii; |
| |
| /* |
| * Now we have to figure out what the next device will be (in the transmission path) the skb |
| * will use to emit to the destination address. |
| */ |
| do { |
| #ifdef ECM_INTERFACE_PPP_ENABLE |
| int channel_count; |
| struct ppp_channel *ppp_chan[1]; |
| int channel_protocol; |
| #ifdef ECM_INTERFACE_PPPOE_ENABLE |
| struct pppoe_opt addressing; |
| #endif |
| #endif |
| |
| DEBUG_TRACE("Net device: %p is type: %d, name: %s\n", dest_dev, dest_dev_type, dest_dev_name); |
| next_dev = NULL; |
| |
| if (dest_dev_type == ARPHRD_ETHER) { |
| /* |
| * Ethernet - but what sub type? |
| */ |
| |
| #ifdef ECM_INTERFACE_VLAN_ENABLE |
| /* |
| * VLAN? |
| */ |
| if (is_vlan_dev(dest_dev)) { |
| /* |
| * VLAN master |
| * No locking needed here, ASSUMPTION is that real_dev is held for as long as we have dev. |
| */ |
| next_dev = ecm_interface_vlan_real_dev(dest_dev); |
| dev_hold(next_dev); |
| DEBUG_TRACE("Net device: %p is VLAN, slave dev: %p (%s)\n", |
| dest_dev, next_dev, next_dev->name); |
| if (current_interface_index == (ECM_DB_IFACE_HEIRARCHY_MAX - 1)) { |
| top_dev_vlan = dest_dev; |
| } |
| break; |
| } |
| #endif |
| |
| /* |
| * BRIDGE? |
| */ |
| if (ecm_front_end_is_bridge_device(dest_dev)) { |
| /* |
| * Bridge |
| * Figure out which port device the skb will go to using the dest_addr. |
| */ |
| uint8_t mac_addr[ETH_ALEN]; |
| |
| if (next_dest_node_addr_valid) { |
| memcpy(mac_addr, next_dest_node_addr, ETH_ALEN); |
| } else if (!next_dest_addr_valid) { |
| dev_put(src_dev); |
| dev_put(dest_dev); |
| |
| /* |
| * Release the interfaces heirarchy we constructed to this point. |
| */ |
| ecm_db_connection_interfaces_deref(interfaces, current_interface_index); |
| return ECM_DB_IFACE_HEIRARCHY_MAX; |
| } else { |
| if (!ecm_interface_get_next_node_mac_address(dest_addr, dest_dev, ip_version, mac_addr)) { |
| dev_put(src_dev); |
| dev_put(dest_dev); |
| |
| /* |
| * Release the interfaces heirarchy we constructed to this point. |
| */ |
| ecm_db_connection_interfaces_deref(interfaces, current_interface_index); |
| return ECM_DB_IFACE_HEIRARCHY_MAX; |
| } |
| } |
| |
| next_dev = br_port_dev_get(dest_dev, |
| mac_addr, skb, serial); |
| |
| if (!next_dev) { |
| DEBUG_WARN("Unable to obtain output port for: %pM\n", mac_addr); |
| dev_put(src_dev); |
| dev_put(dest_dev); |
| |
| /* |
| * Release the interfaces heirarchy we constructed to this point. |
| */ |
| ecm_db_connection_interfaces_deref(interfaces, current_interface_index); |
| return ECM_DB_IFACE_HEIRARCHY_MAX; |
| } |
| DEBUG_TRACE("Net device: %p is BRIDGE, next_dev: %p (%s)\n", dest_dev, next_dev, next_dev->name); |
| break; |
| } |
| |
| #ifdef ECM_INTERFACE_BOND_ENABLE |
| /* |
| * LAG? |
| */ |
| if (ecm_front_end_is_lag_master(dest_dev)) { |
| /* |
| * Link aggregation |
| * Figure out whiich slave device of the link aggregation will be used to reach the destination. |
| */ |
| uint32_t src_addr_32 = 0; |
| uint32_t dest_addr_32 = 0; |
| struct in6_addr src_addr6; |
| struct in6_addr dest_addr6; |
| uint8_t src_mac_addr[ETH_ALEN]; |
| uint8_t dest_mac_addr[ETH_ALEN]; |
| |
| memset(src_mac_addr, 0, ETH_ALEN); |
| memset(dest_mac_addr, 0, ETH_ALEN); |
| |
| if (ip_version == 4) { |
| ECM_IP_ADDR_TO_NIN4_ADDR(src_addr_32, src_addr); |
| ECM_IP_ADDR_TO_NIN4_ADDR(dest_addr_32, real_dest_addr); |
| } |
| |
| if (!is_routed) { |
| memcpy(src_mac_addr, src_node_addr, ETH_ALEN); |
| memcpy(dest_mac_addr, dest_node_addr, ETH_ALEN); |
| } else { |
| struct net_device *master_dev; |
| |
| /* |
| * Use appropriate source MAC address for routed packets and |
| * find proper interface to find the destination mac address and |
| * from which to issue ARP or neighbour solicitation packet. |
| */ |
| master_dev = ecm_interface_get_and_hold_dev_master(dest_dev); |
| if (master_dev) { |
| memcpy(src_mac_addr, master_dev->dev_addr, ETH_ALEN); |
| } else { |
| memcpy(src_mac_addr, dest_dev->dev_addr, ETH_ALEN); |
| master_dev = dest_dev; |
| if (top_dev_vlan) { |
| master_dev = top_dev_vlan; |
| } |
| dev_hold(master_dev); |
| } |
| |
| /* |
| * Determine destination MAC address for this routed packet |
| */ |
| if (next_dest_node_addr_valid) { |
| memcpy(dest_mac_addr, next_dest_node_addr, ETH_ALEN); |
| } else if (!next_dest_addr_valid) { |
| dev_put(src_dev); |
| dev_put(dest_dev); |
| dev_put(master_dev); |
| ecm_db_connection_interfaces_deref(interfaces, current_interface_index); |
| return ECM_DB_IFACE_HEIRARCHY_MAX; |
| } else { |
| if (!ecm_interface_mac_addr_get_no_route(master_dev, dest_addr, dest_mac_addr)) { |
| ip_addr_t gw_addr = ECM_IP_ADDR_NULL; |
| /* |
| * Try one more time with gateway ip address if it exists. |
| */ |
| if (!ecm_interface_find_gateway(dest_addr, gw_addr)) { |
| goto lag_fail; |
| } |
| |
| if (ip_version == 4) { |
| DEBUG_TRACE("Have a gw address " ECM_IP_ADDR_DOT_FMT "\n", ECM_IP_ADDR_TO_DOT(gw_addr)); |
| } |
| #ifdef ECM_IPV6_ENABLE |
| |
| if (ip_version == 6) { |
| DEBUG_TRACE("Have a gw address " ECM_IP_ADDR_OCTAL_FMT "\n", ECM_IP_ADDR_TO_OCTAL(gw_addr)); |
| } |
| #endif |
| if (ecm_interface_mac_addr_get_no_route(master_dev, gw_addr, dest_mac_addr)) { |
| DEBUG_TRACE("Found the mac address for gateway\n"); |
| dev_put(master_dev); |
| goto lag_success; |
| } |
| |
| if (ip_version == 4) { |
| ecm_interface_send_arp_request(master_dev, dest_addr, false, gw_addr); |
| |
| DEBUG_WARN("Unable to obtain any MAC address for " ECM_IP_ADDR_DOT_FMT "\n", ECM_IP_ADDR_TO_DOT(dest_addr)); |
| } |
| #ifdef ECM_IPV6_ENABLE |
| if (ip_version == 6) { |
| ecm_interface_send_neighbour_solicitation(master_dev, dest_addr); |
| |
| DEBUG_WARN("Unable to obtain any MAC address for " ECM_IP_ADDR_OCTAL_FMT "\n", ECM_IP_ADDR_TO_OCTAL(dest_addr)); |
| } |
| #endif |
| lag_fail: |
| dev_put(src_dev); |
| dev_put(dest_dev); |
| dev_put(master_dev); |
| |
| ecm_db_connection_interfaces_deref(interfaces, current_interface_index); |
| return ECM_DB_IFACE_HEIRARCHY_MAX; |
| } |
| } |
| dev_put(master_dev); |
| } |
| lag_success: |
| if (ip_version == 4) { |
| next_dev = bond_get_tx_dev(NULL, src_mac_addr, dest_mac_addr, |
| &src_addr_32, &dest_addr_32, |
| htons((uint16_t)ETH_P_IP), dest_dev, layer4hdr); |
| } else if (ip_version == 6) { |
| ECM_IP_ADDR_TO_NIN6_ADDR(src_addr6, src_addr); |
| ECM_IP_ADDR_TO_NIN6_ADDR(dest_addr6, real_dest_addr); |
| next_dev = bond_get_tx_dev(NULL, src_mac_addr, dest_mac_addr, |
| src_addr6.s6_addr, dest_addr6.s6_addr, |
| htons((uint16_t)ETH_P_IPV6), dest_dev, layer4hdr); |
| } |
| |
| if (next_dev && netif_carrier_ok(next_dev)) { |
| dev_hold(next_dev); |
| } else { |
| DEBUG_WARN("Unable to obtain LAG output slave device\n"); |
| dev_put(src_dev); |
| dev_put(dest_dev); |
| |
| /* |
| * Release the interfaces heirarchy we constructed to this point. |
| */ |
| ecm_db_connection_interfaces_deref(interfaces, current_interface_index); |
| return ECM_DB_IFACE_HEIRARCHY_MAX; |
| } |
| |
| DEBUG_TRACE("Net device: %p is LAG, slave dev: %p (%s)\n", dest_dev, next_dev, next_dev->name); |
| break; |
| } |
| #endif |
| |
| /* |
| * ETHERNET! |
| * Just plain ethernet it seems. |
| */ |
| DEBUG_TRACE("Net device: %p is ETHERNET\n", dest_dev); |
| break; |
| } |
| |
| /* |
| * LOOPBACK? |
| */ |
| if (dest_dev_type == ARPHRD_LOOPBACK) { |
| DEBUG_TRACE("Net device: %p is LOOPBACK type: %d\n", dest_dev, dest_dev_type); |
| break; |
| } |
| |
| /* |
| * IPSEC? |
| */ |
| if (dest_dev_type == ECM_ARPHRD_IPSEC_TUNNEL_TYPE) { |
| DEBUG_TRACE("Net device: %p is IPSec tunnel type: %d\n", dest_dev, dest_dev_type); |
| /* TODO Figure out the next device the tunnel is using... */ |
| break; |
| } |
| |
| /* |
| * SIT (6-in-4)? |
| */ |
| if (dest_dev_type == ARPHRD_SIT) { |
| DEBUG_TRACE("Net device: %p is SIT (6-in-4) type: %d\n", dest_dev, dest_dev_type); |
| /* TODO Figure out the next device the tunnel is using... */ |
| break; |
| } |
| |
| /* |
| * IPIP6 Tunnel? |
| */ |
| if (dest_dev_type == ARPHRD_TUNNEL6) { |
| DEBUG_TRACE("Net device: %p is TUNIPIP6 type: %d\n", dest_dev, dest_dev_type); |
| /* TODO Figure out the next device the tunnel is using... */ |
| break; |
| } |
| |
| #ifdef ECM_INTERFACE_MAP_T_ENABLE |
| /* |
| * MAP-T xlate ? |
| */ |
| if (dest_dev_type == ARPHRD_NONE) { |
| if (is_map_t_dev(dest_dev)) { |
| DEBUG_TRACE("Net device: %p is MAP-T type: %d\n", dest_dev, dest_dev_type); |
| break; |
| } |
| } |
| #endif |
| |
| /* |
| * If this is NOT PPP then it is unknown to the ecm and we cannot figure out it's next device. |
| */ |
| if (dest_dev_type != ARPHRD_PPP) { |
| DEBUG_TRACE("Net device: %p is UNKNOWN type: %d\n", dest_dev, dest_dev_type); |
| break; |
| } |
| |
| #ifndef ECM_INTERFACE_PPP_ENABLE |
| DEBUG_TRACE("Net device: %p is UNKNOWN (PPP Unsupported) type: %d\n", dest_dev, dest_dev_type); |
| #else |
| DEBUG_TRACE("Net device: %p is PPP\n", dest_dev); |
| |
| #ifdef ECM_INTERFACE_L2TPV2_ENABLE |
| if ((given_src_dev->priv_flags & IFF_PPP_L2TPV2) && ppp_is_xmit_locked(given_src_dev)) { |
| if (skb->skb_iif == dest_dev->ifindex) { |
| DEBUG_TRACE("Net device: %p PPP channel is PPPoL2TPV2\n", dest_dev); |
| break; |
| } |
| } |
| #endif |
| |
| #ifdef ECM_INTERFACE_PPTP_ENABLE |
| if (protocol == IPPROTO_GRE && dest_dev && dest_dev->type == ARPHRD_PPP) { |
| DEBUG_TRACE("Net device: %p PPP channel is PPTP\n", dest_dev); |
| break; |
| } |
| #endif |
| /* |
| * PPP - but what is the channel type? |
| * First: If this is multi-link then we do not support it |
| */ |
| if (ppp_is_multilink(dest_dev) > 0) { |
| DEBUG_TRACE("Net device: %p is MULTILINK PPP - Unknown to the ECM\n", dest_dev); |
| break; |
| } |
| |
| /* |
| * Get the PPP channel and then enquire what kind of channel it is |
| * NOTE: Not multilink so only one channel to get. |
| */ |
| channel_count = ppp_hold_channels(dest_dev, ppp_chan, 1); |
| if (channel_count != 1) { |
| DEBUG_TRACE("Net device: %p PPP has %d channels - Unknown to the ECM\n", |
| dest_dev, channel_count); |
| break; |
| } |
| |
| /* |
| * Get channel protocol type |
| * NOTE: Not all PPP channels support channel specific methods. |
| */ |
| channel_protocol = ppp_channel_get_protocol(ppp_chan[0]); |
| |
| #ifdef ECM_INTERFACE_L2TPV2_ENABLE |
| if (channel_protocol == PX_PROTO_OL2TP) { |
| |
| /* |
| * PPPoL2TPV2 channel |
| */ |
| ppp_release_channels(ppp_chan, 1); |
| DEBUG_TRACE("Net device: %p PPP channel is PPPoL2TPV2\n", dest_dev); |
| |
| /* |
| * Release the channel. Note that next_dev not held. |
| */ |
| break; |
| } |
| #endif |
| #ifdef ECM_INTERFACE_PPPOE_ENABLE |
| if (channel_protocol == PX_PROTO_OE) { |
| /* |
| * PPPoE channel |
| */ |
| DEBUG_TRACE("Net device: %p PPP channel is PPPoE\n", dest_dev); |
| |
| /* |
| * Get PPPoE session information and the underlying device it is using. |
| */ |
| pppoe_channel_addressing_get(ppp_chan[0], &addressing); |
| |
| /* |
| * Copy the dev hold into this, we will release the hold later |
| */ |
| next_dev = addressing.dev; |
| next_dest_addr_valid = false; |
| next_dest_node_addr_valid = true; |
| memcpy(next_dest_node_addr, addressing.pa.remote, ETH_ALEN); |
| |
| /* |
| * Release the channel. Note that next_dev is still (correctly) held. |
| */ |
| ppp_release_channels(ppp_chan, 1); |
| break; |
| } |
| #endif |
| |
| DEBUG_TRACE("Net device: %p PPP channel protocol: %d - Unknown to the ECM\n", |
| dest_dev, channel_protocol); |
| |
| /* |
| * Release the channel |
| */ |
| ppp_release_channels(ppp_chan, 1); |
| |
| #endif |
| } while (false); |
| |
| /* |
| * No longer need dest_dev as it may become next_dev |
| */ |
| dev_put(dest_dev); |
| |
| /* |
| * Check out the next_dev, if any |
| */ |
| if (!next_dev) { |
| int32_t i __attribute__((unused)); |
| DEBUG_INFO("Completed interface heirarchy construct with first interface @: %d\n", current_interface_index); |
| #if DEBUG_LEVEL > 1 |
| for (i = current_interface_index; i < ECM_DB_IFACE_HEIRARCHY_MAX; ++i) { |
| DEBUG_TRACE("\tInterface @ %d: %p, type: %d, name: %s\n", |
| i, interfaces[i], ecm_db_connection_iface_type_get(interfaces[i]), ecm_db_interface_type_to_string(ecm_db_connection_iface_type_get(interfaces[i]))); |
| |
| } |
| #endif |
| |
| /* |
| * Release src_dev now |
| */ |
| dev_put(src_dev); |
| return current_interface_index; |
| } |
| |
| /* |
| * dest_dev becomes next_dev |
| */ |
| dest_dev = next_dev; |
| dest_dev_name = dest_dev->name; |
| dest_dev_type = dest_dev->type; |
| } |
| |
| DEBUG_WARN("Too many interfaces: %d\n", current_interface_index); |
| DEBUG_ASSERT(current_interface_index == 0, "Bad logic handling current_interface_index: %d\n", current_interface_index); |
| dev_put(src_dev); |
| dev_put(dest_dev); |
| |
| /* |
| * Release the interfaces heirarchy we constructed to this point. |
| */ |
| ecm_db_connection_interfaces_deref(interfaces, current_interface_index); |
| return ECM_DB_IFACE_HEIRARCHY_MAX; |
| } |
| EXPORT_SYMBOL(ecm_interface_heirarchy_construct); |
| |
| #ifdef ECM_MULTICAST_ENABLE |
| /* |
| * ecm_interface_multicast_from_heirarchy_construct() |
| * Construct an interface heirarchy. |
| * |
| * TODO: This function will be removed later and ecm_interface_heirarchy_construct() function |
| * will be used when the multicast code is fixed to use the new interface hierarchy |
| * construction model which uses the skb's route information instead of doing |
| * the route lookup based on the IP addresses. |
| * |
| * Using the given addressing, locate the interface heirarchy used to emit packets to that destination. |
| * This is the heirarchy of interfaces a packet would transit to emit from the device. |
| * |
| * We will use the given src/dest devices when is_routed is false. |
| * When is_routed is true we will try routing tables first, failing back to any given. |
| * |
| * For example, with this network arrangement: |
| * |
| * PPPoE--VLAN--BRIDGE--BRIDGE_PORT(LAG_MASTER)--LAG_SLAVE_0--10.22.33.11 |
| * |
| * Given the packet_dest_addr IP address 10.22.33.11 this will create an interface heirarchy (in interracfes[]) of: |
| * LAG_SLAVE_0 @ [ECM_DB_IFACE_HEIRARCHY_MAX - 5] |
| * LAG_MASTER @ [ECM_DB_IFACE_HEIRARCHY_MAX - 4] |
| * BRIDGE @ [ECM_DB_IFACE_HEIRARCHY_MAX - 3] |
| * VLAN @ [ECM_DB_IFACE_HEIRARCHY_MAX - 2] |
| * PPPOE @ [ECM_DB_IFACE_HEIRARCHY_MAX - 1] |
| * The value returned is (ECM_DB_IFACE_HEIRARCHY_MAX - 5) |
| * |
| * IMPORTANT: This function will return any known interfaces in the database, when interfaces do not exist in the database |
| * they will be created and added automatically to the database. |
| */ |
| int32_t ecm_interface_multicast_from_heirarchy_construct(struct ecm_front_end_connection_instance *feci, |
| struct ecm_db_iface_instance *interfaces[], |
| ip_addr_t packet_src_addr, |
| ip_addr_t packet_dest_addr, |
| int ip_version, int packet_protocol, |
| struct net_device *given_dest_dev, |
| bool is_routed, struct net_device *given_src_dev, |
| uint8_t *dest_node_addr, uint8_t *src_node_addr, |
| __be16 *layer4hdr, struct sk_buff *skb) |
| { |
| int protocol; |
| ip_addr_t src_addr; |
| ip_addr_t dest_addr; |
| struct net_device *dest_dev; |
| char *dest_dev_name; |
| int32_t dest_dev_type; |
| struct net_device *src_dev; |
| char *src_dev_name; |
| int32_t src_dev_type; |
| int32_t current_interface_index; |
| bool from_local_addr; |
| bool next_dest_addr_valid; |
| bool next_dest_node_addr_valid = false; |
| ip_addr_t next_dest_addr; |
| uint8_t next_dest_node_addr[ETH_ALEN] = {0}; |
| struct net_device *bridge; |
| uint32_t serial = ecm_db_connection_serial_get(feci->ci); |
| |
| /* |
| * Get a big endian of the IPv4 address we have been given as our starting point. |
| */ |
| protocol = packet_protocol; |
| ECM_IP_ADDR_COPY(src_addr, packet_src_addr); |
| ECM_IP_ADDR_COPY(dest_addr, packet_dest_addr); |
| |
| if (ip_version == 4) { |
| DEBUG_TRACE("Construct interface heirarchy for from src_addr: " ECM_IP_ADDR_DOT_FMT " to dest_addr: " ECM_IP_ADDR_DOT_FMT ", protocol: %d (serial %u)\n", |
| ECM_IP_ADDR_TO_DOT(src_addr), ECM_IP_ADDR_TO_DOT(dest_addr), protocol, |
| serial); |
| #ifdef ECM_IPV6_ENABLE |
| } else if (ip_version == 6) { |
| DEBUG_TRACE("Construct interface heirarchy for from src_addr: " ECM_IP_ADDR_OCTAL_FMT " to dest_addr: " ECM_IP_ADDR_OCTAL_FMT ", protocol: %d (serial %u)\n", |
| ECM_IP_ADDR_TO_OCTAL(src_addr), ECM_IP_ADDR_TO_OCTAL(dest_addr), protocol, |
| serial); |
| #endif |
| } else { |
| DEBUG_WARN("Wrong IP protocol: %d\n", ip_version); |
| return ECM_DB_IFACE_HEIRARCHY_MAX; |
| } |
| |
| /* |
| * Get device to reach the given destination address. |
| * If the heirarchy is for a routed connection we must try route lookup first, falling back to any given_dest_dev. |
| * If the heirarchy is NOT for a routed connection we try the given_dest_dev first, followed by routed lookup. |
| */ |
| from_local_addr = false; |
| if (is_routed) { |
| dest_dev = ecm_interface_dev_find_by_addr(dest_addr, &from_local_addr); |
| if (!dest_dev && given_dest_dev) { |
| /* |
| * Fall back to any given |
| */ |
| dest_dev = given_dest_dev; |
| dev_hold(dest_dev); |
| } |
| } else if (given_dest_dev) { |
| dest_dev = given_dest_dev; |
| dev_hold(dest_dev); |
| } else { |
| /* |
| * Fall back to routed look up |
| */ |
| dest_dev = ecm_interface_dev_find_by_addr(dest_addr, &from_local_addr); |
| } |
| |
| /* |
| * GGG ALERT: If the address is a local address and protocol is an IP tunnel |
| * then this connection is a tunnel endpoint made to this device. |
| * In which case we circumvent all proper procedure and just hack the devices to make stuff work. |
| * GGG TODO THIS MUST BE FIXED - WE MUST USE THE INTERFACE HIERARCHY FOR ITS INTENDED PURPOSE TO |
| * PARSE THE DEVICES AND WORK OUT THE PROPER INTERFACES INVOLVED. |
| * E.G. IF WE TRIED TO RUN A TUNNEL OVER A VLAN OR QINQ THIS WILL BREAK AS WE DON'T DISCOVER THAT HIERARCHY |
| */ |
| if (dest_dev && from_local_addr) { |
| if (((ip_version == 4) && (protocol == IPPROTO_IPV6)) || |
| ((ip_version == 6) && (protocol == IPPROTO_IPIP))) { |
| dev_put(dest_dev); |
| dest_dev = given_dest_dev; |
| if (dest_dev) { |
| dev_hold(dest_dev); |
| if (ip_version == 4) { |
| DEBUG_TRACE("HACK: %s tunnel packet with dest_addr: " ECM_IP_ADDR_DOT_FMT " uses dev: %p(%s)\n", "IPV6", ECM_IP_ADDR_TO_DOT(dest_addr), dest_dev, dest_dev->name); |
| } else { |
| DEBUG_TRACE("HACK: %s tunnel packet with dest_addr: " ECM_IP_ADDR_OCTAL_FMT " uses dev: %p(%s)\n", "IPIP", ECM_IP_ADDR_TO_OCTAL(dest_addr), dest_dev, dest_dev->name); |
| } |
| } |
| } |
| } |
| |
| #ifdef ECM_INTERFACE_L2TPV2_ENABLE |
| /* |
| * if the address is a local address and indev=l2tp. |
| */ |
| if ((given_src_dev->type == ARPHRD_PPP) && (given_src_dev->priv_flags & IFF_PPP_L2TPV2) && ppp_is_xmit_locked(given_src_dev)) { |
| dev_put(dest_dev); |
| dest_dev = given_dest_dev; |
| if (dest_dev) { |
| dev_hold(dest_dev); |
| DEBUG_TRACE("l2tp packet tunnel packet with dest_addr: " ECM_IP_ADDR_OCTAL_FMT " uses dev: %p(%s)\n", ECM_IP_ADDR_TO_OCTAL(dest_addr), dest_dev, dest_dev->name); |
| } |
| } |
| #endif |
| |
| #ifdef ECM_INTERFACE_PPTP_ENABLE |
| /* |
| * if the address is a local address and indev=PPTP. |
| */ |
| if (protocol == IPPROTO_GRE && given_dest_dev && given_dest_dev->type == ARPHRD_PPP) { |
| dev_put(dest_dev); |
| dest_dev = given_dest_dev; |
| if (dest_dev) { |
| dev_hold(dest_dev); |
| DEBUG_TRACE("PPTP packet tunnel packet with dest_addr: " ECM_IP_ADDR_OCTAL_FMT " uses dev: %p(%s)\n", ECM_IP_ADDR_TO_OCTAL(dest_addr), dest_dev, dest_dev->name); |
| } |
| } |
| #endif |
| |
| if (!dest_dev) { |
| DEBUG_WARN("dest_addr: " ECM_IP_ADDR_OCTAL_FMT " - cannot locate device\n", ECM_IP_ADDR_TO_OCTAL(dest_addr)); |
| return ECM_DB_IFACE_HEIRARCHY_MAX; |
| } |
| dest_dev_name = dest_dev->name; |
| dest_dev_type = dest_dev->type; |
| |
| /* |
| * Get device to reach the given source address. |
| * If the heirarchy is for a routed connection we must try route lookup first, falling back to any given_src_dev. |
| * If the heirarchy is NOT for a routed connection we try the given_src_dev first, followed by routed lookup. |
| */ |
| from_local_addr = false; |
| if (is_routed) { |
| src_dev = ecm_interface_dev_find_by_addr(src_addr, &from_local_addr); |
| if (!src_dev && given_src_dev) { |
| /* |
| * Fall back to any given |
| */ |
| src_dev = given_src_dev; |
| dev_hold(src_dev); |
| } |
| } else if (given_src_dev) { |
| src_dev = given_src_dev; |
| dev_hold(src_dev); |
| } else { |
| /* |
| * Fall back to routed look up |
| */ |
| src_dev = ecm_interface_dev_find_by_addr(src_addr, &from_local_addr); |
| } |
| |
| /* |
| * GGG ALERT: If the address is a local address and protocol is an IP tunnel |
| * then this connection is a tunnel endpoint made to this device. |
| * In which case we circumvent all proper procedure and just hack the devices to make stuff work. |
| * GGG TODO THIS MUST BE FIXED - WE MUST USE THE INTERFACE HIERARCHY FOR ITS INTENDED PURPOSE TO |
| * PARSE THE DEVICES AND WORK OUT THE PROPER INTERFACES INVOLVED. |
| * E.G. IF WE TRIED TO RUN A TUNNEL OVER A VLAN OR QINQ THIS WILL BREAK AS WE DON'T DISCOVER THAT HIERARCHY |
| */ |
| if (src_dev && from_local_addr) { |
| if (((ip_version == 4) && (protocol == IPPROTO_IPV6)) || |
| ((ip_version == 6) && (protocol == IPPROTO_IPIP))) { |
| dev_put(src_dev); |
| src_dev = given_src_dev; |
| if (src_dev) { |
| dev_hold(src_dev); |
| if (ip_version == 4) { |
| DEBUG_TRACE("HACK: %s tunnel packet with src_addr: " ECM_IP_ADDR_DOT_FMT " uses dev: %p(%s)\n", "IPV6", ECM_IP_ADDR_TO_DOT(src_addr), src_dev, src_dev->name); |
| } else { |
| DEBUG_TRACE("HACK: %s tunnel packet with src_addr: " ECM_IP_ADDR_OCTAL_FMT " uses dev: %p(%s)\n", "IPIP", ECM_IP_ADDR_TO_OCTAL(src_addr), src_dev, src_dev->name); |
| } |
| } |
| } |
| } |
| |
| #ifdef ECM_INTERFACE_L2TPV2_ENABLE |
| /* |
| * if the address is a local address and indev=l2tp. |
| */ |
| if (skb && skb->sk && (skb->sk->sk_protocol == IPPROTO_UDP) && (udp_sk(skb->sk)->encap_type == UDP_ENCAP_L2TPINUDP)) { |
| if (dest_dev != given_src_dev) { |
| dev_put(src_dev); |
| src_dev = given_src_dev; |
| if (src_dev) { |
| dev_hold(src_dev); |
| DEBUG_TRACE("l2tp tunnel packet with src_addr: " ECM_IP_ADDR_OCTAL_FMT " uses dev: %p(%s)\n", ECM_IP_ADDR_TO_OCTAL(src_addr), src_dev, src_dev->name); |
| } |
| } |
| } |
| #endif |
| |
| if (!src_dev) { |
| DEBUG_WARN("src_addr: " ECM_IP_ADDR_OCTAL_FMT " - cannot locate device\n", ECM_IP_ADDR_TO_OCTAL(src_addr)); |
| dev_put(dest_dev); |
| return ECM_DB_IFACE_HEIRARCHY_MAX; |
| } |
| src_dev_name = src_dev->name; |
| src_dev_type = src_dev->type; |
| |
| /* |
| * Check if source and dest dev are same. |
| * For the forwarded flows which involve tunnels this will happen when called from input hook. |
| */ |
| if (src_dev == dest_dev) { |
| DEBUG_TRACE("Protocol is :%d source dev and dest dev are same\n", protocol); |
| if (((ip_version == 4) && ((protocol == IPPROTO_IPV6) || (protocol == IPPROTO_ESP))) |
| || ((ip_version == 6) && (protocol == IPPROTO_IPIP))) { |
| /* |
| * This happens from the input hook |
| * We do not want to create a connection entry for this |
| * GGG TODO YES WE DO. |
| * GGG TODO THIS CONCERNS ME AS THIS SHOULD BE CAUGHT MUCH |
| * EARLIER IN THE FRONT END IF POSSIBLE TO AVOID PERFORMANCE PENALTIES. |
| * WE HAVE DONE A TREMENDOUS AMOUT OF WORK TO GET TO THIS POINT. |
| * WE WILL ABORT HERE AND THIS WILL BE REPEATED FOR EVERY PACKET. |
| * IN KEEPING WITH THE ECM DESIGN IT IS BETTER TO CREATE A CONNECTION AND RECORD IN THE HIERARCHY |
| * ENOUGH INFORMATION TO ENSURE THAT ACCELERATION IS NOT BROKEN / DOES NOT OCCUR AT ALL. |
| * THAT WAY WE DO A HEAVYWEIGHT ESTABLISHING OF A CONNECTION ONCE AND NEVER AGAIN... |
| */ |
| dev_put(src_dev); |
| dev_put(dest_dev); |
| return ECM_DB_IFACE_HEIRARCHY_MAX; |
| } |
| } |
| |
| bridge = ecm_interface_should_update_egress_device_bridged( |
| given_dest_dev, dest_dev, is_routed); |
| |
| if (bridge) { |
| struct net_device *new_dest_dev; |
| new_dest_dev = br_port_dev_get(bridge, dest_node_addr, skb, serial); |
| if (new_dest_dev) { |
| dev_put(dest_dev); |
| if (new_dest_dev != given_dest_dev) { |
| DEBUG_INFO("Adjusted port for %pM is %s (given was %s)\n", |
| dest_node_addr, new_dest_dev->name, |
| given_dest_dev->name); |
| |
| dest_dev = new_dest_dev; |
| dest_dev_name = dest_dev->name; |
| dest_dev_type = dest_dev->type; |
| } |
| } |
| dev_put(bridge); |
| } |
| |
| next_dest_addr_valid = true; |
| next_dest_node_addr_valid = false; |
| ECM_IP_ADDR_COPY(next_dest_addr, dest_addr); |
| |
| /* |
| * Iterate until we are done or get to the max number of interfaces we can record. |
| * NOTE: current_interface_index tracks the position of the first interface position in interfaces[] |
| * because we add from the end first_interface grows downwards. |
| */ |
| current_interface_index = ECM_DB_IFACE_HEIRARCHY_MAX; |
| while (current_interface_index > 0) { |
| struct ecm_db_iface_instance *ii; |
| struct net_device *next_dev; |
| /* |
| * Get the ecm db interface instance for the device at hand |
| */ |
| ii = ecm_interface_establish_and_ref(feci, dest_dev, skb); |
| |
| /* |
| * If the interface could not be established then we abort |
| */ |
| if (!ii) { |
| DEBUG_WARN("Failed to establish interface: %p, name: %s\n", dest_dev, dest_dev_name); |
| dev_put(src_dev); |
| dev_put(dest_dev); |
| |
| /* |
| * Release the interfaces heirarchy we constructed to this point. |
| */ |
| ecm_db_connection_interfaces_deref(interfaces, current_interface_index); |
| return ECM_DB_IFACE_HEIRARCHY_MAX; |
| } |
| |
| /* |
| * Record the interface instance into the interfaces[] |
| */ |
| current_interface_index--; |
| interfaces[current_interface_index] = ii; |
| |
| /* |
| * Now we have to figure out what the next device will be (in the transmission path) the skb |
| * will use to emit to the destination address. |
| */ |
| do { |
| #ifdef ECM_INTERFACE_PPP_ENABLE |
| int channel_count; |
| struct ppp_channel *ppp_chan[1]; |
| int channel_protocol; |
| #ifdef ECM_INTERFACE_PPPOE_ENABLE |
| struct pppoe_opt addressing; |
| #endif |
| #endif |
| |
| DEBUG_TRACE("Net device: %p is type: %d, name: %s\n", dest_dev, dest_dev_type, dest_dev_name); |
| next_dev = NULL; |
| |
| if (dest_dev_type == ARPHRD_ETHER) { |
| /* |
| * Ethernet - but what sub type? |
| */ |
| |
| #ifdef ECM_INTERFACE_VLAN_ENABLE |
| /* |
| * VLAN? |
| */ |
| if (is_vlan_dev(dest_dev)) { |
| /* |
| * VLAN master |
| * No locking needed here, ASSUMPTION is that real_dev is held for as long as we have dev. |
| */ |
| next_dev = ecm_interface_vlan_real_dev(dest_dev); |
| dev_hold(next_dev); |
| DEBUG_TRACE("Net device: %p is VLAN, slave dev: %p (%s)\n", |
| dest_dev, next_dev, next_dev->name); |
| break; |
| } |
| #endif |
| |
| /* |
| * BRIDGE? |
| */ |
| if (ecm_front_end_is_bridge_device(dest_dev)) { |
| /* |
| * Bridge |
| * Figure out which port device the skb will go to using the dest_addr. |
| */ |
| uint8_t mac_addr[ETH_ALEN]; |
| |
| if (next_dest_node_addr_valid) { |
| memcpy(mac_addr, next_dest_node_addr, ETH_ALEN); |
| } else if (!next_dest_addr_valid) { |
| dev_put(src_dev); |
| dev_put(dest_dev); |
| |
| /* |
| * Release the interfaces heirarchy we constructed to this point. |
| */ |
| ecm_db_connection_interfaces_deref(interfaces, current_interface_index); |
| return ECM_DB_IFACE_HEIRARCHY_MAX; |
| } else { |
| if (!ecm_interface_multicast_get_next_node_mac_address(next_dest_addr, dest_dev, ip_version, mac_addr)) { |
| dev_put(src_dev); |
| dev_put(dest_dev); |
| |
| /* |
| * Release the interfaces heirarchy we constructed to this point. |
| */ |
| ecm_db_connection_interfaces_deref(interfaces, current_interface_index); |
| return ECM_DB_IFACE_HEIRARCHY_MAX; |
| } |
| } |
| next_dev = br_port_dev_get(dest_dev, |
| mac_addr, skb, serial); |
| if (!next_dev) { |
| DEBUG_WARN("Unable to obtain output port for: %pM\n", mac_addr); |
| dev_put(src_dev); |
| dev_put(dest_dev); |
| |
| /* |
| * Release the interfaces heirarchy we constructed to this point. |
| */ |
| ecm_db_connection_interfaces_deref(interfaces, current_interface_index); |
| return ECM_DB_IFACE_HEIRARCHY_MAX; |
| } |
| DEBUG_TRACE("Net device: %p is BRIDGE, next_dev: %p (%s)\n", dest_dev, next_dev, next_dev->name); |
| break; |
| } |
| |
| #ifdef ECM_INTERFACE_BOND_ENABLE |
| /* |
| * LAG? |
| */ |
| if (ecm_front_end_is_lag_master(dest_dev)) { |
| /* |
| * Link aggregation |
| * Figure out whiich slave device of the link aggregation will be used to reach the destination. |
| */ |
| bool dest_on_link = false; |
| ip_addr_t dest_gw_addr = ECM_IP_ADDR_NULL; |
| uint32_t src_addr_32 = 0; |
| uint32_t dest_addr_32 = 0; |
| struct in6_addr src_addr6; |
| struct in6_addr dest_addr6; |
| uint8_t src_mac_addr[ETH_ALEN]; |
| uint8_t dest_mac_addr[ETH_ALEN]; |
| struct net_device *master_dev = NULL; |
| |
| memset(src_mac_addr, 0, ETH_ALEN); |
| memset(dest_mac_addr, 0, ETH_ALEN); |
| |
| if (ip_version == 4) { |
| ECM_IP_ADDR_TO_NIN4_ADDR(src_addr_32, src_addr); |
| ECM_IP_ADDR_TO_NIN4_ADDR(dest_addr_32, dest_addr); |
| } |
| |
| if (!is_routed) { |
| memcpy(src_mac_addr, src_node_addr, ETH_ALEN); |
| memcpy(dest_mac_addr, dest_node_addr, ETH_ALEN); |
| } else { |
| struct net_device *dest_dev_master; |
| |
| /* |
| * Use appropriate source MAC address for routed packets |
| */ |
| dest_dev_master = ecm_interface_get_and_hold_dev_master(dest_dev); |
| if (dest_dev_master) { |
| memcpy(src_mac_addr, dest_dev_master->dev_addr, ETH_ALEN); |
| } else { |
| memcpy(src_mac_addr, dest_dev->dev_addr, ETH_ALEN); |
| } |
| |
| /* |
| * Determine destination MAC address for this routed packet |
| */ |
| if (next_dest_node_addr_valid) { |
| memcpy(dest_mac_addr, next_dest_node_addr, ETH_ALEN); |
| } else if (!next_dest_addr_valid) { |
| dev_put(src_dev); |
| dev_put(dest_dev); |
| if (dest_dev_master) { |
| dev_put(dest_dev_master); |
| } |
| |
| ecm_db_connection_interfaces_deref(interfaces, current_interface_index); |
| return ECM_DB_IFACE_HEIRARCHY_MAX; |
| } else { |
| if (!ecm_interface_mac_addr_get(dest_addr, dest_mac_addr, |
| &dest_on_link, dest_gw_addr)) { |
| |
| /* |
| * Find proper interfce from which to issue ARP |
| * or neighbour solicitation packet. |
| */ |
| if (dest_dev_master) { |
| master_dev = dest_dev_master; |
| } else { |
| master_dev = dest_dev; |
| } |
| |
| dev_hold(master_dev); |
| |
| if (dest_dev_master) { |
| dev_put(dest_dev_master); |
| } |
| |
| if (ip_version == 4) { |
| DEBUG_WARN("Unable to obtain MAC address for " ECM_IP_ADDR_DOT_FMT "\n", ECM_IP_ADDR_TO_DOT(dest_addr)); |
| ecm_interface_send_arp_request(dest_dev, dest_addr, dest_on_link, dest_gw_addr); |
| } |
| #ifdef ECM_IPV6_ENABLE |
| if (ip_version == 6) { |
| DEBUG_WARN("Unable to obtain MAC address for " ECM_IP_ADDR_OCTAL_FMT "\n", ECM_IP_ADDR_TO_OCTAL(dest_addr)); |
| ecm_interface_send_neighbour_solicitation(master_dev, dest_addr); |
| } |
| #endif |
| dev_put(src_dev); |
| dev_put(dest_dev); |
| dev_put(master_dev); |
| ecm_db_connection_interfaces_deref(interfaces, current_interface_index); |
| return ECM_DB_IFACE_HEIRARCHY_MAX; |
| } |
| } |
| |
| if (dest_dev_master) { |
| dev_put(dest_dev_master); |
| } |
| } |
| |
| if (ip_version == 4) { |
| next_dev = bond_get_tx_dev(NULL, src_mac_addr, dest_mac_addr, |
| &src_addr_32, &dest_addr_32, |
| htons((uint16_t)ETH_P_IP), dest_dev, layer4hdr); |
| } else if (ip_version == 6) { |
| ECM_IP_ADDR_TO_NIN6_ADDR(src_addr6, src_addr); |
| ECM_IP_ADDR_TO_NIN6_ADDR(dest_addr6, dest_addr); |
| next_dev = bond_get_tx_dev(NULL, src_mac_addr, dest_mac_addr, |
| src_addr6.s6_addr, dest_addr6.s6_addr, |
| htons((uint16_t)ETH_P_IPV6), dest_dev, layer4hdr); |
| } |
| |
| if (next_dev && netif_carrier_ok(next_dev)) { |
| dev_hold(next_dev); |
| } else { |
| DEBUG_WARN("Unable to obtain LAG output slave device\n"); |
| dev_put(src_dev); |
| dev_put(dest_dev); |
| |
| /* |
| * Release the interfaces heirarchy we constructed to this point. |
| */ |
| ecm_db_connection_interfaces_deref(interfaces, current_interface_index); |
| return ECM_DB_IFACE_HEIRARCHY_MAX; |
| } |
| |
| DEBUG_TRACE("Net device: %p is LAG, slave dev: %p (%s)\n", dest_dev, next_dev, next_dev->name); |
| break; |
| } |
| #endif |
| |
| /* |
| * ETHERNET! |
| * Just plain ethernet it seems. |
| */ |
| DEBUG_TRACE("Net device: %p is ETHERNET\n", dest_dev); |
| break; |
| } |
| |
| /* |
| * LOOPBACK? |
| */ |
| if (dest_dev_type == ARPHRD_LOOPBACK) { |
| DEBUG_TRACE("Net device: %p is LOOPBACK type: %d\n", dest_dev, dest_dev_type); |
| break; |
| } |
| |
| /* |
| * IPSEC? |
| */ |
| if (dest_dev_type == ECM_ARPHRD_IPSEC_TUNNEL_TYPE) { |
| DEBUG_TRACE("Net device: %p is IPSec tunnel type: %d\n", dest_dev, dest_dev_type); |
| /* TODO Figure out the next device the tunnel is using... */ |
| break; |
| } |
| |
| /* |
| * SIT (6-in-4)? |
| */ |
| if (dest_dev_type == ARPHRD_SIT) { |
| DEBUG_TRACE("Net device: %p is SIT (6-in-4) type: %d\n", dest_dev, dest_dev_type); |
| /* TODO Figure out the next device the tunnel is using... */ |
| break; |
| } |
| |
| /* |
| * IPIP6 Tunnel? |
| */ |
| if (dest_dev_type == ARPHRD_TUNNEL6) { |
| DEBUG_TRACE("Net device: %p is TUNIPIP6 type: %d\n", dest_dev, dest_dev_type); |
| /* TODO Figure out the next device the tunnel is using... */ |
| break; |
| } |
| |
| /* |
| * If this is NOT PPP then it is unknown to the ecm and we cannot figure out it's next device. |
| */ |
| if (dest_dev_type != ARPHRD_PPP) { |
| DEBUG_TRACE("Net device: %p is UNKNOWN type: %d\n", dest_dev, dest_dev_type); |
| break; |
| } |
| |
| #ifndef ECM_INTERFACE_PPP_ENABLE |
| DEBUG_TRACE("Net device: %p is UNKNOWN (PPP Unsupported) type: %d\n", dest_dev, dest_dev_type); |
| #else |
| DEBUG_TRACE("Net device: %p is PPP\n", dest_dev); |
| |
| #ifdef ECM_INTERFACE_L2TPV2_ENABLE |
| if ((given_src_dev->priv_flags & IFF_PPP_L2TPV2) && ppp_is_xmit_locked(given_src_dev)) { |
| if (skb->skb_iif == dest_dev->ifindex) { |
| DEBUG_TRACE("Net device: %p PPP channel is PPPoL2TPV2\n", dest_dev); |
| break; |
| } |
| } |
| #endif |
| |
| #ifdef ECM_INTERFACE_PPTP_ENABLE |
| if (protocol == IPPROTO_GRE && dest_dev && dest_dev->type == ARPHRD_PPP) { |
| DEBUG_TRACE("Net device: %p PPP channel is PPTP\n", dest_dev); |
| break; |
| } |
| #endif |
| /* |
| * PPP - but what is the channel type? |
| * First: If this is multi-link then we do not support it |
| */ |
| if (ppp_is_multilink(dest_dev) > 0) { |
| DEBUG_TRACE("Net device: %p is MULTILINK PPP - Unknown to the ECM\n", dest_dev); |
| break; |
| } |
| |
| /* |
| * Get the PPP channel and then enquire what kind of channel it is |
| * NOTE: Not multilink so only one channel to get. |
| */ |
| channel_count = ppp_hold_channels(dest_dev, ppp_chan, 1); |
| if (channel_count != 1) { |
| DEBUG_TRACE("Net device: %p PPP has %d channels - Unknown to the ECM\n", |
| dest_dev, channel_count); |
| break; |
| } |
| |
| /* |
| * Get channel protocol type |
| * NOTE: Not all PPP channels support channel specific methods. |
| */ |
| channel_protocol = ppp_channel_get_protocol(ppp_chan[0]); |
| |
| #ifdef ECM_INTERFACE_L2TPV2_ENABLE |
| if (channel_protocol == PX_PROTO_OL2TP) { |
| |
| /* |
| * PPPoL2TPV2 channel |
| */ |
| ppp_release_channels(ppp_chan, 1); |
| DEBUG_TRACE("Net device: %p PPP channel is PPPoL2TPV2\n", dest_dev); |
| |
| /* |
| * Release the channel. Note that next_dev not held. |
| */ |
| break; |
| } |
| #endif |
| #ifdef ECM_INTERFACE_PPPOE_ENABLE |
| if (channel_protocol == PX_PROTO_OE) { |
| /* |
| * PPPoE channel |
| */ |
| DEBUG_TRACE("Net device: %p PPP channel is PPPoE\n", dest_dev); |
| |
| /* |
| * Get PPPoE session information and the underlying device it is using. |
| */ |
| pppoe_channel_addressing_get(ppp_chan[0], &addressing); |
| |
| /* |
| * Copy the dev hold into this, we will release the hold later |
| */ |
| next_dev = addressing.dev; |
| next_dest_addr_valid = false; |
| next_dest_node_addr_valid = true; |
| memcpy(next_dest_node_addr, addressing.pa.remote, ETH_ALEN); |
| |
| /* |
| * Release the channel. Note that next_dev is still (correctly) held. |
| */ |
| ppp_release_channels(ppp_chan, 1); |
| break; |
| } |
| #endif |
| |
| DEBUG_TRACE("Net device: %p PPP channel protocol: %d - Unknown to the ECM\n", |
| dest_dev, channel_protocol); |
| |
| /* |
| * Release the channel |
| */ |
| ppp_release_channels(ppp_chan, 1); |
| |
| #endif |
| } while (false); |
| |
| /* |
| * No longer need dest_dev as it may become next_dev |
| */ |
| dev_put(dest_dev); |
| |
| /* |
| * Check out the next_dev, if any |
| */ |
| if (!next_dev) { |
| int32_t i __attribute__((unused)); |
| DEBUG_INFO("Completed interface heirarchy construct with first interface @: %d\n", current_interface_index); |
| #if DEBUG_LEVEL > 1 |
| for (i = current_interface_index; i < ECM_DB_IFACE_HEIRARCHY_MAX; ++i) { |
| DEBUG_TRACE("\tInterface @ %d: %p, type: %d, name: %s\n", |
| i, interfaces[i], ecm_db_connection_iface_type_get(interfaces[i]), ecm_db_interface_type_to_string(ecm_db_connection_iface_type_get(interfaces[i]))); |
| |
| } |
| #endif |
| |
| /* |
| * Release src_dev now |
| */ |
| dev_put(src_dev); |
| return current_interface_index; |
| } |
| |
| /* |
| * dest_dev becomes next_dev |
| */ |
| dest_dev = next_dev; |
| dest_dev_name = dest_dev->name; |
| dest_dev_type = dest_dev->type; |
| } |
| |
| DEBUG_WARN("Too many interfaces: %d\n", current_interface_index); |
| DEBUG_ASSERT(current_interface_index == 0, "Bad logic handling current_interface_index: %d\n", current_interface_index); |
| dev_put(src_dev); |
| dev_put(dest_dev); |
| |
| /* |
| * Release the interfaces heirarchy we constructed to this point. |
| */ |
| ecm_db_connection_interfaces_deref(interfaces, current_interface_index); |
| return ECM_DB_IFACE_HEIRARCHY_MAX; |
| } |
| EXPORT_SYMBOL(ecm_interface_multicast_from_heirarchy_construct); |
| #endif |
| |
| /* |
| * ecm_interface_list_stats_update() |
| * Given an interface list, walk the interfaces and update the stats for certain types. |
| */ |
| static void ecm_interface_list_stats_update(int iface_list_first, struct ecm_db_iface_instance *iface_list[], uint8_t *mac_addr, |
| bool is_mcast_flow, uint32_t tx_packets, uint32_t tx_bytes, uint32_t rx_packets, uint32_t rx_bytes) |
| { |
| int list_index; |
| |
| for (list_index = iface_list_first; (list_index < ECM_DB_IFACE_HEIRARCHY_MAX); list_index++) { |
| struct ecm_db_iface_instance *ii; |
| ecm_db_iface_type_t ii_type; |
| char *ii_name; |
| struct net_device *dev; |
| |
| ii = iface_list[list_index]; |
| ii_type = ecm_db_connection_iface_type_get(ii); |
| ii_name = ecm_db_interface_type_to_string(ii_type); |
| DEBUG_TRACE("list_index: %d, ii: %p, type: %d (%s)\n", list_index, ii, ii_type, ii_name); |
| |
| /* |
| * Locate real device in system |
| */ |
| dev = dev_get_by_index(&init_net, ecm_db_iface_interface_identifier_get(ii)); |
| if (!dev) { |
| DEBUG_WARN("Could not locate interface\n"); |
| continue; |
| } |
| DEBUG_TRACE("found dev: %p (%s)\n", dev, dev->name); |
| |
| if (likely(!is_mcast_flow)) { |
| /* |
| * Refresh the bridge forward table entry if the port is a bridge port |
| * Note: A bridge port can be of different interface type, e.g VLAN, ethernet. |
| * This check, therefore, should be performed for all interface types. |
| */ |
| if (is_valid_ether_addr(mac_addr) && ecm_front_end_is_bridge_port(dev) && rx_packets) { |
| DEBUG_TRACE("Update bridge fdb entry for mac: %pM\n", mac_addr); |
| br_refresh_fdb_entry(dev, mac_addr); |
| } |
| } |
| |
| switch (ii_type) { |
| struct rtnl_link_stats64 stats; |
| |
| #ifdef ECM_INTERFACE_VLAN_ENABLE |
| case ECM_DB_IFACE_TYPE_VLAN: |
| DEBUG_INFO("VLAN\n"); |
| stats.rx_packets = rx_packets; |
| stats.rx_bytes = rx_bytes; |
| stats.tx_packets = tx_packets; |
| stats.tx_bytes = tx_bytes; |
| __vlan_dev_update_accel_stats(dev, &stats); |
| break; |
| #endif |
| case ECM_DB_IFACE_TYPE_BRIDGE: |
| DEBUG_INFO("BRIDGE\n"); |
| stats.rx_packets = rx_packets; |
| stats.rx_bytes = rx_bytes; |
| stats.tx_packets = tx_packets; |
| stats.tx_bytes = tx_bytes; |
| br_dev_update_stats(dev, &stats); |
| break; |
| |
| #ifdef ECM_INTERFACE_PPPOE_ENABLE |
| case ECM_DB_IFACE_TYPE_PPPOE: |
| DEBUG_INFO("PPPOE\n"); |
| ppp_update_stats(dev, rx_packets, rx_bytes, tx_packets, tx_bytes, 0, 0, 0, 0); |
| break; |
| #endif |
| default: |
| /* |
| * TODO: Extend it accordingly |
| */ |
| break; |
| } |
| |
| dev_put(dev); |
| } |
| } |
| |
| /* |
| * ecm_interface_stats_update() |
| * Using the interface lists for the given connection, update the interface statistics for each. |
| * |
| * 'from' here is wrt the connection 'from' side. Likewise with 'to'. |
| * TX is wrt what the interface has transmitted. RX is what the interface has received. |
| */ |
| void ecm_interface_stats_update(struct ecm_db_connection_instance *ci, |
| uint32_t from_tx_packets, uint32_t from_tx_bytes, uint32_t from_rx_packets, uint32_t from_rx_bytes, |
| uint32_t to_tx_packets, uint32_t to_tx_bytes, uint32_t to_rx_packets, uint32_t to_rx_bytes) |
| { |
| struct ecm_db_iface_instance *from_ifaces[ECM_DB_IFACE_HEIRARCHY_MAX]; |
| struct ecm_db_iface_instance *to_ifaces[ECM_DB_IFACE_HEIRARCHY_MAX]; |
| int from_ifaces_first; |
| int to_ifaces_first; |
| uint8_t mac_addr[ETH_ALEN]; |
| |
| /* |
| * Iterate the 'from' side interfaces and update statistics and state for the real HLOS interfaces |
| * from_tx_packets / bytes: the amount transmitted by the 'from' interface |
| * from_rx_packets / bytes: the amount received by the 'from' interface |
| */ |
| DEBUG_INFO("%p: Update from interface stats\n", ci); |
| from_ifaces_first = ecm_db_connection_from_interfaces_get_and_ref(ci, from_ifaces); |
| ecm_db_connection_from_node_address_get(ci, mac_addr); |
| ecm_interface_list_stats_update(from_ifaces_first, from_ifaces, mac_addr, false, from_tx_packets, from_tx_bytes, from_rx_packets, from_rx_bytes); |
| ecm_db_connection_interfaces_deref(from_ifaces, from_ifaces_first); |
| |
| /* |
| * Iterate the 'to' side interfaces and update statistics and state for the real HLOS interfaces |
| * to_tx_packets / bytes: the amount transmitted by the 'to' interface |
| * to_rx_packets / bytes: the amount received by the 'to' interface |
| */ |
| DEBUG_INFO("%p: Update to interface stats\n", ci); |
| to_ifaces_first = ecm_db_connection_to_interfaces_get_and_ref(ci, to_ifaces); |
| ecm_db_connection_to_node_address_get(ci, mac_addr); |
| ecm_interface_list_stats_update(to_ifaces_first, to_ifaces, mac_addr, false, to_tx_packets, to_tx_bytes, to_rx_packets, to_rx_bytes); |
| ecm_db_connection_interfaces_deref(to_ifaces, to_ifaces_first); |
| } |
| EXPORT_SYMBOL(ecm_interface_stats_update); |
| |
| #ifdef ECM_MULTICAST_ENABLE |
| /* |
| * ecm_interface_multicast_stats_update() |
| * Using the interface lists for the given connection, update the interface statistics for each. |
| * |
| * 'from interface' here is the connection 'from' side. Likewise with 'to interface'. |
| * TX is wrt what the interface has transmitted. RX is what the interface has received. |
| */ |
| void ecm_interface_multicast_stats_update(struct ecm_db_connection_instance *ci, uint32_t from_tx_packets, uint32_t from_tx_bytes, |
| uint32_t from_rx_packets, uint32_t from_rx_bytes, uint32_t to_tx_packets, uint32_t to_tx_bytes, |
| uint32_t to_rx_packets, uint32_t to_rx_bytes) |
| { |
| struct ecm_db_iface_instance *from_ifaces[ECM_DB_IFACE_HEIRARCHY_MAX]; |
| struct ecm_db_iface_instance *to_list_single[ECM_DB_IFACE_HEIRARCHY_MAX]; |
| struct ecm_db_iface_instance *to_ifaces; |
| struct ecm_db_iface_instance *ii_temp; |
| int from_ifaces_first; |
| int *to_ifaces_first; |
| int if_index; |
| int ret; |
| uint8_t mac_addr[ETH_ALEN]; |
| |
| /* |
| * Iterate the 'from' side interfaces and update statistics and state for the real HLOS interfaces |
| * from_tx_packets / bytes: the amount transmitted by the 'from' interface |
| * from_rx_packets / bytes: the amount received by the 'from' interface |
| */ |
| DEBUG_INFO("%p: Update from interface stats\n", ci); |
| from_ifaces_first = ecm_db_connection_from_interfaces_get_and_ref(ci, from_ifaces); |
| ecm_db_connection_from_node_address_get(ci, mac_addr); |
| ecm_interface_list_stats_update(from_ifaces_first, from_ifaces, mac_addr, false, from_tx_packets, from_tx_bytes, from_rx_packets, from_rx_bytes); |
| ecm_db_connection_interfaces_deref(from_ifaces, from_ifaces_first); |
| |
| /* |
| * Iterate the 'to' side interfaces and update statistics and state for the real HLOS interfaces |
| * to_tx_packets / bytes: the amount transmitted by the 'to' interface |
| * to_rx_packets / bytes: the amount received by the 'to' interface |
| */ |
| DEBUG_INFO("%p: Update to interface stats\n", ci); |
| |
| /* |
| * This function allocates the memory for temporary destination interface heirarchies. |
| * This memory needs to be free at the end. |
| */ |
| ret = ecm_db_multicast_connection_to_interfaces_get_and_ref_all(ci, &to_ifaces, &to_ifaces_first); |
| if (ret == 0) { |
| DEBUG_WARN("%p: Get and ref to all multicast detination interface heirarchies failed\n", ci); |
| return; |
| } |
| |
| for (if_index = 0; if_index < ECM_DB_MULTICAST_IF_MAX; if_index++) { |
| if (to_ifaces_first[if_index] < ECM_DB_IFACE_HEIRARCHY_MAX) { |
| ii_temp = ecm_db_multicast_if_heirarchy_get(to_ifaces, if_index); |
| ecm_db_multicast_copy_if_heirarchy(to_list_single, ii_temp); |
| ecm_interface_list_stats_update(to_ifaces_first[if_index], to_list_single, mac_addr, true, to_tx_packets, to_tx_bytes, to_rx_packets, to_rx_bytes); |
| } |
| } |
| |
| ecm_db_multicast_connection_to_interfaces_deref_all(to_ifaces, to_ifaces_first); |
| } |
| EXPORT_SYMBOL(ecm_interface_multicast_stats_update); |
| #endif |
| |
| /* |
| * ecm_interface_regenerate_connections() |
| * Cause regeneration of all connections that are using the specified interface. |
| */ |
| static void ecm_interface_regenerate_connections(struct ecm_db_iface_instance *ii) |
| { |
| #ifdef ECM_DB_XREF_ENABLE |
| struct ecm_db_connection_instance *ci_from; |
| struct ecm_db_connection_instance *ci_to; |
| struct ecm_db_connection_instance *ci_from_nat; |
| struct ecm_db_connection_instance *ci_to_nat; |
| struct ecm_db_connection_instance *ci_mcast __attribute__ ((unused)); |
| #endif |
| |
| DEBUG_TRACE("Regenerate connections using interface: %p\n", ii); |
| |
| #ifndef ECM_DB_XREF_ENABLE |
| /* |
| * An interface has changed, re-generate the connections to ensure all state is updated. |
| */ |
| ecm_db_regeneration_needed(); |
| #else |
| /* |
| * If the interface has NO connections then we re-generate all. |
| */ |
| ci_from = ecm_db_iface_connections_from_get_and_ref_first(ii); |
| ci_to = ecm_db_iface_connections_to_get_and_ref_first(ii); |
| ci_from_nat = ecm_db_iface_connections_nat_from_get_and_ref_first(ii); |
| ci_to_nat = ecm_db_iface_connections_nat_to_get_and_ref_first(ii); |
| if (!ci_from && !ci_to && !ci_from_nat && !ci_to_nat) { |
| ecm_db_regeneration_needed(); |
| DEBUG_TRACE("%p: Regenerate (ALL) COMPLETE\n", ii); |
| return; |
| } |
| |
| /* |
| * Re-generate all connections associated with this interface |
| */ |
| DEBUG_TRACE("%p: Regenerate 'from' connections\n", ii); |
| while (ci_from) { |
| struct ecm_db_connection_instance *cin; |
| cin = ecm_db_connection_iface_from_get_and_ref_next(ci_from); |
| |
| DEBUG_TRACE("%p: Regenerate: %p", ii, ci_from); |
| ecm_db_connection_regenerate(ci_from); |
| ecm_db_connection_deref(ci_from); |
| ci_from = cin; |
| } |
| |
| DEBUG_TRACE("%p: Regenerate 'to' connections\n", ii); |
| while (ci_to) { |
| struct ecm_db_connection_instance *cin; |
| cin = ecm_db_connection_iface_to_get_and_ref_next(ci_to); |
| |
| DEBUG_TRACE("%p: Regenerate: %p", ii, ci_to); |
| ecm_db_connection_regenerate(ci_to); |
| ecm_db_connection_deref(ci_to); |
| ci_to = cin; |
| } |
| |
| /* |
| * GGG TODO These deprecated lists _nat_ lists will eventually be removed |
| */ |
| DEBUG_TRACE("%p: Regenerate 'from_nat' connections\n", ii); |
| while (ci_from_nat) { |
| struct ecm_db_connection_instance *cin; |
| cin = ecm_db_connection_iface_nat_from_get_and_ref_next(ci_from_nat); |
| |
| DEBUG_TRACE("%p: Regenerate: %p", ii, ci_from_nat); |
| ecm_db_connection_regenerate(ci_from_nat); |
| ecm_db_connection_deref(ci_from_nat); |
| ci_from_nat = cin; |
| } |
| |
| DEBUG_TRACE("%p: Regenerate 'to_nat' connections\n", ii); |
| while (ci_to_nat) { |
| struct ecm_db_connection_instance *cin; |
| cin = ecm_db_connection_iface_nat_to_get_and_ref_next(ci_to_nat); |
| |
| DEBUG_TRACE("%p: Regenerate: %p", ii, ci_to_nat); |
| ecm_db_connection_regenerate(ci_to_nat); |
| ecm_db_connection_deref(ci_to_nat); |
| ci_to_nat = cin; |
| } |
| |
| #ifdef ECM_MULTICAST_ENABLE |
| /* |
| * Multicasts would not have recorded in the lists above. |
| * Our only way to re-gen those is to iterate all multicasts. |
| * GGG TODO This will be optimised in a future release. |
| */ |
| ci_mcast = ecm_db_connections_get_and_ref_first(); |
| while (ci_mcast) { |
| struct ecm_db_connection_instance *cin; |
| |
| /* |
| * Multicast and NOT flagged for re-gen? |
| */ |
| if (ecm_db_multicast_connection_to_interfaces_set_check(ci_mcast) |
| && ecm_db_connection_regeneration_required_peek(ci_mcast)) { |
| ecm_db_connection_regenerate(ci_mcast); |
| } |
| |
| cin = ecm_db_connection_get_and_ref_next(ci_mcast); |
| ecm_db_connection_deref(ci_mcast); |
| ci_mcast = cin; |
| } |
| #endif |
| |
| #endif |
| DEBUG_TRACE("%p: Regenerate COMPLETE\n", ii); |
| } |
| |
| /* |
| * ecm_interface_dev_regenerate_connections() |
| * Cause regeneration of all connections that are using the specified interface. |
| */ |
| void ecm_interface_dev_regenerate_connections(struct net_device *dev) |
| { |
| struct ecm_db_iface_instance *ii; |
| |
| DEBUG_INFO("Regenerate connections for: %p (%s)\n", dev, dev->name); |
| |
| /* |
| * If the interface is known to us then we will get it returned by this |
| * function and process it accordingly. |
| */ |
| ii = ecm_db_iface_find_and_ref_by_interface_identifier(dev->ifindex); |
| if (!ii) { |
| DEBUG_WARN("%p: No interface instance could be established for this dev\n", dev); |
| return; |
| } |
| ecm_interface_regenerate_connections(ii); |
| DEBUG_TRACE("%p: Regenerate for %p: COMPLETE\n", dev, ii); |
| ecm_db_iface_deref(ii); |
| } |
| |
| /* |
| * ecm_interface_defunct_connections() |
| * Cause defunct of all connections that are using the specified interface. |
| */ |
| static void ecm_interface_defunct_connections(struct ecm_db_iface_instance *ii) |
| { |
| #ifndef ECM_DB_XREF_ENABLE |
| ecm_db_connection_defunct_all(); |
| #else |
| struct ecm_db_connection_instance *ci_from; |
| struct ecm_db_connection_instance *ci_to; |
| struct ecm_db_connection_instance *ci_from_nat; |
| struct ecm_db_connection_instance *ci_to_nat; |
| struct ecm_db_connection_instance *ci_mcast __attribute__ ((unused)); |
| |
| DEBUG_TRACE("defunct connections using interface: %p\n", ii); |
| |
| ci_from = ecm_db_iface_connections_from_get_and_ref_first(ii); |
| ci_to = ecm_db_iface_connections_to_get_and_ref_first(ii); |
| ci_from_nat = ecm_db_iface_connections_nat_from_get_and_ref_first(ii); |
| ci_to_nat = ecm_db_iface_connections_nat_to_get_and_ref_first(ii); |
| |
| /* |
| * Defunct ALL if all the four connection instances are NULL |
| */ |
| if (!ci_from && !ci_to && !ci_from_nat && !ci_to_nat) { |
| ecm_db_connection_defunct_all(); |
| DEBUG_TRACE("%p: Defunct (ALL) COMPLETE\n", ii); |
| return; |
| } |
| |
| /* |
| * Defunct all connections associated with this interface |
| */ |
| DEBUG_TRACE("%p: Defunct 'from' connections\n", ii); |
| while (ci_from) { |
| struct ecm_db_connection_instance *cin; |
| cin = ecm_db_connection_iface_from_get_and_ref_next(ci_from); |
| |
| DEBUG_TRACE("%p: Defunct: %p", ii, ci_from); |
| ecm_db_connection_make_defunct(ci_from); |
| ecm_db_connection_deref(ci_from); |
| ci_from = cin; |
| } |
| |
| DEBUG_TRACE("%p: Defunct 'to' connections\n", ii); |
| while (ci_to) { |
| struct ecm_db_connection_instance *cin; |
| cin = ecm_db_connection_iface_from_get_and_ref_next(ci_to); |
| |
| DEBUG_TRACE("%p: Defunct: %p", ii, ci_to); |
| ecm_db_connection_make_defunct(ci_to); |
| ecm_db_connection_deref(ci_to); |
| ci_to = cin; |
| } |
| |
| DEBUG_TRACE("%p: Defunct 'from_nat' connections\n", ii); |
| while (ci_from_nat) { |
| struct ecm_db_connection_instance *cin; |
| cin = ecm_db_connection_iface_from_get_and_ref_next(ci_from_nat); |
| |
| DEBUG_TRACE("%p: Defunct: %p", ii, ci_from_nat); |
| ecm_db_connection_make_defunct(ci_from_nat); |
| ecm_db_connection_deref(ci_from_nat); |
| ci_from_nat = cin; |
| } |
| |
| DEBUG_TRACE("%p: Defunct 'to_nat' connections\n", ii); |
| while (ci_to_nat) { |
| struct ecm_db_connection_instance *cin; |
| cin = ecm_db_connection_iface_from_get_and_ref_next(ci_to_nat); |
| |
| DEBUG_TRACE("%p: Defunct: %p", ii, ci_to_nat); |
| ecm_db_connection_make_defunct(ci_to_nat); |
| ecm_db_connection_deref(ci_to_nat); |
| ci_to_nat = cin; |
| } |
| #endif |
| DEBUG_TRACE("%p: Defunct COMPLETE\n", ii); |
| } |
| |
| /* |
| * ecm_interface_dev_defunct_connections() |
| * Cause defunct of all connections that are using the specified interface. |
| */ |
| void ecm_interface_dev_defunct_connections(struct net_device *dev) |
| { |
| struct ecm_db_iface_instance *ii; |
| |
| DEBUG_INFO("defunct connections for: %p (%s)\n", dev, dev->name); |
| |
| /* |
| * If the interface is known to us then we will get it returned by this |
| * function and process it accordingly. |
| */ |
| ii = ecm_db_iface_find_and_ref_by_interface_identifier(dev->ifindex); |
| if (!ii) { |
| DEBUG_WARN("%p: No interface instance could be established for this dev\n", dev); |
| return; |
| } |
| ecm_interface_defunct_connections(ii); |
| DEBUG_TRACE("%p: defunct for %p: COMPLETE\n", dev, ii); |
| ecm_db_iface_deref(ii); |
| } |
| |
| /* |
| * ecm_interface_mtu_change() |
| * MTU of interface has changed |
| */ |
| static void ecm_interface_mtu_change(struct net_device *dev) |
| { |
| int mtu; |
| struct ecm_db_iface_instance *ii; |
| |
| mtu = dev->mtu; |
| DEBUG_INFO("%p (%s): MTU Change to: %d\n", dev, dev->name, mtu); |
| |
| /* |
| * Find the interface for the given device. |
| */ |
| ii = ecm_db_iface_find_and_ref_by_interface_identifier(dev->ifindex); |
| if (!ii) { |
| DEBUG_WARN("%p: No interface instance could be established for this dev\n", dev); |
| return; |
| } |
| |
| /* |
| * Change the mtu |
| */ |
| ecm_db_iface_mtu_reset(ii, mtu); |
| DEBUG_TRACE("%p (%s): MTU Changed to: %d\n", dev, dev->name, mtu); |
| if (netif_is_bond_slave(dev)) { |
| struct net_device *master = NULL; |
| master = ecm_interface_get_and_hold_dev_master(dev); |
| DEBUG_ASSERT(master, "Expected a master\n"); |
| ecm_interface_dev_regenerate_connections(master); |
| dev_put(master); |
| } else { |
| ecm_interface_regenerate_connections(ii); |
| } |
| |
| DEBUG_TRACE("%p: Regenerate for %p: COMPLETE\n", dev, ii); |
| ecm_db_iface_deref(ii); |
| } |
| |
| /* |
| * ecm_interface_netdev_notifier_callback() |
| * Netdevice notifier callback to inform us of change of state of a netdevice |
| */ |
| static int ecm_interface_netdev_notifier_callback(struct notifier_block *this, unsigned long event, void *ptr) |
| { |
| #if (LINUX_VERSION_CODE <= KERNEL_VERSION(3, 10, 0)) |
| struct net_device *dev __attribute__ ((unused)) = (struct net_device *)ptr; |
| #else |
| struct net_device *dev = netdev_notifier_info_to_dev(ptr); |
| #endif |
| struct net_device *master = NULL; |
| |
| DEBUG_INFO("Net device notifier for: %p, name: %s, event: %lx\n", dev, dev->name, event); |
| |
| switch (event) { |
| case NETDEV_DOWN: |
| DEBUG_INFO("Net device: %p, DOWN\n", dev); |
| if (netif_is_bond_slave(dev)) { |
| master = ecm_interface_get_and_hold_dev_master(dev); |
| DEBUG_ASSERT(master, "Expected a master\n"); |
| ecm_interface_dev_defunct_connections(master); |
| dev_put(master); |
| } else { |
| ecm_interface_dev_defunct_connections(dev); |
| } |
| break; |
| |
| case NETDEV_CHANGE: |
| DEBUG_INFO("Net device: %p, CHANGE\n", dev); |
| if (!netif_carrier_ok(dev)) { |
| DEBUG_INFO("Net device: %p, CARRIER BAD\n", dev); |
| if (netif_is_bond_slave(dev)) { |
| master = ecm_interface_get_and_hold_dev_master(dev); |
| DEBUG_ASSERT(master, "Expected a master.\n"); |
| ecm_interface_dev_defunct_connections(master); |
| dev_put(master); |
| } else { |
| ecm_interface_dev_defunct_connections(dev); |
| } |
| } |
| break; |
| |
| case NETDEV_CHANGEMTU: |
| DEBUG_INFO("Net device: %p, MTU CHANGE\n", dev); |
| ecm_interface_mtu_change(dev); |
| break; |
| |
| default: |
| DEBUG_TRACE("Net device: %p, UNHANDLED: %lx\n", dev, event); |
| break; |
| } |
| |
| return NOTIFY_DONE; |
| } |
| |
| /* |
| * ecm_interface_node_connections_defunct() |
| * Defunct the connections on this node. |
| */ |
| void ecm_interface_node_connections_defunct(uint8_t *mac) |
| { |
| struct ecm_db_node_instance *ni = NULL; |
| |
| if (unlikely(!mac)) { |
| DEBUG_WARN("mac address is null\n"); |
| return; |
| } |
| |
| ni = ecm_db_node_chain_get_and_ref_first(mac); |
| while (ni) { |
| struct ecm_db_node_instance *nin; |
| |
| if (ecm_db_node_is_mac_addr_equal(ni, mac)) { |
| ecm_db_traverse_node_from_connection_list_and_defunct(ni); |
| ecm_db_traverse_node_to_connection_list_and_defunct(ni); |
| ecm_db_traverse_node_from_nat_connection_list_and_defunct(ni); |
| ecm_db_traverse_node_to_nat_connection_list_and_defunct(ni); |
| } |
| |
| /* |
| * Get next node in the chain |
| */ |
| nin = ecm_db_node_chain_get_and_ref_next(ni); |
| ecm_db_node_deref(ni); |
| ni = nin; |
| } |
| } |
| EXPORT_SYMBOL(ecm_interface_node_connections_defunct); |
| |
| /* |
| * struct notifier_block ecm_interface_netdev_notifier |
| * Registration for net device changes of state. |
| */ |
| static struct notifier_block ecm_interface_netdev_notifier __read_mostly = { |
| .notifier_call = ecm_interface_netdev_notifier_callback, |
| }; |
| |
| #if defined(ECM_DB_XREF_ENABLE) && defined(ECM_BAND_STEERING_ENABLE) |
| /* |
| * ecm_interfae_node_br_fdb_notify_event() |
| * This is a call back for "bridge fdb update event/ageing timer expire |
| * event". |
| */ |
| static int ecm_interface_node_br_fdb_notify_event(struct notifier_block *nb, |
| unsigned long val, |
| void *data) |
| { |
| uint8_t *mac = (uint8_t *)data; |
| |
| if (ECM_FRONT_END_TYPE_NSS == ecm_front_end_type_get()) { |
| DEBUG_INFO("FDB updated for node %pM\n", mac); |
| ecm_interface_node_connections_defunct(mac); |
| } |
| |
| return NOTIFY_DONE; |
| } |
| |
| static struct notifier_block ecm_interface_node_br_fdb_update_nb = { |
| .notifier_call = ecm_interface_node_br_fdb_notify_event, |
| }; |
| |
| static int ecm_interface_node_br_fdb_delete_event(struct notifier_block *nb, |
| unsigned long event, |
| void *ctx) |
| { |
| struct br_fdb_event *fe = (struct br_fdb_event *)ctx; |
| |
| if ((event != BR_FDB_EVENT_DEL) || fe->is_local) { |
| DEBUG_WARN("local fdb or not deleting event, ignore\n"); |
| return NOTIFY_DONE; |
| } |
| |
| return ecm_interface_node_br_fdb_notify_event(nb, event, fe->addr); |
| } |
| |
| static struct notifier_block ecm_interface_node_br_fdb_delete_nb = { |
| .notifier_call = ecm_interface_node_br_fdb_delete_event, |
| }; |
| #endif |
| |
| #ifdef ECM_MULTICAST_ENABLE |
| /* |
| * ecm_interface_multicast_find_outdated_iface_instances() |
| * |
| * Called in the case of Routing/Bridging Multicast update events. |
| * |
| * This function takes a list of ifindex for the connection which was received |
| * from MFC or bridge snooper, compares it against the existing list of interfaces |
| * in the DB connection, and extracts the list of those interfaces that have left |
| * the multicast group. |
| * |
| * ci A DB connection instance. |
| * mc_updates Part of return Information. The function will mark the index of those |
| * interfaces in the DB connection 'to_mcast_interfaces' array that have |
| * left the group, in the mc_updates->if_leave_idx array. The caller uses this |
| * information to delete those outdated interface heirarchies from the |
| * connection. |
| * is_bridged True if the function called due to bridge multicast snooper update event. |
| * dst_dev Holds the netdevice ifindex number of the new list of interfaces as reported |
| * by the update from MFC or Bridge snooper. |
| * max_to_dev Size of the array 'dst_dev' |
| * |
| * Return true if outdated interfaces found |
| */ |
| static bool ecm_interface_multicast_find_outdated_iface_instances(struct ecm_db_connection_instance *ci, struct ecm_multicast_if_update *mc_updates, |
| uint32_t flags, bool is_br_snooper, uint32_t *mc_dst_if_index, uint32_t max_to_dev) |
| { |
| struct ecm_db_iface_instance *mc_ifaces; |
| struct ecm_db_iface_instance *ii_temp; |
| struct ecm_db_iface_instance *ii_single; |
| struct ecm_db_iface_instance **ifaces; |
| struct ecm_db_iface_instance *to_iface; |
| int32_t *to_iface_first; |
| int32_t *mc_ifaces_first; |
| uint32_t *dst_if_index; |
| ecm_db_iface_type_t ii_type; |
| int32_t heirarchy_index; |
| int32_t if_index; |
| int32_t if_cnt = 0; |
| int found = 0; |
| int ii; |
| int ret; |
| int32_t ifaces_identifier; |
| |
| ret = ecm_db_multicast_connection_to_interfaces_get_and_ref_all(ci, &mc_ifaces, &mc_ifaces_first); |
| if (ret == 0) { |
| DEBUG_WARN("%p: multicast interfaces ref fail!\n", ci); |
| return false; |
| } |
| |
| /* |
| * Loop through the current interface list in the DB |
| * connection 'to_mcast_interfaces' array |
| */ |
| for (heirarchy_index = 0; heirarchy_index < ECM_DB_MULTICAST_IF_MAX; heirarchy_index++) { |
| found = 0; |
| to_iface_first = ecm_db_multicast_if_first_get_at_index(mc_ifaces_first, heirarchy_index); |
| |
| /* |
| * Invalid interface entry, skip |
| */ |
| if (*to_iface_first == ECM_DB_IFACE_HEIRARCHY_MAX) { |
| continue; |
| } |
| |
| ii_temp = ecm_db_multicast_if_heirarchy_get(mc_ifaces, heirarchy_index); |
| ii_single = ecm_db_multicast_if_instance_get_at_index(ii_temp, ECM_DB_IFACE_HEIRARCHY_MAX - 1); |
| ifaces = (struct ecm_db_iface_instance **)ii_single; |
| to_iface = *ifaces; |
| ii_type = ecm_db_connection_iface_type_get(to_iface); |
| |
| /* |
| * If the update was received from bridge snooper, do not consider entries in the |
| * interface list that are not part of a bridge. |
| */ |
| if (is_br_snooper && (ii_type != ECM_DB_IFACE_TYPE_BRIDGE)) { |
| continue; |
| } |
| |
| /* |
| * If the update was received from MFC, do not consider entries in the |
| * interface list that are part of a bridge. The bridge entries will be |
| * taken care by the Bridge Snooper Callback |
| */ |
| if (ii_type == ECM_DB_IFACE_TYPE_BRIDGE) { |
| if (!is_br_snooper && !(flags & ECM_DB_MULTICAST_CONNECTION_BRIDGE_DEV_SET_FLAG)) { |
| continue; |
| } |
| } |
| |
| /* |
| * Try to find a match in the newly received interface list, for any of |
| * the interface instance in the heirarchy. If found, it means that this |
| * interface has not left the group. If not found, it means that this |
| * interface has left the group. |
| */ |
| for (ii = ECM_DB_IFACE_HEIRARCHY_MAX - 1; ii >= *to_iface_first; ii--) { |
| ii_single = ecm_db_multicast_if_instance_get_at_index(ii_temp, ii); |
| ifaces = (struct ecm_db_iface_instance **)ii_single; |
| to_iface = *ifaces; |
| |
| ii_type = ecm_db_connection_iface_type_get(to_iface); |
| ifaces_identifier = ecm_db_iface_interface_identifier_get(to_iface); |
| for (if_index = 0; if_index < max_to_dev; if_index++) { |
| dst_if_index = ecm_db_multicast_if_num_get_at_index(mc_dst_if_index, if_index); |
| if (*dst_if_index == ifaces_identifier) { |
| found = 1; |
| break; |
| } |
| } |
| if (found) { |
| break; |
| } |
| } |
| |
| /* |
| * We did not find a match for the interface in the present list. So mark |
| * if as one that has left the group. |
| */ |
| if (!found) { |
| if_cnt++; |
| mc_updates->if_leave_idx[heirarchy_index] = 1; |
| } |
| } |
| |
| ecm_db_multicast_connection_to_interfaces_deref_all(mc_ifaces, mc_ifaces_first); |
| mc_updates->if_leave_cnt = if_cnt; |
| return (if_cnt > 0); |
| } |
| |
| /* |
| * ecm_interface_multicast_find_new_iface_instances() |
| * |
| * Called in the case of Routing/Bridging Multicast update events. |
| * |
| * This function takes a list of ifindex for the connection which was received |
| * from MFC or bridge snooper, compares it against the existing list of interfaces |
| * in the DB connection, and extracts the list of the new joinees for the multicast |
| * group. |
| * |
| * ci A DB connection instance. |
| * mc_updates Part of return Information. The function will mark the index of those |
| * interfaces in the 'dst_dev' array that have joined the group, in the |
| * mc_updates->if_join_idx array. The caller uses this information to add the new |
| * interface heirarchies into the connection. |
| * dst_dev Holds the netdevice ifindex number of the new list of interfaces as reported |
| * by the update from MFC or Bridge snooper. |
| * max_to_dev Size of the array 'dst_dev' |
| * |
| * Return true if new joinees found |
| */ |
| static bool ecm_interface_multicast_find_new_iface_instances(struct ecm_db_connection_instance *ci, |
| struct ecm_multicast_if_update *mc_updates, uint32_t *mc_dst_if_index, uint32_t max_to_dev) |
| { |
| struct ecm_db_iface_instance *mc_ifaces; |
| struct ecm_db_iface_instance *ii_temp; |
| struct ecm_db_iface_instance *ii_single; |
| struct ecm_db_iface_instance **ifaces; |
| int32_t *mc_ifaces_first; |
| int32_t *to_list_first; |
| int32_t heirarchy_index; |
| int32_t if_index; |
| int32_t if_cnt = 0; |
| int found = 0; |
| int ii; |
| int ret; |
| uint32_t *dst_if_index; |
| int32_t ifaces_identifier; |
| struct ecm_db_iface_instance *to_list; |
| |
| ret = ecm_db_multicast_connection_to_interfaces_get_and_ref_all(ci, &mc_ifaces, &mc_ifaces_first); |
| if (ret == 0) { |
| DEBUG_WARN("%p: multicast interfaces ref fail!\n", ci); |
| return false; |
| } |
| |
| /* |
| * Loop through the new interface list 'dst_dev' |
| */ |
| for (if_index = 0; if_index < max_to_dev; if_index++) { |
| found = 0; |
| dst_if_index = ecm_db_multicast_if_num_get_at_index(mc_dst_if_index, if_index); |
| if (*dst_if_index == 0) { |
| continue; |
| } |
| |
| for (heirarchy_index = 0; heirarchy_index < ECM_DB_MULTICAST_IF_MAX ; heirarchy_index++) { |
| to_list_first = ecm_db_multicast_if_first_get_at_index(mc_ifaces_first, heirarchy_index); |
| |
| /* |
| * Invalid interface entry, skip |
| */ |
| if (*to_list_first == ECM_DB_IFACE_HEIRARCHY_MAX) { |
| continue; |
| } |
| |
| ii_temp = ecm_db_multicast_if_heirarchy_get(mc_ifaces, heirarchy_index); |
| |
| /* |
| * Try to find a match for this ifindex (dst_dev[if_index]), in any of the |
| * interface instance in the heirarchy. If not found, it means that this |
| * ifindex has joined the group. If found, it means that this ifindex was |
| * already part of the list of destination interfaces. |
| */ |
| for (ii = ECM_DB_IFACE_HEIRARCHY_MAX - 1; ii >= *to_list_first; ii--) { |
| ii_single = ecm_db_multicast_if_instance_get_at_index(ii_temp, ii); |
| ifaces = (struct ecm_db_iface_instance **)ii_single; |
| to_list = *ifaces; |
| ifaces_identifier = ecm_db_iface_interface_identifier_get(to_list); |
| if (*dst_if_index == ifaces_identifier) { |
| found = 1; |
| break; |
| } |
| } |
| |
| if (found) { |
| break; |
| } |
| } |
| |
| /* |
| * We did not find a match for the interface in the present list. So mark |
| * it as one that has joined the group. |
| */ |
| if (!found) { |
| |
| /* |
| * Store the if index of the new joinee |
| */ |
| mc_updates->join_dev[if_cnt] = *dst_if_index; |
| |
| /* |
| * Identify a new vacant slot in the 'to_mcast_interfaces' to place |
| * the new interface |
| */ |
| for (heirarchy_index = 0; heirarchy_index < ECM_DB_MULTICAST_IF_MAX ; heirarchy_index++) { |
| to_list_first = ecm_db_multicast_if_first_get_at_index(mc_ifaces_first, heirarchy_index); |
| if (*to_list_first == ECM_DB_IFACE_HEIRARCHY_MAX) { |
| mc_updates->if_join_idx[heirarchy_index] = 1; |
| break; |
| } |
| } |
| |
| if_cnt++; |
| } |
| } |
| |
| ecm_db_multicast_connection_to_interfaces_deref_all(mc_ifaces, mc_ifaces_first); |
| mc_updates->if_join_cnt = if_cnt; |
| |
| return (if_cnt > 0); |
| } |
| |
| /* |
| * ecm_interface_multicast_find_updates_to_iface_list() |
| * Process IGMP/MLD updates either from MFC or bridge snooper. Identity the interfaces |
| * that have left the group and new interfaces that have joined the group. |
| * |
| * The function returns true if there was any update necessary to the current destination |
| * interface list |
| */ |
| bool ecm_interface_multicast_find_updates_to_iface_list(struct ecm_db_connection_instance *ci, struct ecm_multicast_if_update *mc_updates, |
| uint32_t flags, bool is_br_snooper, uint32_t *mc_dst_if_index, uint32_t max_to_dev) |
| { |
| bool join; |
| bool leave; |
| /* |
| * Find destination interfaces that have left the group |
| */ |
| leave = ecm_interface_multicast_find_outdated_iface_instances(ci, mc_updates, flags, is_br_snooper, mc_dst_if_index, max_to_dev); |
| /* |
| * Find new destination interfaces that have joined the group |
| */ |
| join = ecm_interface_multicast_find_new_iface_instances(ci, mc_updates, mc_dst_if_index, max_to_dev); |
| |
| return (leave || join); |
| } |
| EXPORT_SYMBOL(ecm_interface_multicast_find_updates_to_iface_list); |
| #endif |
| |
| #ifdef ECM_DB_XREF_ENABLE |
| /* |
| * ecm_interface_neigh_mac_update_notify_event() |
| * Neighbour mac address change handler. |
| */ |
| static int ecm_interface_neigh_mac_update_notify_event(struct notifier_block *nb, |
| unsigned long val, |
| void *data) |
| { |
| struct neigh_mac_update *nmu = (struct neigh_mac_update *)data; |
| |
| /* |
| * If the old and new mac addresses are equal, do nothing. |
| * This case shouldn't happen. |
| */ |
| if (!ecm_mac_addr_equal(nmu->old_mac, nmu->update_mac)) { |
| DEBUG_TRACE("old and new mac addresses are equal: %pM\n", nmu->old_mac); |
| return NOTIFY_DONE; |
| } |
| |
| /* |
| * If the old mac is zero, do nothing. When a host joins the arp table first |
| * time, its old mac comes as zero. We shouldn't handle this case, because |
| * there is not any connection in ECM db with zero mac. |
| */ |
| if (is_zero_ether_addr(nmu->old_mac)) { |
| DEBUG_WARN("old mac is zero\n"); |
| return NOTIFY_DONE; |
| } |
| |
| DEBUG_TRACE("old mac: %pM new mac: %pM\n", nmu->old_mac, nmu->update_mac); |
| |
| DEBUG_INFO("neigh mac update notify for node %pM\n", nmu->old_mac); |
| ecm_interface_node_connections_defunct((uint8_t *)nmu->old_mac); |
| |
| return NOTIFY_DONE; |
| } |
| |
| /* |
| * struct notifier_block ecm_interface_neigh_mac_update_nb |
| * Registration for neighbour mac address update. |
| */ |
| static struct notifier_block ecm_interface_neigh_mac_update_nb = { |
| .notifier_call = ecm_interface_neigh_mac_update_notify_event, |
| }; |
| #endif |
| |
| /* |
| * ecm_interface_wifi_event_iwevent |
| * wireless event handler |
| */ |
| static int ecm_interface_wifi_event_iwevent(int ifindex, unsigned char *buf, size_t len) |
| { |
| struct iw_event iwe_buf, *iwe = &iwe_buf; |
| char *pos, *end; |
| |
| pos = buf; |
| end = buf + len; |
| while (pos + IW_EV_LCP_LEN <= end) { |
| |
| /* |
| * Copy the base data structure to get iwe->len |
| */ |
| memcpy(&iwe_buf, pos, IW_EV_LCP_LEN); |
| |
| /* |
| * Check that len is valid and that we have that much in the buffer. |
| * |
| */ |
| if (iwe->len < IW_EV_LCP_LEN) { |
| return -1; |
| } |
| |
| if ((iwe->len > sizeof (struct iw_event)) || (iwe->len + pos) > end) { |
| return -1; |
| } |
| |
| /* |
| * Do the copy again with the full length. |
| */ |
| memcpy(&iwe_buf, pos, iwe->len); |
| |
| if (iwe->cmd == IWEVREGISTERED) { |
| DEBUG_INFO("STA %pM joining\n", (uint8_t *)iwe->u.addr.sa_data); |
| } else if (iwe->cmd == IWEVEXPIRED) { |
| DEBUG_INFO("STA %pM leaving\n", (uint8_t *)iwe->u.addr.sa_data); |
| ecm_interface_node_connections_defunct((uint8_t *)iwe->u.addr.sa_data); |
| } else { |
| DEBUG_INFO("iwe->cmd is %d for STA %pM\n", iwe->cmd, (unsigned char *) iwe->u.addr.sa_data); |
| } |
| |
| pos += iwe->len; |
| } |
| |
| return 0; |
| } |
| |
| /* |
| * ecm_interface_wifi_event_newlink |
| * Link event handler |
| */ |
| static int ecm_interface_wifi_event_newlink(struct ifinfomsg *ifi, unsigned char *buf, size_t len) |
| { |
| struct rtattr *attr; |
| int attrlen, rta_len; |
| |
| DEBUG_TRACE("Event from interface %d\n", ifi->ifi_index); |
| |
| attrlen = len; |
| attr = (struct rtattr *) buf; |
| rta_len = RTA_ALIGN(sizeof(struct rtattr)); |
| |
| while (RTA_OK(attr, attrlen)) { |
| if (attr->rta_type == IFLA_WIRELESS) { |
| ecm_interface_wifi_event_iwevent(ifi->ifi_index, ((char *) attr) + rta_len, attr->rta_len - rta_len); |
| } |
| attr = RTA_NEXT(attr, attrlen); |
| } |
| |
| return 0; |
| } |
| |
| /* |
| * ecm_interface_wifi_event_handler |
| * Netlink event handler |
| */ |
| static int ecm_interface_wifi_event_handler(unsigned char *buf, int len) |
| { |
| struct nlmsghdr *nlh; |
| struct ifinfomsg *ifi; |
| int left; |
| |
| nlh = (struct nlmsghdr *) buf; |
| left = len; |
| |
| while (NLMSG_OK(nlh, left)) { |
| switch (nlh->nlmsg_type) { |
| case RTM_NEWLINK: |
| case RTM_DELLINK: |
| if (NLMSG_PAYLOAD(nlh, 0) < sizeof(struct ifinfomsg)) { |
| DEBUG_INFO("invalid netlink message\n"); |
| break; |
| } |
| |
| ifi = NLMSG_DATA(nlh); |
| DEBUG_INFO("ifi->ifi_family: %d\n", ifi->ifi_family); |
| if (ifi->ifi_family != AF_BRIDGE) { |
| ecm_interface_wifi_event_newlink(ifi, (u8 *)ifi + NLMSG_ALIGN(sizeof(struct ifinfomsg)), |
| NLMSG_PAYLOAD(nlh, sizeof(struct ifinfomsg))); |
| } |
| break; |
| } |
| |
| nlh = NLMSG_NEXT(nlh, left); |
| } |
| |
| return 0; |
| } |
| |
| /* |
| * ecm_interface_wifi_event_rx |
| * Receive netlink message from socket |
| */ |
| static int ecm_interface_wifi_event_rx(struct socket *sock, struct sockaddr_nl *addr, unsigned char *buf, int len) |
| { |
| struct msghdr msg; |
| struct iovec iov; |
| mm_segment_t oldfs; |
| int size; |
| |
| iov.iov_base = buf; |
| iov.iov_len = len; |
| |
| msg.msg_flags = 0; |
| msg.msg_name = addr; |
| msg.msg_namelen = sizeof(struct sockaddr_nl); |
| msg.msg_control = NULL; |
| msg.msg_controllen = 0; |
| #if (LINUX_VERSION_CODE < KERNEL_VERSION(3, 19, 0)) |
| msg.msg_iov = &iov; |
| msg.msg_iovlen = 1; |
| #else |
| iov_iter_init(&msg.msg_iter, READ, &iov, 1, 1); |
| #endif |
| oldfs = get_fs(); |
| set_fs(KERNEL_DS); |
| size = sock_recvmsg(sock, &msg, len, msg.msg_flags); |
| set_fs(oldfs); |
| |
| return size; |
| } |
| |
| /* |
| * ecm_interface_wifi_event_thread |
| */ |
| static void ecm_interface_wifi_event_thread(void) |
| { |
| int err; |
| int size; |
| struct sockaddr_nl saddr; |
| unsigned char buf[512]; |
| int len = sizeof(buf); |
| |
| allow_signal(SIGKILL|SIGSTOP); |
| err = sock_create(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE, &__ewn.sock); |
| if (err < 0) { |
| DEBUG_ERROR("failed to create sock\n"); |
| goto exit1; |
| } |
| |
| memset(&saddr, 0, sizeof(saddr)); |
| saddr.nl_family = AF_NETLINK; |
| saddr.nl_groups = RTNLGRP_LINK; |
| saddr.nl_pid = current->pid; |
| |
| err = __ewn.sock->ops->bind(__ewn.sock, (struct sockaddr *)&saddr, sizeof(struct sockaddr)); |
| if (err < 0) { |
| DEBUG_ERROR("failed to bind sock\n"); |
| goto exit2; |
| } |
| |
| DEBUG_INFO("ecm_interface_wifi_event thread started\n"); |
| while (!kthread_should_stop()) { |
| size = ecm_interface_wifi_event_rx(__ewn.sock, &saddr, buf, len); |
| DEBUG_TRACE("got a netlink msg with len %d\n", size); |
| |
| if (signal_pending(current)) |
| break; |
| |
| if (size < 0) { |
| DEBUG_WARN("netlink rx error\n"); |
| } else { |
| ecm_interface_wifi_event_handler(buf, size); |
| } |
| } |
| |
| DEBUG_INFO("ecm_interface_wifi_event thread stopped\n"); |
| exit2: |
| sock_release(__ewn.sock); |
| exit1: |
| __ewn.sock = NULL; |
| |
| return; |
| } |
| |
| /* |
| * ecm_interface_wifi_event_start() |
| */ |
| int ecm_interface_wifi_event_start(void) |
| { |
| if (__ewn.thread) { |
| return 0; |
| } |
| |
| __ewn.thread = kthread_run((void *)ecm_interface_wifi_event_thread, NULL, "ECM_wifi_event"); |
| if (IS_ERR(__ewn.thread)) { |
| DEBUG_ERROR("Unable to start kernel thread\n"); |
| return -ENOMEM; |
| } |
| |
| return 0; |
| } |
| |
| /* |
| * ecm_interface_wifi_event_stop() |
| */ |
| int ecm_interface_wifi_event_stop(void) |
| { |
| int err; |
| |
| if (__ewn.thread == NULL) { |
| return 0; |
| } |
| |
| DEBUG_INFO("kill ecm_interface_wifi_event thread\n"); |
| force_sig(SIGKILL, __ewn.thread); |
| err = kthread_stop(__ewn.thread); |
| __ewn.thread = NULL; |
| |
| return err; |
| } |
| |
| /* |
| * ecm_interface_src_check_handler() |
| * Source interface check sysctl node handler. |
| */ |
| static int ecm_interface_src_check_handler(struct ctl_table *ctl, int write, void __user *buffer, size_t *lenp, loff_t *ppos) |
| { |
| int ret; |
| int current_value; |
| |
| /* |
| * Take the current value |
| */ |
| current_value = ecm_interface_src_check; |
| |
| /* |
| * Write the variable with user input |
| */ |
| ret = proc_dointvec(ctl, write, buffer, lenp, ppos); |
| if (ret || (!write)) { |
| return ret; |
| } |
| |
| if (ECM_FRONT_END_TYPE_NSS != ecm_front_end_type_get()) { |
| DEBUG_WARN("Source interface check is for NSS only.\n"); |
| return -EINVAL; |
| } |
| |
| if ((ecm_interface_src_check != 1) && (ecm_interface_src_check != 0)) { |
| DEBUG_WARN("Invalid input. Valid values 0/1\n"); |
| ecm_interface_src_check = current_value; |
| return -EINVAL; |
| } |
| |
| return ret; |
| } |
| |
| static struct ctl_table ecm_interface_table[] = { |
| { |
| .procname = "src_interface_check", |
| .data = &ecm_interface_src_check, |
| .maxlen = sizeof(int), |
| .mode = 0644, |
| .proc_handler = &ecm_interface_src_check_handler, |
| }, |
| { } |
| }; |
| |
| static struct ctl_table ecm_interface_root_dir[] = { |
| { |
| .procname = "ecm", |
| .mode = 0555, |
| .child = ecm_interface_table, |
| }, |
| { } |
| }; |
| |
| static struct ctl_table ecm_interface_root[] = { |
| { |
| .procname = "net", |
| .mode = 0555, |
| .child = ecm_interface_root_dir, |
| }, |
| { } |
| }; |
| |
| /* |
| * ecm_interface_init() |
| */ |
| int ecm_interface_init(void) |
| { |
| int result; |
| DEBUG_INFO("ECM Interface init\n"); |
| |
| /* |
| * Register sysctl table. |
| */ |
| ecm_interface_ctl_table_header = register_sysctl_table(ecm_interface_root); |
| |
| result = register_netdevice_notifier(&ecm_interface_netdev_notifier); |
| if (result != 0) { |
| DEBUG_ERROR("Failed to register netdevice notifier %d\n", result); |
| unregister_sysctl_table(ecm_interface_ctl_table_header); |
| return result; |
| } |
| #if defined(ECM_DB_XREF_ENABLE) && defined(ECM_BAND_STEERING_ENABLE) |
| /* |
| * register for bridge fdb database modificationevents |
| */ |
| br_fdb_update_register_notify(&ecm_interface_node_br_fdb_update_nb); |
| br_fdb_register_notify(&ecm_interface_node_br_fdb_delete_nb); |
| #endif |
| #ifdef ECM_DB_XREF_ENABLE |
| neigh_mac_update_register_notify(&ecm_interface_neigh_mac_update_nb); |
| #endif |
| ecm_interface_wifi_event_start(); |
| |
| return 0; |
| } |
| EXPORT_SYMBOL(ecm_interface_init); |
| |
| /* |
| * ecm_interface_exit() |
| */ |
| void ecm_interface_exit(void) |
| { |
| DEBUG_INFO("ECM Interface exit\n"); |
| |
| spin_lock_bh(&ecm_interface_lock); |
| ecm_interface_terminate_pending = true; |
| spin_unlock_bh(&ecm_interface_lock); |
| |
| unregister_netdevice_notifier(&ecm_interface_netdev_notifier); |
| #ifdef ECM_DB_XREF_ENABLE |
| neigh_mac_update_unregister_notify(&ecm_interface_neigh_mac_update_nb); |
| #endif |
| |
| #if defined(ECM_DB_XREF_ENABLE) && defined(ECM_BAND_STEERING_ENABLE) |
| /* |
| * unregister for bridge fdb update events |
| */ |
| br_fdb_update_unregister_notify(&ecm_interface_node_br_fdb_update_nb); |
| br_fdb_unregister_notify(&ecm_interface_node_br_fdb_delete_nb); |
| #endif |
| ecm_interface_wifi_event_stop(); |
| |
| /* |
| * Unregister sysctl table. |
| */ |
| if (ecm_interface_ctl_table_header) { |
| unregister_sysctl_table(ecm_interface_ctl_table_header); |
| } |
| } |
| EXPORT_SYMBOL(ecm_interface_exit); |