opendaylight/sal/api/src/main/java/org/opendaylight/controller/sal/packet/TCP.java

   1
   2 /*
   3  * Copyright (c) 2013 Cisco Systems, Inc. and others.  All rights reserved.
   4  *
   5  * This program and the accompanying materials are made available under the
   6  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   7  * and is available at http://www.eclipse.org/legal/epl-v10.html
   8  */
   9
  10 package org.opendaylight.controller.sal.packet;
  11
  12 import java.util.HashMap;
  13 import java.util.LinkedHashMap;
  14 import java.util.Map;
  15
  16 import org.apache.commons.lang3.tuple.ImmutablePair;
  17 import org.apache.commons.lang3.tuple.Pair;
  18
  19 /**
  20  * Class that represents the TCP segment objects
  21  */
  22 public class TCP extends Packet {
  23
  24     private static final String SRCPORT = "SourcePort";
  25     private static final String DESTPORT = "DestinationPort";
  26     private static final String SEQNUMBER = "SequenceNumber";
  27     private static final String ACKNUMBER = "AcknoledgementNumber";
  28     private static final String DATAOFFSET = "DataOffset";
  29     private static final String RESERVED = "Reserved";
  30     private static final String HEADERLENFLAGS = "HeaderLenFlags";
  31     private static final String WINDOWSIZE = "WindowSize";
  32     private static final String CHECKSUM = "Checksum";
  33     private static final String URGENTPOINTER = "UrgentPointer";
  34
  35     private static Map<String, Pair<Integer, Integer>> fieldCoordinates = new LinkedHashMap<String, Pair<Integer, Integer>>() {
  36         private static final long serialVersionUID = 1L;
  37         {
  38             put(SRCPORT, new ImmutablePair<Integer, Integer>(0, 16));
  39             put(DESTPORT, new ImmutablePair<Integer, Integer>(16, 16));
  40             put(SEQNUMBER, new ImmutablePair<Integer, Integer>(32, 32));
  41             put(ACKNUMBER, new ImmutablePair<Integer, Integer>(64, 32));
  42             put(DATAOFFSET, new ImmutablePair<Integer, Integer>(96, 4));
  43             put(RESERVED, new ImmutablePair<Integer, Integer>(100, 3));
  44             put(HEADERLENFLAGS, new ImmutablePair<Integer, Integer>(103, 9));
  45             put(WINDOWSIZE, new ImmutablePair<Integer, Integer>(112, 16));
  46             put(CHECKSUM, new ImmutablePair<Integer, Integer>(128, 16));
  47             put(URGENTPOINTER, new ImmutablePair<Integer, Integer>(144, 16));
  48         }
  49     };
  50
  51     private final Map<String, byte[]> fieldValues;
  52
  53     /**
  54      * Default constructor that sets all the header fields to zero
  55      */
  56     public TCP() {
  57         super();
  58         fieldValues = new HashMap<String, byte[]>();
  59         hdrFieldCoordMap = fieldCoordinates;
  60         hdrFieldsMap = fieldValues;
  61         /* Setting all remaining header field values to
  62          * default value of 0.  These maybe changed as needed
  63          */
  64         setSourcePort((short) 0);
  65         setDestinationPort((short) 0);
  66         setSequenceNumber(0);
  67         setAckNumber(0);
  68         setDataOffset((byte) 0);
  69         setReserved((byte) 0);
  70         setWindowSize((short) 0);
  71         setUrgentPointer((short) 0);
  72         setChecksum((short) 0);
  73     }
  74
  75     /**
  76      * Constructor that sets the access level for the packet and
  77      * sets all the header fields to zero.
  78      */
  79     public TCP(boolean writeAccess) {
  80         super(writeAccess);
  81         fieldValues = new HashMap<String, byte[]>();
  82         hdrFieldCoordMap = fieldCoordinates;
  83         hdrFieldsMap = fieldValues;
  84         /* Setting all remaining header field values to
  85          * default value of 0.  These maybe changed as needed
  86          */
  87         setSourcePort((short) 0);
  88         setDestinationPort((short) 0);
  89         setSequenceNumber(0);
  90         setAckNumber(0);
  91         setDataOffset((byte) 0);
  92         setReserved((byte) 0);
  93         setWindowSize((short) 0);
  94         setUrgentPointer((short) 0);
  95         setChecksum((short) 0);
  96     }
  97
  98     @Override
  99     /**
 100      * Stores the value read from data stream
 101      */
 102     public void setHeaderField(String headerField, byte[] readValue) {
 103         hdrFieldsMap.put(headerField, readValue);
 104     }
 105
 106     /**
 107      * Sets the TCP source port for the current TCP object instance
 108      * @param short tcpSourcePort
 109      * @return TCP
 110      */
 111     public TCP setSourcePort(short tcpSourcePort) {
 112         byte[] sourcePort = BitBufferHelper.toByteArray(tcpSourcePort);
 113         fieldValues.put(SRCPORT, sourcePort);
 114         return this;
 115     }
 116
 117     /**
 118      * Sets the TCP destination port for the current TCP object instance
 119      * @param short tcpDestinationPort
 120      * @return TCP
 121      */
 122     public TCP setDestinationPort(short tcpDestinationPort) {
 123         byte[] destinationPort = BitBufferHelper
 124                 .toByteArray(tcpDestinationPort);
 125         fieldValues.put(DESTPORT, destinationPort);
 126         return this;
 127     }
 128
 129     /**
 130      * Sets the TCP sequence number for the current TCP object instance
 131      * @param int tcpSequenceNumber
 132      * @return TCP
 133      */
 134     public TCP setSequenceNumber(int tcpSequenceNumber) {
 135         byte[] sequenceNumber = BitBufferHelper.toByteArray(tcpSequenceNumber);
 136         fieldValues.put(SEQNUMBER, sequenceNumber);
 137         return this;
 138     }
 139
 140     /**
 141      * Sets the TCP data offset for the current TCP object instance
 142      * @param byte tcpDataOffset
 143      * @return TCP
 144      */
 145     public TCP setDataOffset(byte tcpDataOffset) {
 146         byte[] offset = BitBufferHelper.toByteArray(tcpDataOffset);
 147         fieldValues.put("DataOffset", offset);
 148         return this;
 149     }
 150
 151     /**
 152      * Sets the TCP reserved bits for the current TCP object instance
 153      * @param byte tcpReserved
 154      * @return TCP
 155      */
 156     public TCP setReserved(byte tcpReserved) {
 157         byte[] reserved = BitBufferHelper.toByteArray(tcpReserved);
 158         fieldValues.put("Reserved", reserved);
 159         return this;
 160     }
 161
 162     /**
 163      * Sets the TCP Ack number for the current TCP object instance
 164      * @param int tcpAckNumber
 165      * @return TCP
 166      */
 167     public TCP setAckNumber(int tcpAckNumber) {
 168         byte[] ackNumber = BitBufferHelper.toByteArray(tcpAckNumber);
 169         fieldValues.put(ACKNUMBER, ackNumber);
 170         return this;
 171     }
 172
 173     /**
 174      * Sets the TCP flags for the current TCP object instance
 175      * @param short tcpFlags
 176      * @return TCP
 177      */
 178     public TCP setHeaderLenFlags(short tcpFlags) {
 179         byte[] headerLenFlags = BitBufferHelper.toByteArray(tcpFlags);
 180         fieldValues.put(HEADERLENFLAGS, headerLenFlags);
 181         return this;
 182     }
 183
 184     /**
 185      * Sets the TCP window size for the current TCP object instance
 186      * @param short tcpWsize
 187      * @return TCP
 188      */
 189     public TCP setWindowSize(short tcpWsize) {
 190         byte[] wsize = BitBufferHelper.toByteArray(tcpWsize);
 191         fieldValues.put(WINDOWSIZE, wsize);
 192         return this;
 193     }
 194
 195     /**
 196      * Sets the TCP checksum for the current TCP object instance
 197      * @param short tcpChecksum
 198      * @return TCP
 199      */
 200     public TCP setChecksum(short tcpChecksum) {
 201         byte[] checksum = BitBufferHelper.toByteArray(tcpChecksum);
 202         fieldValues.put(CHECKSUM, checksum);
 203         return this;
 204     }
 205
 206     /**
 207      * Sets the TCP Urgent Pointer for the current TCP object instance
 208      * @param short tcpUrgentPointer
 209      * @return TCP
 210      */
 211     public TCP setUrgentPointer(short tcpUrgentPointer) {
 212         byte[] urgentPointer = BitBufferHelper.toByteArray(tcpUrgentPointer);
 213         fieldValues.put(URGENTPOINTER, urgentPointer);
 214         return this;
 215     }
 216
 217     /**
 218      * Gets the stored source port value of TCP header
 219      * @return the sourcePort
 220      */
 221     public short getSourcePort() {
 222         return (BitBufferHelper.getShort(fieldValues.get(SRCPORT)));
 223     }
 224
 225     /**
 226      * Gets the stored destination port value of TCP header
 227      * @return the destinationPort
 228      */
 229     public short getDestinationPort() {
 230         return (BitBufferHelper.getShort(fieldValues.get(DESTPORT)));
 231     }
 232
 233 }