src/main/java/net/onrc/onos/apps/segmentrouting/ArpHandler.java

/*******************************************************************************
 * Copyright (c) 2014 Open Networking Laboratory.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Apache License v2.0
 * which accompanies this distribution, and is available at
 * http://www.apache.org/licenses/LICENSE-2.0
 ******************************************************************************/

package net.onrc.onos.apps.segmentrouting;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;

import net.floodlightcontroller.core.IFloodlightProviderService;
import net.floodlightcontroller.core.IOFSwitch;
import net.floodlightcontroller.core.module.FloodlightModuleContext;
import net.floodlightcontroller.util.MACAddress;
import net.onrc.onos.core.flowprogrammer.IFlowPusherService;
import net.onrc.onos.core.packet.ARP;
import net.onrc.onos.core.packet.Ethernet;
import net.onrc.onos.core.packet.IPv4;
import net.onrc.onos.core.topology.Host;
import net.onrc.onos.core.topology.ITopologyService;
import net.onrc.onos.core.topology.MutableTopology;
import net.onrc.onos.core.topology.Port;
import net.onrc.onos.core.topology.Switch;

import org.json.JSONArray;
import org.json.JSONException;
import org.projectfloodlight.openflow.protocol.OFFactory;
import org.projectfloodlight.openflow.protocol.OFPacketOut;
import org.projectfloodlight.openflow.protocol.action.OFAction;
import org.projectfloodlight.openflow.types.IPv4Address;
import org.projectfloodlight.openflow.types.MacAddress;
import org.projectfloodlight.openflow.types.OFPort;
import org.projectfloodlight.openflow.types.U32;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.esotericsoftware.minlog.Log;

/**
 * Handling ARP requests to switches for Segment Routing.
 * <p/>
 * The module is for handling ARP requests to switches. It sends ARP response for any known
 * hosts to the controllers.
 * TODO: need to check the network config file for all hosts and packets
 */
public class ArpHandler {

    private static final Logger log = LoggerFactory
            .getLogger(ArpHandler.class);

    private IFloodlightProviderService floodlightProvider;
    private IFlowPusherService flowPusher;
    private ITopologyService topologyService;
    private MutableTopology mutableTopology;
    //private List<ArpEntry> arpEntries;
    private SegmentRoutingManager srManager;

    private static final short IDLE_TIMEOUT = 0;
    private static final short HARD_TIMEOUT = 0;

    private static final int TABLE_VLAN = 0;
    private static final int TABLE_TMAC = 1;
    private static final int TABLE_IPv4_UNICAST = 2;
    private static final int TABLE_MPLS = 3;
    private static final int TABLE_META = 4;
    private static final int TABLE_ACL = 5;

    private static final short MAX_PRIORITY = (short) 0xffff;
    private static final short SLASH_24_PRIORITY = (short) 0xfff0;
    private static final short SLASH_16_PRIORITY = (short) 0xff00;
    private static final short SLASH_8_PRIORITY = (short) 0xf000;
    private static final short MIN_PRIORITY = 0x0;


    /*
     * Default Constructor
     */
    public ArpHandler(FloodlightModuleContext context, SegmentRoutingManager segmentRoutingManager) {

        this.floodlightProvider = context.getServiceImpl(IFloodlightProviderService.class);
        this.flowPusher = context.getServiceImpl(IFlowPusherService.class);
        this.topologyService = context.getServiceImpl(ITopologyService.class);
        this.srManager = segmentRoutingManager;
        this.mutableTopology = topologyService.getTopology();

        Log.debug("Arp Handler is initialized");

    }

