/*******************************************************************************
* Copyright 2014 Open Networking Laboratory
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
******************************************************************************/
package net.onrc.onos.core.packet;
import java.nio.ByteBuffer;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import net.onrc.onos.core.util.SwitchPort;
import org.apache.commons.lang3.ArrayUtils;
import com.google.common.base.Charsets;
/**
* LLDP packets ONOS uses for discovery of physical network topology.
* Refer to IEEE Std 802.1ABTM-2009 for more information.
*
*/
public class OnosLldp extends LLDP {
// ON.Lab OUI and ONOS name for organizationally specific TLVs
static final byte[] ONLAB_OUI = {(byte) 0xa4, 0x23, 0x05};
public static final String ONOS_NAME = "ONOSVirteX";
static final byte[] LLDP_NICIRA = {0x01, 0x23, 0x20, 0x00, 0x00,
0x01};
static final byte[] LLDP_MULTICAST = {0x01, (byte) 0x80,
(byte) 0xc2, 0x00, 0x00, 0x0e};
static final byte[] BDDP_MULTICAST = {(byte) 0xff, (byte) 0xff,
(byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff};
public static final short ETHERTYPE_VLAN = (short) 0x8100;
// TLV constants: type, size and subtype
// Organizationally specific TLV also have packet offset and contents of TLV
// header
private static final byte CHASSIS_TLV_TYPE = 1;
private static final byte CHASSIS_TLV_SIZE = 7;
private static final byte CHASSIS_TLV_SUBTYPE = 4;
private static final byte PORT_TLV_TYPE = 2;
private static final byte PORT_TLV_SIZE = 3;
private static final byte PORT_TLV_SUBTYPE = 2;
private static final byte TTL_TLV_TYPE = 3;
private static final byte TTL_TLV_SIZE = 2;
private static final byte NAME_TLV_TYPE = 127;
// 4 = OUI (3) + subtype (1)
private static final byte NAME_TLV_SIZE = (byte) (4 + OnosLldp.ONOS_NAME.length());
private static final byte NAME_TLV_SUBTYPE = 1;
private static final short NAME_TLV_OFFSET = 32;
private static final short NAME_TLV_HEADER = (short) ((NAME_TLV_TYPE << 9) | (NAME_TLV_SIZE & 0xff));
// Contents of full name TLV
private static final byte[] NAME_TLV = ByteBuffer.allocate(NAME_TLV_SIZE + 2)
.putShort(NAME_TLV_HEADER).put(ONLAB_OUI).put(NAME_TLV_SUBTYPE)
.put(ONOS_NAME.getBytes(Charsets.UTF_8)).array();
private static final byte DPID_TLV_TYPE = 127;
private static final byte DPID_TLV_SIZE = (byte) (12); // 12 = OUI (3) + subtype
// (1) + dpid (8)
private static final byte DPID_TLV_SUBTYPE = 2;
private static final short DPID_TLV_HEADER = (short) ((DPID_TLV_TYPE << 9) | DPID_TLV_SIZE);
// Contents of dpid TLV
// Note that this does *not* contain the actual dpid since we cannot match
// on it
private static final byte[] DPID_TLV = ByteBuffer.allocate(DPID_TLV_SIZE + 2 - 8)
.putShort(DPID_TLV_HEADER).put(ONLAB_OUI).put(DPID_TLV_SUBTYPE)
.array();
// Pre-built contents of both organizationally specific TLVs
private static final byte[] OUI_TLV = ArrayUtils.addAll(NAME_TLV, DPID_TLV);
// Default switch, port number and TTL
private static final byte[] DEFAULT_DPID = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00 };
private static final short DEFAULT_PORT = 0;
private static final short DEFAULT_TTL = 120; // in seconds
// Minimum and ONOS-generated LLDP packet sizes
private static final short MINIMUM_LLDP_SIZE = 61;
// Add 12 for 2-byte header of each TLV and a single EndOfLLDPTLV
private static final short ONOS_LLDP_SIZE = (short) (CHASSIS_TLV_SIZE
+ PORT_TLV_SIZE + TTL_TLV_SIZE + NAME_TLV_SIZE + DPID_TLV_SIZE + 12);
// Direction TLVs are used to indicate if the LLDPs were sent
// periodically or in response to a received LLDP
private static final byte TLV_DIRECTION_TYPE = 0x73;
private static final short TLV_DIRECTION_LENGTH = 1; // 1 byte
private static final byte[] TLV_DIRECTION_VALUE_FORWARD = {0x01};
private static final byte[] TLV_DIRECTION_VALUE_REVERSE = {0x02};
private static final LLDPTLV FORWARD_TLV
= new LLDPTLV().
setType(TLV_DIRECTION_TYPE).
setLength(TLV_DIRECTION_LENGTH).
setValue(TLV_DIRECTION_VALUE_FORWARD);
private static final LLDPTLV REVERSE_TLV
= new LLDPTLV().
setType(TLV_DIRECTION_TYPE).
setLength(TLV_DIRECTION_LENGTH).
setValue(TLV_DIRECTION_VALUE_REVERSE);
// Field offsets in ONOS-generated LLDP
private static final short ETHERTYPE_OFFSET = 12;
private static final short PORT_OFFSET = 26;
private static final short DPID_OFFSET = 54;
// Private member fields
// Byte arrays for TLV information string
private byte[] chassisId = new byte[CHASSIS_TLV_SIZE];
private byte[] portId = new byte[PORT_TLV_SIZE];
private byte[] ttl = new byte[TTL_TLV_SIZE];
private byte[] ouiName = new byte[NAME_TLV_SIZE];
private byte[] ouiDpid = new byte[DPID_TLV_SIZE];
// TLVs
private LLDPTLV chassisTLV;
private LLDPTLV portTLV;
private LLDPTLV ttlTLV;
private LLDPTLV ouiNameTLV;
private LLDPTLV ouiDpidTLV;
private List<LLDPTLV> optionalTLVList;
/**
* Instantiates a new ONOS LDDP message.
*/
public OnosLldp() {
// Create TLVs
this.chassisTLV = new LLDPTLV();
this.portTLV = new LLDPTLV();
this.ttlTLV = new LLDPTLV();
this.ouiNameTLV = new LLDPTLV();
this.ouiDpidTLV = new LLDPTLV();
this.optionalTLVList = new LinkedList<LLDPTLV>();
this.optionalTLVList.add(this.ouiNameTLV);
this.optionalTLVList.add(this.ouiDpidTLV);
// Add TLVs to LLDP packet
this.setChassisId(this.chassisTLV);
this.setPortId(this.portTLV);
this.setTtl(this.ttlTLV);
this.setOptionalTLVList(this.optionalTLVList);
// Set TLVs to default values
this.setChassisTLV(DEFAULT_DPID);
this.setPortTLV(DEFAULT_PORT);
this.setTTLTLV(DEFAULT_TTL);
this.setOUIName(OnosLldp.ONOS_NAME);
this.setOUIDpid(DEFAULT_DPID);
}
/**
* Sets chassis TLV. Note that we can only put 6 bytes in the chassis ID, so
* we use another organizationally specific TLV to put the full dpid (see
* setOUIDpid()).
*
* @param dpid the switch DPID
*/
private void setChassisTLV(final byte[] dpid) {
ByteBuffer bb = ByteBuffer.wrap(this.chassisId);
bb.put(CHASSIS_TLV_SUBTYPE);
for (int i = 2; i < 8; i++) {
bb.put(dpid[i]);
}
this.chassisTLV.setLength(CHASSIS_TLV_SIZE);
this.chassisTLV.setType(CHASSIS_TLV_TYPE);
this.chassisTLV.setValue(this.chassisId);
}
/**
* Sets port TLV.
*
* @param portNumber the port number
*/
private void setPortTLV(final short portNumber) {
ByteBuffer bb = ByteBuffer.wrap(this.portId);
bb.put(PORT_TLV_SUBTYPE);
bb.putShort(portNumber);
this.portTLV.setLength(PORT_TLV_SIZE);
this.portTLV.setType(PORT_TLV_TYPE);
this.portTLV.setValue(this.portId);
}
/**
* Sets Time To Live TLV.
*
* @param time the time to live
*/
private void setTTLTLV(final short time) {
ByteBuffer bb = ByteBuffer.wrap(this.ttl);
bb.putShort(time);
this.ttlTLV.setLength(TTL_TLV_SIZE);
this.ttlTLV.setType(TTL_TLV_TYPE);
this.ttlTLV.setValue(this.ttl);
}
/**
* Sets organizationally specific TLV for ONOS name (subtype 1).
*
* @param name the name
*/
private void setOUIName(final String name) {
ByteBuffer bb = ByteBuffer.wrap(ouiName);
bb.put(OnosLldp.ONLAB_OUI);
bb.put(NAME_TLV_SUBTYPE);
bb.put(name.getBytes(Charsets.UTF_8));
this.ouiNameTLV.setLength(NAME_TLV_SIZE);
this.ouiNameTLV.setType(NAME_TLV_TYPE);
this.ouiNameTLV.setValue(ouiName);
}
/**
* Sets organizationally specific TLV for ONOS full dpid (subtype 2).
*
* @param dpid the switch DPID
*/
private void setOUIDpid(final byte[] dpid) {
ByteBuffer bb = ByteBuffer.wrap(ouiDpid);
bb.put(OnosLldp.ONLAB_OUI);
bb.put(DPID_TLV_SUBTYPE);
bb.put(dpid);
this.ouiDpidTLV.setLength(DPID_TLV_SIZE);
this.ouiDpidTLV.setType(DPID_TLV_TYPE);
this.ouiDpidTLV.setValue(ouiDpid);
}
/**
* Sets switch DPID in LLDP packet.
*
* @param dpid the switch dpid
*/
public void setSwitch(Long dpid) {
final byte[] byteDpid = ByteBuffer.allocate(8).putLong(dpid)
.array();
this.setChassisTLV(byteDpid);
this.setOUIDpid(byteDpid);
}
/**
* Sets the port number in LLDP packet.
*
* @param portNumber the port number
*/
public void setPort(short portNumber) {
this.setPortTLV(portNumber);
}
/**
* Sets whether this is a forward or reverse LLDP.
*
* @param isReverse true if reverse, false if forward
*/
public void setReverse(boolean isReverse) {
optionalTLVList.add((isReverse) ? REVERSE_TLV : FORWARD_TLV);
}
/**
* Serializes full LLDP packet to byte array.
*
* @return the serialized packet
*/
@Override
public byte[] serialize() {
return super.serialize();
}
/**
* Checks if LLDP packet has correct size, LLDP multicast address, and
* ethertype. Packet assumed to have Ethernet header.
*
* @param packet full packet starting from the Ethernet header
* @return true if packet is LLDP, false otherwise
*/
public static boolean isLLDP(final byte[] packet) {
// Does packet exist and does it have the mininum size?
if (packet == null || packet.length < MINIMUM_LLDP_SIZE) {
return false;
}
// Packet has LLDP multicast destination address?
final ByteBuffer bb = ByteBuffer.wrap(packet);
final byte[] dst = new byte[6];
bb.get(dst);
if (!(Arrays.equals(dst, OnosLldp.LLDP_NICIRA)
|| Arrays.equals(dst, OnosLldp.LLDP_MULTICAST) || Arrays.equals(
dst, OnosLldp.BDDP_MULTICAST))) {
return false;
}
// Fetch ethertype, skip VLAN tag if it's there
short etherType = bb.getShort(ETHERTYPE_OFFSET);
if (etherType == ETHERTYPE_VLAN) {
etherType = bb.getShort(ETHERTYPE_OFFSET + 4);
}
// Check ethertype
if (etherType == Ethernet.TYPE_LLDP) {
return true;
}
if (etherType == Ethernet.TYPE_BSN) {
return true;
}
return false;
}
/**
* Checks if packet has size of ONOS-generated LLDP, and correctness of two
* organizationally specific TLVs that use ON.Lab's OUI. Assumes packet is
* valid LLDP packet
*
* @param packet full packet starting from the Ethernet header
* @return true if this is an ONOS-generated LLDP, otherwise false
*/
public static boolean isOnosLldp(byte[] packet) {
if (packet.length < ONOS_LLDP_SIZE) {
return false;
}
// Extra offset due to VLAN tag
final ByteBuffer bb = ByteBuffer.wrap(packet);
int offset = 0;
if (bb.getShort(ETHERTYPE_OFFSET) != Ethernet.TYPE_LLDP
&& bb.getShort(ETHERTYPE_OFFSET) != Ethernet.TYPE_BSN) {
offset = 4;
}
// Compare packet's organizationally specific TLVs to the expected
// values
for (int i = 0; i < OUI_TLV.length; i++) {
if (packet[NAME_TLV_OFFSET + offset + i] != OUI_TLV[i]) {
return false;
}
}
return true;
}
/**
* Extracts dpid and port from ONOS-generated LLDP packet.
*
* @param packet full packet started at the Ethernet header
* @return switchport switch and port info from the DPID and Port TLVs
*/
public static SwitchPort extractSwitchPort(final byte[] packet) {
final ByteBuffer bb = ByteBuffer.wrap(packet);
// Extra offset due to VLAN tag
int offset = 0;
if (bb.getShort(ETHERTYPE_OFFSET) != Ethernet.TYPE_LLDP
&& bb.getShort(ETHERTYPE_OFFSET) != Ethernet.TYPE_BSN) {
offset = 4;
}
final short port = bb.getShort(PORT_OFFSET + offset);
final long dpid = bb.getLong(DPID_OFFSET + offset);
return new SwitchPort(dpid, port);
}
/**
* Checks if the LLDP is a reverse LLDP (i.e. sent in response to receiving
* an LLDP on the link). This information is stored in the Direction TLV.
*
* @param lldp parsed LLDP packet
* @return true if the LLDP is a reverse LLDP, otherwise false
*/
public static boolean isReverse(final LLDP lldp) {
for (LLDPTLV lldpTlv : lldp.getOptionalTLVList()) {
if ((lldpTlv.getType() == TLV_DIRECTION_TYPE) &&
Arrays.equals(lldpTlv.getValue(), TLV_DIRECTION_VALUE_REVERSE)) {
return true;
}
}
return false;
}
@Override
public boolean equals(Object other) {
if (other == this) {
return true;
}
if (!super.equals(other)) {
return false;
}
//
// NOTE: Subclasses are are considered as change of identity, hence
// equals() will return false if the class type doesn't match.
//
if (getClass() != other.getClass()) {
return false;
}
OnosLldp otherLldp = (OnosLldp) other;
if (!this.chassisTLV.equals(otherLldp.chassisTLV)) {
return false;
}
if (!this.portTLV.equals(otherLldp.portTLV)) {
return false;
}
if (!this.ttlTLV.equals(otherLldp.ttlTLV)) {
return false;
}
if (!this.ouiNameTLV.equals(otherLldp.ouiNameTLV)) {
return false;
}
if (!this.ouiDpidTLV.equals(otherLldp.ouiDpidTLV)) {
return false;
}
return true;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + chassisTLV.hashCode();
result = prime * result + portTLV.hashCode();
result = prime * result + ttlTLV.hashCode();
result = prime * result + ouiNameTLV.hashCode();
result = prime * result + ouiDpidTLV.hashCode();
return result;
}
}