first version

25 files changed, 2811 insertions, 0 deletions

diff --git a/src/common/Network/Packet/CPktCmn.cpp b/src/common/Network/Packet/CPktCmn.cpp
new file mode 100755
index 00000000..9f682826
--- /dev/null
+++ b/src/common/Network/Packet/CPktCmn.cpp
@@ -0,0 +1,145 @@
+#include "CPktCmn.h"
+/*
+Copyright (c) 2015-2015 Cisco Systems, Inc.
+
+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.
+*/
+
+
+
+#define TouchCacheLine(a)
+
+uint16_t pkt_InetChecksum(uint8_t* data , 
+                        uint16_t len, uint8_t* data2 , uint16_t len2){
+
+    TouchCacheLine(data2);
+    TouchCacheLine(data2+32);
+    TouchCacheLine(data2+64);
+
+    int sum = 0;
+    while(len>1){
+        TouchCacheLine(data+96); //three lines ahead !
+        sum += PKT_NTOHS(*((uint16_t*)data));
+        data += 2;
+        len -= 2;
+    }
+
+    while(len2>1){
+        TouchCacheLine(data2+96); //three lines ahead !
+        sum += PKT_NTOHS(*((uint16_t*)data2));
+        data2 += 2;
+        len2 -= 2;
+    }
+
+    if(len2){
+        sum += (PKT_NTOHS(*((uint16_t*)data2)) & 0xff00);
+    }
+
+    while(sum >> 16){
+        sum = (sum & 0xffff) + (sum >> 16);
+    }
+
+    return PKT_NTOHS((uint16_t)(~sum));
+}
+
+uint16_t pkt_InetChecksum(uint8_t* data , uint16_t len){
+
+    int sum = 0;
+    while(len>1){
+        TouchCacheLine(data+96); //three line ahead !
+        sum += PKT_NTOHS(*((uint16_t*)data));
+        data += 2;
+        len -= 2;
+    }
+
+    if(len){
+        sum += (PKT_NTOHS(*((uint16_t*)data)) & 0xff00);
+    }
+
+    while(sum >> 16){
+        sum = (sum & 0xffff) + (sum >> 16);
+    }
+
+    return PKT_NTOHS((uint16_t)(~sum));
+}
+
+uint16_t pkt_UpdateInetChecksum(uint16_t csFieldFromPacket, uint16_t oldVal, uint16_t newVal){
+    uint32_t newCS;
+    newCS = (uint16_t)(~PKT_NTOHS(csFieldFromPacket));
+    newCS += (uint16_t)(~PKT_NTOHS(oldVal));
+    newCS += (uint16_t)PKT_NTOHS(newVal);
+    while(newCS >> 16){
+        newCS = (newCS & 0xffff) + (newCS >> 16);
+    }
+    return PKT_NTOHS((uint16_t)(~newCS));
+}
+
+uint16_t pkt_SubtractInetChecksum(uint16_t checksum, uint16_t csToSubtract){
+    uint32_t newCS;
+    newCS = (uint16_t)(~PKT_NTOHS(checksum));
+
+    // since the cs is already in ~ format in the packet, there is no need
+    // to negate it for subtraction in 1's complement.
+    newCS += (uint16_t)PKT_NTOHS(csToSubtract);
+
+    while(newCS >> 16){
+        newCS = (newCS & 0xffff) + (newCS >> 16);
+    }
+    return PKT_NTOHS((uint16_t)(~newCS));
+}
+
+uint16_t pkt_AddInetChecksum(uint16_t checksum, uint16_t csToAdd){
+    uint32_t newCS;
+    newCS = (uint16_t)(~PKT_NTOHS(checksum));
+
+    // since the cs is already in ~ format in the packet, there is a need
+    // to negate it for addition in 1's complement.
+    newCS += (uint16_t)PKT_NTOHS(~csToAdd);
+
+    while(newCS >> 16){
+        newCS = (newCS & 0xffff) + (newCS >> 16);
+    }
+    return PKT_NTOHS((uint16_t)(~newCS));
+}
+
+
+extern "C" void pkt_ChecksumTest(){
+
+    uint16_t cs;
+    uint8_t data[5] = {0xcd,0x7a,0x55,0x55,0xa1};
+
+    cs = pkt_InetChecksum((uint8_t*)data,5);
+    printf("CS = 0x%04x: ",cs);
+    if(cs == 0x2F3C){
+        printf("CS func with odd len OK.\n");
+    }else{
+        printf("ERROR: CS func produced wrong value with odd number of bytes.\n");
+    }
+    
+    cs = pkt_InetChecksum((uint8_t*)data,4);
+    printf("CS = 0x%04x: ",cs);
+    if(cs == 0x2FDD){
+        printf("CS func with even len OK.\n");
+    }else{
+        printf("ERROR: CS func produced wrong value with even number of bytes.\n");
+    }
+
+    cs = pkt_UpdateInetChecksum(cs,0x5555,0x8532);
+    printf("CS = 0x%04x: ",cs);
+    if(cs == 0x0000){
+        printf("Update CS func OK.\n");
+    }else{
+        printf("ERROR: Update CS func produced wrong value.\n");
+    }   
+
+}
diff --git a/src/common/Network/Packet/CPktCmn.h b/src/common/Network/Packet/CPktCmn.h
new file mode 100755
index 00000000..a107c5a3
--- /dev/null
+++ b/src/common/Network/Packet/CPktCmn.h
@@ -0,0 +1,88 @@
+#ifndef PKT_CMN_H
+#define PKT_CMN_H
+/*
+Copyright (c) 2015-2015 Cisco Systems, Inc.
+
+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.
+*/
+
+
+                                
+#include <common/c_common.h>
+#include <common/bitMan.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include "pal_utl.h"
+
+
+#define PKT_HTONL(x) (PAL_NTOHL(x))
+#define PKT_HTONS(x) (PAL_NTOHS(x))
+
+#define PKT_NTOHL(x) (PAL_NTOHL(x))
+#define PKT_NTOHS(x) (PAL_NTOHS(x))
+
+
+// returns cs in NETWROK order
+uint16_t pkt_InetChecksum(uint8_t* data , uint16_t len);
+
+// len MUST be an even number !!!
+// len2 can be odd.
+// returns cs in NETWROK order
+uint16_t pkt_InetChecksum(uint8_t* data , uint16_t len, uint8_t* data2 , uint16_t len2);
+    
+// this functiion updates an inet-checksum.
+// It accepts the checksum field AS IS from the packet, the old byte's value
+// and the new byte's value.
+// the cs, old and new values must be entered in NETWORK byte order !!!
+// the return value is also in NETWORK byte order !!
+uint16_t pkt_UpdateInetChecksum(uint16_t csFieldFromPacket, uint16_t oldVal, uint16_t newVal);
+
+// checksum and csToSubtract are two uint16_t cs fields AS THEY APPEAR INSIDE A PACKET !
+uint16_t pkt_SubtractInetChecksum(uint16_t checksum, uint16_t csToSubtract);
+
+// checksum and csToAdd are two uint16_t cs fields AS THEY APPEAR INSIDE A PACKET !
+uint16_t pkt_AddInetChecksum(uint16_t checksum, uint16_t csToAdd);
+
+
+struct Tunnels
+{
+	enum Type 
+	{
+		// basic tunnels have a bit each. They can be bitwise OR ed.
+		// WARNING: We use this number as a Uint8 in some places - don't go over 1 byte !!!
+
+		//Another warning: DO NOT change the values of these symbols, unless you have permission from everyone who
+		//uses them. These values are externally exposed through CmdlTunnel interfaces, and therefore JRT relies on these 
+		//specific values. (Assi - Jan 2006)
+		Empty			= 0x00,
+		UNTUNNELED_Marker       = 0x01,
+		VLAN			= 0x01, 
+		MPLS			= 0x02, 
+		L2TP			= 0x04,
+		IPinIP			= 0x08,
+        GRE			    = 0x10,
+		Ethernet		= 0x20,//This is not tunneled. It's an exception, until all these values are changed.
+		AnyIP			= 0x40,
+        AnyTunneled     = 0x7f,
+		TUNNELED_Marker = AnyTunneled,//Any sum of the values written above mustn't reach this value		
+		Unrecognized	= 0x80,
+        GTP             = 0x81        
+	};
+};
+
+
+
+
+#endif 
+
diff --git a/src/common/Network/Packet/EthernetHeader.cpp b/src/common/Network/Packet/EthernetHeader.cpp
new file mode 100755
index 00000000..2c6891a1
--- /dev/null
+++ b/src/common/Network/Packet/EthernetHeader.cpp
@@ -0,0 +1,32 @@
+/*
+Copyright (c) 2015-2015 Cisco Systems, Inc.
+
+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.
+*/
+
+
+#include "EthernetHeader.h"
+
+void    EthernetHeader::dump(FILE*  fd)
+{
+    fprintf(fd,"EthernetHeader\n");
+    fprintf(fd,"Destination : ");
+    myDestination.dump(fd);;
+    fprintf(fd,"Source      : ");
+    mySource.dump(fd);;
+    fprintf(fd,"Protocol      : 0x%04x \n",getNextProtocol());
+}
+
+
+
+
diff --git a/src/common/Network/Packet/EthernetHeader.h b/src/common/Network/Packet/EthernetHeader.h
new file mode 100755
index 00000000..87d1ed91
--- /dev/null
+++ b/src/common/Network/Packet/EthernetHeader.h
@@ -0,0 +1,98 @@
+/*
+Copyright (c) 2015-2015 Cisco Systems, Inc.
+
+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.
+*/
+
+#ifndef _ETHERNET_HEADER_H_
+#define _ETHERNET_HEADER_H_
+
+#include "PacketHeaderBase.h"
+#include "MacAddress.h"
+
+
+/**
+ * This class encapsulates an ethernet header.
+ * It has fields that are equivalent to the ethernet header fields.
+ * The data is saved in network byte order, and therefore the class can be used to create a packet in a buffer
+ * and send it over the network.
+ */ 
+class EthernetHeader
+{
+public:
+
+    struct Protocol
+    {
+        enum    Type
+        {
+            IP              =   0x0800,
+            VLAN            =   0x8100,
+            ARP             =   0x0806,
+            IPv6             =   0x86DD,
+            MPLS_Unicast    =   0x8847,
+            MPLS_Multicast  =   0x8848,
+            PPP             =   0x880b,
+            PPPoED          =   0x8863,
+            PPPoES          =   0x8864
+        };
+    };
+
+	
+////////////////////////////////////////////////////////////////////////////////////////
+// Common Header Interface
+////////////////////////////////////////////////////////////////////////////////////////
+
+public: 
+	//Empty constructor
+	EthernetHeader() :
+        myProtocol(0)
+	{}
+	//Construct an EthernetHeader object from a given buffer, ordered in Network byte order
+	inline EthernetHeader(uint8_t* packet);
+
+    inline  uint8_t*  getPointer          (){return (uint8_t*)this;}
+    static inline  uint32_t  getSize             (){return (uint32_t)sizeof(EthernetHeader);}
+
+    // Get dest MAC pointer
+    MacAddress *getDestMacP()             { return &myDestination; }
+
+    // Get source MAC pointer
+    MacAddress *getSrcMacP()              { return &mySource; }
+
+    //Returns the next protocol, in host byte order
+    inline  uint16_t  getNextProtocol     ();
+
+    //Set the next protocol value. The argument is receieved in host byte order.
+    inline  void    setNextProtocol     (uint16_t);
+
+    // Retrieve VLAN fields for tag and protocol information
+    inline  uint16_t getVlanTag ();
+    inline  uint16_t getVlanProtocol ();
+
+    void    dump                (FILE*  fd);
+
+
+public:
+    MacAddress          myDestination;
+    MacAddress          mySource;
+private:
+    uint16_t              myProtocol;
+    uint16_t              myVlanTag;
+    uint16_t              myVlanProtocol;
+
+};
+
+#include "EthernetHeader.inl"
+
+#endif //_ETHERNET_HEADER_H_
+
diff --git a/src/common/Network/Packet/EthernetHeader.inl b/src/common/Network/Packet/EthernetHeader.inl
new file mode 100755
index 00000000..0d6e32c9
--- /dev/null
+++ b/src/common/Network/Packet/EthernetHeader.inl
@@ -0,0 +1,39 @@
+/*
+Copyright (c) 2015-2015 Cisco Systems, Inc.
+
+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.
+*/
+
+inline EthernetHeader::EthernetHeader(uint8_t* packet)
+{
+	*this = *((EthernetHeader*)packet);
+}
+inline void   EthernetHeader::setNextProtocol(uint16_t argProtocol)
+{
+    myProtocol = PKT_HTONS(argProtocol);
+}
+
+inline uint16_t EthernetHeader::getNextProtocol()
+{
+    return( PKT_HTONS(myProtocol));
+}
+
+inline uint16_t EthernetHeader::getVlanProtocol()
+{
+    return( PKT_HTONS(myVlanProtocol));
+}
+
+inline uint16_t EthernetHeader::getVlanTag()
+{
+    return( PKT_HTONS(myVlanTag));
+}
diff --git a/src/common/Network/Packet/IPHeader.cpp b/src/common/Network/Packet/IPHeader.cpp
new file mode 100755
index 00000000..3b90a1aa
--- /dev/null
+++ b/src/common/Network/Packet/IPHeader.cpp
@@ -0,0 +1,71 @@
+/*
+Copyright (c) 2015-2015 Cisco Systems, Inc.
+
+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.
+*/
+
+#include "IPHeader.h"
+
+
+char * IPHeader::Protocol::interpretIpProtocolName(uint8_t argType)
+{
+    switch (argType)
+    {
+    case TCP:
+        return (char *)"TCP";
+        break;
+    case UDP:
+        return (char *)"UDP";
+        break;
+    case IP:
+        return (char *)"IP";
+        break;
+    case ICMP:
+        return (char *)"ICMP";
+        break;
+    case ESP:
+        return (char *)"ESP";
+        break;
+    case AH:
+        return (char *)"AH";
+        break;
+    case IGMP:
+        return (char *)"IGMP";
+        break;
+    default:
+        return (char *)NULL;
+        break;
+    }
+}
+
+void IPHeader::dump(FILE *fd)
+{
+    fprintf(fd, "\nIPHeader");
+    fprintf(fd, "\nSource 0x%.8lX, Destination 0x%.8lX, Protocol 0x%.1X",
+            getSourceIp(), getDestIp(), getProtocol());
+    fprintf(fd, "\nTTL : %d, Id : 0x%.2X, Ver %d, Header Length %d, Total Length %d",
+            getTimeToLive(), getId(), getVersion(), getHeaderLength(), getTotalLength());
+    if(isFragmented())
+    {
+        fprintf(fd,"\nIsFirst %d, IsMiddle %d, IsLast %d, Offset %d",
+                isFirstFragment(), isMiddleFragment(), isLastFragment(), getFragmentOffset());
+    }
+    else
+    {
+        fprintf(fd, "\nDont fragment %d", isDontFragment());
+    }
+    fprintf(fd, "\n");
+}
+
+
+
diff --git a/src/common/Network/Packet/IPHeader.h b/src/common/Network/Packet/IPHeader.h
new file mode 100755
index 00000000..5dfd03d8
--- /dev/null
+++ b/src/common/Network/Packet/IPHeader.h
@@ -0,0 +1,197 @@
+/*
+Copyright (c) 2015-2015 Cisco Systems, Inc.
+
+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.
+*/
+
+#ifndef _IP_HEADER_H_
+#define _IP_HEADER_H_
+
+#include "PacketHeaderBase.h"
+
+#define IPV4_HDR_LEN 20
+
+class IPHeader
+{
+
+public:
+    IPHeader()
+    {
+		myVer_HeaderLength = 0;  //must initialize it cause when doing setLenght or setVersion we mask it (found in purify)
+        setDestIp(0xDEADBEEF);
+        setSourceIp(0xBEEFDEAD);
+        setProtocol(0xDD);
+    };
+    
+    IPHeader          (uint32_t argSource,
+                       uint32_t argDestinaction,
+                       uint8_t  argProtocol)
+    {
+		myVer_HeaderLength = 0;  //must initialize it cause when doing setLenght or setVersion we mask it
+        setDestIp(argDestinaction);
+        setSourceIp(argSource);
+        setProtocol(argProtocol);
+    };
+
+
+    struct Protocol
+    {
+        enum Type 
+        {
+            IP     	= 0x04 , 
+            TCP     = 0x06 , 
+            UDP     = 0x11 , 
+            ICMP    = 0x01 , 
+            IGMP    = 0x02,
+            ESP     = 0x32,
+            AH      = 0x33,
+            GRE     = 0x2F,
+            IPV6_ICMP = 0x3A,
+            IPV6_NONXT = 0x3B,
+        };
+        //get the IP-Protocol name by protocol number
+        static char * interpretIpProtocolName(uint8_t argType);
+    };
+
+    enum
+    {
+        DefaultSize = 20
+    };
+
+
+public:
+
+    inline  uint8_t   getVersion          ();
+    inline  void    setVersion          (uint8_t);
+    
+    /**
+     * Return the header length in bytes
+     * 
+     * @return 
+     */
+    inline  uint8_t   getHeaderLength     ();
+
+    /**
+     * Receives the header length in bytes and sets it
+     * appropriately in the packet
+     */
+    inline  void    setHeaderLength     (uint8_t);
+
+    inline  uint8_t   getTOS              ();
+    inline  void    setTOS              (uint8_t);
+
+    inline  uint16_t  getTotalLength      ();
+    inline  void    setTotalLength      (uint16_t);
+
+    inline  uint16_t  getId               ();
+    inline  void    setId               (uint16_t);
+
+    inline  uint16_t  getFragmentOffset   ();// return the result in bytes
+    inline  bool    isFirstFragment     ();
+    inline  bool    isMiddleFragment    ();
+    inline  bool    isFragmented        ();
+    inline  bool    isMoreFragments     ();
+    inline  bool    isDontFragment      ();
+    inline  bool    isLastFragment      ();
+    inline  bool    isNotFirstFragment  ();
+    inline  void    setFragment         (uint16_t         argOffset, 
+                                         bool           argMoreFrag,
+                                         bool           argDontFrag);
+
+    inline  uint8_t   getTimeToLive       (void);
+    inline  void    setTimeToLive       (uint8_t);
+                                        
+    inline  uint8_t   getProtocol         (void);
+    inline  void    setProtocol         (uint8_t);
+                                        
+    inline  uint32_t  getSourceIp         ();
+    inline  void    setSourceIp         (uint32_t);
+                                        
+    inline  uint32_t  getDestIp           ();
+    inline  void    setDestIp           (uint32_t);
+                                        
+    bool            isMulticast         ();
+    bool            isBroadcast         ();
+                                        
+    inline  uint16_t  getChecksum         ();
+    bool            isChecksumOK        ();
+
+public:
+
+    inline  void    updateTos           (uint8_t newTos);
+	inline	void	updateTotalLength	(uint16_t newlen);
+    inline  void    updateIpSrc(uint32_t ipsrc);
+    inline  void    updateIpDst(uint32_t ipsrc);
+
+
+
+    inline  void    updateCheckSum      ();
+    inline  void    updateCheckSum2(uint8_t* data1, uint16_t len1, uint8_t* data2 , uint16_t len2);
+
+	inline 	void	swapSrcDest			();
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Common Header Interface
+////////////////////////////////////////////////////////////////////////////////////////
+
+public: 
+    inline  uint8_t*  getPointer          (){return (uint8_t*)this;}
+    inline  uint32_t  getSize             (){return  getHeaderLength();}
+
+    inline  uint8_t  getNextProtocol     ();
+
+    void    dump                (FILE*  fd);
+
+    inline  uint8_t*  getOption          (){ return ((uint8_t*)&myOption[0]); }
+    inline  uint8_t   getOptionLen()    { return ( getHeaderLength() - DefaultSize ); }
+
+
+public:
+    uint8_t       myVer_HeaderLength;
+    uint8_t       myTos;
+    uint16_t      myLength;
+        
+    uint16_t      myId;
+    uint16_t      myFrag;
+        
+    uint8_t       myTTL;
+    uint8_t       myProtocol;
+    uint16_t      myChecksum;
+
+    uint32_t      mySource;
+    uint32_t      myDestination;
+    uint32_t      myOption[1];
+};
+
+
+class IPPseudoHeader
+{
+public:
+  uint32_t m_source_ip;
+  uint32_t m_dest_ip;
+  uint8_t  m_zero;  
+  uint8_t  m_protocol; 
+  uint16_t m_length; 
+public:
+    inline uint8_t* getPointer(){return (uint8_t*)this;}
+
+	inline uint32_t getSize();
+
+	inline uint16_t inetChecksum();
+};
+
+
+#include "IPHeader.inl"
+
+#endif 
+
diff --git a/src/common/Network/Packet/IPHeader.inl b/src/common/Network/Packet/IPHeader.inl
new file mode 100755
index 00000000..e7b87f06
--- /dev/null
+++ b/src/common/Network/Packet/IPHeader.inl
@@ -0,0 +1,290 @@
+/*
+Copyright (c) 2015-2015 Cisco Systems, Inc.
+
+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.
+*/
+
+#include <common/BigEndianBitManipulation.h>
+
+
+inline void  IPHeader::setVersion(uint8_t argVersion)
+{
+    setMaskBit8(myVer_HeaderLength, 0, 3, argVersion);
+}
+
+inline uint8_t IPHeader::getVersion()
+{
+    return  getMaskBit8(myVer_HeaderLength, 0, 3);
+}
+
+inline uint8_t IPHeader::getHeaderLength()
+{
+    return (getMaskBit8(myVer_HeaderLength, 4, 7) << 2);
+}
+
+inline void  IPHeader::setHeaderLength(uint8_t    argLength)
+{
+    setMaskBit8(myVer_HeaderLength, 4, 7, (argLength>>2));
+}
+
+inline uint8_t IPHeader::getNextProtocol()
+{
+	return myProtocol;
+}
+
+//--------------------------------
+
+inline void  IPHeader::setTOS(uint8_t argTOS)
+{
+    myTos = argTOS;
+}
+
+inline uint8_t IPHeader::getTOS()
+{
+    return myTos;
+}
+
+//--------------------------------
+// length of ip packet 
+inline void IPHeader::setTotalLength(uint16_t argLength)
+{
+    myLength = PKT_NTOHS(argLength);
+}
+
+inline  uint16_t  IPHeader::getTotalLength()
+{
+    return(PKT_NTOHS(myLength));
+}
+
+//--------------------------------
+inline  uint16_t  IPHeader::getId()
+{
+    return(PKT_NTOHS(myId));
+}
+
+inline void IPHeader::setId(uint16_t argID)
+{
+    myId = PKT_NTOHS(argID);
+}
+
+//--------------------------------
+
+uint16_t IPHeader::getFragmentOffset()
+{
+    uint16_t  theFrag = (PKT_NTOHS(myFrag));
+    return ((theFrag & 0x1FFF) << 3);
+    //return (getMaskBit16(theFrag, 3, 15) << 3);//The field is in 8 byte units
+}
+
+bool    IPHeader::isMoreFragments()
+{
+    uint16_t  theFrag = (PKT_NTOHS(myFrag));
+    if(theFrag & 0x2000)
+    //if(getMaskBit16(theFrag, 2, 2) == 1)
+    {
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+bool    IPHeader::isDontFragment()
+{
+    uint16_t  theFrag = (PKT_NTOHS(myFrag));
+    if(theFrag & 0x4000)
+    //if(getMaskBit16(theFrag, 1, 1) == 1)
+    {
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+inline void IPHeader::setFragment      (uint16_t    argOffset , 
+                                        bool      argMoreFrag,
+                                        bool      argDontFrag)
+{
+    uint16_t  theFragmentWord = 0;
+    setMaskBit16(theFragmentWord, 3, 15, argOffset);
+    setMaskBit16(theFragmentWord, 1, 1,  argDontFrag ? 1 : 0);
+    setMaskBit16(theFragmentWord, 2, 2,  argMoreFrag ? 1 : 0);
+    myFrag = (PKT_NTOHS(theFragmentWord));
+}
+
+inline bool IPHeader::isFirstFragment()
+{
+    return((getFragmentOffset() == 0) && (isMoreFragments() == true));
+}
+
+inline bool IPHeader::isMiddleFragment()
+{
+    return((getFragmentOffset() != 0) && (isMoreFragments() == true));
+}
+
+inline bool IPHeader::isFragmented()
+{
+    return((getFragmentOffset() != 0) || (isMoreFragments() == true));
+}
+
+inline bool IPHeader::isLastFragment()
+{
+    return((getFragmentOffset() != 0) && (isMoreFragments() == false));
+}
+
+//return true if this is fragment but not first 
+inline bool IPHeader::isNotFirstFragment()
+{
+    return((isFragmented() == true)  && (isFirstFragment() == false));
+
+}
+
+
+//--------------------------------
+inline uint8_t IPHeader::getTimeToLive()
+{
+    return(myTTL);
+}
+inline void IPHeader::setTimeToLive(uint8_t argTTL)
+{
+    myTTL = argTTL;
+}
+
+//--------------------------------
+inline uint8_t IPHeader::getProtocol()
+{
+    return (myProtocol);
+}
+
+inline void IPHeader::setProtocol(uint8_t argProtocol)
+{
+    myProtocol = argProtocol;
+}
+//--------------------------------
+
+
+inline  uint32_t IPHeader::getSourceIp()
+{
+    return (PKT_NTOHL(mySource));
+}
+
+inline void IPHeader::setSourceIp(uint32_t argSourceAddress)
+{
+    mySource = PKT_NTOHL(argSourceAddress);
+}
+
+//--------------------------------
+inline  uint32_t IPHeader::getDestIp()
+{
+    return (PKT_NTOHL(myDestination));
+}
+
+inline void IPHeader::setDestIp(uint32_t argDestAddress)
+{
+    myDestination = PKT_NTOHL(argDestAddress);
+}
+
+//--------------------------------
+inline bool IPHeader::isMulticast()
+{
+    return((getDestIp() & 0xf0) == 0xe0);
+}
+
+inline bool IPHeader::isBroadcast()
+{
+    return(getDestIp() == 0xffffffff);
+}
+//--------------------------------
+
+inline uint16_t IPHeader::getChecksum()
+{
+    return PKT_NTOHS(myChecksum);
+}
+
+inline bool IPHeader::isChecksumOK()
+{
+    uint16_t theChecksum = pkt_InetChecksum(getPointer(),(uint16_t)getSize() );
+    return(theChecksum == 0);
+}
+
+
+inline void IPHeader::updateTos(uint8_t newTos)
+{
+    uint16_t oldWord = *((uint16_t *)(getPointer()));
+    myTos = newTos;
+    uint16_t newWord = *((uint16_t *)(getPointer()));
+    myChecksum =   pkt_UpdateInetChecksum(myChecksum,oldWord,newWord);
+}
+
+
+
+    
+inline  void    IPHeader::updateIpDst(uint32_t ipsrc){
+    uint32_t old      = myDestination;
+    uint32_t _new_src = PKT_NTOHL(ipsrc);
+
+    myChecksum =   pkt_UpdateInetChecksum(myChecksum,(old&0xffff0000)>>16,((_new_src&0xffff0000)>>16));
+    myChecksum =   pkt_UpdateInetChecksum(myChecksum,(old&0xffff),(_new_src&0xffff));
+    myDestination=_new_src;
+}
+
+inline  void   IPHeader::updateIpSrc(uint32_t ipsrc){
+    uint32_t old      = mySource;
+    uint32_t _new_src = PKT_NTOHL(ipsrc);
+
+    myChecksum =   pkt_UpdateInetChecksum(myChecksum,(old&0xffff0000)>>16,((_new_src&0xffff0000)>>16));
+    myChecksum =   pkt_UpdateInetChecksum(myChecksum,(old&0xffff),(_new_src&0xffff));
+    mySource=_new_src;
+}
+
+
+inline void IPHeader::updateTotalLength(uint16_t newlen)
+{
+    uint16_t oldLen = myLength;
+    myLength = PKT_NTOHS(newlen);
+    myChecksum =   pkt_UpdateInetChecksum(myChecksum,oldLen,myLength);
+}
+
+inline void IPHeader::updateCheckSum()
+{
+    myChecksum = 0;
+    myChecksum = pkt_InetChecksum(getPointer(), (uint16_t)getSize());
+}
+
+inline void IPHeader::updateCheckSum2(uint8_t* data1, uint16_t len1, uint8_t* data2 , uint16_t len2)
+{
+    myChecksum = 0;
+    myChecksum = pkt_InetChecksum(data1, len1, data2, len2);
+}
+
+inline void IPHeader::swapSrcDest()
+{
+	uint32_t tmp = myDestination;
+	myDestination = mySource;
+	mySource = tmp;
+}
+
+inline uint32_t IPPseudoHeader::getSize()
+{
+	return sizeof(IPPseudoHeader);
+}
+inline uint16_t IPPseudoHeader::inetChecksum()
+{
+    return(pkt_InetChecksum(getPointer(), (uint16_t)getSize()));
+}
+
+
+
diff --git a/src/common/Network/Packet/IPv6Header.cpp b/src/common/Network/Packet/IPv6Header.cpp
new file mode 100755
index 00000000..cf1f632a
--- /dev/null
+++ b/src/common/Network/Packet/IPv6Header.cpp
@@ -0,0 +1,71 @@
+/*
+Copyright (c) 2015-2015 Cisco Systems, Inc.
+
+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.
+*/
+
+#include "IPv6Header.h"
+
+
+char * IPv6Header::Protocol::interpretIpProtocolName(uint8_t argType)
+{
+    switch (argType)
+    {
+    case TCP:
+        return (char *)"TCP";
+        break;
+    case UDP:
+        return (char *)"UDP";
+        break;
+    case IP:
+        return (char *)"IP";
+        break;
+    case ICMP:
+        return (char *)"ICMP";
+        break;
+    case ESP:
+        return (char *)"ESP";
+        break;
+    case AH:
+        return (char *)"AH";
+        break;
+    case IGMP:
+        return (char *)"IGMP";
+        break;
+    default:
+        return (char *)NULL;
+        break;
+    }
+}
+
+void IPv6Header::dump(FILE *fd)
+{
+    fprintf(fd, "\nIPv6Header");
+    fprintf(fd, "\nSource 0x%.8lX, Destination 0x%.8lX, Protocol 0x%.1X",
+            getSourceIp(), getDestIp(), getProtocol());
+    fprintf(fd, "\nTTL : %d, Id : 0x%.2X, Ver %d, Header Length %d, Total Length %d",
+            getTimeToLive(), getId(), getVersion(), getHeaderLength(), getTotalLength());
+    if(isFragmented())
+    {
+        fprintf(fd,"\nIsFirst %d, IsMiddle %d, IsLast %d, Offset %d",
+                isFirstFragment(), isMiddleFragment(), isLastFragment(), getFragmentOffset());
+    }
+    else
+    {
+        fprintf(fd, "\nDont fragment %d", isDontFragment());
+    }
+    fprintf(fd, "\n");
+}
+
+
+
diff --git a/src/common/Network/Packet/IPv6Header.h b/src/common/Network/Packet/IPv6Header.h
new file mode 100755
index 00000000..8a246359
--- /dev/null
+++ b/src/common/Network/Packet/IPv6Header.h
@@ -0,0 +1,142 @@
+/*
+Copyright (c) 2015-2015 Cisco Systems, Inc.
+
+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.
+*/
+
+#ifndef _IPV6_HEADER_H_
+#define _IPV6_HEADER_H_
+
+#include "PacketHeaderBase.h"
+
+#define IPV6_16b_ADDR_GROUPS 8
+#define IPV6_16b_ADDR_GROUPS_MSB 6
+#define IPV6_HDR_LEN 40
+static uint16_t default_ipv6[8] = { 0xDEAD, 0xBEEF,
+                                              0xDEAD, 0xBEEF,
+                                              0xDEAD, 0xBEEF,
+                                              0xDEAD, 0xBEEF };
+
+
+class IPv6Header
+{
+
+public:
+    IPv6Header()
+    {
+        setDestIpv6(default_ipv6);
+        setSourceIpv6(default_ipv6);
+        setTrafficClass(0xDD);
+    };
+    
+    IPv6Header  (uint16_t *argSource,
+                       uint16_t *argDestinaction,
+                       uint8_t  argTrafficClass)
+    {
+        setDestIpv6(argDestinaction);
+        setSourceIpv6(argSource);
+        setTrafficClass(argTrafficClass);
+    };
+
+    enum
+    {
+        DefaultSize = 40
+    };
+
+
+public:
+
+    inline  uint8_t   getVersion          ();
+    inline  void    setVersion          (uint8_t);
+    
+    inline  uint8_t   getHeaderLength     (){return (IPV6_HDR_LEN);}
+
+    inline  uint16_t   getTrafficClass              ();
+    inline  void    setTrafficClass             (uint16_t);
+    
+    inline  uint32_t   getFlowLabel     ();
+    inline  void    setFlowLabel     (uint32_t);
+    
+    inline  uint16_t   getPayloadLen     ();
+    inline  void    setPayloadLen     (uint16_t);
+
+    inline  uint8_t  getNextHdr      ();
+    inline  void    setNextHdr      (uint8_t);
+
+    inline  uint8_t  getHopLimit      ();
+    inline  void    setHopLimit      (uint8_t);
+                                     
+    inline  void    getSourceIpv6         (uint16_t *);
+    inline  void    setSourceIpv6         (uint16_t *);
+                                        
+    inline  void    getDestIpv6           (uint16_t *);
+    inline  void    setDestIpv6           (uint16_t *);
+
+public:
+
+    inline  void    updateTrafficClass(uint8_t newclass);
+    inline  void    updatePayloadLength(uint16_t newlen);
+    inline  void    updateIpv6Src(uint16_t *ipsrc);
+    inline  void    updateIpv6Dst(uint16_t *ipdst);
+    inline  void    updateMSBIpv6Src(uint16_t *ipsrc);
+    inline  void    updateMSBIpv6Dst(uint16_t *ipdst);
+    inline  void    updateLSBIpv6Src(uint32_t ipsrc);
+    inline  void    updateLSBIpv6Dst(uint32_t ipdst);
+
+    inline  void    swapSrcDest();
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Common Header Interface
+////////////////////////////////////////////////////////////////////////////////////////
+
+public: 
+    inline  uint8_t*  getPointer          (){return (uint8_t*)this;}
+    inline  uint32_t  getSize             (){return  getHeaderLength();}
+
+    void    dump                (FILE*  fd);
+
+
+public:
+    uint32_t     myVer_TrafficClass_FlowLabel;
+        
+    uint16_t     myPayloadLen;
+    uint8_t       myNextHdr;
+    uint8_t       myHopLimit;
+
+    uint16_t      mySource[IPV6_16b_ADDR_GROUPS];
+    uint16_t      myDestination[IPV6_16b_ADDR_GROUPS];
+    uint32_t      myOption[1];
+};
+
+
+class IPv6PseudoHeader
+{
+public:
+  uint32_t m_source_ip;
+  uint32_t m_dest_ip;
+  uint8_t  m_zero;  
+  uint8_t  m_protocol; 
+  uint16_t m_length; 
+public:
+    inline uint8_t* getPointer(){return (uint8_t*)this;}
+
+	inline uint32_t getSize();
+
+	inline uint16_t inetChecksum();
+};
+
+
+#include "IPv6Header.inl"
+
+#endif 
+
diff --git a/src/common/Network/Packet/IPv6Header.inl b/src/common/Network/Packet/IPv6Header.inl
new file mode 100755
index 00000000..5098bc3e
--- /dev/null
+++ b/src/common/Network/Packet/IPv6Header.inl
@@ -0,0 +1,182 @@
+/*
+Copyright (c) 2015-2015 Cisco Systems, Inc.
+
+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.
+*/
+#include <common/BigEndianBitManipulation.h>
+
+//--------------------------------
+inline uint8_t IPv6Header::getVersion()
+{
+    return getMaskBit32(PKT_NTOHL(myVer_TrafficClass_FlowLabel), 0, 3);
+}
+
+inline void  IPv6Header::setVersion(uint8_t argVersion)
+{
+    uint32_t myVer = PKT_HTONL(myVer_TrafficClass_FlowLabel);
+    setMaskBit32(myVer, 0, 3, argVersion);
+    myVer_TrafficClass_FlowLabel = PKT_NTOHL(myVer);
+}
+
+//--------------------------------
+inline uint16_t IPv6Header::getTrafficClass()
+{
+    return  getMaskBit32(PKT_NTOHL(myVer_TrafficClass_FlowLabel),  4, 11);
+}
+
+inline void 
+IPv6Header::setTrafficClass(uint16_t argTrafficClass)
+{
+    uint32_t myTrafficClass = PKT_HTONL(myVer_TrafficClass_FlowLabel);
+    setMaskBit32(myTrafficClass, 4, 11, argTrafficClass);
+    myVer_TrafficClass_FlowLabel = PKT_NTOHL(myTrafficClass);
+}
+
+//--------------------------------
+inline uint32_t IPv6Header::getFlowLabel()
+{
+    return  getMaskBit32(PKT_NTOHL(myVer_TrafficClass_FlowLabel), 12, 31);
+}
+
+inline void  IPv6Header::setFlowLabel(uint32_t argFlowLabel)
+{
+    uint32_t myFlowLabel = PKT_HTONL(myVer_TrafficClass_FlowLabel);
+    setMaskBit32(myFlowLabel, 12, 31, argFlowLabel);
+    myVer_TrafficClass_FlowLabel = PKT_NTOHL(myFlowLabel);
+}
+
+//--------------------------------
+inline uint16_t IPv6Header::getPayloadLen()
+{
+    return  PKT_NTOHS(myPayloadLen);
+}
+
+inline void  IPv6Header::setPayloadLen(uint16_t argPayloadLen)
+{
+    myPayloadLen = PKT_HTONS(argPayloadLen);
+}
+
+//--------------------------------
+inline uint8_t IPv6Header::getNextHdr()
+{
+    return  myNextHdr;
+}
+
+inline void  IPv6Header::setNextHdr(uint8_t argNextHdr)
+{
+    myNextHdr = argNextHdr;
+}
+
+//--------------------------------
+inline uint8_t IPv6Header::getHopLimit()
+{
+    return  myHopLimit;
+}
+
+inline void  IPv6Header::setHopLimit(uint8_t argHopLimit)
+{
+    myHopLimit = argHopLimit;
+}
+
+//--------------------------------
+inline  void IPv6Header::getSourceIpv6(uint16_t *argSourceAddress)
+{
+    uint8_t i;
+    for (i=0; i<IPV6_16b_ADDR_GROUPS; i++) {
+        argSourceAddress[i] = PKT_NTOHS(mySource[i]);
+    }
+}
+
+inline void IPv6Header::setSourceIpv6(uint16_t *argSourceAddress)
+{
+    uint8_t i;
+    for (i=0; i<IPV6_16b_ADDR_GROUPS; i++) {
+        mySource[i] = PKT_HTONS(argSourceAddress[i]);
+    }
+}
+
+//--------------------------------
+inline  void IPv6Header::getDestIpv6(uint16_t *argDestAddress)
+{
+    uint8_t i;
+    for (i=0; i<IPV6_16b_ADDR_GROUPS; i++) {
+        argDestAddress[i] = PKT_NTOHS(myDestination[i]);
+    }
+}
+
+inline void IPv6Header::setDestIpv6(uint16_t *argDestAddress)
+{
+    uint8_t i;
+    for (i=0; i<IPV6_16b_ADDR_GROUPS; i++) {
+        myDestination[i] = PKT_HTONS(argDestAddress[i]);
+    }
+}
+
+//--------------------------------
+inline void IPv6Header::updateIpv6Src(uint16_t *ipsrc)
+{
+    uint8_t i;
+    for (i=0; i<IPV6_16b_ADDR_GROUPS; i++) {
+        mySource[i] = PKT_HTONS(ipsrc[i]);
+    }
+}
+
+inline void IPv6Header::updateIpv6Dst(uint16_t *ipdst)
+{
+    uint8_t i;
+    for (i=0; i<IPV6_16b_ADDR_GROUPS; i++) {
+        myDestination[i] = PKT_HTONS(ipdst[i]);
+    }
+}
+
+//--------------------------------
+inline void IPv6Header::updateMSBIpv6Src(uint16_t *ipsrc)
+{
+    uint8_t i;
+    for (i=0; i<IPV6_16b_ADDR_GROUPS_MSB; i++) {
+        mySource[i] = PKT_HTONS(ipsrc[i]);
+    }
+}
+
+inline void IPv6Header::updateMSBIpv6Dst(uint16_t *ipdst)
+{
+    uint8_t i;
+    for (i=0; i<IPV6_16b_ADDR_GROUPS_MSB; i++) {
+        myDestination[i] = PKT_HTONS(ipdst[i]);
+    }
+}
+
+//--------------------------------
+inline void IPv6Header::updateLSBIpv6Src(uint32_t ipsrc)
+{
+     uint32_t *lsb = (uint32_t *)&mySource[6];
+     *lsb = PKT_HTONL(ipsrc);
+}
+
+inline void IPv6Header::updateLSBIpv6Dst(uint32_t ipdst)
+{
+     uint32_t *lsb = (uint32_t *)&myDestination[6];
+     *lsb = PKT_HTONL(ipdst);
+}
+
+//--------------------------------
+inline void IPv6Header::swapSrcDest()
+{
+    uint8_t i;
+    uint16_t tmp[IPV6_16b_ADDR_GROUPS];
+    for (i=0; i<IPV6_16b_ADDR_GROUPS; i++) {
+        tmp[i] = myDestination[i];
+        myDestination[i] = mySource[i];
+        mySource[i] = tmp[i];
+    }
+}
diff --git a/src/common/Network/Packet/MacAddress.cpp b/src/common/Network/Packet/MacAddress.cpp
new file mode 100755
index 00000000..42331e50
--- /dev/null
+++ b/src/common/Network/Packet/MacAddress.cpp
@@ -0,0 +1,24 @@
+/*
+Copyright (c) 2015-2015 Cisco Systems, Inc.
+
+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.
+*/
+
+#include "MacAddress.h"
+
+
+void    MacAddress::dump(FILE *fd) const
+{
+
+}
+
diff --git a/src/common/Network/Packet/MacAddress.h b/src/common/Network/Packet/MacAddress.h
new file mode 100755
index 00000000..69272339
--- /dev/null
+++ b/src/common/Network/Packet/MacAddress.h
@@ -0,0 +1,130 @@
+/*
+Copyright (c) 2015-2015 Cisco Systems, Inc.
+
+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.
+*/
+
+#ifndef _MAC_ADDRESS_H_
+#define _MAC_ADDRESS_H_
+
+#include "CPktCmn.h"
+
+    
+class MacAddress
+{
+public:
+
+    MacAddress()
+    {
+        set(0xca, 0xfe, 0xde, 0xad, 0xbe, 0xef);
+    };
+
+    MacAddress(uint8_t a0,
+               uint8_t a1,
+               uint8_t a2,
+               uint8_t a3,
+               uint8_t a4,
+               uint8_t a5)
+    {
+        set(a0,
+            a1,
+            a2,
+            a3,
+            a4,
+            a5);
+    };
+
+	MacAddress(uint8_t macAddr[6])
+	{
+		set(macAddr[0],
+			macAddr[1],
+			macAddr[2],
+			macAddr[3],
+			macAddr[4],
+			macAddr[5]	);
+	};
+
+    void    set(uint8_t a0,
+                uint8_t a1,
+                uint8_t a2,
+                uint8_t a3,
+                uint8_t a4,
+                uint8_t a5)
+    {
+        data[0]=a0;
+        data[1]=a1;
+        data[2]=a2;
+        data[3]=a3;
+        data[4]=a4;
+        data[5]=a5;
+    };
+
+    void set(uint8_t *argPtr) {
+        memcpy( data, argPtr, sizeof(data) );
+    }
+
+    void set(uint8_t *argPtr,uint8_t val) {
+        memcpy( data, argPtr, sizeof(data) );
+        data[5]=val;
+    }
+
+
+	bool isInvalidAddress() const
+	{
+		static MacAddress allZeros(0,0,0,0,0,0);
+		static MacAddress cafeDeadBeef;
+		return (*this == allZeros || *this == cafeDeadBeef);
+	}
+	void setIdentifierAsBogusAddr(uint32_t identifier)
+	{
+		*(uint32_t*)data = identifier;
+	}
+
+	uint32_t getIdentifierFromBogusAddr()
+	{
+		return *(uint32_t*)data;
+	}
+
+	bool operator == (const MacAddress& rhs) const
+	{
+		for(int i=0; i<6; i++)
+		{
+			if(data[i] != rhs.data[i])
+				return false;
+		}
+
+		return true;
+	}
+
+	uint8_t*	GetBuffer()
+	{
+		return data;
+	}
+
+	const uint8_t*	GetConstBuffer() const
+	{
+		return data;
+	}
+    void dump(FILE *fd) const;
+
+	void copyToArray(uint8_t *arrayToFill) const
+	{
+        ((uint32_t*)arrayToFill)[0] = ((uint32_t*)data)[0];//Copy first 32bit
+		((uint16_t*)arrayToFill)[2] = ((uint16_t*)data)[2];//Copy last 16bit
+	}
+
+public:
+    uint8_t data[6];
+};
+
+#endif //_MAC_ADDRESS_H_
diff --git a/src/common/Network/Packet/PacketHeaderBase.h b/src/common/Network/Packet/PacketHeaderBase.h
new file mode 100755
index 00000000..14a570c8
--- /dev/null
+++ b/src/common/Network/Packet/PacketHeaderBase.h
@@ -0,0 +1,50 @@
+#ifndef _PACKET_HEADER_BASE_H_
+#define _PACKET_HEADER_BASE_H_
+/*
+Copyright (c) 2015-2015 Cisco Systems, Inc.
+
+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.
+*/
+
+
+#include "CPktCmn.h"
+
+/**
+ * This class should be the base class for all packet headers in the system.
+ * Its target is to obligate all the headers to implement some common interface.
+ * e.g. Providing the pointer for the header, its size, dumping itself etc.
+ * Since that all header are being casted over some memory because
+ * of performance orientation, we are not using the pure virtual feature
+ * of C++. Thus this obligation is enforced at link time since there will be
+ * no implmentation in the base and if the interface will be used in some derived
+ * that didn't implement it, it will fail at link time.
+ */
+class PacketHeaderBase
+{
+public:
+    uint8_t*  getPointer          (){return (uint8_t*)this;};
+    uint32_t  getSize             ();
+
+    uint16_t  getNextProtocol     ();
+    void    setNextProtocol     (uint16_t);
+
+    void    dump                (FILE*  fd);
+};
+
+enum
+{
+    TCPDefaultHeaderSize = 20,//TCP 
+    UDPDefaultHeaderSize = 8  //UDP
+};
+
+#endif //_PACKET_HEADER_BASE_H_
diff --git a/src/common/Network/Packet/TCPHeader.cpp b/src/common/Network/Packet/TCPHeader.cpp
new file mode 100755
index 00000000..bf28db2e
--- /dev/null
+++ b/src/common/Network/Packet/TCPHeader.cpp
@@ -0,0 +1,35 @@
+/*
+Copyright (c) 2015-2015 Cisco Systems, Inc.
+
+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.
+*/
+
+
+#include "TcpHeader.h"
+
+
+
+void TCPHeader::dump(FILE *fd)
+{
+    fprintf(fd, "\nTCPHeader");
+    fprintf(fd, "\nSourcePort 0x%.4X, DestPort 0x%.4X",
+            getSourcePort(), getDestPort());
+    fprintf(fd, "\nSeqNum 0x%.8lX, AckNum 0x%.8lX, Window %d",
+            getSeqNumber(), getAckNumber(), getWindowSize());
+    fprintf(fd, "\nHeader Length : %d, Checksum : 0x%.4X",
+            getHeaderLength(), getChecksum());
+    fprintf(fd, "\nFlags : SYN - %d, FIN - %d, ACK - %d, URG - %d, RST - %d, PSH - %d",
+            getSynFlag(), getFinFlag(), getAckFlag(), getUrgentFlag(), getResetFlag(), getPushFlag());
+    fprintf(fd, "\nUrgent Offset %d", getUrgentOffset());
+	fprintf(fd, "\n");
+}
diff --git a/src/common/Network/Packet/TCPOptions.cpp b/src/common/Network/Packet/TCPOptions.cpp
new file mode 100755
index 00000000..d8312ccc
--- /dev/null
+++ b/src/common/Network/Packet/TCPOptions.cpp
@@ -0,0 +1,176 @@
+/*
+Copyright (c) 2015-2015 Cisco Systems, Inc.
+
+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.
+*/
+
+
+#include "TCPOptions.h"
+#include "IPHeader.h"
+
+bool                    TCPOptions::ourOneShotDump          = false;
+TCPOptions::Counters    TCPOptions::ourCounters             = {0,0,0};
+
+TCPOptions::TCPOptions(uint8_t*   argOptionsP, uint16_t argOptionsSize):
+myOptionsP      (argOptionsP),
+myOptionsSize   (argOptionsSize),
+myCurrentOptionP((Option*)argOptionsP)
+{
+    ;
+}
+
+bool    TCPOptions::doesContain(TCPOptions::Kind::Val argKind)
+{
+    uint32_t  optionTypeIdx = 0;// Used to verify that we're not in infinite loop
+
+    // we'll run over the whole list of TLVs and check each relative to the time stamp 
+    // option kind value.
+    do 
+    {
+        Kind::Val   theCurrentOptionKind;
+        uint8_t       theOptionLength;
+        getCurrentOption(theCurrentOptionKind, theOptionLength);
+        optionTypeIdx++;
+        if( theCurrentOptionKind == argKind )
+        {
+            return true;
+        }
+    } while( (nextOption() == true)  && (optionTypeIdx < MaxOptionsInPacket));
+
+    if(optionTypeIdx >= MaxOptionsInPacket)
+    {
+        ourCounters.itsPossibleEndlessLoop++;
+    }
+
+    // none of the TLV was of type TimeStamp
+    return false;
+}
+
+//--------------------------------------------------------------------------------------------------
+// Set methods
+//--------------------------------------------------------------------------------------------------
+
+//--------------------------------------------------------------------------------------------------
+// Miscellaneous Operations
+//--------------------------------------------------------------------------------------------------
+
+void    TCPOptions::dump(FILE*  argOutputFile)
+{
+    fprintf(argOutputFile, "\nNot supported yet!\n");
+}
+
+void    TCPOptions::get(TCPOptions::Counters& argCounters)
+{
+     argCounters.itsOptionsSizeMismatch = ourCounters.itsOptionsSizeMismatch;  
+     argCounters.itsZeroLengthOptions   = ourCounters.itsZeroLengthOptions;    
+     argCounters.itsPossibleEndlessLoop = ourCounters.itsPossibleEndlessLoop;  
+}
+
+uint8_t*  TCPOptions::getCurrentOption    (Kind::Val&    argKind, uint8_t& argLength)
+{
+    argKind     = (Kind::Val)myCurrentOptionP->theKind;
+    argLength   = getCurrentOptionLength();
+    return(uint8_t*)myCurrentOptionP;
+}
+
+
+uint8_t   TCPOptions::getCurrentOptionLength()
+{
+    if(myCurrentOptionP->theKind == Kind::NO_OP || 
+       myCurrentOptionP->theKind == Kind::EOL)
+    {
+        return 1;
+    }
+    else
+    {
+        return myCurrentOptionP->theLength;
+    }
+}
+
+
+// This is a patch for temporary packet dump facility
+//
+#define MAX_BUFFER_SIZE (8 * 2048)
+static  char    theDumpBuffer[MAX_BUFFER_SIZE] ={0};
+
+bool    TCPOptions::isLastOption        ()
+{
+    // Below is the total length of the options we've passed so far
+    uint32_t  theCurrentOffset = (uint32_t)((uintptr_t)((char *)myCurrentOptionP - (char *)myOptionsP));
+
+    uint32_t  theCurrentLength = getCurrentOptionLength();
+    if( (theCurrentOffset + theCurrentLength) >= myOptionsSize )
+    {
+        // debug check
+        if( (theCurrentOffset + theCurrentLength) > myOptionsSize )
+        {
+            ourCounters.itsOptionsSizeMismatch++;
+            if(ourOneShotDump == false)
+            {
+                ourOneShotDump = true;//disable for next time
+                uint8_t*    theIPPacket     = (uint8_t*)((uintptr_t)(myOptionsP - 40));
+                IPHeader* theIPHeader     = (IPHeader*)theIPPacket;
+                uint16_t    thePacketLength = theIPHeader->getTotalLength();
+
+                if(thePacketLength < (MAX_BUFFER_SIZE / 8))
+                {
+                    int numWritten = sprintf(theDumpBuffer, "\nDump Size %u\n", thePacketLength);
+
+                    for (uint32_t i = 0; i < thePacketLength; i++)
+                    {
+                        numWritten += sprintf(theDumpBuffer + numWritten,"%.2x ", theIPPacket[i]); 
+
+                        if ((i % 16) == 15)
+                        {
+                            numWritten += sprintf(theDumpBuffer + numWritten,"\n");
+                        }
+                    }
+                }
+            }
+        }
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+//--------------------------------------------------------------------------------------------------
+// Set methods
+//--------------------------------------------------------------------------------------------------
+
+bool    TCPOptions::nextOption          ()
+{
+    if( isLastOption() == true )
+    {
+        return false;
+    }
+    else
+    {
+        uint32_t  theCurrentOptionLength = getCurrentOptionLength();
+        if(theCurrentOptionLength > 0)
+        {
+            uint8_t*  theCurrentP = (uint8_t*)myCurrentOptionP;
+            theCurrentP         += theCurrentOptionLength;
+            myCurrentOptionP    = (Option*)theCurrentP;
+            return true;
+        }
+        else
+        {
+            ourCounters.itsZeroLengthOptions++;
+            return false;
+        }
+    }
+}
+
diff --git a/src/common/Network/Packet/TCPOptions.h b/src/common/Network/Packet/TCPOptions.h
new file mode 100755
index 00000000..2133db5a
--- /dev/null
+++ b/src/common/Network/Packet/TCPOptions.h
@@ -0,0 +1,163 @@
+/*
+Copyright (c) 2015-2015 Cisco Systems, Inc.
+
+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.
+*/
+#ifndef _TCP_OPTIONS_H_
+#define _TCP_OPTIONS_H_
+
+#include "PacketHeaderBase.h"
+
+
+class TCPOptions
+{
+
+public:
+
+//--------------------------------------------------------------------------------------------------
+// Typedef & Enum
+//--------------------------------------------------------------------------------------------------
+
+    struct  Kind
+    {
+        enum Val
+        {
+            EOL         =   0,
+            NO_OP       =   1,
+            MSS         =   2,
+            WIN_SCL     =   3,
+            SACK_PER    =   4,
+            SACK        =   5,
+            TIME_STAMP  =   8
+        };
+    };
+
+    enum
+    {
+        TimeStampSize   =   12
+    };
+
+    enum 
+    {
+        MaxOptionsInPacket = 64
+    };
+
+    struct  Option
+    {
+        uint8_t   theKind;
+        uint8_t   theLength; //Not always valid, depends on theKind
+        uint8_t   theData[1];//variable. [1] only for compilation
+    };
+
+    struct  Counters
+    {
+        uint32_t    itsOptionsSizeMismatch; 
+        uint32_t    itsZeroLengthOptions;  
+        uint32_t    itsPossibleEndlessLoop;
+    };
+
+
+//--------------------------------------------------------------------------------------------------
+// Constructor & Destructor
+//--------------------------------------------------------------------------------------------------
+
+    TCPOptions(uint8_t*   argOptionsP, uint16_t argOptionsSize);
+
+//--------------------------------------------------------------------------------------------------
+// Utility methods
+//--------------------------------------------------------------------------------------------------
+
+    /**
+     * This method allows the user of this class to query whether
+     * the options in hand contains a specific type of its
+     * interest.
+     * 
+     * @return  true if the specified option exist.
+     */
+    bool    doesContain(Kind::Val);
+
+//--------------------------------------------------------------------------------------------------
+// Get methods
+//--------------------------------------------------------------------------------------------------
+
+
+    /**
+     * Returns a pointer to the current option.
+     * With the kind and length of it.
+     * 
+     * @param argKind
+     * @param argLength
+     * @return 
+     */
+    uint8_t*  getCurrentOption    (Kind::Val&    argKind, uint8_t& argLength);
+
+    /**
+     * This method gives the length of the current option.
+     * Can vary since there are two options that are exception to
+     * the usual TLV definition. 
+     * 
+     * @return 
+     */
+    uint8_t   getCurrentOptionLength();
+
+    /**
+     * This is an internal method that verifies based on the current
+     * pointer, the total options length and the current options length,
+     * whether this is the last option.
+     * 
+     * @return 
+     */
+    bool    isLastOption        ();
+
+//--------------------------------------------------------------------------------------------------
+// Set methods
+//--------------------------------------------------------------------------------------------------
+
+    /**
+     * This method tells the object to advance one option ahead.
+     * i.e. to the next option.
+     * 
+     * @return True if next option exist.
+     *         False if we are at the last option.
+     */
+    bool    nextOption          ();
+
+
+//--------------------------------------------------------------------------------------------------
+// Miscellaneous Operations
+//--------------------------------------------------------------------------------------------------
+
+    static  void get (Counters&);
+
+            void dump(FILE* argOutputFile);
+
+
+private:
+
+//--------------------------------------------------------------------------------------------------
+// Data members
+//--------------------------------------------------------------------------------------------------
+
+    uint8_t*           myOptionsP;
+    uint16_t           myOptionsSize;
+
+    Option*          myCurrentOptionP;
+
+    static  Counters ourCounters;
+
+    static  bool     ourOneShotDump;
+};
+
+
+#endif // _TCP_OPTIONS_H_
+
diff --git a/src/common/Network/Packet/TcpHeader.h b/src/common/Network/Packet/TcpHeader.h
new file mode 100755
index 00000000..e07df927
--- /dev/null
+++ b/src/common/Network/Packet/TcpHeader.h
@@ -0,0 +1,124 @@
+/*
+Copyright (c) 2015-2015 Cisco Systems, Inc.
+
+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.
+*/
+#ifndef _TCP_HEADER_H_
+#define _TCP_HEADER_H_
+
+#include "PacketHeaderBase.h"
+
+                 
+class TCPHeader
+{
+
+public:
+    TCPHeader(){}
+
+    TCPHeader(uint16_t    argSourcePort,
+              uint16_t    argDestinationPort,
+              uint8_t     argFlags,
+              uint32_t    argSeqNum,
+              uint32_t    argAckNum);
+
+    struct Flag
+    {
+        enum Type
+        {
+            FIN =          0x01,
+            SYN =          0x02,
+            RST =          0x04,
+            PSH =          0x08,
+            ACK =          0x10,
+            URG =          0x20
+        };
+    };
+
+    void    setSourcePort   (uint16_t);
+    uint16_t  getSourcePort   ();
+
+    void    setDestPort     (uint16_t);
+    uint16_t  getDestPort     ();
+
+    void    setSeqNumber    (uint32_t);
+    uint32_t  getSeqNumber    ();
+
+    void    setAckNumber    (uint32_t);
+    uint32_t  getAckNumber    ();
+
+    //this is factor 4
+    void    setHeaderLength (uint8_t);
+    uint8_t   getHeaderLength ();
+
+    void    setFlag         (uint8_t);
+    uint8_t   getFlags        ();
+
+    void    setFinFlag      (bool);
+    bool    getFinFlag      ();
+
+    void    setSynFlag      (bool);
+    bool    getSynFlag      ();
+
+    void    setResetFlag    (bool);
+    bool    getResetFlag    ();
+
+    void    setPushFlag     (bool);
+    bool    getPushFlag     ();
+
+    void    setAckFlag      (bool);
+    bool    getAckFlag      ();
+
+    void    setUrgentFlag   (bool);
+    bool    getUrgentFlag   ();
+
+    void    setWindowSize   (uint16_t);
+    uint16_t  getWindowSize   ();
+
+    void    setChecksum     (uint16_t);
+    uint16_t  getChecksum     ();
+
+    void    setUrgentOffset (uint16_t);
+    uint16_t  getUrgentOffset ();
+
+    uint32_t* getOptionPtr    ();
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Common Header Interface
+////////////////////////////////////////////////////////////////////////////////////////
+
+public: 
+    uint8_t*  getPointer      (){return (uint8_t*)this;}
+    uint32_t  getSize         (){return  getHeaderLength();}
+
+    uint16_t  getNextProtocol ();
+    void    setNextProtocol (uint16_t);
+
+    void    dump            (FILE*  fd);
+
+private:
+    uint16_t mySourcePort;
+    uint16_t myDestinationPort;
+    uint32_t mySeqNum;
+    uint32_t myAckNum;
+    uint8_t  myHeaderLength;
+    uint8_t  myFlags;
+    uint16_t myWindowSize;
+    uint16_t myChecksum;
+    uint16_t myUrgentPtr;
+    uint32_t myOption[1];
+};
+
+#include "TcpHeader.inl"
+
+#endif //_TCP_HEADER_H_
diff --git a/src/common/Network/Packet/TcpHeader.inl b/src/common/Network/Packet/TcpHeader.inl
new file mode 100755
index 00000000..52364d06
--- /dev/null
+++ b/src/common/Network/Packet/TcpHeader.inl
@@ -0,0 +1,220 @@
+/*
+Copyright (c) 2015-2015 Cisco Systems, Inc.
+
+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.
+*/
+
+#include <common/BigEndianBitManipulation.h> 
+
+inline void   TCPHeader::setSourcePort(uint16_t argSourcePort)
+{
+    mySourcePort = PKT_NTOHS(argSourcePort);
+}
+
+inline uint16_t TCPHeader::getSourcePort()
+{
+    return(PKT_NTOHS(mySourcePort));
+}
+
+inline void   TCPHeader::setDestPort(uint16_t argDestinationPort)
+{
+    myDestinationPort = PKT_NTOHS(argDestinationPort);
+}
+
+inline uint16_t TCPHeader::getDestPort()
+{
+    return (PKT_NTOHS(myDestinationPort));
+}
+
+inline void   TCPHeader::setSeqNumber(uint32_t argSeqNum)
+{
+    mySeqNum = PKT_NTOHL(argSeqNum);
+}
+
+inline uint32_t TCPHeader::getSeqNumber()
+{
+    return (PKT_NTOHL(mySeqNum));
+}
+
+inline void TCPHeader::setAckNumber(uint32_t argAckNum)
+{
+    myAckNum = PKT_NTOHL(argAckNum);
+}
+
+inline uint32_t TCPHeader::getAckNumber()
+{
+    return(PKT_NTOHL(myAckNum));
+}
+
+inline void  TCPHeader::setHeaderLength(uint8_t argHeaderLength)
+{
+    setMaskBit8(myHeaderLength, 0, 3, argHeaderLength >> 2);
+}
+
+inline uint8_t TCPHeader::getHeaderLength()
+{
+    return  getMaskBit8(myHeaderLength, 0, 3) << 2;
+}
+
+inline void TCPHeader::setFlag(uint8_t data)
+{
+    btSetMaskBit8(myFlags,5,0,data);
+}
+
+inline  uint8_t TCPHeader::getFlags()
+{
+    return(myFlags & 0x3f);
+}
+
+inline void TCPHeader::setFinFlag(bool toSet)
+{
+    if(toSet)
+    {
+        myFlags |=  Flag::FIN;
+    }
+    else
+    {
+        myFlags &= ~Flag::FIN;
+    }
+}
+
+inline bool TCPHeader::getFinFlag()
+{
+    return(getFlags() & Flag::FIN)?true:false;
+}
+
+inline void TCPHeader::setSynFlag(bool toSet)
+{
+    if(toSet)
+    {
+        myFlags|=Flag::SYN;
+    }
+    else
+    {
+        myFlags&=~Flag::SYN;
+    }
+}
+
+inline	bool TCPHeader::getSynFlag()
+{
+    return(getFlags() & Flag::SYN)?true:false;
+}
+
+inline void TCPHeader::setResetFlag(bool toSet)
+{
+    if(toSet)
+    {
+        myFlags|=Flag::RST;
+    }
+    else
+    {
+        myFlags&=~Flag::RST;
+    }
+}
+
+inline	bool TCPHeader::getResetFlag()
+{
+    return(getFlags() & Flag::RST)?true:false;
+}
+
+inline void TCPHeader::setPushFlag(bool toSet)
+{
+    if(toSet)
+    {
+        myFlags|=Flag::PSH;
+    }
+    else
+    {
+        myFlags&=~Flag::PSH;
+    }
+}
+
+inline	bool TCPHeader::getPushFlag()
+{
+    return(getFlags() & Flag::PSH)?true:false;
+}
+
+inline void TCPHeader::setAckFlag(bool toSet)
+{
+    if(toSet)
+    {
+        myFlags|=Flag::ACK;
+    }
+    else
+    {
+        myFlags&=~Flag::ACK;
+    }
+}
+
+inline bool TCPHeader::getAckFlag()
+{
+    return(getFlags() & Flag::ACK)?true:false;
+}
+
+inline void TCPHeader::setUrgentFlag(bool toSet)
+{
+    if(toSet)
+    {
+        myFlags|=Flag::URG;
+    }
+    else
+    {
+        myFlags&=~Flag::URG;
+    }
+}
+
+inline bool TCPHeader::getUrgentFlag()
+{
+    return(getFlags() & Flag::URG)?true:false;
+}
+
+//---------------------------------------
+inline void   TCPHeader::setWindowSize(uint16_t argWindowSize)
+{
+    myWindowSize = PKT_NTOHS(argWindowSize);
+}
+inline uint16_t TCPHeader::getWindowSize()
+{
+    return PKT_NTOHS(myWindowSize);
+}
+
+inline void   TCPHeader::setChecksum(uint16_t argChecksum)
+{
+    myChecksum = PKT_NTOHS(argChecksum);
+
+}
+
+inline	uint16_t TCPHeader::getChecksum()
+{
+    return PKT_NTOHS(myChecksum);
+}
+
+inline void   TCPHeader::setUrgentOffset(uint16_t argUrgentOffset)
+{
+    myUrgentPtr = argUrgentOffset;
+}
+
+inline	uint16_t TCPHeader::getUrgentOffset()
+{
+    return PKT_NTOHS(myUrgentPtr);
+}
+
+inline uint32_t * TCPHeader::getOptionPtr()
+{
+    return(myOption);
+}
+
+
+
+
+
diff --git a/src/common/Network/Packet/UDPHeader.cpp b/src/common/Network/Packet/UDPHeader.cpp
new file mode 100755
index 00000000..159e14fc
--- /dev/null
+++ b/src/common/Network/Packet/UDPHeader.cpp
@@ -0,0 +1,28 @@
+/*
+Copyright (c) 2015-2015 Cisco Systems, Inc.
+
+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.
+*/
+
+#include "UdpHeader.h"
+
+
+void UDPHeader::dump(FILE *fd)
+{
+    fprintf(fd, "\nUDPHeader");
+    fprintf(fd, "\nSourcePort 0x%.4X, DestPort 0x%.4X",
+            getSourcePort(), getDestPort());
+    fprintf(fd, "\nLength : %d, Checksum : 0x%.4X",
+            getLength(), getChecksum());
+	fprintf(fd, "\n");
+}
diff --git a/src/common/Network/Packet/UdpHeader.h b/src/common/Network/Packet/UdpHeader.h
new file mode 100755
index 00000000..43d08fe1
--- /dev/null
+++ b/src/common/Network/Packet/UdpHeader.h
@@ -0,0 +1,86 @@
+/*
+Copyright (c) 2015-2015 Cisco Systems, Inc.
+
+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.
+*/
+
+#ifndef _UDP_HEADER_H_
+#define _UDP_HEADER_H_
+
+#include "PacketHeaderBase.h"
+#include "IPHeader.h"
+
+class UDPHeader
+{
+
+public:
+    UDPHeader()
+	{
+		setDestPort(0xDEAD);
+		setSourcePort(0xBEEF);
+		setChecksum(0);
+		setLength(0);
+	}
+
+    UDPHeader(uint16_t argSourcePort,
+              uint16_t argDestinationPort)
+	{
+		setDestPort(argDestinationPort);
+		setSourcePort(argSourcePort);
+	}
+
+
+    inline  void    setSourcePort(uint16_t data);
+    inline  uint16_t  getSourcePort();
+
+    inline  void    setDestPort(uint16_t data);
+    inline  uint16_t  getDestPort();
+
+    inline  void    setLength(uint16_t data);
+    inline  uint16_t  getLength();
+
+    inline  void    setChecksum(uint16_t data);
+    inline  uint16_t  getChecksum();
+
+	inline void     updateCheckSum(IPHeader  *ipHeader);
+    inline bool 	isCheckSumOk(IPHeader  *ipHeader);
+    inline uint16_t   calcCheckSum(IPHeader  *ipHeader);
+
+	inline  void	swapSrcDest();
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Common Header Interface
+////////////////////////////////////////////////////////////////////////////////////////
+
+public: 
+    inline	uint8_t*  getPointer          (){return (uint8_t*)this;}
+    inline	uint32_t  getSize             (){return 8;}
+
+    inline	uint16_t  getNextProtocol     (){return getDestPort();};
+    inline	void    setNextProtocol     (uint16_t argNextProtcool){setDestPort(argNextProtcool);};
+
+    void    dump                (FILE*  fd);
+
+
+private:
+    uint16_t  mySourcePort;
+    uint16_t  myDestinationPort;
+    uint16_t  myLength;
+    uint16_t  myChecksum;
+};
+
+
+#include "UdpHeader.inl"
+
+#endif 
+
diff --git a/src/common/Network/Packet/UdpHeader.inl b/src/common/Network/Packet/UdpHeader.inl
new file mode 100755
index 00000000..77afc193
--- /dev/null
+++ b/src/common/Network/Packet/UdpHeader.inl
@@ -0,0 +1,102 @@
+/*
+Copyright (c) 2015-2015 Cisco Systems, Inc.
+
+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.
+*/
+
+inline void   UDPHeader::setSourcePort(uint16_t argSourcePort)
+{
+    mySourcePort = PKT_NTOHS(argSourcePort);
+}
+
+uint16_t UDPHeader::getSourcePort()
+{
+    return PKT_NTOHS(mySourcePort);
+}
+
+inline void    UDPHeader::setDestPort(uint16_t argDestPort)
+{
+    myDestinationPort = PKT_NTOHS(argDestPort);
+}
+
+uint16_t UDPHeader::getDestPort()
+{
+    return PKT_NTOHS(myDestinationPort);
+}
+
+inline void  UDPHeader::setLength(uint16_t argLength)
+{
+    myLength = PKT_NTOHS(argLength);
+}
+
+uint16_t UDPHeader::getLength()
+{
+    return PKT_NTOHS(myLength);
+}
+
+inline void    UDPHeader::setChecksum(uint16_t argNewChecksum)
+{
+    myChecksum = PKT_NTOHS(argNewChecksum);
+}
+
+uint16_t UDPHeader::getChecksum()
+{
+    return PKT_NTOHS(myChecksum);
+}
+
+void UDPHeader::updateCheckSum(IPHeader  *ipHeader)
+{
+	setChecksum(0);// must be here 
+
+	myChecksum =calcCheckSum(ipHeader);
+}
+
+bool UDPHeader::isCheckSumOk(IPHeader  *ipHeader)
+{
+	uint16_t theChecksum= PKT_NTOHS(calcCheckSum(ipHeader));
+
+	return(theChecksum == 0);
+}
+
+uint16_t UDPHeader::calcCheckSum(IPHeader  *ipHeader)
+{
+	IPPseudoHeader pseudo;
+
+    uint16_t length= ipHeader->getTotalLength() - ipHeader->getHeaderLength();
+
+	pseudo.m_source_ip = PKT_NTOHL(ipHeader->getSourceIp());
+
+	pseudo.m_dest_ip   = PKT_NTOHL(ipHeader->getDestIp());
+
+	pseudo.m_zero      = 0;
+
+	pseudo.m_protocol  = ipHeader->getProtocol();
+
+	pseudo.m_length    = PKT_NTOHS(length);
+
+	uint16_t theChecksum = pkt_InetChecksum((uint8_t*)this,length);
+
+	theChecksum = pkt_AddInetChecksum(theChecksum,pseudo.inetChecksum());
+
+	return(theChecksum);
+}
+
+void UDPHeader::swapSrcDest()
+{
+	uint16_t tmp = myDestinationPort;
+	myDestinationPort = mySourcePort;
+	mySourcePort = tmp;
+}
+
+
+
diff --git a/src/common/Network/Packet/VLANHeader.cpp b/src/common/Network/Packet/VLANHeader.cpp
new file mode 100755
index 00000000..3bb48fdd
--- /dev/null
+++ b/src/common/Network/Packet/VLANHeader.cpp
@@ -0,0 +1,100 @@
+/*
+Copyright (c) 2015-2015 Cisco Systems, Inc.
+
+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.
+*/
+
+#include "VLANHeader.h"
+
+
+/*   
+                              VLAN Header Fields
+                              ------------------
+                                    
+    0       2   3   4                                                            15
+    ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+    |Priority| CFI |                Tag                                             |
+    ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+    |                              Type                                          |
+    ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+*/
+
+
+void    VLANHeader::dump             (FILE*  fd)
+{
+    fprintf(fd, "\nVLAN Header");
+    fprintf(fd, "\nTag %d (0x%.2X), Pri %d, CFI - %d, Next protocol - %d (0x%.2X)",
+            getTagID(), getTagID(), getTagUserPriorty(), getTagCFI(), getNextProtocolHostOrder(), getNextProtocolHostOrder());
+    fprintf(fd, "\n");
+}
+
+uint8_t VLANHeader::reconstructFromBuffer(uint8_t* destBuffer, uint8_t* srcBuffer)
+{
+	uint8_t type = srcBuffer[0];
+	uint8_t size = srcBuffer[1];	
+	if((type != Tunnels::VLAN) || (size != sizeof(VLANHeader)))
+	{
+		// DBG_Error2(PACKET_DBG_TUNNEL_RECONSTRUCTION_ERROR,Tunnels::VLAN,size);
+		return 0;
+	}	
+	memcpy(destBuffer,srcBuffer+2,sizeof(VLANHeader));
+	return size;
+}
+
+uint8_t VLANHeader::fillReconstructionBuffer(uint8_t* destBuffer, uint8_t* srcBuffer)
+{
+	destBuffer[0] = (uint8_t)Tunnels::VLAN;
+	destBuffer[1] = sizeof(VLANHeader);
+	memcpy(destBuffer+2,srcBuffer,sizeof(VLANHeader));
+	return sizeof(VLANHeader)+2;	
+}
+
+uint8_t VLANHeader::fillReconstructionBuffer(uint8_t* destBuffer, VLANHeader& vHeader)
+{
+	destBuffer[0] = (uint8_t)Tunnels::VLAN;
+	destBuffer[1] = sizeof(VLANHeader);
+    vHeader.reconstructPkt(destBuffer+2);
+	return sizeof(VLANHeader)+2;	
+}
+
+#if 0
+Status VLANHeader::parseAsText(uint8_t* srcBuffer, TextCollectorInterface &tc)
+{
+	uint8_t type = srcBuffer[0];
+	uint8_t size = srcBuffer[1];	
+	if((type != Tunnels::VLAN) //The buffer doesn't contain valid information
+	   || (size < sizeof(VLANHeader))) //The buffer isn't big enough
+	{
+        return FAIL;
+	}
+	tc << "VLAN: ";
+	uint32_t offset = 0;
+	while (offset < size)
+	{
+		VLANHeader vlanHeader;
+		vlanHeader.setFromPkt(&srcBuffer[2+offset]);
+		
+		tc.printf("Tag %d (0x%.2X), Pri %d, CFI - %d, Next protocol - %d (0x%.2X)\n",
+            vlanHeader.getTagID(), vlanHeader.getTagID(), vlanHeader.getTagUserPriorty(), vlanHeader.getTagCFI(), vlanHeader.getNextProtocolHostOrder(), vlanHeader.getNextProtocolHostOrder());
+		offset += sizeof(VLANHeader);
+	}
+
+	return SUCCESS;
+}
+#endif
+
+
+
+
+
+
diff --git a/src/common/Network/Packet/VLANHeader.h b/src/common/Network/Packet/VLANHeader.h
new file mode 100755
index 00000000..cf6b2eff
--- /dev/null
+++ b/src/common/Network/Packet/VLANHeader.h
@@ -0,0 +1,107 @@
+/*
+Copyright (c) 2015-2015 Cisco Systems, Inc.
+
+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.
+*/
+
+#ifndef _VLAN_HEADER_H_
+#define _VLAN_HEADER_H_
+    
+#include "PacketHeaderBase.h"
+#include "EthernetHeader.h"
+
+
+/*   
+                              VLAN Header Fields
+                              ------------------
+                                    
+    0       2   3   4                                                            15
+    ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+    |Priority| CFI |                                                             |
+    ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+    |                              Type                                          |
+    ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+*/
+/**
+ * This class encapsulates a VLAN header.
+ * It has fields that are equivalent to the VLAN header fields.
+ * The data is saved in network byte order, and therefore the class can be used to create a packet in a buffer
+ * and send it over the network.
+ */ 
+class VLANHeader
+{
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Field Manipulation
+////////////////////////////////////////////////////////////////////////////////////////
+public:
+
+    // Sets the complete tag field without sub fields manipulation
+    void    setVlanTag          (uint16_t data);
+    uint16_t  getVlanTag          ();
+
+    void    setTagUserPriorty   (uint8_t data);
+    uint8_t   getTagUserPriorty   ();
+    
+    bool    getTagCFI           ();
+    void    setTagCFI           (bool);
+
+    uint16_t  getTagID            ();
+    void    setTagID            (uint16_t);
+
+    void    incrementTagID(uint16_t inc_value);
+
+    void    setFromPkt          (uint8_t* data);
+
+    uint8_t   reconstructPkt      (uint8_t* destBuff);
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Common Interface
+////////////////////////////////////////////////////////////////////////////////////////
+
+public: 
+    uint8_t*  getPointer          (){return (uint8_t*)this;}
+    uint32_t  getSize      (){return (uint32_t)sizeof(VLANHeader);}
+
+    uint16_t  getNextProtocolNetOrder    ();
+	uint16_t  getNextProtocolHostOrder   ();
+    void    setNextProtocolFromNetOrder(uint16_t);
+	void    setNextProtocolFromHostOrder(uint16_t);
+
+    void    dump                (FILE*  fd);
+
+	static uint16_t bytesToSkip(uint8_t* base)
+	{
+		return sizeof(VLANHeader);
+	}
+
+	static uint8_t reconstructFromBuffer(uint8_t* destBuffer, uint8_t* srcBuffer);
+
+	static uint8_t fillReconstructionBuffer(uint8_t* destBuffer, uint8_t* srcBuffer);
+
+    static uint8_t fillReconstructionBuffer(uint8_t* destBuffer, VLANHeader& vHeader);
+
+    
+    static uint32_t getMaxVlanTag()  { return (1<<12) - 1 ; }
+
+public:
+    uint16_t      myTag;
+    uint16_t      myNextProtocol;
+};
+
+#include "VLANHeader.inl"
+
+#endif //_VLAN_HEADER_H_
+
diff --git a/src/common/Network/Packet/VLANHeader.inl b/src/common/Network/Packet/VLANHeader.inl
new file mode 100755
index 00000000..a1c584c1
--- /dev/null
+++ b/src/common/Network/Packet/VLANHeader.inl
@@ -0,0 +1,111 @@
+/*
+Copyright (c) 2015-2015 Cisco Systems, Inc.
+
+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.
+*/
+
+#include <common/BigEndianBitManipulation.h> 
+
+inline  void   VLANHeader::setVlanTag(uint16_t data)
+{
+    myTag = PKT_HTONS(data);
+}
+
+inline  uint16_t VLANHeader::getVlanTag()
+{
+    return(PKT_HTONS(myTag));
+}
+
+inline  void  VLANHeader::setTagUserPriorty(uint8_t   argUserPriority)
+{
+    uint16_t  tempTag = myTag;
+    setMaskBit16(tempTag, 0, 2, argUserPriority);
+    myTag = tempTag;
+}
+
+inline  uint8_t VLANHeader::getTagUserPriorty()
+{
+    return (uint8_t)(getMaskBit16(myTag, 0, 2));
+}
+
+
+inline  void  VLANHeader::setTagCFI(bool    isSet)
+{
+    uint16_t  tempTag = myTag;
+    setMaskBit16(tempTag, 3, 3, isSet? 1 : 0);
+    myTag = tempTag;
+}
+
+inline  bool  VLANHeader::getTagCFI()
+{
+    return (getMaskBit16(myTag, 3, 3) == 1);
+}
+
+// This returns host order
+inline  uint16_t VLANHeader::getTagID(void)
+{
+    return  getMaskBit16(myTag, 4, 15);
+}
+
+inline  void    VLANHeader::setTagID(uint16_t argNewTag)
+{
+    uint16_t  tempTag = myTag;
+    setMaskBit16(tempTag, 4, 15, argNewTag);
+    myTag = tempTag;
+}
+
+inline void  VLANHeader::incrementTagID(uint16_t inc_value)
+{
+    uint16_t  tempTag_Host   = myTag;
+    uint16_t  curTagID_Host  = getTagID();
+    uint16_t  newTagId_Host  = (0xfff & (curTagID_Host + (0xfff & inc_value))); // addition with 12 LSBits
+    setMaskBit16(tempTag_Host, 4, 15, newTagId_Host);
+    myTag = tempTag_Host;
+}
+
+inline  uint16_t VLANHeader::getNextProtocolNetOrder()
+{
+    return myNextProtocol;
+}
+
+inline  uint16_t VLANHeader::getNextProtocolHostOrder()
+{
+    return (PKT_HTONS(myNextProtocol));
+}
+
+inline  void    VLANHeader::setNextProtocolFromHostOrder(uint16_t  argNextProtocol)
+{
+    myNextProtocol = PKT_HTONS(argNextProtocol);
+}
+
+inline  void    VLANHeader::setNextProtocolFromNetOrder(uint16_t  argNextProtocol)
+{
+    myNextProtocol = argNextProtocol;
+}
+
+inline void     VLANHeader::setFromPkt          (uint8_t* data)
+{
+    // set the tag from the data
+    setVlanTag(*(uint16_t*)data);
+    setNextProtocolFromNetOrder(*((uint16_t*)(data + 2))); // next protocol is after the vlan tag
+}
+
+inline uint8_t    VLANHeader::reconstructPkt      (uint8_t* destBuff)
+{
+    *(uint16_t*)destBuff     = getVlanTag();
+    *(uint16_t*)(destBuff+2) = getNextProtocolNetOrder();
+    return sizeof(VLANHeader);
+}
+
+
+