    /**
     * process ARP packets from switches
     * It add a IP routing rule to the host
     * If it is an ARP response, then flush out all pending packets to the host
     *
     * @param sw
     * @param inPort
     * @param payload
     */
    public void processPacketIn(Switch sw, Port inPort, Ethernet payload){

    	log.debug("ArpHandler: Received a ARP packet from sw {} ", sw.getDpid());

        ARP arp = (ARP)payload.getPayload();

        byte[] senderMacAddressByte = arp.getSenderHardwareAddress();
        IPv4Address hostIpAddress = IPv4Address.of(arp.getSenderProtocolAddress());
        log.debug("ArpHandler: Add IP route to Host {} ", hostIpAddress);
        srManager.addRouteToHost(sw,hostIpAddress.getInt(), senderMacAddressByte);

        if (arp.getOpCode() == ARP.OP_REQUEST) {
        	log.debug("ArpHandler: Received a ARP Requestfrom sw {} ", sw.getDpid());
            handleArpRequest(sw, inPort, payload);
        }
        else {
            byte[] destIp = arp.getSenderProtocolAddress();
            for (IPv4 ipPacket: srManager.getIpPacketFromQueue(destIp)) {
                if (ipPacket != null && !inSameSubnet(sw, ipPacket)) {
                    Ethernet eth = new Ethernet();
                    eth.setDestinationMACAddress(payload.getSourceMACAddress());
                    eth.setSourceMACAddress(sw.getStringAttribute("routerMac"));
                    eth.setEtherType(Ethernet.TYPE_IPV4);
                    eth.setPayload(ipPacket);
                    sendPacketOut(sw, eth, inPort.getNumber().shortValue());
                }
            }
        }
    }

    /**
     * Send an ARP response for the ARP request to the known switches
     *
     * @param sw Switch
     * @param inPort port to send ARP response to
     * @param arpRequest ARP request packet to handle
     */
    private void handleArpRequest(Switch sw, Port inPort, Ethernet payload) {

    	ARP arpRequest = (ARP)payload.getPayload();
    	MACAddress targetMac = null;

    	if (isArpReqForSwitch(sw, arpRequest)) {
            String switchMacAddressStr = sw.getStringAttribute("routerMac");
            targetMac = MACAddress.valueOf(switchMacAddressStr);
        	log.debug("ArpHandler: Received a ARP query for a sw {} ", sw.getDpid());
    	}
    	else {
        	Host knownHost = isArpReqForKnownHost(sw, arpRequest);
        	if (knownHost != null) {
                targetMac = knownHost.getMacAddress();
            	log.debug("ArpHandler: Received a ARP query for a known host {} ",
            						IPv4Address.of(knownHost.getIpAddress()));
        	}
    	}

    	if (targetMac != null) {
    		/* ARP Destination is known. Packet out ARP Reply */
            ARP arpReply = new ARP();
            arpReply.setHardwareType(ARP.HW_TYPE_ETHERNET)
                    .setProtocolType(ARP.PROTO_TYPE_IP)
                    .setHardwareAddressLength(
                            (byte) Ethernet.DATALAYER_ADDRESS_LENGTH)
                    .setProtocolAddressLength((byte) IPv4.ADDRESS_LENGTH)
                    .setOpCode(ARP.OP_REPLY)
                    .setSenderHardwareAddress(targetMac.toBytes())
                    .setSenderProtocolAddress(arpRequest.getTargetProtocolAddress())
                    .setTargetHardwareAddress(arpRequest.getSenderHardwareAddress())
                    .setTargetProtocolAddress(arpRequest.getSenderProtocolAddress());

            Ethernet eth = new Ethernet();
            eth.setDestinationMACAddress(arpRequest.getSenderHardwareAddress())
                    .setSourceMACAddress(targetMac.toBytes())
                    .setEtherType(Ethernet.TYPE_ARP).setPayload(arpReply);

            sendPacketOut(sw, eth, inPort.getPortNumber().shortValue());
    	}
    	else
    	{
    		/* Broadcast the received ARP request to all switch ports
    		 * that subnets are connected to except the port from which
    		 * ARP request is received
    		 */
    	    IPv4Address targetAddress =
    	            IPv4Address.of(arpRequest.getTargetProtocolAddress());
        	log.debug("ArpHandler: Received a ARP query for unknown host {} ",
        			IPv4Address.of(arpRequest.getTargetProtocolAddress()));
    		for (Integer portNo : getSwitchSubnetPorts(sw, targetAddress)) {
    			if (portNo.shortValue() == inPort.getPortNumber().shortValue())
    				continue;
            	log.debug("ArpHandler: Sending ARP request on switch {} port {}",
            			sw.getDpid(), portNo.shortValue());
                sendPacketOut(sw, payload, portNo.shortValue());
    		}
    	}
    }

