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
42using namespace std;
43namespace Net {
44
45EthAddr::EthAddr()
46{
47 memset(data, 0, ETH_ADDR_LEN);
48}
49
50EthAddr::EthAddr(const uint8_t ea[ETH_ADDR_LEN])
51{
52 *data = *ea;
53}
54
55EthAddr::EthAddr(const eth_addr &ea)
56{
57 *data = *ea.data;
58}
59
60EthAddr::EthAddr(const std::string &addr)
61{
62 parse(addr);
63}
64
65const EthAddr &
66EthAddr::operator=(const eth_addr &ea)
67{
68 *data = *ea.data;
69 return *this;
70}
71
72const EthAddr &
73EthAddr::operator=(const std::string &addr)
74{
75 parse(addr);
76 return *this;
77}
78
79void
80EthAddr::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
101string
102EthAddr::string() const
103{
104 stringstream stream;
105 stream << *this;
106 return stream.str();
107}
108
109bool
110operator==(const EthAddr &left, const EthAddr &right)
111{
112 return memcmp(left.bytes(), right.bytes(), ETH_ADDR_LEN);
113}
114
115ostream &
116operator<<(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
123string
124IpAddress::string() const
125{
126 stringstream stream;
127 stream << *this;
128 return stream.str();
129}
130
131bool
132operator==(const IpAddress &left, const IpAddress &right)
133{
134 return left.ip() == right.ip();
135}
136
137ostream &
138operator<<(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
147string
148IpNetmask::string() const
149{
150 stringstream stream;
151 stream << *this;
152 return stream.str();
153}
154
155bool
156operator==(const IpNetmask &left, const IpNetmask &right)
157{
158 return (left.ip() == right.ip()) &&
159 (left.netmask() == right.netmask());
160}
161
162ostream &
163operator<<(ostream &stream, const IpNetmask &in)
164{
165 ccprintf(stream, "%s/%d", (const IpAddress &)in, in.netmask());
166 return stream;
167}
168
169string
170IpWithPort::string() const
171{
172 stringstream stream;
173 stream << *this;
174 return stream.str();
175}
176
177bool
178operator==(const IpWithPort &left, const IpWithPort &right)
179{
180 return (left.ip() == right.ip()) && (left.port() == right.port());
181}
182
183ostream &
184operator<<(ostream &stream, const IpWithPort &iwp)
185{
186 ccprintf(stream, "%s:%d", (const IpAddress &)iwp, iwp.port());
187 return stream;
188}
189
190uint16_t
191cksum(const IpPtr &ptr)
192{
193 int sum = ip_cksum_add(ptr->bytes(), ptr->hlen(), 0);
194 return ip_cksum_carry(sum);
195}
196
197uint16_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
207uint16_t
208cksum(const TcpPtr &tcp)
209{ return __tu_cksum(IpPtr(tcp.packet())); }
210
211uint16_t
212cksum(const UdpPtr &udp)
213{ return __tu_cksum(IpPtr(udp.packet())); }
214
215bool
216IpHdr::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
236bool
237TcpHdr::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
257int
258hsplit(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