src/base/inet.cc

   1 /*
   2  * Copyright (c) 2002-2005 The Regents of The University of Michigan
   3  * Copyright (c) 2010 Advanced Micro Devices, Inc.
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions are
   8  * met: redistributions of source code must retain the above copyright
   9  * notice, this list of conditions and the following disclaimer;
  10  * redistributions in binary form must reproduce the above copyright
  11  * notice, this list of conditions and the following disclaimer in the
  12  * documentation and/or other materials provided with the distribution;
  13  * neither the name of the copyright holders nor the names of its
  14  * contributors may be used to endorse or promote products derived from
  15  * this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  18  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  19  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  20  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  21  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  22  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  23  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  24  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  25  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  27  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  *
  29  * Authors: Nathan Binkert
  30  *          Gabe Black
  31  */
  32
  33 #include <cstddef>
  34 #include <cstdio>
  35 #include <sstream>
  36 #include <string>
  37
  38 #include "base/cprintf.hh"
  39 #include "base/inet.hh"
  40 #include "base/types.hh"
  41
  42 using namespace std;
  43 namespace Net {
  44
  45 EthAddr::EthAddr()
  46 {
  47     memset(data, 0, ETH_ADDR_LEN);
  48 }
  49
  50 EthAddr::EthAddr(const uint8_t ea[ETH_ADDR_LEN])
  51 {
  52     *data = *ea;
  53 }
  54
  55 EthAddr::EthAddr(const eth_addr &ea)
  56 {
  57     *data = *ea.data;
  58 }
  59
  60 EthAddr::EthAddr(const std::string &addr)
  61 {
  62     parse(addr);
  63 }
  64
  65 const EthAddr &
  66 EthAddr::operator=(const eth_addr &ea)
  67 {
  68     *data = *ea.data;
  69     return *this;
  70 }
  71
  72 const EthAddr &
  73 EthAddr::operator=(const std::string &addr)
  74 {
  75     parse(addr);
  76     return *this;
  77 }
  78
  79 void
  80 EthAddr::parse(const std::string &addr)
  81 {
  82     // the hack below is to make sure that ETH_ADDR_LEN is 6 otherwise
  83     // the sscanf function won't work.
  84     int bytes[ETH_ADDR_LEN == 6 ? ETH_ADDR_LEN : -1];
  85     if (sscanf(addr.c_str(), "%x:%x:%x:%x:%x:%x", &bytes[0], &bytes[1],
  86                &bytes[2], &bytes[3], &bytes[4], &bytes[5]) != ETH_ADDR_LEN) {
  87         memset(data, 0xff, ETH_ADDR_LEN);
  88         return;
  89     }
  90
  91     for (int i = 0; i < ETH_ADDR_LEN; ++i) {
  92         if (bytes[i] & ~0xff) {
  93             memset(data, 0xff, ETH_ADDR_LEN);
  94             return;
  95         }
  96
  97         data[i] = bytes[i];
  98     }
  99 }
 100
 101 string
 102 EthAddr::string() const
 103 {
 104     stringstream stream;
 105     stream << *this;
 106     return stream.str();
 107 }
 108
 109 bool
 110 operator==(const EthAddr &left, const EthAddr &right)
 111 {
 112     return memcmp(left.bytes(), right.bytes(), ETH_ADDR_LEN);
 113 }
 114
 115 ostream &
 116 operator<<(ostream &stream, const EthAddr &ea)
 117 {
 118     const uint8_t *a = ea.addr();
 119     ccprintf(stream, "%x:%x:%x:%x:%x:%x", a[0], a[1], a[2], a[3], a[4], a[5]);
 120     return stream;
 121 }
 122
 123 string
 124 IpAddress::string() const
 125 {
 126     stringstream stream;
 127     stream << *this;
 128     return stream.str();
 129 }
 130
 131 bool
 132 operator==(const IpAddress &left, const IpAddress &right)
 133 {
 134     return left.ip() == right.ip();
 135 }
 136
 137 ostream &
 138 operator<<(ostream &stream, const IpAddress &ia)
 139 {
 140     uint32_t ip = ia.ip();
 141     ccprintf(stream, "%x.%x.%x.%x",
 142             (uint8_t)(ip >> 24), (uint8_t)(ip >> 16),
 143             (uint8_t)(ip >> 8),  (uint8_t)(ip >> 0));
 144     return stream;
 145 }
 146
 147 string
 148 IpNetmask::string() const
 149 {
 150     stringstream stream;
 151     stream << *this;
 152     return stream.str();
 153 }
 154
 155 bool
 156 operator==(const IpNetmask &left, const IpNetmask &right)
 157 {
 158     return (left.ip() == right.ip()) &&
 159         (left.netmask() == right.netmask());
 160 }
 161
 162 ostream &
 163 operator<<(ostream &stream, const IpNetmask &in)
 164 {
 165     ccprintf(stream, "%s/%d", (const IpAddress &)in, in.netmask());
 166     return stream;
 167 }
 168
 169 string
 170 IpWithPort::string() const
 171 {
 172     stringstream stream;
 173     stream << *this;
 174     return stream.str();
 175 }
 176
 177 bool
 178 operator==(const IpWithPort &left, const IpWithPort &right)
 179 {
 180     return (left.ip() == right.ip()) && (left.port() == right.port());
 181 }
 182
 183 ostream &
 184 operator<<(ostream &stream, const IpWithPort &iwp)
 185 {
 186     ccprintf(stream, "%s:%d", (const IpAddress &)iwp, iwp.port());
 187     return stream;
 188 }
 189
 190 uint16_t
 191 cksum(const IpPtr &ptr)
 192 {
 193     int sum = ip_cksum_add(ptr->bytes(), ptr->hlen(), 0);
 194     return ip_cksum_carry(sum);
 195 }
 196
 197 uint16_t
 198 __tu_cksum(const IpPtr &ip)
 199 {
 200     int tcplen = ip->len() - ip->hlen();
 201     int sum = ip_cksum_add(ip->payload(), tcplen, 0);
 202     sum = ip_cksum_add(&ip->ip_src, 8, sum); // source and destination
 203     sum += htons(ip->ip_p + tcplen);
 204     return ip_cksum_carry(sum);
 205 }
 206
 207 uint16_t
 208 cksum(const TcpPtr &tcp)
 209 { return __tu_cksum(IpPtr(tcp.packet())); }
 210
 211 uint16_t
 212 cksum(const UdpPtr &udp)
 213 { return __tu_cksum(IpPtr(udp.packet())); }
 214
 215 bool
 216 IpHdr::options(vector<const IpOpt *> &vec) const
 217 {
 218     vec.clear();
 219
 220     const uint8_t *data = bytes() + sizeof(struct ip_hdr);
 221     int all = hlen() - sizeof(struct ip_hdr);
 222     while (all > 0) {
 223         const IpOpt *opt = (const IpOpt *)data;
 224         int len = opt->len();
 225         if (all < len)
 226             return false;
 227
 228         vec.push_back(opt);
 229         all -= len;
 230         data += len;
 231     }
 232
 233     return true;
 234 }
 235
 236 bool
 237 TcpHdr::options(vector<const TcpOpt *> &vec) const
 238 {
 239     vec.clear();
 240
 241     const uint8_t *data = bytes() + sizeof(struct tcp_hdr);
 242     int all = off() - sizeof(struct tcp_hdr);
 243     while (all > 0) {
 244         const TcpOpt *opt = (const TcpOpt *)data;
 245         int len = opt->len();
 246         if (all < len)
 247             return false;
 248
 249         vec.push_back(opt);
 250         all -= len;
 251         data += len;
 252     }
 253
 254     return true;
 255 }
 256
 257 int
 258 hsplit(const EthPacketPtr &ptr)
 259 {
 260     int split_point = 0;
 261
 262     IpPtr ip(ptr);
 263     if (ip) {
 264         split_point = ip.pstart();
 265
 266         TcpPtr tcp(ip);
 267         if (tcp)
 268             split_point = tcp.pstart();
 269
 270         UdpPtr udp(ip);
 271         if (udp)
 272             split_point = udp.pstart();
 273     }
 274     return split_point;
 275 }
 276
 277
 278 } // namespace Net