pcep/spi/src/main/java/org/opendaylight/protocol/pcep/spi/AbstractObjectParser.java

   1 /*
   2  * Copyright (c) 2013 Cisco Systems, Inc. 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 package org.opendaylight.protocol.pcep.spi;
   9
  10 import java.util.List;
  11 import java.util.Map;
  12 import java.util.Map.Entry;
  13
  14 import org.opendaylight.protocol.pcep.PCEPDeserializerException;
  15 import org.opendaylight.protocol.util.ByteArray;
  16 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.Tlv;
  17 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.rsvp.rev130820.CSubobject;
  18 import org.slf4j.Logger;
  19 import org.slf4j.LoggerFactory;
  20
  21 import com.google.common.collect.Lists;
  22 import com.google.common.collect.Maps;
  23
  24 public abstract class AbstractObjectParser<BUILDER> implements ObjectParser, ObjectSerializer {
  25
  26         private static final Logger logger = LoggerFactory.getLogger(AbstractObjectParser.class);
  27
  28         private static final int TLV_TYPE_F_LENGTH = 2;
  29         private static final int TLV_LENGTH_F_LENGTH = 2;
  30         private static final int TLV_HEADER_LENGTH = TLV_LENGTH_F_LENGTH + TLV_TYPE_F_LENGTH;
  31
  32         private static final int SUB_TYPE_FLAG_F_LENGTH = 1;
  33         private static final int SUB_LENGTH_F_LENGTH = 1;
  34         private static final int SUB_HEADER_LENGTH = SUB_TYPE_FLAG_F_LENGTH + SUB_LENGTH_F_LENGTH;
  35
  36         public static final int TYPE_FLAG_F_OFFSET = 0;
  37         public static final int LENGTH_F_OFFSET = TYPE_FLAG_F_OFFSET + SUB_TYPE_FLAG_F_LENGTH;
  38         public static final int SO_CONTENTS_OFFSET = LENGTH_F_OFFSET + SUB_LENGTH_F_LENGTH;
  39
  40         protected static final int PADDED_TO = 4;
  41
  42         private final HandlerRegistry registry;
  43
  44         protected AbstractObjectParser(final HandlerRegistry registry) {
  45                 this.registry = registry;
  46         }
  47
  48         protected final void parseTlvs(final BUILDER builder, final byte[] bytes) throws PCEPDeserializerException {
  49                 if (bytes == null)
  50                         throw new IllegalArgumentException("Byte array is mandatory.");
  51
  52                 int length;
  53                 int byteOffset = 0;
  54                 int type = 0;
  55
  56                 while (byteOffset < bytes.length) {
  57                         type = ByteArray.bytesToInt(ByteArray.subByte(bytes, byteOffset, TLV_TYPE_F_LENGTH));
  58                         byteOffset += TLV_TYPE_F_LENGTH;
  59                         length = ByteArray.bytesToInt(ByteArray.subByte(bytes, byteOffset, TLV_LENGTH_F_LENGTH));
  60                         byteOffset += TLV_LENGTH_F_LENGTH;
  61
  62                         if (TLV_HEADER_LENGTH + length > bytes.length - byteOffset)
  63                                 throw new PCEPDeserializerException("Wrong length specified. Passed: " + (TLV_HEADER_LENGTH + length) + "; Expected: <= "
  64                                                 + (bytes.length - byteOffset) + ".");
  65
  66                         final byte[] tlvBytes = ByteArray.subByte(bytes, byteOffset, length);
  67
  68                         logger.trace("Attempt to parse tlv from bytes: {}", ByteArray.bytesToHexString(tlvBytes));
  69                         final Tlv tlv = this.registry.getTlvParser(type).parseTlv(tlvBytes);
  70                         logger.trace("Tlv was parsed. {}", tlv);
  71
  72                         addTlv(builder, tlv);
  73
  74                         byteOffset += length + getPadding(TLV_HEADER_LENGTH + length, PADDED_TO);
  75                 }
  76         }
  77
  78         protected final byte[] serializeTlv(final Tlv tlv) {
  79
  80                 final TlvSerializer serializer = this.registry.getTlvSerializer(tlv);
  81
  82                 final byte[] typeBytes = (ByteArray.cutBytes(ByteArray.intToBytes(serializer.getType()), (Integer.SIZE / 8) - TLV_TYPE_F_LENGTH));
  83
  84                 final byte[] valueBytes = serializer.serializeTlv(tlv);
  85
  86                 final byte[] lengthBytes = ByteArray.cutBytes(ByteArray.intToBytes(valueBytes.length), (Integer.SIZE / 8) - TLV_LENGTH_F_LENGTH);
  87
  88                 final byte[] bytes = new byte[TLV_HEADER_LENGTH + valueBytes.length + getPadding(TLV_HEADER_LENGTH + valueBytes.length, PADDED_TO)];
  89
  90                 int byteOffset = 0;
  91                 System.arraycopy(typeBytes, 0, bytes, byteOffset, TLV_TYPE_F_LENGTH);
  92                 System.arraycopy(lengthBytes, 0, bytes, byteOffset += TLV_TYPE_F_LENGTH, TLV_LENGTH_F_LENGTH);
  93                 System.arraycopy(valueBytes, 0, bytes, byteOffset += TLV_LENGTH_F_LENGTH, valueBytes.length);
  94                 return bytes;
  95         }
  96
  97         protected final void parseSubobjects(final BUILDER builder, final byte[] bytes) throws PCEPDeserializerException {
  98                 if (bytes == null)
  99                         throw new IllegalArgumentException("Byte array is mandatory.");
 100
 101                 boolean loose_flag = false;
 102                 int type;
 103
 104                 final Map<CSubobject, Boolean> subs = Maps.newHashMap();
 105
 106                 byte[] soContentsBytes;
 107                 int length;
 108                 int offset = 0;
 109
 110                 while (offset < bytes.length) {
 111
 112                         loose_flag = ((bytes[offset + TYPE_FLAG_F_OFFSET] & (1 << 7)) != 0) ? true : false;
 113                         length = ByteArray.bytesToInt(ByteArray.subByte(bytes, offset + LENGTH_F_OFFSET, SUB_LENGTH_F_LENGTH));
 114
 115                         type = (bytes[offset + TYPE_FLAG_F_OFFSET] & 0xff) & ~(1 << 7);
 116
 117                         if (length > bytes.length - offset)
 118                                 throw new PCEPDeserializerException("Wrong length specified. Passed: " + length + "; Expected: <= "
 119                                                 + (bytes.length - offset));
 120
 121                         soContentsBytes = new byte[length - SO_CONTENTS_OFFSET];
 122                         System.arraycopy(bytes, offset + SO_CONTENTS_OFFSET, soContentsBytes, 0, length - SO_CONTENTS_OFFSET);
 123
 124                         logger.debug("Attempt to parse subobject from bytes: {}", ByteArray.bytesToHexString(soContentsBytes));
 125                         final CSubobject subObj = this.registry.getSubobjectParser(type).parseSubobject(soContentsBytes);
 126                         logger.debug("Subobject was parsed. {}", subObj);
 127
 128                         subs.put(subObj, loose_flag);
 129
 130                         offset += length;
 131                 }
 132                 // addSubobject(builder, subs);
 133         }
 134
 135         protected final byte[] serializeSubobject(final Map<CSubobject, Boolean> subobjects) {
 136
 137                 final List<byte[]> result = Lists.newArrayList();
 138
 139                 int finalLength = 0;
 140
 141                 for (final Entry<CSubobject, Boolean> entry : subobjects.entrySet()) {
 142
 143                         final CSubobject subobject = entry.getKey();
 144
 145                         final SubobjectSerializer serializer = this.registry.getSubobjectSerializer(subobject);
 146
 147                         final byte[] valueBytes = serializer.serializeSubobject(subobject);
 148
 149                         final byte[] bytes = new byte[SUB_HEADER_LENGTH + valueBytes.length];
 150
 151                         final byte typeBytes = (byte) (ByteArray.cutBytes(ByteArray.intToBytes(serializer.getType()), (Integer.SIZE / 8) - 1)[0] | (entry.getValue() ? 1 << 7
 152                                         : 0));
 153                         final byte lengthBytes = ByteArray.cutBytes(ByteArray.intToBytes(valueBytes.length), (Integer.SIZE / 8) - 1)[0];
 154
 155                         bytes[0] = typeBytes;
 156                         bytes[1] = lengthBytes;
 157                         System.arraycopy(valueBytes, 0, bytes, SUB_HEADER_LENGTH, valueBytes.length);
 158
 159                         finalLength += bytes.length;
 160                         result.add(bytes);
 161                 }
 162
 163                 final byte[] resultBytes = new byte[finalLength];
 164                 int byteOffset = 0;
 165                 for (final byte[] b : result) {
 166                         System.arraycopy(b, 0, resultBytes, byteOffset, b.length);
 167                         byteOffset += b.length;
 168                 }
 169                 return resultBytes;
 170         }
 171
 172         // public abstract void addSubobject(final BUILDER builder, final Map<CSubobject, Boolean> subobjects);
 173
 174         public abstract void addTlv(final BUILDER builder, final Tlv tlv);
 175
 176         private static int getPadding(final int length, final int padding) {
 177                 return (padding - (length % padding)) % padding;
 178         }
 179 }