openflow-protocol-impl/src/main/java/org/opendaylight/openflowjava/protocol/impl/util/MatchSerializer.java

   1 /*
   2  * Copyright (c) 2013 Pantheon Technologies s.r.o. and others. All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8
   9 package org.opendaylight.openflowjava.protocol.impl.util;
  10
  11 import io.netty.buffer.ByteBuf;
  12
  13 import java.util.Arrays;
  14 import java.util.HashMap;
  15 import java.util.List;
  16 import java.util.Map;
  17
  18 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.BosMatchEntry;
  19 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.DscpMatchEntry;
  20 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.EcnMatchEntry;
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.EthTypeMatchEntry;
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.Icmpv4CodeMatchEntry;
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.Icmpv4TypeMatchEntry;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.Icmpv6CodeMatchEntry;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.Icmpv6TypeMatchEntry;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.Ipv4AddressMatchEntry;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.Ipv6AddressMatchEntry;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.Ipv6FlabelMatchEntry;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.IsidMatchEntry;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.MacAddressMatchEntry;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.MaskMatchEntry;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.MetadataMatchEntry;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.MplsLabelMatchEntry;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.OpCodeMatchEntry;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.PortMatchEntry;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.PortNumberMatchEntry;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.ProtocolNumberMatchEntry;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.PseudoFieldMatchEntry;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.PseudoFieldMatchEntry.PseudoField;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.TcMatchEntry;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.VlanPcpMatchEntry;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.VlanVidMatchEntry;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.StandardMatchType;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.ArpOp;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.ArpSha;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.ArpSpa;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.ArpTha;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.ArpTpa;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.Clazz;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.EthDst;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.EthSrc;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.EthType;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.ExperimenterClass;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.Icmpv4Code;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.Icmpv4Type;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.Icmpv6Code;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.Icmpv6Type;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.InPhyPort;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.InPort;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.IpDscp;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.IpEcn;
  62 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.IpProto;
  63 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.Ipv4Dst;
  64 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.Ipv4Src;
  65 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.Ipv6Dst;
  66 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.Ipv6Exthdr;
  67 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.Ipv6Flabel;
  68 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.Ipv6NdSll;
  69 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.Ipv6NdTarget;
  70 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.Ipv6NdTll;
  71 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.Ipv6Src;
  72 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.MatchField;
  73 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.Metadata;
  74 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.MplsBos;
  75 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.MplsLabel;
  76 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.MplsTc;
  77 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.Nxm0Class;
  78 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.Nxm1Class;
  79 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.OpenflowBasicClass;
  80 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.OxmMatchType;
  81 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.PbbIsid;
  82 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.SctpDst;
  83 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.SctpSrc;
  84 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.TcpDst;
  85 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.TcpSrc;
  86 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.TunnelId;
  87 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.UdpDst;
  88 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.UdpSrc;
  89 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.VlanPcp;
  90 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.VlanVid;
  91 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.oxm.fields.MatchEntries;
  92 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.match.grouping.Match;
  93 import org.slf4j.Logger;
  94 import org.slf4j.LoggerFactory;
  95
  96 /**
  97  * Serializes ofp_match (OpenFlow v1.3) and its oxm_fields structures
  98  * @author michal.polkorab
  99  * @author timotej.kubas
 100  */
 101 public class MatchSerializer {
 102     private static final Logger LOGGER = LoggerFactory.getLogger(MatchSerializer.class);
 103     private static final byte STANDARD_MATCH_TYPE_CODE = 0;
 104     private static final byte OXM_MATCH_TYPE_CODE = 1;
 105     private static final int NXM0_CLASS_CODE = 0x0000;
 106     private static final int NXM1_CLASS_CODE = 0x0001;
 107     private static final int OPENFLOW_BASIC_CLASS_CODE = 0x8000;
 108     private static final int EXPERIMENTER_CLASS_CODE = 0xFFFF;
 109     private static final byte MATCH_TYPE_AND_LENGTH_SIZE = 4;
 110     private static final byte MATCH_ENTRY_HEADER_LENGTH = 4;
 111
 112     /**
 113      * Encodes match (OpenFlow v1.3)
 114      * @param match ofp_match object
 115      * @param out output ByteBuf
 116      */
 117     public static void encodeMatch(Match match, ByteBuf out) {
 118         if (match == null) {
 119             LOGGER.debug("Match is null");
 120             return;
 121         }
 122         encodeType(match, out);
 123         // Length of ofp_match (excluding padding)
 124         int length = computeMatchLengthInternal(match);
 125         out.writeShort(length);
 126         encodeMatchEntries(match.getMatchEntries(), out);
 127         int paddingRemainder = length % EncodeConstants.PADDING;
 128         if (paddingRemainder != 0) {
 129             ByteBufUtils.padBuffer(EncodeConstants.PADDING - paddingRemainder, out);
 130         }
 131     }
 132
 133     private static void encodeType(Match match, ByteBuf out) {
 134         if (match.getType().isAssignableFrom(StandardMatchType.class)) {
 135             out.writeShort(STANDARD_MATCH_TYPE_CODE);
 136         } else if (match.getType().isAssignableFrom(OxmMatchType.class)) {
 137             out.writeShort(OXM_MATCH_TYPE_CODE);
 138         }
 139     }
 140
 141     /**
 142      * Encodes MatchEntries
 143      * @param matchEntries list of match entries (oxm_fields)
 144      * @param out output ByteBuf
 145      */
 146     public static void encodeMatchEntries(List<MatchEntries> matchEntries, ByteBuf out) {
 147         if (matchEntries == null) {
 148             LOGGER.warn("Match entries are null");
 149             return;
 150         }
 151         for (MatchEntries entry : matchEntries) {
 152             encodeClass(entry.getOxmClass(), out);
 153             encodeRest(entry, out);
 154         }
 155     }
 156
 157     private static void encodeClass(Class<? extends Clazz> clazz, ByteBuf out) {
 158         if (clazz.isAssignableFrom(Nxm0Class.class)) {
 159             out.writeShort(NXM0_CLASS_CODE);
 160         } else if (clazz.isAssignableFrom(Nxm1Class.class)) {
 161             out.writeShort(NXM1_CLASS_CODE);
 162         } else if (clazz.isAssignableFrom(OpenflowBasicClass.class)) {
 163             out.writeShort(OPENFLOW_BASIC_CLASS_CODE);
 164         } else if (clazz.isAssignableFrom(ExperimenterClass.class)) {
 165             out.writeShort(EXPERIMENTER_CLASS_CODE);
 166         }
 167     }
 168
 169     private static void encodeRest(MatchEntries entry, ByteBuf out) {
 170         int fieldValue = 0;
 171         Class<? extends MatchField> field = entry.getOxmMatchField();
 172         if (field.isAssignableFrom(InPort.class)) {
 173             fieldValue = 0;
 174             writeOxmFieldAndLength(out, fieldValue, false, EncodeConstants.SIZE_OF_INT_IN_BYTES);
 175             out.writeInt(entry.getAugmentation(PortNumberMatchEntry.class).getPortNumber().getValue().intValue());
 176         } else if (field.isAssignableFrom(InPhyPort.class)) {
 177             fieldValue = 1;
 178             writeOxmFieldAndLength(out, fieldValue, false, EncodeConstants.SIZE_OF_INT_IN_BYTES);
 179             out.writeInt(entry.getAugmentation(PortNumberMatchEntry.class).getPortNumber().getValue().intValue());
 180         } else if (field.isAssignableFrom(Metadata.class)) {
 181             fieldValue = 2;
 182             writeMetadataRelatedEntry(entry, out, fieldValue);
 183         } else if (field.isAssignableFrom(EthDst.class)) {
 184             fieldValue = 3;
 185             writeMacAddressRelatedEntry(entry, out, fieldValue);
 186         } else if (field.isAssignableFrom(EthSrc.class)) {
 187             fieldValue = 4;
 188             writeMacAddressRelatedEntry(entry, out, fieldValue);
 189         } else if (field.isAssignableFrom(EthType.class)) {
 190             fieldValue = 5;
 191             writeOxmFieldAndLength(out, fieldValue, false, EncodeConstants.SIZE_OF_SHORT_IN_BYTES);
 192             out.writeShort(entry.getAugmentation(EthTypeMatchEntry.class).getEthType().getValue().shortValue());
 193         } else if (field.isAssignableFrom(VlanVid.class)) {
 194             fieldValue = 6;
 195             VlanVidMatchEntry vlanVid = entry.getAugmentation(VlanVidMatchEntry.class);
 196             int vlanVidValue = vlanVid.getVlanVid();
 197             if (vlanVid.isCfiBit()) {
 198                 short cfi = 1 << 12; // 13-th bit
 199                 vlanVidValue = vlanVidValue | cfi;
 200             }
 201
 202             writeOxmFieldAndLength(out, fieldValue, entry.isHasMask(),
 203                     EncodeConstants.SIZE_OF_SHORT_IN_BYTES);
 204             out.writeShort(vlanVidValue);
 205             writeMask(entry, out, EncodeConstants.SIZE_OF_SHORT_IN_BYTES);
 206         } else if (field.isAssignableFrom(VlanPcp.class)) {
 207             fieldValue = 7;
 208             writeOxmFieldAndLength(out, fieldValue, false, EncodeConstants.SIZE_OF_BYTE_IN_BYTES);
 209             out.writeByte(entry.getAugmentation(VlanPcpMatchEntry.class).getVlanPcp().byteValue());
 210         } else if (field.isAssignableFrom(IpDscp.class)) {
 211             fieldValue = 8;
 212             writeOxmFieldAndLength(out, fieldValue, false, EncodeConstants.SIZE_OF_BYTE_IN_BYTES);
 213             out.writeByte(entry.getAugmentation(DscpMatchEntry.class).getDscp().getValue());
 214         } else if (field.isAssignableFrom(IpEcn.class)) {
 215             fieldValue = 9;
 216             writeOxmFieldAndLength(out, fieldValue, false, EncodeConstants.SIZE_OF_BYTE_IN_BYTES);
 217             out.writeByte(entry.getAugmentation(EcnMatchEntry.class).getEcn());
 218         } else if (field.isAssignableFrom(IpProto.class)) {
 219             fieldValue = 10;
 220             writeOxmFieldAndLength(out, fieldValue, false, EncodeConstants.SIZE_OF_BYTE_IN_BYTES);
 221             out.writeByte(entry.getAugmentation(ProtocolNumberMatchEntry.class).getProtocolNumber());
 222         } else if (field.isAssignableFrom(Ipv4Src.class)) {
 223             fieldValue = 11;
 224             writeIpv4AddressRelatedEntry(entry, out, fieldValue);
 225         } else if (field.isAssignableFrom(Ipv4Dst.class)) {
 226             fieldValue = 12;
 227             writeIpv4AddressRelatedEntry(entry, out, fieldValue);
 228         } else if (field.isAssignableFrom(TcpSrc.class)) {
 229             fieldValue = 13;
 230             writeOxmFieldAndLength(out, fieldValue, false, EncodeConstants.SIZE_OF_SHORT_IN_BYTES);
 231             out.writeShort(entry.getAugmentation(PortMatchEntry.class).getPort().getValue().intValue());
 232         } else if (field.isAssignableFrom(TcpDst.class)) {
 233             fieldValue = 14;
 234             writeOxmFieldAndLength(out, fieldValue, false, EncodeConstants.SIZE_OF_SHORT_IN_BYTES);
 235             out.writeShort(entry.getAugmentation(PortMatchEntry.class).getPort().getValue().intValue());
 236         } else if (field.isAssignableFrom(UdpSrc.class)) {
 237             fieldValue = 15;
 238             writeOxmFieldAndLength(out, fieldValue, false, EncodeConstants.SIZE_OF_SHORT_IN_BYTES);
 239             out.writeShort(entry.getAugmentation(PortMatchEntry.class).getPort().getValue().intValue());
 240         } else if (field.isAssignableFrom(UdpDst.class)) {
 241             fieldValue = 16;
 242             writeOxmFieldAndLength(out, fieldValue, false, EncodeConstants.SIZE_OF_SHORT_IN_BYTES);
 243             out.writeShort(entry.getAugmentation(PortMatchEntry.class).getPort().getValue().intValue());
 244         } else if (field.isAssignableFrom(SctpSrc.class)) {
 245             fieldValue = 17;
 246             writeOxmFieldAndLength(out, fieldValue, false, EncodeConstants.SIZE_OF_SHORT_IN_BYTES);
 247             out.writeShort(entry.getAugmentation(PortMatchEntry.class).getPort().getValue().intValue());
 248         } else if (field.isAssignableFrom(SctpDst.class)) {
 249             fieldValue = 18;
 250             writeOxmFieldAndLength(out, fieldValue, false, EncodeConstants.SIZE_OF_SHORT_IN_BYTES);
 251             out.writeShort(entry.getAugmentation(PortMatchEntry.class).getPort().getValue().intValue());
 252         } else if (field.isAssignableFrom(Icmpv4Type.class)) {
 253             fieldValue = 19;
 254             writeOxmFieldAndLength(out, fieldValue, false, EncodeConstants.SIZE_OF_BYTE_IN_BYTES);
 255             out.writeByte(entry.getAugmentation(Icmpv4TypeMatchEntry.class).getIcmpv4Type());
 256         } else if (field.isAssignableFrom(Icmpv4Code.class)) {
 257             fieldValue = 20;
 258             writeOxmFieldAndLength(out, fieldValue, false, EncodeConstants.SIZE_OF_BYTE_IN_BYTES);
 259             out.writeByte(entry.getAugmentation(Icmpv4CodeMatchEntry.class).getIcmpv4Code());
 260         } else if (field.isAssignableFrom(ArpOp.class)) {
 261             fieldValue = 21;
 262             writeOxmFieldAndLength(out, fieldValue, false, EncodeConstants.SIZE_OF_SHORT_IN_BYTES);
 263             out.writeShort(entry.getAugmentation(OpCodeMatchEntry.class).getOpCode());
 264         } else if (field.isAssignableFrom(ArpSpa.class)) {
 265             fieldValue = 22;
 266             writeIpv4AddressRelatedEntry(entry, out, fieldValue);
 267         } else if (field.isAssignableFrom(ArpTpa.class)) {
 268             fieldValue = 23;
 269             writeIpv4AddressRelatedEntry(entry, out, fieldValue);
 270         } else if (field.isAssignableFrom(ArpSha.class)) {
 271             fieldValue = 24;
 272             writeMacAddressRelatedEntry(entry, out, fieldValue);
 273         } else if (field.isAssignableFrom(ArpTha.class)) {
 274             fieldValue = 25;
 275             writeMacAddressRelatedEntry(entry, out, fieldValue);
 276         } else if (field.isAssignableFrom(Ipv6Src.class)) {
 277             fieldValue = 26;
 278             writeIpv6AddressRelatedEntry(entry, out, fieldValue);
 279         } else if (field.isAssignableFrom(Ipv6Dst.class)) {
 280             fieldValue = 27;
 281             writeIpv6AddressRelatedEntry(entry, out, fieldValue);
 282         } else if (field.isAssignableFrom(Ipv6Flabel.class)) {
 283             fieldValue = 28;
 284             writeOxmFieldAndLength(out, fieldValue, entry.isHasMask(),
 285                     EncodeConstants.SIZE_OF_INT_IN_BYTES);
 286             out.writeInt(entry.getAugmentation(Ipv6FlabelMatchEntry.class).getIpv6Flabel().getValue().intValue());
 287             writeMask(entry, out, EncodeConstants.SIZE_OF_INT_IN_BYTES);
 288         } else if (field.isAssignableFrom(Icmpv6Type.class)) {
 289             fieldValue = 29;
 290             writeOxmFieldAndLength(out, fieldValue, false, EncodeConstants.SIZE_OF_BYTE_IN_BYTES);
 291             out.writeByte(entry.getAugmentation(Icmpv6TypeMatchEntry.class).getIcmpv6Type());
 292         } else if (field.isAssignableFrom(Icmpv6Code.class)) {
 293             fieldValue = 30;
 294             writeOxmFieldAndLength(out, fieldValue, false, EncodeConstants.SIZE_OF_BYTE_IN_BYTES);
 295             out.writeByte(entry.getAugmentation(Icmpv6CodeMatchEntry.class).getIcmpv6Code());
 296         } else if (field.isAssignableFrom(Ipv6NdTarget.class)) {
 297             fieldValue = 31;
 298             writeIpv6AddressRelatedEntry(entry, out, fieldValue);
 299         } else if (field.isAssignableFrom(Ipv6NdSll.class)) {
 300             fieldValue = 32;
 301             writeMacAddressRelatedEntry(entry, out, fieldValue);
 302         } else if (field.isAssignableFrom(Ipv6NdTll.class)) {
 303             fieldValue = 33;
 304             writeMacAddressRelatedEntry(entry, out, fieldValue);
 305         } else if (field.isAssignableFrom(MplsLabel.class)) {
 306             fieldValue = 34;
 307             writeOxmFieldAndLength(out, fieldValue, false, EncodeConstants.SIZE_OF_INT_IN_BYTES);
 308             out.writeInt(entry.getAugmentation(MplsLabelMatchEntry.class).getMplsLabel().intValue());
 309         } else if (field.isAssignableFrom(MplsTc.class)) {
 310             fieldValue = 35;
 311             writeOxmFieldAndLength(out, fieldValue, false, EncodeConstants.SIZE_OF_BYTE_IN_BYTES);
 312             out.writeByte(entry.getAugmentation(TcMatchEntry.class).getTc());
 313         } else if (field.isAssignableFrom(MplsBos.class)) {
 314             fieldValue = 36;
 315             writeOxmFieldAndLength(out, fieldValue, false, EncodeConstants.SIZE_OF_BYTE_IN_BYTES);
 316             out.writeBoolean(entry.getAugmentation(BosMatchEntry.class).isBos().booleanValue());
 317         } else if (field.isAssignableFrom(PbbIsid.class)) {
 318             fieldValue = 37;
 319             writeOxmFieldAndLength(out, fieldValue, entry.isHasMask(), EncodeConstants.SIZE_OF_3_BYTES);
 320             out.writeMedium(entry.getAugmentation(IsidMatchEntry.class).getIsid().intValue());
 321             writeMask(entry, out, EncodeConstants.SIZE_OF_3_BYTES);
 322         } else if (field.isAssignableFrom(TunnelId.class)) {
 323             fieldValue = 38;
 324             writeMetadataRelatedEntry(entry, out, fieldValue);
 325         } else if (field.isAssignableFrom(Ipv6Exthdr.class)) {
 326             fieldValue = 39;
 327             fieldValue = fieldValue << 1;
 328             PseudoField pseudoField = entry.getAugmentation(PseudoFieldMatchEntry.class).getPseudoField();
 329             Map<Integer, Boolean> map = new HashMap<>();
 330             map.put(0, pseudoField.isNonext());
 331             map.put(1, pseudoField.isEsp());
 332             map.put(2, pseudoField.isAuth());
 333             map.put(3, pseudoField.isDest());
 334             map.put(4, pseudoField.isFrag());
 335             map.put(5, pseudoField.isRouter());
 336             map.put(6, pseudoField.isHop());
 337             map.put(7, pseudoField.isUnrep());
 338             map.put(8, pseudoField.isUnseq());
 339             int bitmap = ByteBufUtils.fillBitMaskFromMap(map);
 340
 341             writeOxmFieldAndLength(out, fieldValue, entry.isHasMask(),
 342                     EncodeConstants.SIZE_OF_SHORT_IN_BYTES);
 343             out.writeShort(bitmap);
 344             writeMask(entry, out, EncodeConstants.SIZE_OF_SHORT_IN_BYTES);
 345         }
 346     }
 347
 348     /**
 349      * @param entry
 350      * @param out
 351      * @param length TODO
 352      */
 353     private static void writeMask(MatchEntries entry, ByteBuf out, int length) {
 354         if (entry.isHasMask()) {
 355             byte[] mask = entry.getAugmentation(MaskMatchEntry.class).getMask();
 356             if (mask != null && mask.length != length) {
 357                 throw new IllegalArgumentException("incorrect length of mask: "+
 358                         mask.length + ", expected: " + length);
 359             }
 360             out.writeBytes(mask);
 361         }
 362     }
 363
 364     private static void writeOxmFieldAndLength(ByteBuf out, int fieldValue, boolean hasMask, int lengthArg) {
 365         int fieldAndMask = fieldValue << 1;
 366         int length = lengthArg;
 367         if (hasMask) {
 368             fieldAndMask |= 1;
 369             length *= 2;
 370         }
 371
 372         out.writeByte(fieldAndMask);
 373         out.writeByte(length);
 374
 375     }
 376
 377     private static void writeMetadataRelatedEntry(MatchEntries entry, ByteBuf out, int value) {
 378         int fieldValue = value;
 379         writeOxmFieldAndLength(out, fieldValue, entry.isHasMask(),
 380                 EncodeConstants.SIZE_OF_LONG_IN_BYTES);
 381         out.writeBytes(entry.getAugmentation(MetadataMatchEntry.class).getMetadata());
 382         writeMask(entry, out, EncodeConstants.SIZE_OF_LONG_IN_BYTES);
 383     }
 384
 385     private static void writeMacAddressRelatedEntry(MatchEntries entry, ByteBuf out, int value) {
 386         int fieldValue = value;
 387
 388         writeOxmFieldAndLength(out, fieldValue, entry.isHasMask(),
 389                 EncodeConstants.MAC_ADDRESS_LENGTH);
 390         String macAddress = entry.getAugmentation(MacAddressMatchEntry.class).getMacAddress().getValue();
 391         out.writeBytes(ByteBufUtils.macAddressToBytes(macAddress)); // 48 b + mask [OF 1.3.2 spec]
 392         writeMask(entry, out, EncodeConstants.MAC_ADDRESS_LENGTH);
 393     }
 394
 395     private static void writeIpv4AddressRelatedEntry(MatchEntries entry, ByteBuf out, int value) {
 396         int fieldValue = value;
 397
 398         writeOxmFieldAndLength(out, fieldValue, entry.isHasMask(),
 399                 EncodeConstants.SIZE_OF_INT_IN_BYTES);
 400         writeIpv4Address(entry, out);
 401         writeMask(entry, out, EncodeConstants.SIZE_OF_INT_IN_BYTES);
 402     }
 403
 404     private static void writeIpv4Address(MatchEntries entry, ByteBuf out) {
 405         String[] addressGroups = entry.getAugmentation(Ipv4AddressMatchEntry.class).getIpv4Address().getValue().split("\\.");
 406         for (int i = 0; i < addressGroups.length; i++) {
 407             out.writeByte(Integer.parseInt(addressGroups[i]));
 408         }
 409     }
 410
 411     private static void writeIpv6AddressRelatedEntry(MatchEntries entry, ByteBuf out, int value) {
 412         int fieldValue = value;
 413         String textAddress = entry.getAugmentation(Ipv6AddressMatchEntry.class).getIpv6Address().getValue();
 414         String[] address;
 415         if (textAddress.equals("::")) {
 416             address = new String[EncodeConstants.GROUPS_IN_IPV6_ADDRESS];
 417             Arrays.fill(address, "0");
 418         } else {
 419             address = parseIpv6Address(textAddress.split(":"));
 420         }
 421
 422         writeOxmFieldAndLength(out, fieldValue, entry.isHasMask(),
 423                 EncodeConstants.SIZE_OF_IPV6_ADDRESS_IN_BYTES);
 424         for (int i = 0; i < address.length; i++) {
 425             out.writeShort(Integer.parseInt(address[i], 16));
 426         }
 427         writeMask(entry, out, EncodeConstants.SIZE_OF_IPV6_ADDRESS_IN_BYTES);
 428     }
 429
 430     private static String[] parseIpv6Address(String[] addressGroups) {
 431         int countEmpty = 0;
 432         for (int i = 0; i < addressGroups.length; i++) {
 433             if (addressGroups[i].equals("")){
 434                 countEmpty++;
 435             }
 436         }
 437         String[] ready = new String[EncodeConstants.GROUPS_IN_IPV6_ADDRESS];
 438         switch (countEmpty) {
 439         case 0:
 440             ready = addressGroups;
 441             break;
 442         case 1:
 443             int zerosToBePushed = EncodeConstants.GROUPS_IN_IPV6_ADDRESS - addressGroups.length + 1;
 444             int index = 0;
 445             for (int i = 0; i < addressGroups.length; i++) {
 446                 if (addressGroups[i].equals("")) {
 447                     for (int j = 0; j < zerosToBePushed; j++) {
 448                         ready[index] = "0";
 449                         index++;
 450                     }
 451                 } else {
 452                     ready[index] = addressGroups[i];
 453                     index++;
 454                 }
 455             }
 456             break;
 457         case 2:
 458             Arrays.fill(ready, "0");
 459             ready[ready.length - 1] = addressGroups[addressGroups.length - 1];
 460             break;
 461         default:
 462             throw new IllegalStateException("Incorrect ipv6 address");
 463         }
 464         return ready;
 465     }
 466
 467     /**
 468      * Computes length of match (in bytes)
 469      * @param match
 470      * @return length of ofp_match (excluding padding)
 471      */
 472     public static int computeMatchLengthInternal(Match match) {
 473         int length = 0;
 474         if (match != null) {
 475             length += MATCH_TYPE_AND_LENGTH_SIZE + computeMatchEntriesLength(match.getMatchEntries());
 476         }
 477         return length;
 478     }
 479
 480     /**
 481      * Computes length of match (in bytes)
 482      * @param match
 483      * @return length of ofp_match (excluding padding)
 484      */
 485     public static int computeMatchLength(Match match) {
 486         int length = computeMatchLengthInternal(match);
 487         int paddingRemainder = length % EncodeConstants.PADDING;
 488         if (paddingRemainder != 0) {
 489             length += EncodeConstants.PADDING - paddingRemainder;
 490         }
 491         return length;
 492     }
 493
 494     /**
 495      * Computes length of MatchEntries (in bytes)
 496      * @param matchEntries list of match entries (oxm_fields)
 497      * @return length of MatchEntries
 498      */
 499     public static int computeMatchEntriesLength(List<MatchEntries> matchEntries) {
 500         int length = 0;
 501         if (matchEntries != null) {
 502             for (MatchEntries entry : matchEntries) {
 503                 length += MATCH_ENTRY_HEADER_LENGTH;
 504                 Class<? extends MatchField> field = entry.getOxmMatchField();
 505                 if (field.isAssignableFrom(InPort.class)) {
 506                     length += EncodeConstants.SIZE_OF_INT_IN_BYTES;
 507                 } else if (field.isAssignableFrom(InPhyPort.class)) {
 508                     length += EncodeConstants.SIZE_OF_INT_IN_BYTES;
 509                 } else if (field.isAssignableFrom(Metadata.class)) {
 510                     length += computePossibleMaskEntryLength(entry, EncodeConstants.SIZE_OF_LONG_IN_BYTES);
 511                 } else if (field.isAssignableFrom(EthDst.class)) {
 512                     length += computePossibleMaskEntryLength(entry, EncodeConstants.MAC_ADDRESS_LENGTH);
 513                 } else if (field.isAssignableFrom(EthSrc.class)) {
 514                     length += computePossibleMaskEntryLength(entry, EncodeConstants.MAC_ADDRESS_LENGTH);
 515                 } else if (field.isAssignableFrom(EthType.class)) {
 516                     length += EncodeConstants.SIZE_OF_SHORT_IN_BYTES;
 517                 } else if (field.isAssignableFrom(VlanVid.class)) {
 518                     length += computePossibleMaskEntryLength(entry, EncodeConstants.SIZE_OF_SHORT_IN_BYTES);
 519                 } else if (field.isAssignableFrom(VlanPcp.class)) {
 520                     length += EncodeConstants.SIZE_OF_BYTE_IN_BYTES;
 521                 } else if (field.isAssignableFrom(IpDscp.class)) {
 522                     length += EncodeConstants.SIZE_OF_BYTE_IN_BYTES;
 523                 } else if (field.isAssignableFrom(IpEcn.class)) {
 524                     length += EncodeConstants.SIZE_OF_BYTE_IN_BYTES;
 525                 } else if (field.isAssignableFrom(IpProto.class)) {
 526                     length += EncodeConstants.SIZE_OF_BYTE_IN_BYTES;
 527                 } else if (field.isAssignableFrom(Ipv4Src.class)) {
 528                     length += computePossibleMaskEntryLength(entry, EncodeConstants.SIZE_OF_INT_IN_BYTES);
 529                 } else if (field.isAssignableFrom(Ipv4Dst.class)) {
 530                     length += computePossibleMaskEntryLength(entry, EncodeConstants.SIZE_OF_INT_IN_BYTES);
 531                 } else if (field.isAssignableFrom(TcpSrc.class)) {
 532                     length += EncodeConstants.SIZE_OF_SHORT_IN_BYTES;
 533                 } else if (field.isAssignableFrom(TcpDst.class)) {
 534                     length += EncodeConstants.SIZE_OF_SHORT_IN_BYTES;
 535                 } else if (field.isAssignableFrom(UdpSrc.class)) {
 536                     length += EncodeConstants.SIZE_OF_SHORT_IN_BYTES;
 537                 } else if (field.isAssignableFrom(UdpDst.class)) {
 538                     length += EncodeConstants.SIZE_OF_SHORT_IN_BYTES;
 539                 } else if (field.isAssignableFrom(SctpSrc.class)) {
 540                     length += EncodeConstants.SIZE_OF_SHORT_IN_BYTES;
 541                 } else if (field.isAssignableFrom(SctpDst.class)) {
 542                     length += EncodeConstants.SIZE_OF_SHORT_IN_BYTES;
 543                 } else if (field.isAssignableFrom(Icmpv4Type.class)) {
 544                     length += EncodeConstants.SIZE_OF_BYTE_IN_BYTES;
 545                 } else if (field.isAssignableFrom(Icmpv4Code.class)) {
 546                     length += EncodeConstants.SIZE_OF_BYTE_IN_BYTES;
 547                 } else if (field.isAssignableFrom(ArpOp.class)) {
 548                     length += EncodeConstants.SIZE_OF_SHORT_IN_BYTES;
 549                 } else if (field.isAssignableFrom(ArpSpa.class)) {
 550                     length += computePossibleMaskEntryLength(entry, EncodeConstants.SIZE_OF_INT_IN_BYTES);
 551                 } else if (field.isAssignableFrom(ArpTpa.class)) {
 552                     length += computePossibleMaskEntryLength(entry, EncodeConstants.SIZE_OF_INT_IN_BYTES);
 553                 } else if (field.isAssignableFrom(ArpSha.class)) {
 554                     length += computePossibleMaskEntryLength(entry, EncodeConstants.MAC_ADDRESS_LENGTH);
 555                 } else if (field.isAssignableFrom(ArpTha.class)) {
 556                     length += computePossibleMaskEntryLength(entry, EncodeConstants.MAC_ADDRESS_LENGTH);
 557                 } else if (field.isAssignableFrom(Ipv6Src.class)) {
 558                     length += computePossibleMaskEntryLength(entry, EncodeConstants.SIZE_OF_IPV6_ADDRESS_IN_BYTES);
 559                 } else if (field.isAssignableFrom(Ipv6Dst.class)) {
 560                     length += computePossibleMaskEntryLength(entry, EncodeConstants.SIZE_OF_IPV6_ADDRESS_IN_BYTES);
 561                 } else if (field.isAssignableFrom(Ipv6Flabel.class)) {
 562                     length += computePossibleMaskEntryLength(entry, EncodeConstants.SIZE_OF_INT_IN_BYTES);
 563                 } else if (field.isAssignableFrom(Icmpv6Type.class)) {
 564                     length += EncodeConstants.SIZE_OF_BYTE_IN_BYTES;
 565                 } else if (field.isAssignableFrom(Icmpv6Code.class)) {
 566                     length += EncodeConstants.SIZE_OF_BYTE_IN_BYTES;
 567                 } else if (field.isAssignableFrom(Ipv6NdTarget.class)) {
 568                     length += computePossibleMaskEntryLength(entry, EncodeConstants.SIZE_OF_IPV6_ADDRESS_IN_BYTES);
 569                 } else if (field.isAssignableFrom(Ipv6NdSll.class)) {
 570                     length += computePossibleMaskEntryLength(entry, EncodeConstants.MAC_ADDRESS_LENGTH);
 571                 } else if (field.isAssignableFrom(Ipv6NdTll.class)) {
 572                     length += computePossibleMaskEntryLength(entry, EncodeConstants.MAC_ADDRESS_LENGTH);
 573                 } else if (field.isAssignableFrom(MplsLabel.class)) {
 574                     length += EncodeConstants.SIZE_OF_INT_IN_BYTES;
 575                 } else if (field.isAssignableFrom(MplsTc.class)) {
 576                     length += EncodeConstants.SIZE_OF_BYTE_IN_BYTES;
 577                 } else if (field.isAssignableFrom(MplsBos.class)) {
 578                     length += EncodeConstants.SIZE_OF_BYTE_IN_BYTES;
 579                 } else if (field.isAssignableFrom(PbbIsid.class)) {
 580                     length += computePossibleMaskEntryLength(entry, EncodeConstants.SIZE_OF_3_BYTES);
 581                 } else if (field.isAssignableFrom(TunnelId.class)) {
 582                     length += computePossibleMaskEntryLength(entry, EncodeConstants.SIZE_OF_LONG_IN_BYTES);
 583                 } else if (field.isAssignableFrom(Ipv6Exthdr.class)) {
 584                     length += computePossibleMaskEntryLength(entry, EncodeConstants.SIZE_OF_SHORT_IN_BYTES);
 585                 }
 586             }
 587         }
 588         return length;
 589     }
 590
 591     private static int computePossibleMaskEntryLength(MatchEntries entry, int length) {
 592         int entryLength = length;
 593         if (entry.isHasMask()) {
 594             entryLength *= 2;
 595         }
 596         return entryLength;
 597     }
 598
 599 }