0d8acb52b736df2055a94aa523e4091c38718ca8
[controller.git] / opendaylight / commons / liblldp / src / main / java / org / opendaylight / controller / liblldp / Packet.java
1 /*
2  * Copyright (c) 2013, 2015 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
9 package org.opendaylight.controller.liblldp;
10
11 import java.util.Arrays;
12 import java.util.Map;
13 import java.util.Map.Entry;
14
15 import org.apache.commons.lang3.tuple.Pair;
16 import org.slf4j.Logger;
17 import org.slf4j.LoggerFactory;
18
19 /**
20  * Abstract class which represents the generic network packet object It provides
21  * the basic methods which are common for all the packets, like serialize and
22  * deserialize
23  */
24
25 public abstract class Packet {
26     protected static final Logger logger = LoggerFactory
27             .getLogger(Packet.class);
28     // Access level granted to this packet
29     protected boolean writeAccess;
30     // When deserialized from wire, packet could result corrupted
31     protected boolean corrupted;
32     // The packet that encapsulate this packet
33     protected Packet parent;
34     // The packet encapsulated by this packet
35     protected Packet payload;
36     // The unparsed raw payload carried by this packet
37     protected byte[] rawPayload;
38     // Bit coordinates of packet header fields
39     protected Map<String, Pair<Integer, Integer>> hdrFieldCoordMap;
40     // Header fields values: Map<FieldName,Value>
41     protected Map<String, byte[]> hdrFieldsMap;
42     // The class of the encapsulated packet object
43     protected Class<? extends Packet> payloadClass;
44
45     public Packet() {
46         writeAccess = false;
47         corrupted = false;
48     }
49
50     public Packet(final boolean writeAccess) {
51         this.writeAccess = writeAccess;
52         corrupted = false;
53     }
54
55     public Packet getParent() {
56         return parent;
57     }
58
59     public Packet getPayload() {
60         return payload;
61     }
62
63     public void setParent(final Packet parent) {
64         this.parent = parent;
65     }
66
67     public void setPayload(final Packet payload) {
68         this.payload = payload;
69     }
70
71     public void setHeaderField(final String headerField, final byte[] readValue) {
72         hdrFieldsMap.put(headerField, readValue);
73     }
74
75     /**
76      * This method deserializes the data bits obtained from the wire into the
77      * respective header and payload which are of type Packet
78      *
79      * @param data - data from wire to deserialize
80      * @param bitOffset bit position where packet header starts in data
81      *        array
82      * @param size size of packet in bits
83      * @return Packet
84      * @throws PacketException
85      */
86     public Packet deserialize(final byte[] data, final int bitOffset, final int size)
87             throws PacketException {
88
89         // Deserialize the header fields one by one
90         int startOffset = 0, numBits = 0;
91         for (Entry<String, Pair<Integer, Integer>> pairs : hdrFieldCoordMap
92                 .entrySet()) {
93             String hdrField = pairs.getKey();
94             startOffset = bitOffset + this.getfieldOffset(hdrField);
95             numBits = this.getfieldnumBits(hdrField);
96
97             byte[] hdrFieldBytes = null;
98             try {
99                 hdrFieldBytes = BitBufferHelper.getBits(data, startOffset,
100                         numBits);
101             } catch (final BufferException e) {
102                 throw new PacketException(e.getMessage());
103             }
104
105             /*
106              * Store the raw read value, checks the payload type and set the
107              * payloadClass accordingly
108              */
109             this.setHeaderField(hdrField, hdrFieldBytes);
110
111             if (logger.isTraceEnabled()) {
112                 logger.trace("{}: {}: {} (offset {} bitsize {})",
113                         new Object[] { this.getClass().getSimpleName(), hdrField,
114                         HexEncode.bytesToHexString(hdrFieldBytes),
115                         startOffset, numBits });
116             }
117         }
118
119         // Deserialize the payload now
120         int payloadStart = startOffset + numBits;
121         int payloadSize = data.length * NetUtils.NumBitsInAByte - payloadStart;
122
123         if (payloadClass != null) {
124             try {
125                 payload = payloadClass.newInstance();
126             } catch (final Exception e) {
127                 throw new RuntimeException(
128                         "Error parsing payload for Ethernet packet", e);
129             }
130             payload.deserialize(data, payloadStart, payloadSize);
131             payload.setParent(this);
132         } else {
133             /*
134              *  The payload class was not set, it means no class for parsing
135              *  this payload is present. Let's store the raw payload if any.
136              */
137             int start = payloadStart / NetUtils.NumBitsInAByte;
138             int stop = start + payloadSize / NetUtils.NumBitsInAByte;
139             rawPayload = Arrays.copyOfRange(data, start, stop);
140         }
141
142
143         // Take care of computation that can be done only after deserialization
144         postDeserializeCustomOperation(data, payloadStart - getHeaderSize());
145
146         return this;
147     }
148
149     /**
150      * This method serializes the header and payload from the respective
151      * packet class, into a single stream of bytes to be sent on the wire
152      *
153      * @return The byte array representing the serialized Packet
154      * @throws PacketException
155      */
156     public byte[] serialize() throws PacketException {
157
158         // Acquire or compute the serialized payload
159         byte[] payloadBytes = null;
160         if (payload != null) {
161             payloadBytes = payload.serialize();
162         } else if (rawPayload != null) {
163             payloadBytes = rawPayload;
164         }
165         int payloadSize = (payloadBytes == null) ? 0 : payloadBytes.length;
166
167         // Allocate the buffer to contain the full (header + payload) packet
168         int headerSize = this.getHeaderSize() / NetUtils.NumBitsInAByte;
169         byte packetBytes[] = new byte[headerSize + payloadSize];
170         if (payloadBytes != null) {
171             System.arraycopy(payloadBytes, 0, packetBytes, headerSize, payloadSize);
172         }
173
174         // Serialize this packet header, field by field
175         for (Map.Entry<String, Pair<Integer, Integer>> pairs : hdrFieldCoordMap
176                 .entrySet()) {
177             String field = pairs.getKey();
178             byte[] fieldBytes = hdrFieldsMap.get(field);
179             // Let's skip optional fields when not set
180             if (fieldBytes != null) {
181                 try {
182                     BitBufferHelper.setBytes(packetBytes, fieldBytes,
183                             getfieldOffset(field), getfieldnumBits(field));
184                 } catch (final BufferException e) {
185                     throw new PacketException(e.getMessage());
186                 }
187             }
188         }
189
190         // Perform post serialize operations (like checksum computation)
191         postSerializeCustomOperation(packetBytes);
192
193         if (logger.isTraceEnabled()) {
194             logger.trace("{}: {}", this.getClass().getSimpleName(),
195                     HexEncode.bytesToHexString(packetBytes));
196         }
197
198         return packetBytes;
199     }
200
201     /**
202      * This method gets called at the end of the serialization process It is
203      * intended for the child packets to insert some custom data into the output
204      * byte stream which cannot be done or cannot be done efficiently during the
205      * normal Packet.serialize() path. An example is the checksum computation
206      * for IPv4
207      *
208      * @param myBytes serialized bytes
209      * @throws PacketException
210      */
211     protected void postSerializeCustomOperation(byte[] myBytes)
212             throws PacketException {
213         // no op
214     }
215
216     /**
217      * This method re-computes the checksum of the bits received on the wire and
218      * validates it with the checksum in the bits received Since the computation
219      * of checksum varies based on the protocol, this method is overridden.
220      * Currently only IPv4 and ICMP do checksum computation and validation. TCP
221      * and UDP need to implement these if required.
222      *
223      * @param data The byte stream representing the Ethernet frame
224      * @param startBitOffset The bit offset from where the byte array corresponding to this Packet starts in the frame
225      * @throws PacketException
226      */
227     protected void postDeserializeCustomOperation(byte[] data, int startBitOffset)
228             throws PacketException {
229         // no op
230     }
231
232     /**
233      * Gets the header length in bits
234      *
235      * @return int the header length in bits
236      */
237     public int getHeaderSize() {
238         int size = 0;
239         /*
240          * We need to iterate over the fields that were read in the frame
241          * (hdrFieldsMap) not all the possible ones described in
242          * hdrFieldCoordMap. For ex, 802.1Q may or may not be there
243          */
244         for (Map.Entry<String, byte[]> fieldEntry : hdrFieldsMap.entrySet()) {
245             if (fieldEntry.getValue() != null) {
246                 String field = fieldEntry.getKey();
247                 size += getfieldnumBits(field);
248             }
249         }
250         return size;
251     }
252
253     /**
254      * This method fetches the start bit offset for header field specified by
255      * 'fieldname'. The offset is present in the hdrFieldCoordMap of the
256      * respective packet class
257      *
258      * @return Integer - startOffset of the requested field
259      */
260     public int getfieldOffset(final String fieldName) {
261         return hdrFieldCoordMap.get(fieldName).getLeft();
262     }
263
264     /**
265      * This method fetches the number of bits for header field specified by
266      * 'fieldname'. The numBits are present in the hdrFieldCoordMap of the
267      * respective packet class
268      *
269      * @return Integer - number of bits of the requested field
270      */
271     public int getfieldnumBits(final String fieldName) {
272         return hdrFieldCoordMap.get(fieldName).getRight();
273     }
274
275     @Override
276     public String toString() {
277         StringBuilder ret = new StringBuilder();
278         ret.append(this.getClass().getSimpleName());
279         ret.append(": [");
280         for (String field : hdrFieldCoordMap.keySet()) {
281             byte[] value = hdrFieldsMap.get(field);
282             ret.append(field);
283             ret.append(": ");
284             ret.append(HexEncode.bytesToHexString(value));
285             ret.append(", ");
286         }
287         ret.replace(ret.length()-2, ret.length()-1, "]");
288         return ret.toString();
289     }
290
291     /**
292      * Returns the raw payload carried by this packet in case payload was not
293      * parsed. Caller can call this function in case the getPaylod() returns null.
294      *
295      * @return The raw payload if not parsable as an array of bytes, null otherwise
296      */
297     public byte[] getRawPayload() {
298         return rawPayload;
299     }
300
301     /**
302      * Set a raw payload in the packet class
303      *
304      * @param payload The raw payload as byte array
305      */
306     public void setRawPayload(final byte[] payload) {
307         this.rawPayload = Arrays.copyOf(payload, payload.length);
308     }
309
310     /**
311      * Return whether the deserialized packet is to be considered corrupted.
312      * This is the case when the checksum computed after reconstructing the
313      * packet received from wire is not equal to the checksum read from the
314      * stream. For the Packet class which do not have a checksum field, this
315      * function will always return false.
316      *
317      *
318      * @return true if the deserialized packet's recomputed checksum is not
319      *         equal to the packet carried checksum
320      */
321     public boolean isCorrupted() {
322         return corrupted;
323     }
324
325     @Override
326     public int hashCode() {
327         final int prime = 31;
328         int result = super.hashCode();
329         result = prime * result
330                 + ((this.hdrFieldsMap == null) ? 0 : hdrFieldsMap.hashCode());
331         return result;
332     }
333
334     @Override
335     public boolean equals(final Object obj) {
336         if (this == obj) {
337             return true;
338         }
339         if (getClass() != obj.getClass()) {
340             return false;
341         }
342         Packet other = (Packet) obj;
343         if (hdrFieldsMap == other.hdrFieldsMap) {
344             return true;
345         }
346         if (hdrFieldsMap == null || other.hdrFieldsMap == null) {
347             return false;
348         }
349         if (hdrFieldsMap != null && other.hdrFieldsMap != null) {
350             for (String field : hdrFieldsMap.keySet()) {
351                 if (!Arrays.equals(hdrFieldsMap.get(field), other.hdrFieldsMap.get(field))) {
352                     return false;
353                 }
354             }
355         } else {
356             return false;
357         }
358         return true;
359     }
360 }

©2013 OpenDaylight, A Linux Foundation Collaborative Project. All Rights Reserved.
OpenDaylight is a registered trademark of The OpenDaylight Project, Inc.
Linux Foundation and OpenDaylight are registered trademarks of the Linux Foundation.
Linux is a registered trademark of Linus Torvalds.