1 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

     2 /*

     3  * Copyright (c) 2008 Liu Jian

     4  *

     5  * This program is free software; you can redistribute it and/or modify

     6  * it under the terms of the GNU General Public License version 2 as

     7  * published by the Free Software Foundation;

     8  *

     9  * This program is distributed in the hope that it will be useful,

    10  * but WITHOUT ANY WARRANTY; without even the implied warranty of

    11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    12  * GNU General Public License for more details.

    13  *

    14  * You should have received a copy of the GNU General Public License

    15  * along with this program; if not, write to the Free Software

    16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    17  *

    18  * Author: Liu Jian <liujatp@gmail.com>

    19  *         Hajime Tazaki <tazaki@sfc.wide.ad.jp>

    20  */

    21 

    22 #include "netlink-attribute.h"

    23 #include "netlink-message.h"

    24 #include "netlink-message-route.h"

    25 #include "ns3/address-utils.h"

    26 

    27 namespace ns3 {

    28 

    29 

    30 /***********************************************************************************

    31 * \ NetlinkAttributeValue

    32 ***********************************************************************************/

    33 NetlinkAttributeValue::NetlinkAttributeValue ()

    34 {

    35   m_type = UNSPEC;

    36   m_u32 = 0;

    37 }

    38 

    39 NetlinkAttributeValue:: NetlinkAttributeValue (NetlinkAttributeValueType type, uint8_t v)

    40 {

    41   NS_ASSERT (type == U8);

    42   m_type = U8;

    43   m_u8 = v;

    44 }

    45 NetlinkAttributeValue:: NetlinkAttributeValue (NetlinkAttributeValueType type, uint16_t v)

    46 {

    47   NS_ASSERT (type == U16);

    48   m_type = U16;

    49   m_u16 = v;

    50 }

    51 NetlinkAttributeValue:: NetlinkAttributeValue (NetlinkAttributeValueType type, uint32_t v)

    52 {

    53   NS_ASSERT (type == U32);

    54   m_type = U32;

    55   m_u32 = v;

    56 }

    57 NetlinkAttributeValue:: NetlinkAttributeValue (NetlinkAttributeValueType type, uint64_t v)

    58 {

    59   NS_ASSERT (type == U64);

    60   m_type = U64;

    61   m_u64 = v;

    62 }

    63 NetlinkAttributeValue:: NetlinkAttributeValue (NetlinkAttributeValueType type, std::string v)

    64 {

    65   NS_ASSERT (type == STRING);

    66   m_type = STRING;

    67   m_string = v;

    68 }

    69 NetlinkAttributeValue:: NetlinkAttributeValue (NetlinkAttributeValueType type, Address v)

    70 {

    71   NS_ASSERT (type == ADDRESS);

    72   m_type = ADDRESS;

    73   m_address = v;

    74 }

    75 

    76 void

    77 NetlinkAttributeValue::SetType (NetlinkAttributeValueType type)

    78 {

    79   m_type = type;

    80 }

    81 NetlinkAttributeValueType

    82 NetlinkAttributeValue::GetType (void) const

    83 {

    84   return m_type;

    85 }

    86 void

    87 NetlinkAttributeValue::SetAddress (Address value)

    88 {

    89   m_address = value;

    90 }

    91 void

    92 NetlinkAttributeValue::SetString (std::string value)

    93 {

    94   m_string = value;

    95 }

    96 void

    97 NetlinkAttributeValue::SetU64 (uint64_t value)

    98 {

    99   m_u64 = value;

   100 }

   101 void

   102 NetlinkAttributeValue::SetU32 (uint32_t value)

   103 {

   104   m_u32 = value;

   105 }

   106 void

   107 NetlinkAttributeValue::SetU16 (uint16_t value)

   108 {

   109   m_u16 = value;

   110 }

   111 void

   112 NetlinkAttributeValue::SetU8 (uint8_t value)

   113 {

   114   m_u8 = value;

   115 }

   116 Address

   117 NetlinkAttributeValue::GetAddress (void) const

   118 {

   119   return m_address;

   120 }

   121 std::string

   122 NetlinkAttributeValue::GetString (void) const

   123 {

   124   return m_string;

   125 }

   126 uint64_t

   127 NetlinkAttributeValue::GetU64 (void) const

   128 {

   129   return m_u64;

   130 }

   131 uint32_t

   132 NetlinkAttributeValue::GetU32 (void) const

   133 {

   134   return m_u32;

   135 }

   136 uint16_t

   137 NetlinkAttributeValue::GetU16 (void) const

   138 {

   139   return m_u16;

   140 }

   141 uint8_t

   142 NetlinkAttributeValue::GetU8 (void) const

   143 {

   144   return m_u8;

   145 }

   146 

   147 void

   148 NetlinkAttributeValue::Serialize (Buffer::Iterator& start) const

   149 {

   150   uint32_t len;

   151 

   152   if (m_type == U8)

   153     {

   154       start.WriteU8 (m_u8);

   155       len = 1;

   156     }

   157   else if(m_type == U16)

   158     {

   159       start.WriteU16 (m_u16);

   160       len = 2;

   161     }

   162   else if(m_type == U32)

   163     {

   164       start.WriteU32 (m_u32);

   165       len = 4;

   166     }

   167   else if(m_type == STRING)

   168     {

   169       start.Write ((const uint8_t *)m_string.c_str (), (uint32_t)m_string.size ()+1);

   170       len = (uint32_t)m_string.size () + 1;

   171     }

   172   else if(m_type == ADDRESS)

   173     {

   174       WriteTo (start, m_address);

   175       len = m_address.GetLength ();

   176     }

   177   else

   178     {

   179       len = 0;

   180     }

   181   //netlink align

   182   start.WriteU8 (0, NETLINK_MSG_ALIGN (len) - len);

   183 }

   184 

   185 uint32_t

   186 NetlinkAttributeValue::DeserializeWithType (Buffer::Iterator& start, 

   187                                             NetlinkAttributeValueType_e type, uint16_t remaining)

   188 {

   189   uint32_t len =0;

   190   m_type = type;  

   191 

   192   if (m_type == U8)

   193     {

   194       m_u8 = start.ReadU8 ();

   195       len = 1;

   196     }

   197   else if (m_type == U16)

   198     {

   199       m_u16 = start.ReadU16 ();

   200       len = 2;

   201     }

   202   else if (m_type == U32)

   203     {

   204       m_u32 = start.ReadU32 ();

   205       len = 4;

   206     }

   207   else if (m_type == U64)

   208     {

   209       m_u64 = start.ReadU64 ();

   210     }  

   211   else if (m_type == STRING)

   212     {

   213       char buf[512];

   214       uint32_t i = 0;

   215       do 

   216       {

   217         buf[i] = start.ReadU8 ();

   218       } while (buf[i++]);

   219       

   220       m_string = std::string (buf);

   221       len = (uint32_t)m_string.size () + 1;

   222     }

   223   else if (m_type == ADDRESS)

   224     {

   225       ReadFrom (start, m_address, remaining);

   226       len = m_address.GetLength ();

   227     }

   228   else

   229     {

   230       len = 0;

   231     }

   232 

   233   //netlink align

   234   uint8_t buf[4];

   235   start.Read (buf, NETLINK_MSG_ALIGN (len) - len);

   236   

   237   return NETLINK_MSG_ALIGN (len);

   238 }

   239 

   240 uint32_t

   241 NetlinkAttributeValue::GetSerializedSize ()const

   242 {

   243   return NETLINK_MSG_ALIGN (GetSize ());

   244 }

   245 

   246 uint32_t

   247 NetlinkAttributeValue::GetSize () const

   248 {

   249   uint32_t len;

   250 

   251   if (m_type == U8)

   252     {

   253       len = 1;

   254     }

   255   else if(m_type == U16)

   256     {

   257       len =  2;

   258     }

   259   else if(m_type == U32)

   260     {

   261       len =  4;

   262     }

   263   else if (m_type == STRING)

   264     {

   265       len =  uint32_t (m_string.size () + 1);

   266     }

   267   else if (m_type == ADDRESS)

   268     {

   269       len =  m_address.GetLength ();

   270     }

   271   else

   272     {

   273       len = 0;

   274     }

   275 

   276     return len;

   277 }

   278 

   279 void

   280 NetlinkAttributeValue::Print (std::ostream &os) const

   281 {

   282   os << "NetlinkAttributeValue (type= " << m_type <<", v= ";

   283   if (m_type == U8)

   284     {

   285       os << m_u8;

   286     }

   287   else if (m_type == U16)

   288     {

   289       os << m_u16;

   290     }

   291   else if (m_type == U32)

   292     {

   293       os << m_u32;

   294     }

   295   else if (m_type == U64)

   296     {

   297       os << m_u64;

   298     }  

   299   else if (m_type == STRING)

   300     {

   301       os << m_string;

   302     }

   303   else if (m_type == ADDRESS)

   304     {

   305       os << "address(" << m_address <<")";

   306     }

   307   else

   308     {

   309       os << "NULL";

   310     }

   311   os <<")";

   312 }

   313 

   314 

   315 /***********************************************************************************

   316 * \ NetlinkAttribute

   317 ***********************************************************************************/

   318 

   319 NetlinkAttribute::NetlinkAttribute ()

   320   : m_len(4),

   321     m_type (0)

   322 {

   323 }

   324 

   325 NetlinkAttribute::NetlinkAttribute (uint16_t type, NetlinkAttributeValueType payloadtype,  uint8_t payload)

   326 {

   327   m_payload = NetlinkAttributeValue (payloadtype, payload);

   328   m_len = NETLINK_MSG_ATTR_SIZE + m_payload.GetSize ();

   329   m_type = type;

   330 }

   331 

   332 NetlinkAttribute::NetlinkAttribute (uint16_t type, NetlinkAttributeValueType payloadtype,  uint16_t payload)

   333 {

   334   m_payload = NetlinkAttributeValue (payloadtype, payload);

   335   m_len = NETLINK_MSG_ATTR_SIZE + m_payload.GetSize ();

   336   m_type = type;

   337 }

   338 NetlinkAttribute::NetlinkAttribute (uint16_t type, NetlinkAttributeValueType payloadtype,  uint32_t payload)

   339 {

   340   m_payload = NetlinkAttributeValue (payloadtype, payload);

   341   m_len = NETLINK_MSG_ATTR_SIZE + m_payload.GetSize ();

   342   m_type = type;;

   343 }

   344 NetlinkAttribute::NetlinkAttribute (uint16_t type, NetlinkAttributeValueType payloadtype,  uint64_t payload)

   345 {

   346   m_payload = NetlinkAttributeValue (payloadtype, payload);

   347   m_len = NETLINK_MSG_ATTR_SIZE + m_payload.GetSize ();

   348   m_type = type;

   349 }

   350 NetlinkAttribute::NetlinkAttribute (uint16_t type, NetlinkAttributeValueType payloadtype,  std::string payload)

   351 {

   352   m_payload = NetlinkAttributeValue (payloadtype, payload);

   353   m_len = NETLINK_MSG_ATTR_SIZE + m_payload.GetSize ();

   354   m_type = type;

   355 }

   356 NetlinkAttribute::NetlinkAttribute (uint16_t type, NetlinkAttributeValueType payloadtype,  Address payload)

   357 {

   358   m_payload = NetlinkAttributeValue (payloadtype, payload);

   359   m_len = NETLINK_MSG_ATTR_SIZE + m_payload.GetSize ();

   360   m_type = type;

   361 }

   362 

   363 void

   364 NetlinkAttribute::SetAttrLen (uint16_t v)

   365 {

   366   m_len = v;

   367 }

   368 void 

   369 NetlinkAttribute::SetAttrType (uint16_t v)

   370 {

   371   m_type = v;

   372 }

   373 void

   374 NetlinkAttribute::SetAttrPayload (NetlinkAttributeValue v)

   375 {

   376   m_payload = v;

   377 }

   378 uint16_t

   379 NetlinkAttribute::GetAttrLen () const

   380 {

   381   return m_len;

   382 }

   383 uint16_t

   384 NetlinkAttribute::GetAttrType () const

   385 {

   386   return m_type;

   387 }

   388 NetlinkAttributeValue

   389 NetlinkAttribute::GetAttrPayload() const

   390 {

   391   return m_payload;

   392 }

   393 

   394 void 

   395 NetlinkAttribute::Print (std::ostream &os) const

   396 {  

   397   os << "NetlinkAttribute "

   398      << "len: " << m_len << " "

   399      << "type: " << m_type<<" "

   400      << "payload:[";

   401   m_payload.Print(os);

   402   os<<"]";

   403 }

   404 

   405 uint32_t 

   406 NetlinkAttribute::GetSerializedSize (void) const

   407 {

   408   /* this is the size of an nlattr payload. */

   409   return NETLINK_MSG_ATTR_SIZE + m_payload.GetSerializedSize ();

   410 }

   411 

   412 void

   413 NetlinkAttribute::Serialize (Buffer::Iterator& start) const

   414 {

   415   start.WriteU16 (m_len);

   416   start.WriteU16 (m_type);

   417   m_payload.Serialize (start);

   418 }

   419 

   420 uint32_t

   421 NetlinkAttribute::Deserialize (Buffer::Iterator& start, NetlinkAttributeValueType vtypes[])

   422 {

   423   NetlinkAttributeValueType type;

   424 

   425   m_len = start.ReadU16 ();

   426   m_type = start.ReadU16 ();

   427   type = vtypes[m_type];

   428   m_payload.DeserializeWithType (start, type, m_len - 4);

   429 

   430   return GetSerializedSize ();

   431 }

   432 

   433 }; // namespace ns3