    /**
     * Check if the ARP request is to known hosts
     *
     * @param sw  Switch
     * @param arpRequest  ARP request to check
     */
    private Host isArpReqForKnownHost(Switch sw, ARP arpRequest) {
    	Host knownHost = null;

        IPv4Address targetIPAddress = IPv4Address.of(
        					arpRequest.getTargetProtocolAddress());

        for (Host host:sw.getHosts()) {
        	if (host.getIpAddress() == targetIPAddress.getInt()) {
        		knownHost = host;
        		break;
        	}
        }
        return knownHost;

    }

    /**
     *
     * Check if the ARP is for the switch
     *
     * @param sw Switch
     * @param arpRequest ARP request to check
     * @return true if the ARP is for the switch
     */
    private boolean isArpReqForSwitch(Switch sw, ARP arpRequest) {
        List<String> subnetGatewayIPs = getSubnetGatewayIps(sw);
        boolean isArpForSwitch = false;
        if (!subnetGatewayIPs.isEmpty()) {
            IPv4Address targetProtocolAddress = IPv4Address.of(arpRequest.getTargetProtocolAddress());
            if (subnetGatewayIPs.contains(targetProtocolAddress.toString())) {
            	isArpForSwitch = true;
            }
        }
        return isArpForSwitch;
    }

    /**
     * Retrieve Gateway IP address of all subnets defined in net config file
     *
     * @param sw Switch to retrieve subnet GW IPs for
     * @return list of GW IP addresses for all subnets
     */
    private List<String> getSubnetGatewayIps(Switch sw) {

        List<String> gatewayIps = new ArrayList<String>();

        String subnets = sw.getStringAttribute("subnets");
        try {
            JSONArray arry = new JSONArray(subnets);
            for (int i = 0; i < arry.length(); i++) {
                String subnetIpSlash = (String) arry.getJSONObject(i).get("subnetIp");
                if (subnetIpSlash != null) {
                    String subnetIp = subnetIpSlash.substring(0, subnetIpSlash.indexOf('/'));
                    gatewayIps.add(subnetIp);
                }
            }
        } catch (JSONException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        return gatewayIps;
    }

    private HashSet<Integer> getSwitchSubnetPorts(Switch sw, IPv4Address targetAddress) {
        HashSet<Integer> switchSubnetPorts = new HashSet<Integer>();

        String subnets = sw.getStringAttribute("subnets");
        try {
            JSONArray arry = new JSONArray(subnets);
            for (int i = 0; i < arry.length(); i++) {
                String subnetIpSlash = (String) arry.getJSONObject(i).get("subnetIp");
                if (srManager.netMatch(subnetIpSlash, targetAddress.toString())) {
                    Integer subnetPort = (Integer)arry.getJSONObject(i).get("portNo");
                    switchSubnetPorts.add(subnetPort);
                }
            }
        } catch (JSONException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        return switchSubnetPorts;
    }

    /**
     * Send an ARP request
     *
     * @param sw Switch
     * @param targetAddress Target IP address
     * @param inPort Port to send the ARP request
     *
     */
    public void sendArpRequest(Switch sw, int targetAddressInt, Port inPort) {

        IPv4Address targetAddress = IPv4Address.of(targetAddressInt);
        String senderMacAddressStr = sw.getStringAttribute("routerMac");
        String senderIpAddressSlash = sw.getStringAttribute("routerIp");
        if (senderMacAddressStr == null || senderIpAddressSlash == null)
            return;
        String senderIpAddressStr =
                senderIpAddressSlash.substring(0, senderIpAddressSlash.indexOf('/'));
        byte[] senderMacAddress = MacAddress.of(senderMacAddressStr).getBytes();
        byte[] senderIpAddress = IPv4Address.of(senderIpAddressStr).getBytes();

        ARP arpRequest = new ARP();
        arpRequest.setHardwareType(ARP.HW_TYPE_ETHERNET)
                .setProtocolType(ARP.PROTO_TYPE_IP)
                .setHardwareAddressLength(
                        (byte) Ethernet.DATALAYER_ADDRESS_LENGTH)
                .setProtocolAddressLength((byte) IPv4.ADDRESS_LENGTH)
                .setOpCode(ARP.OP_REQUEST)
                .setSenderHardwareAddress(senderMacAddress)
                .setTargetHardwareAddress(MacAddress.NONE.getBytes())
                .setSenderProtocolAddress(senderIpAddress)
                .setTargetProtocolAddress(targetAddress.getBytes());

        Ethernet eth = new Ethernet();
        eth.setDestinationMACAddress(MacAddress.BROADCAST.getBytes())
                .setSourceMACAddress(senderMacAddress)
                .setEtherType(Ethernet.TYPE_ARP).setPayload(arpRequest);

		/* Broadcast the ARP request to all switch ports
		 * that subnets are connected to except the port from which
		 * ARP request is received
		 */
		for (Integer portNo : getSwitchSubnetPorts(sw, targetAddress)) {
			if (portNo.shortValue() == inPort.getPortNumber().shortValue())
				continue;
        	log.debug("ArpHandler: Sending ARP request on switch {} port {}",
        			sw.getDpid(), portNo.shortValue());
            sendPacketOut(sw, eth, portNo.shortValue());
		}
    }

    /**
     * Send PACKET_OUT packet to switch
     *
     * @param sw Switch to send the packet to
     * @param packet Packet to send
     * @param switchPort port to send (if -1, broadcast)
     */
    private void sendPacketOut(Switch sw, Ethernet packet, short port) {

        IOFSwitch ofSwitch = floodlightProvider.getMasterSwitch(sw.getDpid().value());
        OFFactory factory = ofSwitch.getFactory();

        List<OFAction> actions = new ArrayList<>();

        if (port > 0) {
            OFAction outport = factory.actions().output(OFPort.of(port), Short.MAX_VALUE);
            actions.add(outport);
        }
        else {
            Iterator<Port> iter = sw.getPorts().iterator();
            while (iter.hasNext()) {
                Port p = iter.next();
                int pnum = p.getPortNumber().shortValue();
                if (U32.of(pnum).compareTo(U32.of(OFPort.MAX.getPortNumber())) < 1) {
                    OFAction outport = factory.actions().output(OFPort.of(p.getNumber().shortValue()),
                            Short.MAX_VALUE);
                    actions.add(outport);
                }
            }
        }

        OFPacketOut po = factory.buildPacketOut()
                .setData(packet.serialize())
                .setActions(actions)
                .build();

        flowPusher.add(sw.getDpid(), po);
    }

    /**
     * Check if the source IP and destination IP are in the same subnet
     *
     * @param sw Switch
     * @param ipv4 IP address to check
     * @return return true if the IP packet is within the same subnet
     */
    private boolean inSameSubnet(Switch sw, IPv4 ipv4) {

        String gwIpSrc = getGwIpForSubnet(ipv4.getSourceAddress());
        String gwIpDest = getGwIpForSubnet(ipv4.getDestinationAddress());

        if (gwIpSrc.equals(gwIpDest)) {
            return true;
        }
        else
            return false;
    }

    /**
     * Get router IP address for the given IP address
     *
     * @param sourceAddress
     * @return
     */
    private String getGwIpForSubnet(int sourceAddress) {

        String gwIp = null;
        IPv4Address srcIp = IPv4Address.of(sourceAddress);

        for (Switch sw: mutableTopology.getSwitches()) {

            String subnets = sw.getStringAttribute("subnets");
            try {
                JSONArray arry = new JSONArray(subnets);
                for (int i = 0; i < arry.length(); i++) {
                    String subnetIpSlash = (String) arry.getJSONObject(i).get("subnetIp");
                    if (srManager.netMatch(subnetIpSlash, srcIp.toString())) {
                        gwIp = subnetIpSlash;
                    }
                }
            } catch (JSONException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

        return gwIp;
    }

}