1/* 2 * Copyright (c) 2013 ARM Limited 3 * All rights reserved 4 * 5 * The license below extends only to copyright in the software and shall 6 * not be construed as granting a license to any other intellectual 7 * property including but not limited to intellectual property relating 8 * to a hardware implementation of the functionality of the software 9 * licensed hereunder. You may use the software subject to the license 10 * terms below provided that you ensure that this notice is replicated 11 * unmodified and in its entirety in all distributions of the software, 12 * modified or unmodified, in source code or in binary form. 13 * 14 * Copyright (c) 2002-2005 The Regents of The University of Michigan 15 * Copyright (c) 2010 Advanced Micro Devices, Inc. 16 * All rights reserved. 17 * 18 * Redistribution and use in source and binary forms, with or without 19 * modification, are permitted provided that the following conditions are 20 * met: redistributions of source code must retain the above copyright 21 * notice, this list of conditions and the following disclaimer; 22 * redistributions in binary form must reproduce the above copyright 23 * notice, this list of conditions and the following disclaimer in the 24 * documentation and/or other materials provided with the distribution; 25 * neither the name of the copyright holders nor the names of its 26 * contributors may be used to endorse or promote products derived from 27 * this software without specific prior written permission. 28 * 29 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 30 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 31 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 32 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 33 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 34 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 35 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 36 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 37 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 38 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 39 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 40 * 41 * Authors: Nathan Binkert 42 * Steve Reinhardt 43 * Gabe Black 44 * Geoffrey Blake 45 */ 46 47#ifndef __BASE_INET_HH__ 48#define __BASE_INET_HH__ 49 50#include <iosfwd> 51#include <string> 52#include <utility> 53#include <vector> 54 55#include "base/types.hh" 56#include "dev/etherpkt.hh" 57#include "dnet/os.h" 58#include "dnet/eth.h" 59#include "dnet/ip.h" 60#include "dnet/ip6.h" 61#include "dnet/addr.h" 62#include "dnet/arp.h" 63#include "dnet/icmp.h" 64#include "dnet/tcp.h" 65#include "dnet/udp.h" 66#include "dnet/intf.h" 67#include "dnet/route.h" 68#include "dnet/fw.h" 69#include "dnet/blob.h" 70#include "dnet/rand.h" 71 72namespace Net { 73 74/* 75 * Ethernet Stuff 76 */ 77struct EthAddr : protected eth_addr 78{ 79 protected: 80 void parse(const std::string &addr); 81 82 public: 83 EthAddr(); 84 EthAddr(const uint8_t ea[ETH_ADDR_LEN]); 85 EthAddr(const eth_addr &ea); 86 EthAddr(const std::string &addr); 87 const EthAddr &operator=(const eth_addr &ea); 88 const EthAddr &operator=(const std::string &addr); 89 90 int size() const { return sizeof(eth_addr); } 91 92 const uint8_t *bytes() const { return &data[0]; } 93 uint8_t *bytes() { return &data[0]; } 94 95 const uint8_t *addr() const { return &data[0]; }
| 1/* 2 * Copyright (c) 2013 ARM Limited 3 * All rights reserved 4 * 5 * The license below extends only to copyright in the software and shall 6 * not be construed as granting a license to any other intellectual 7 * property including but not limited to intellectual property relating 8 * to a hardware implementation of the functionality of the software 9 * licensed hereunder. You may use the software subject to the license 10 * terms below provided that you ensure that this notice is replicated 11 * unmodified and in its entirety in all distributions of the software, 12 * modified or unmodified, in source code or in binary form. 13 * 14 * Copyright (c) 2002-2005 The Regents of The University of Michigan 15 * Copyright (c) 2010 Advanced Micro Devices, Inc. 16 * All rights reserved. 17 * 18 * Redistribution and use in source and binary forms, with or without 19 * modification, are permitted provided that the following conditions are 20 * met: redistributions of source code must retain the above copyright 21 * notice, this list of conditions and the following disclaimer; 22 * redistributions in binary form must reproduce the above copyright 23 * notice, this list of conditions and the following disclaimer in the 24 * documentation and/or other materials provided with the distribution; 25 * neither the name of the copyright holders nor the names of its 26 * contributors may be used to endorse or promote products derived from 27 * this software without specific prior written permission. 28 * 29 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 30 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 31 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 32 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 33 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 34 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 35 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 36 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 37 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 38 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 39 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 40 * 41 * Authors: Nathan Binkert 42 * Steve Reinhardt 43 * Gabe Black 44 * Geoffrey Blake 45 */ 46 47#ifndef __BASE_INET_HH__ 48#define __BASE_INET_HH__ 49 50#include <iosfwd> 51#include <string> 52#include <utility> 53#include <vector> 54 55#include "base/types.hh" 56#include "dev/etherpkt.hh" 57#include "dnet/os.h" 58#include "dnet/eth.h" 59#include "dnet/ip.h" 60#include "dnet/ip6.h" 61#include "dnet/addr.h" 62#include "dnet/arp.h" 63#include "dnet/icmp.h" 64#include "dnet/tcp.h" 65#include "dnet/udp.h" 66#include "dnet/intf.h" 67#include "dnet/route.h" 68#include "dnet/fw.h" 69#include "dnet/blob.h" 70#include "dnet/rand.h" 71 72namespace Net { 73 74/* 75 * Ethernet Stuff 76 */ 77struct EthAddr : protected eth_addr 78{ 79 protected: 80 void parse(const std::string &addr); 81 82 public: 83 EthAddr(); 84 EthAddr(const uint8_t ea[ETH_ADDR_LEN]); 85 EthAddr(const eth_addr &ea); 86 EthAddr(const std::string &addr); 87 const EthAddr &operator=(const eth_addr &ea); 88 const EthAddr &operator=(const std::string &addr); 89 90 int size() const { return sizeof(eth_addr); } 91 92 const uint8_t *bytes() const { return &data[0]; } 93 uint8_t *bytes() { return &data[0]; } 94 95 const uint8_t *addr() const { return &data[0]; }
|
99 std::string string() const; 100 101 operator uint64_t() const 102 { 103 uint64_t reg = 0; 104 reg |= ((uint64_t)data[0]) << 40; 105 reg |= ((uint64_t)data[1]) << 32; 106 reg |= ((uint64_t)data[2]) << 24; 107 reg |= ((uint64_t)data[3]) << 16; 108 reg |= ((uint64_t)data[4]) << 8; 109 reg |= ((uint64_t)data[5]) << 0; 110 return reg; 111 } 112 113}; 114 115std::ostream &operator<<(std::ostream &stream, const EthAddr &ea); 116bool operator==(const EthAddr &left, const EthAddr &right); 117 118struct EthHdr : public eth_hdr 119{ 120 bool isVlan() const { return (ntohs(eth_type) == ETH_TYPE_8021Q); } 121 uint16_t type() const { 122 if (!isVlan()) 123 return ntohs(eth_type); 124 else 125 // L3 type is now 16 bytes into the hdr with 802.1Q 126 // instead of 12. dnet/eth.h only supports 802.1 127 return ntohs(*((uint16_t*)(((uint8_t *)this) + 16))); 128 } 129 uint16_t vlanId() const { 130 if (isVlan()) 131 return ntohs(*((uint16_t*)(((uint8_t *)this) + 14))); 132 else 133 return 0x0000; 134 } 135 136 const EthAddr &src() const { return *(EthAddr *)ð_src; } 137 const EthAddr &dst() const { return *(EthAddr *)ð_dst; } 138 139 int size() const { 140 if (!isVlan()) 141 return sizeof(eth_hdr); 142 else 143 return (sizeof(eth_hdr)+4); 144 } 145 146 const uint8_t *bytes() const { return (const uint8_t *)this; } 147 const uint8_t *payload() const { return bytes() + size(); } 148 uint8_t *bytes() { return (uint8_t *)this; } 149 uint8_t *payload() { return bytes() + size(); } 150}; 151 152class EthPtr 153{ 154 protected: 155 friend class IpPtr; 156 friend class Ip6Ptr; 157 EthPacketPtr p; 158 159 public: 160 EthPtr() {} 161 EthPtr(const EthPacketPtr &ptr) : p(ptr) { } 162 163 EthHdr *operator->() { return (EthHdr *)p->data; } 164 EthHdr &operator*() { return *(EthHdr *)p->data; } 165 operator EthHdr *() { return (EthHdr *)p->data; } 166 167 const EthHdr *operator->() const { return (const EthHdr *)p->data; } 168 const EthHdr &operator*() const { return *(const EthHdr *)p->data; } 169 operator const EthHdr *() const { return (const EthHdr *)p->data; } 170 171 const EthPtr &operator=(const EthPacketPtr &ptr) { p = ptr; return *this; } 172 173 const EthPacketPtr packet() const { return p; } 174 EthPacketPtr packet() { return p; } 175 bool operator!() const { return !p; } 176 operator bool() const { return p; } 177 int off() const { return 0; } 178 int pstart() const { return off() + ((const EthHdr*)p->data)->size(); } 179}; 180 181/* 182 * IP Stuff 183 */ 184struct IpAddress 185{ 186 protected: 187 uint32_t _ip; 188 189 public: 190 IpAddress() : _ip(0) 191 {} 192 IpAddress(const uint32_t __ip) : _ip(__ip) 193 {} 194 195 uint32_t ip() const { return _ip; } 196 197 std::string string() const; 198}; 199 200std::ostream &operator<<(std::ostream &stream, const IpAddress &ia); 201bool operator==(const IpAddress &left, const IpAddress &right); 202 203struct IpNetmask : public IpAddress 204{ 205 protected: 206 uint8_t _netmask; 207 208 public: 209 IpNetmask() : IpAddress(), _netmask(0) 210 {} 211 IpNetmask(const uint32_t __ip, const uint8_t __netmask) : 212 IpAddress(__ip), _netmask(__netmask) 213 {} 214 215 uint8_t netmask() const { return _netmask; } 216 217 std::string string() const; 218}; 219 220std::ostream &operator<<(std::ostream &stream, const IpNetmask &in); 221bool operator==(const IpNetmask &left, const IpNetmask &right); 222 223struct IpWithPort : public IpAddress 224{ 225 protected: 226 uint16_t _port; 227 228 public: 229 IpWithPort() : IpAddress(), _port(0) 230 {} 231 IpWithPort(const uint32_t __ip, const uint16_t __port) : 232 IpAddress(__ip), _port(__port) 233 {} 234 235 uint8_t port() const { return _port; } 236 237 std::string string() const; 238}; 239 240std::ostream &operator<<(std::ostream &stream, const IpWithPort &iwp); 241bool operator==(const IpWithPort &left, const IpWithPort &right); 242 243struct IpOpt; 244struct IpHdr : public ip_hdr 245{ 246 uint8_t version() const { return ip_v; } 247 uint8_t hlen() const { return ip_hl * 4; } 248 uint8_t tos() const { return ip_tos; } 249 uint16_t len() const { return ntohs(ip_len); } 250 uint16_t id() const { return ntohs(ip_id); } 251 uint16_t frag_flags() const { return ntohs(ip_off) >> 13; } 252 uint16_t frag_off() const { return ntohs(ip_off) & 0x1fff; } 253 uint8_t ttl() const { return ip_ttl; } 254 uint8_t proto() const { return ip_p; } 255 uint16_t sum() const { return ip_sum; } 256 uint32_t src() const { return ntohl(ip_src); } 257 uint32_t dst() const { return ntohl(ip_dst); } 258 259 void sum(uint16_t sum) { ip_sum = sum; } 260 void id(uint16_t _id) { ip_id = htons(_id); } 261 void len(uint16_t _len) { ip_len = htons(_len); } 262 263 bool options(std::vector<const IpOpt *> &vec) const; 264 265 int size() const { return hlen(); } 266 const uint8_t *bytes() const { return (const uint8_t *)this; } 267 const uint8_t *payload() const { return bytes() + size(); } 268 uint8_t *bytes() { return (uint8_t *)this; } 269 uint8_t *payload() { return bytes() + size(); } 270}; 271 272class IpPtr 273{ 274 protected: 275 friend class TcpPtr; 276 friend class UdpPtr; 277 EthPacketPtr p; 278 bool eth_hdr_vlan; 279 280 void set(const EthPacketPtr &ptr) 281 { 282 p = 0; 283 eth_hdr_vlan = false; 284 285 if (ptr) { 286 EthHdr *eth = (EthHdr *)ptr->data; 287 if (eth->type() == ETH_TYPE_IP) 288 p = ptr; 289 if (eth->isVlan()) 290 eth_hdr_vlan = true; 291 } 292 } 293 294 public: 295 IpPtr() : p(0), eth_hdr_vlan(false) {} 296 IpPtr(const EthPacketPtr &ptr) : p(0), eth_hdr_vlan(false) { set(ptr); } 297 IpPtr(const EthPtr &ptr) : p(0), eth_hdr_vlan(false) { set(ptr.p); } 298 IpPtr(const IpPtr &ptr) : p(ptr.p), eth_hdr_vlan(ptr.eth_hdr_vlan) { } 299 300 IpHdr *get() { return (IpHdr *)(p->data + sizeof(eth_hdr) + 301 ((eth_hdr_vlan) ? 4 : 0)); } 302 IpHdr *operator->() { return get(); } 303 IpHdr &operator*() { return *get(); } 304 305 const IpHdr *get() const 306 { return (const IpHdr *)(p->data + sizeof(eth_hdr) + 307 ((eth_hdr_vlan) ? 4 : 0)); } 308 const IpHdr *operator->() const { return get(); } 309 const IpHdr &operator*() const { return *get(); } 310 311 const IpPtr &operator=(const EthPacketPtr &ptr) { set(ptr); return *this; } 312 const IpPtr &operator=(const EthPtr &ptr) { set(ptr.p); return *this; } 313 const IpPtr &operator=(const IpPtr &ptr) { p = ptr.p; return *this; } 314 315 const EthPacketPtr packet() const { return p; } 316 EthPacketPtr packet() { return p; } 317 bool operator!() const { return !p; } 318 operator bool() const { return p; } 319 int off() const { return (sizeof(eth_hdr) + ((eth_hdr_vlan) ? 4 : 0)); } 320 int pstart() const { return (off() + get()->size()); } 321}; 322 323uint16_t cksum(const IpPtr &ptr); 324 325struct IpOpt : public ip_opt 326{ 327 uint8_t type() const { return opt_type; } 328 uint8_t typeNumber() const { return IP_OPT_NUMBER(opt_type); } 329 uint8_t typeClass() const { return IP_OPT_CLASS(opt_type); } 330 uint8_t typeCopied() const { return IP_OPT_COPIED(opt_type); } 331 uint8_t len() const { return IP_OPT_TYPEONLY(type()) ? 1 : opt_len; } 332 333 bool isNumber(int num) const { return typeNumber() == IP_OPT_NUMBER(num); } 334 bool isClass(int cls) const { return typeClass() == IP_OPT_CLASS(cls); } 335 bool isCopied(int cpy) const { return typeCopied() == IP_OPT_COPIED(cpy); } 336 337 const uint8_t *data() const { return opt_data.data8; } 338 void sec(ip_opt_data_sec &sec) const; 339 void lsrr(ip_opt_data_rr &rr) const; 340 void ssrr(ip_opt_data_rr &rr) const; 341 void ts(ip_opt_data_ts &ts) const; 342 uint16_t satid() const { return ntohs(opt_data.satid); } 343 uint16_t mtup() const { return ntohs(opt_data.mtu); } 344 uint16_t mtur() const { return ntohs(opt_data.mtu); } 345 void tr(ip_opt_data_tr &tr) const; 346 const uint32_t *addext() const { return &opt_data.addext[0]; } 347 uint16_t rtralt() const { return ntohs(opt_data.rtralt); } 348 void sdb(std::vector<uint32_t> &vec) const; 349}; 350 351/* 352 * Ip6 Classes 353 */ 354struct Ip6Opt; 355struct Ip6Hdr : public ip6_hdr 356{ 357 uint8_t version() const { return ip6_vfc; } 358 uint32_t flow() const { return ntohl(ip6_flow); } 359 uint16_t plen() const { return ntohs(ip6_plen); } 360 uint16_t hlen() const { return IP6_HDR_LEN; } 361 uint8_t nxt() const { return ip6_nxt; } 362 uint8_t hlim() const { return ip6_hlim; } 363 364 const uint8_t* src() const { return ip6_src.data; } 365 const uint8_t* dst() const { return ip6_dst.data; } 366 367 int extensionLength() const; 368 const Ip6Opt* getExt(uint8_t ext) const; 369 const Ip6Opt* fragmentExt() const { return getExt(IP_PROTO_FRAGMENT); } 370 const Ip6Opt* rtTypeExt() const { return getExt(IP_PROTO_ROUTING); } 371 const Ip6Opt* dstOptExt() const { return getExt(IP_PROTO_DSTOPTS); } 372 uint8_t proto() const; 373 374 void plen(uint16_t _plen) { ip6_plen = htons(_plen); } 375 376 int size() const { return IP6_HDR_LEN + extensionLength(); } 377 const uint8_t *bytes() const { return (const uint8_t *)this; } 378 const uint8_t *payload() const { return bytes() + IP6_HDR_LEN 379 + extensionLength(); } 380 uint8_t *bytes() { return (uint8_t *)this; } 381 uint8_t *payload() { return bytes() + IP6_HDR_LEN 382 + extensionLength(); } 383}; 384 385class Ip6Ptr 386{ 387 protected: 388 friend class TcpPtr; 389 friend class UdpPtr; 390 EthPacketPtr p; 391 bool eth_hdr_vlan; 392 393 void set(const EthPacketPtr &ptr) 394 { 395 p = 0; 396 eth_hdr_vlan = false; 397 398 if (ptr) { 399 EthHdr *eth = (EthHdr *)ptr->data; 400 if (eth->type() == ETH_TYPE_IPV6) 401 p = ptr; 402 if (eth->isVlan()) 403 eth_hdr_vlan = true; 404 } 405 } 406 407 public: 408 Ip6Ptr() : p(0), eth_hdr_vlan(false) {} 409 Ip6Ptr(const EthPacketPtr &ptr) : p(0), eth_hdr_vlan(false) { set(ptr); } 410 Ip6Ptr(const EthPtr &ptr) : p(0), eth_hdr_vlan(false) { set(ptr.p); } 411 Ip6Ptr(const Ip6Ptr &ptr) : p(ptr.p), eth_hdr_vlan(ptr.eth_hdr_vlan) { } 412 413 Ip6Hdr *get() { return (Ip6Hdr *)(p->data + sizeof(eth_hdr) 414 + ((eth_hdr_vlan) ? 4 : 0)); } 415 Ip6Hdr *operator->() { return get(); } 416 Ip6Hdr &operator*() { return *get(); } 417 418 const Ip6Hdr *get() const 419 { return (const Ip6Hdr *)(p->data + sizeof(eth_hdr) 420 + ((eth_hdr_vlan) ? 4 : 0)); } 421 const Ip6Hdr *operator->() const { return get(); } 422 const Ip6Hdr &operator*() const { return *get(); } 423 424 const Ip6Ptr &operator=(const EthPacketPtr &ptr) 425 { set(ptr); return *this; } 426 const Ip6Ptr &operator=(const EthPtr &ptr) 427 { set(ptr.p); return *this; } 428 const Ip6Ptr &operator=(const Ip6Ptr &ptr) 429 { p = ptr.p; return *this; } 430 431 const EthPacketPtr packet() const { return p; } 432 EthPacketPtr packet() { return p; } 433 bool operator!() const { return !p; } 434 operator bool() const { return p; } 435 int off() const { return sizeof(eth_hdr) + ((eth_hdr_vlan) ? 4 : 0); } 436 int pstart() const { return off() + get()->size(); } 437}; 438 439// Dnet supplied ipv6 opt header is incomplete and 440// newer NIC card filters expect a more robust 441// ipv6 header option declaration. 442struct ip6_opt_fragment { 443 uint16_t offlg; 444 uint32_t ident; 445}; 446 447struct ip6_opt_routing_type2 { 448 uint8_t type; 449 uint8_t segleft; 450 uint32_t reserved; 451 ip6_addr_t addr; 452}; 453 454#define HOME_ADDRESS_OPTION 0xC9 455struct ip6_opt_dstopts { 456 uint8_t type; 457 uint8_t length; 458 ip6_addr_t addr; 459} __attribute__((packed)); 460 461struct ip6_opt_hdr 462{ 463 uint8_t ext_nxt; 464 uint8_t ext_len; 465 union { 466 struct ip6_opt_fragment fragment; 467 struct ip6_opt_routing_type2 rtType2; 468 struct ip6_opt_dstopts dstOpts; 469 } ext_data; 470} __attribute__((packed)); 471 472struct Ip6Opt : public ip6_opt_hdr 473{ 474 uint8_t nxt() const { return ext_nxt; } 475 uint8_t extlen() const { return ext_len; } 476 uint8_t len() const { return extlen() + 8; } 477 478 // Supporting the types of header extensions likely to be encountered: 479 // fragment, routing type 2 and dstopts. 480 481 // Routing type 2 482 uint8_t rtType2Type() const { return ext_data.rtType2.type; } 483 uint8_t rtType2SegLft() const { return ext_data.rtType2.segleft; } 484 const uint8_t* rtType2Addr() const { return ext_data.rtType2.addr.data; } 485 486 // Fragment 487 uint16_t fragmentOfflg() const { return ntohs(ext_data.fragment.offlg); } 488 uint32_t fragmentIdent() const { return ntohl(ext_data.fragment.ident); } 489 490 // Dst Options/Home Address Option 491 uint8_t dstOptType() const { return ext_data.dstOpts.type; } 492 uint8_t dstOptLength() const { return ext_data.dstOpts.length; } 493 const uint8_t* dstOptAddr() const { return ext_data.dstOpts.addr.data; } 494}; 495 496 497/* 498 * TCP Stuff 499 */ 500struct TcpOpt; 501struct TcpHdr : public tcp_hdr 502{ 503 uint16_t sport() const { return ntohs(th_sport); } 504 uint16_t dport() const { return ntohs(th_dport); } 505 uint32_t seq() const { return ntohl(th_seq); } 506 uint32_t ack() const { return ntohl(th_ack); } 507 uint8_t off() const { return th_off*4; } 508 uint8_t flags() const { return th_flags & 0x3f; } 509 uint16_t win() const { return ntohs(th_win); } 510 uint16_t sum() const { return th_sum; } 511 uint16_t urp() const { return ntohs(th_urp); } 512 513 void sum(uint16_t sum) { th_sum = sum; } 514 void seq(uint32_t _seq) { th_seq = htonl(_seq); } 515 void flags(uint8_t _flags) { th_flags = _flags; } 516 517 bool options(std::vector<const TcpOpt *> &vec) const; 518 519 int size() const { return off(); } 520 const uint8_t *bytes() const { return (const uint8_t *)this; } 521 const uint8_t *payload() const { return bytes() + size(); } 522 uint8_t *bytes() { return (uint8_t *)this; } 523 uint8_t *payload() { return bytes() + size(); } 524}; 525 526class TcpPtr 527{ 528 protected: 529 EthPacketPtr p; 530 int _off; 531 532 void set(const EthPacketPtr &ptr, int offset) { p = ptr; _off = offset; } 533 void set(const IpPtr &ptr) 534 { 535 if (ptr && ptr->proto() == IP_PROTO_TCP) 536 set(ptr.p, ptr.pstart()); 537 else 538 set(0, 0); 539 } 540 void set(const Ip6Ptr &ptr) 541 { 542 if (ptr && ptr->proto() == IP_PROTO_TCP) 543 set(ptr.p, ptr.pstart()); 544 else 545 set(0, 0); 546 } 547 548 public: 549 TcpPtr() : p(0), _off(0) {} 550 TcpPtr(const IpPtr &ptr) : p(0), _off(0) { set(ptr); } 551 TcpPtr(const Ip6Ptr &ptr) : p(0), _off(0) { set(ptr); } 552 TcpPtr(const TcpPtr &ptr) : p(ptr.p), _off(ptr._off) {} 553 554 TcpHdr *get() { return (TcpHdr *)(p->data + _off); } 555 TcpHdr *operator->() { return get(); } 556 TcpHdr &operator*() { return *get(); } 557 558 const TcpHdr *get() const { return (const TcpHdr *)(p->data + _off); } 559 const TcpHdr *operator->() const { return get(); } 560 const TcpHdr &operator*() const { return *get(); } 561 562 const TcpPtr &operator=(const IpPtr &i) 563 { set(i); return *this; } 564 const TcpPtr &operator=(const TcpPtr &t) 565 { set(t.p, t._off); return *this; } 566 567 const EthPacketPtr packet() const { return p; } 568 EthPacketPtr packet() { return p; } 569 bool operator!() const { return !p; } 570 operator bool() const { return p; } 571 int off() const { return _off; } 572 int pstart() const { return off() + get()->size(); } 573}; 574 575uint16_t cksum(const TcpPtr &ptr); 576 577struct TcpOpt : public tcp_opt 578{ 579 uint8_t type() const { return opt_type; } 580 uint8_t len() const { return TCP_OPT_TYPEONLY(type()) ? 1 : opt_len; } 581 582 bool isopt(int opt) const { return type() == opt; } 583 584 const uint8_t *data() const { return opt_data.data8; } 585 586 uint16_t mss() const { return ntohs(opt_data.mss); } 587 uint8_t wscale() const { return opt_data.wscale; } 588 uint32_t echo() const { return ntohl(opt_data.echo); } 589 uint32_t tsval() const { return ntohl(opt_data.timestamp[0]); } 590 uint32_t tsecr() const { return ntohl(opt_data.timestamp[1]); } 591 uint32_t cc() const { return ntohl(opt_data.cc); } 592 uint8_t cksum() const{ return opt_data.cksum; } 593 const uint8_t *md5() const { return opt_data.md5; } 594 595 int size() const { return len(); } 596 const uint8_t *bytes() const { return (const uint8_t *)this; } 597 const uint8_t *payload() const { return bytes() + size(); } 598 uint8_t *bytes() { return (uint8_t *)this; } 599 uint8_t *payload() { return bytes() + size(); } 600}; 601 602/* 603 * UDP Stuff 604 */ 605struct UdpHdr : public udp_hdr 606{ 607 uint16_t sport() const { return ntohs(uh_sport); } 608 uint16_t dport() const { return ntohs(uh_dport); } 609 uint16_t len() const { return ntohs(uh_ulen); } 610 uint16_t sum() const { return uh_sum; } 611 612 void sum(uint16_t sum) { uh_sum = sum; } 613 void len(uint16_t _len) { uh_ulen = htons(_len); } 614 615 int size() const { return sizeof(udp_hdr); } 616 const uint8_t *bytes() const { return (const uint8_t *)this; } 617 const uint8_t *payload() const { return bytes() + size(); } 618 uint8_t *bytes() { return (uint8_t *)this; } 619 uint8_t *payload() { return bytes() + size(); } 620}; 621 622class UdpPtr 623{ 624 protected: 625 EthPacketPtr p; 626 int _off; 627 628 void set(const EthPacketPtr &ptr, int offset) { p = ptr; _off = offset; } 629 void set(const IpPtr &ptr) 630 { 631 if (ptr && ptr->proto() == IP_PROTO_UDP) 632 set(ptr.p, ptr.pstart()); 633 else 634 set(0, 0); 635 } 636 void set(const Ip6Ptr &ptr) 637 { 638 if (ptr && ptr->proto() == IP_PROTO_UDP) 639 set(ptr.p, ptr.pstart()); 640 else 641 set(0, 0); 642 } 643 644 public: 645 UdpPtr() : p(0), _off(0) {} 646 UdpPtr(const IpPtr &ptr) : p(0), _off(0) { set(ptr); } 647 UdpPtr(const Ip6Ptr &ptr) : p(0), _off(0) { set(ptr); } 648 UdpPtr(const UdpPtr &ptr) : p(ptr.p), _off(ptr._off) {} 649 650 UdpHdr *get() { return (UdpHdr *)(p->data + _off); } 651 UdpHdr *operator->() { return get(); } 652 UdpHdr &operator*() { return *get(); } 653 654 const UdpHdr *get() const { return (const UdpHdr *)(p->data + _off); } 655 const UdpHdr *operator->() const { return get(); } 656 const UdpHdr &operator*() const { return *get(); } 657 658 const UdpPtr &operator=(const IpPtr &i) { set(i); return *this; } 659 const UdpPtr &operator=(const UdpPtr &t) 660 { set(t.p, t._off); return *this; } 661 662 const EthPacketPtr packet() const { return p; } 663 EthPacketPtr packet() { return p; } 664 bool operator!() const { return !p; } 665 operator bool() const { return p; } 666 int off() const { return _off; } 667 int pstart() const { return off() + get()->size(); } 668}; 669 670uint16_t __tu_cksum6(const Ip6Ptr &ip6); 671uint16_t __tu_cksum(const IpPtr &ip); 672uint16_t cksum(const UdpPtr &ptr); 673 674int hsplit(const EthPacketPtr &ptr); 675 676} // namespace Net 677 678#endif // __BASE_INET_HH__
| 108 std::string string() const; 109 110 operator uint64_t() const 111 { 112 uint64_t reg = 0; 113 reg |= ((uint64_t)data[0]) << 40; 114 reg |= ((uint64_t)data[1]) << 32; 115 reg |= ((uint64_t)data[2]) << 24; 116 reg |= ((uint64_t)data[3]) << 16; 117 reg |= ((uint64_t)data[4]) << 8; 118 reg |= ((uint64_t)data[5]) << 0; 119 return reg; 120 } 121 122}; 123 124std::ostream &operator<<(std::ostream &stream, const EthAddr &ea); 125bool operator==(const EthAddr &left, const EthAddr &right); 126 127struct EthHdr : public eth_hdr 128{ 129 bool isVlan() const { return (ntohs(eth_type) == ETH_TYPE_8021Q); } 130 uint16_t type() const { 131 if (!isVlan()) 132 return ntohs(eth_type); 133 else 134 // L3 type is now 16 bytes into the hdr with 802.1Q 135 // instead of 12. dnet/eth.h only supports 802.1 136 return ntohs(*((uint16_t*)(((uint8_t *)this) + 16))); 137 } 138 uint16_t vlanId() const { 139 if (isVlan()) 140 return ntohs(*((uint16_t*)(((uint8_t *)this) + 14))); 141 else 142 return 0x0000; 143 } 144 145 const EthAddr &src() const { return *(EthAddr *)ð_src; } 146 const EthAddr &dst() const { return *(EthAddr *)ð_dst; } 147 148 int size() const { 149 if (!isVlan()) 150 return sizeof(eth_hdr); 151 else 152 return (sizeof(eth_hdr)+4); 153 } 154 155 const uint8_t *bytes() const { return (const uint8_t *)this; } 156 const uint8_t *payload() const { return bytes() + size(); } 157 uint8_t *bytes() { return (uint8_t *)this; } 158 uint8_t *payload() { return bytes() + size(); } 159}; 160 161class EthPtr 162{ 163 protected: 164 friend class IpPtr; 165 friend class Ip6Ptr; 166 EthPacketPtr p; 167 168 public: 169 EthPtr() {} 170 EthPtr(const EthPacketPtr &ptr) : p(ptr) { } 171 172 EthHdr *operator->() { return (EthHdr *)p->data; } 173 EthHdr &operator*() { return *(EthHdr *)p->data; } 174 operator EthHdr *() { return (EthHdr *)p->data; } 175 176 const EthHdr *operator->() const { return (const EthHdr *)p->data; } 177 const EthHdr &operator*() const { return *(const EthHdr *)p->data; } 178 operator const EthHdr *() const { return (const EthHdr *)p->data; } 179 180 const EthPtr &operator=(const EthPacketPtr &ptr) { p = ptr; return *this; } 181 182 const EthPacketPtr packet() const { return p; } 183 EthPacketPtr packet() { return p; } 184 bool operator!() const { return !p; } 185 operator bool() const { return p; } 186 int off() const { return 0; } 187 int pstart() const { return off() + ((const EthHdr*)p->data)->size(); } 188}; 189 190/* 191 * IP Stuff 192 */ 193struct IpAddress 194{ 195 protected: 196 uint32_t _ip; 197 198 public: 199 IpAddress() : _ip(0) 200 {} 201 IpAddress(const uint32_t __ip) : _ip(__ip) 202 {} 203 204 uint32_t ip() const { return _ip; } 205 206 std::string string() const; 207}; 208 209std::ostream &operator<<(std::ostream &stream, const IpAddress &ia); 210bool operator==(const IpAddress &left, const IpAddress &right); 211 212struct IpNetmask : public IpAddress 213{ 214 protected: 215 uint8_t _netmask; 216 217 public: 218 IpNetmask() : IpAddress(), _netmask(0) 219 {} 220 IpNetmask(const uint32_t __ip, const uint8_t __netmask) : 221 IpAddress(__ip), _netmask(__netmask) 222 {} 223 224 uint8_t netmask() const { return _netmask; } 225 226 std::string string() const; 227}; 228 229std::ostream &operator<<(std::ostream &stream, const IpNetmask &in); 230bool operator==(const IpNetmask &left, const IpNetmask &right); 231 232struct IpWithPort : public IpAddress 233{ 234 protected: 235 uint16_t _port; 236 237 public: 238 IpWithPort() : IpAddress(), _port(0) 239 {} 240 IpWithPort(const uint32_t __ip, const uint16_t __port) : 241 IpAddress(__ip), _port(__port) 242 {} 243 244 uint8_t port() const { return _port; } 245 246 std::string string() const; 247}; 248 249std::ostream &operator<<(std::ostream &stream, const IpWithPort &iwp); 250bool operator==(const IpWithPort &left, const IpWithPort &right); 251 252struct IpOpt; 253struct IpHdr : public ip_hdr 254{ 255 uint8_t version() const { return ip_v; } 256 uint8_t hlen() const { return ip_hl * 4; } 257 uint8_t tos() const { return ip_tos; } 258 uint16_t len() const { return ntohs(ip_len); } 259 uint16_t id() const { return ntohs(ip_id); } 260 uint16_t frag_flags() const { return ntohs(ip_off) >> 13; } 261 uint16_t frag_off() const { return ntohs(ip_off) & 0x1fff; } 262 uint8_t ttl() const { return ip_ttl; } 263 uint8_t proto() const { return ip_p; } 264 uint16_t sum() const { return ip_sum; } 265 uint32_t src() const { return ntohl(ip_src); } 266 uint32_t dst() const { return ntohl(ip_dst); } 267 268 void sum(uint16_t sum) { ip_sum = sum; } 269 void id(uint16_t _id) { ip_id = htons(_id); } 270 void len(uint16_t _len) { ip_len = htons(_len); } 271 272 bool options(std::vector<const IpOpt *> &vec) const; 273 274 int size() const { return hlen(); } 275 const uint8_t *bytes() const { return (const uint8_t *)this; } 276 const uint8_t *payload() const { return bytes() + size(); } 277 uint8_t *bytes() { return (uint8_t *)this; } 278 uint8_t *payload() { return bytes() + size(); } 279}; 280 281class IpPtr 282{ 283 protected: 284 friend class TcpPtr; 285 friend class UdpPtr; 286 EthPacketPtr p; 287 bool eth_hdr_vlan; 288 289 void set(const EthPacketPtr &ptr) 290 { 291 p = 0; 292 eth_hdr_vlan = false; 293 294 if (ptr) { 295 EthHdr *eth = (EthHdr *)ptr->data; 296 if (eth->type() == ETH_TYPE_IP) 297 p = ptr; 298 if (eth->isVlan()) 299 eth_hdr_vlan = true; 300 } 301 } 302 303 public: 304 IpPtr() : p(0), eth_hdr_vlan(false) {} 305 IpPtr(const EthPacketPtr &ptr) : p(0), eth_hdr_vlan(false) { set(ptr); } 306 IpPtr(const EthPtr &ptr) : p(0), eth_hdr_vlan(false) { set(ptr.p); } 307 IpPtr(const IpPtr &ptr) : p(ptr.p), eth_hdr_vlan(ptr.eth_hdr_vlan) { } 308 309 IpHdr *get() { return (IpHdr *)(p->data + sizeof(eth_hdr) + 310 ((eth_hdr_vlan) ? 4 : 0)); } 311 IpHdr *operator->() { return get(); } 312 IpHdr &operator*() { return *get(); } 313 314 const IpHdr *get() const 315 { return (const IpHdr *)(p->data + sizeof(eth_hdr) + 316 ((eth_hdr_vlan) ? 4 : 0)); } 317 const IpHdr *operator->() const { return get(); } 318 const IpHdr &operator*() const { return *get(); } 319 320 const IpPtr &operator=(const EthPacketPtr &ptr) { set(ptr); return *this; } 321 const IpPtr &operator=(const EthPtr &ptr) { set(ptr.p); return *this; } 322 const IpPtr &operator=(const IpPtr &ptr) { p = ptr.p; return *this; } 323 324 const EthPacketPtr packet() const { return p; } 325 EthPacketPtr packet() { return p; } 326 bool operator!() const { return !p; } 327 operator bool() const { return p; } 328 int off() const { return (sizeof(eth_hdr) + ((eth_hdr_vlan) ? 4 : 0)); } 329 int pstart() const { return (off() + get()->size()); } 330}; 331 332uint16_t cksum(const IpPtr &ptr); 333 334struct IpOpt : public ip_opt 335{ 336 uint8_t type() const { return opt_type; } 337 uint8_t typeNumber() const { return IP_OPT_NUMBER(opt_type); } 338 uint8_t typeClass() const { return IP_OPT_CLASS(opt_type); } 339 uint8_t typeCopied() const { return IP_OPT_COPIED(opt_type); } 340 uint8_t len() const { return IP_OPT_TYPEONLY(type()) ? 1 : opt_len; } 341 342 bool isNumber(int num) const { return typeNumber() == IP_OPT_NUMBER(num); } 343 bool isClass(int cls) const { return typeClass() == IP_OPT_CLASS(cls); } 344 bool isCopied(int cpy) const { return typeCopied() == IP_OPT_COPIED(cpy); } 345 346 const uint8_t *data() const { return opt_data.data8; } 347 void sec(ip_opt_data_sec &sec) const; 348 void lsrr(ip_opt_data_rr &rr) const; 349 void ssrr(ip_opt_data_rr &rr) const; 350 void ts(ip_opt_data_ts &ts) const; 351 uint16_t satid() const { return ntohs(opt_data.satid); } 352 uint16_t mtup() const { return ntohs(opt_data.mtu); } 353 uint16_t mtur() const { return ntohs(opt_data.mtu); } 354 void tr(ip_opt_data_tr &tr) const; 355 const uint32_t *addext() const { return &opt_data.addext[0]; } 356 uint16_t rtralt() const { return ntohs(opt_data.rtralt); } 357 void sdb(std::vector<uint32_t> &vec) const; 358}; 359 360/* 361 * Ip6 Classes 362 */ 363struct Ip6Opt; 364struct Ip6Hdr : public ip6_hdr 365{ 366 uint8_t version() const { return ip6_vfc; } 367 uint32_t flow() const { return ntohl(ip6_flow); } 368 uint16_t plen() const { return ntohs(ip6_plen); } 369 uint16_t hlen() const { return IP6_HDR_LEN; } 370 uint8_t nxt() const { return ip6_nxt; } 371 uint8_t hlim() const { return ip6_hlim; } 372 373 const uint8_t* src() const { return ip6_src.data; } 374 const uint8_t* dst() const { return ip6_dst.data; } 375 376 int extensionLength() const; 377 const Ip6Opt* getExt(uint8_t ext) const; 378 const Ip6Opt* fragmentExt() const { return getExt(IP_PROTO_FRAGMENT); } 379 const Ip6Opt* rtTypeExt() const { return getExt(IP_PROTO_ROUTING); } 380 const Ip6Opt* dstOptExt() const { return getExt(IP_PROTO_DSTOPTS); } 381 uint8_t proto() const; 382 383 void plen(uint16_t _plen) { ip6_plen = htons(_plen); } 384 385 int size() const { return IP6_HDR_LEN + extensionLength(); } 386 const uint8_t *bytes() const { return (const uint8_t *)this; } 387 const uint8_t *payload() const { return bytes() + IP6_HDR_LEN 388 + extensionLength(); } 389 uint8_t *bytes() { return (uint8_t *)this; } 390 uint8_t *payload() { return bytes() + IP6_HDR_LEN 391 + extensionLength(); } 392}; 393 394class Ip6Ptr 395{ 396 protected: 397 friend class TcpPtr; 398 friend class UdpPtr; 399 EthPacketPtr p; 400 bool eth_hdr_vlan; 401 402 void set(const EthPacketPtr &ptr) 403 { 404 p = 0; 405 eth_hdr_vlan = false; 406 407 if (ptr) { 408 EthHdr *eth = (EthHdr *)ptr->data; 409 if (eth->type() == ETH_TYPE_IPV6) 410 p = ptr; 411 if (eth->isVlan()) 412 eth_hdr_vlan = true; 413 } 414 } 415 416 public: 417 Ip6Ptr() : p(0), eth_hdr_vlan(false) {} 418 Ip6Ptr(const EthPacketPtr &ptr) : p(0), eth_hdr_vlan(false) { set(ptr); } 419 Ip6Ptr(const EthPtr &ptr) : p(0), eth_hdr_vlan(false) { set(ptr.p); } 420 Ip6Ptr(const Ip6Ptr &ptr) : p(ptr.p), eth_hdr_vlan(ptr.eth_hdr_vlan) { } 421 422 Ip6Hdr *get() { return (Ip6Hdr *)(p->data + sizeof(eth_hdr) 423 + ((eth_hdr_vlan) ? 4 : 0)); } 424 Ip6Hdr *operator->() { return get(); } 425 Ip6Hdr &operator*() { return *get(); } 426 427 const Ip6Hdr *get() const 428 { return (const Ip6Hdr *)(p->data + sizeof(eth_hdr) 429 + ((eth_hdr_vlan) ? 4 : 0)); } 430 const Ip6Hdr *operator->() const { return get(); } 431 const Ip6Hdr &operator*() const { return *get(); } 432 433 const Ip6Ptr &operator=(const EthPacketPtr &ptr) 434 { set(ptr); return *this; } 435 const Ip6Ptr &operator=(const EthPtr &ptr) 436 { set(ptr.p); return *this; } 437 const Ip6Ptr &operator=(const Ip6Ptr &ptr) 438 { p = ptr.p; return *this; } 439 440 const EthPacketPtr packet() const { return p; } 441 EthPacketPtr packet() { return p; } 442 bool operator!() const { return !p; } 443 operator bool() const { return p; } 444 int off() const { return sizeof(eth_hdr) + ((eth_hdr_vlan) ? 4 : 0); } 445 int pstart() const { return off() + get()->size(); } 446}; 447 448// Dnet supplied ipv6 opt header is incomplete and 449// newer NIC card filters expect a more robust 450// ipv6 header option declaration. 451struct ip6_opt_fragment { 452 uint16_t offlg; 453 uint32_t ident; 454}; 455 456struct ip6_opt_routing_type2 { 457 uint8_t type; 458 uint8_t segleft; 459 uint32_t reserved; 460 ip6_addr_t addr; 461}; 462 463#define HOME_ADDRESS_OPTION 0xC9 464struct ip6_opt_dstopts { 465 uint8_t type; 466 uint8_t length; 467 ip6_addr_t addr; 468} __attribute__((packed)); 469 470struct ip6_opt_hdr 471{ 472 uint8_t ext_nxt; 473 uint8_t ext_len; 474 union { 475 struct ip6_opt_fragment fragment; 476 struct ip6_opt_routing_type2 rtType2; 477 struct ip6_opt_dstopts dstOpts; 478 } ext_data; 479} __attribute__((packed)); 480 481struct Ip6Opt : public ip6_opt_hdr 482{ 483 uint8_t nxt() const { return ext_nxt; } 484 uint8_t extlen() const { return ext_len; } 485 uint8_t len() const { return extlen() + 8; } 486 487 // Supporting the types of header extensions likely to be encountered: 488 // fragment, routing type 2 and dstopts. 489 490 // Routing type 2 491 uint8_t rtType2Type() const { return ext_data.rtType2.type; } 492 uint8_t rtType2SegLft() const { return ext_data.rtType2.segleft; } 493 const uint8_t* rtType2Addr() const { return ext_data.rtType2.addr.data; } 494 495 // Fragment 496 uint16_t fragmentOfflg() const { return ntohs(ext_data.fragment.offlg); } 497 uint32_t fragmentIdent() const { return ntohl(ext_data.fragment.ident); } 498 499 // Dst Options/Home Address Option 500 uint8_t dstOptType() const { return ext_data.dstOpts.type; } 501 uint8_t dstOptLength() const { return ext_data.dstOpts.length; } 502 const uint8_t* dstOptAddr() const { return ext_data.dstOpts.addr.data; } 503}; 504 505 506/* 507 * TCP Stuff 508 */ 509struct TcpOpt; 510struct TcpHdr : public tcp_hdr 511{ 512 uint16_t sport() const { return ntohs(th_sport); } 513 uint16_t dport() const { return ntohs(th_dport); } 514 uint32_t seq() const { return ntohl(th_seq); } 515 uint32_t ack() const { return ntohl(th_ack); } 516 uint8_t off() const { return th_off*4; } 517 uint8_t flags() const { return th_flags & 0x3f; } 518 uint16_t win() const { return ntohs(th_win); } 519 uint16_t sum() const { return th_sum; } 520 uint16_t urp() const { return ntohs(th_urp); } 521 522 void sum(uint16_t sum) { th_sum = sum; } 523 void seq(uint32_t _seq) { th_seq = htonl(_seq); } 524 void flags(uint8_t _flags) { th_flags = _flags; } 525 526 bool options(std::vector<const TcpOpt *> &vec) const; 527 528 int size() const { return off(); } 529 const uint8_t *bytes() const { return (const uint8_t *)this; } 530 const uint8_t *payload() const { return bytes() + size(); } 531 uint8_t *bytes() { return (uint8_t *)this; } 532 uint8_t *payload() { return bytes() + size(); } 533}; 534 535class TcpPtr 536{ 537 protected: 538 EthPacketPtr p; 539 int _off; 540 541 void set(const EthPacketPtr &ptr, int offset) { p = ptr; _off = offset; } 542 void set(const IpPtr &ptr) 543 { 544 if (ptr && ptr->proto() == IP_PROTO_TCP) 545 set(ptr.p, ptr.pstart()); 546 else 547 set(0, 0); 548 } 549 void set(const Ip6Ptr &ptr) 550 { 551 if (ptr && ptr->proto() == IP_PROTO_TCP) 552 set(ptr.p, ptr.pstart()); 553 else 554 set(0, 0); 555 } 556 557 public: 558 TcpPtr() : p(0), _off(0) {} 559 TcpPtr(const IpPtr &ptr) : p(0), _off(0) { set(ptr); } 560 TcpPtr(const Ip6Ptr &ptr) : p(0), _off(0) { set(ptr); } 561 TcpPtr(const TcpPtr &ptr) : p(ptr.p), _off(ptr._off) {} 562 563 TcpHdr *get() { return (TcpHdr *)(p->data + _off); } 564 TcpHdr *operator->() { return get(); } 565 TcpHdr &operator*() { return *get(); } 566 567 const TcpHdr *get() const { return (const TcpHdr *)(p->data + _off); } 568 const TcpHdr *operator->() const { return get(); } 569 const TcpHdr &operator*() const { return *get(); } 570 571 const TcpPtr &operator=(const IpPtr &i) 572 { set(i); return *this; } 573 const TcpPtr &operator=(const TcpPtr &t) 574 { set(t.p, t._off); return *this; } 575 576 const EthPacketPtr packet() const { return p; } 577 EthPacketPtr packet() { return p; } 578 bool operator!() const { return !p; } 579 operator bool() const { return p; } 580 int off() const { return _off; } 581 int pstart() const { return off() + get()->size(); } 582}; 583 584uint16_t cksum(const TcpPtr &ptr); 585 586struct TcpOpt : public tcp_opt 587{ 588 uint8_t type() const { return opt_type; } 589 uint8_t len() const { return TCP_OPT_TYPEONLY(type()) ? 1 : opt_len; } 590 591 bool isopt(int opt) const { return type() == opt; } 592 593 const uint8_t *data() const { return opt_data.data8; } 594 595 uint16_t mss() const { return ntohs(opt_data.mss); } 596 uint8_t wscale() const { return opt_data.wscale; } 597 uint32_t echo() const { return ntohl(opt_data.echo); } 598 uint32_t tsval() const { return ntohl(opt_data.timestamp[0]); } 599 uint32_t tsecr() const { return ntohl(opt_data.timestamp[1]); } 600 uint32_t cc() const { return ntohl(opt_data.cc); } 601 uint8_t cksum() const{ return opt_data.cksum; } 602 const uint8_t *md5() const { return opt_data.md5; } 603 604 int size() const { return len(); } 605 const uint8_t *bytes() const { return (const uint8_t *)this; } 606 const uint8_t *payload() const { return bytes() + size(); } 607 uint8_t *bytes() { return (uint8_t *)this; } 608 uint8_t *payload() { return bytes() + size(); } 609}; 610 611/* 612 * UDP Stuff 613 */ 614struct UdpHdr : public udp_hdr 615{ 616 uint16_t sport() const { return ntohs(uh_sport); } 617 uint16_t dport() const { return ntohs(uh_dport); } 618 uint16_t len() const { return ntohs(uh_ulen); } 619 uint16_t sum() const { return uh_sum; } 620 621 void sum(uint16_t sum) { uh_sum = sum; } 622 void len(uint16_t _len) { uh_ulen = htons(_len); } 623 624 int size() const { return sizeof(udp_hdr); } 625 const uint8_t *bytes() const { return (const uint8_t *)this; } 626 const uint8_t *payload() const { return bytes() + size(); } 627 uint8_t *bytes() { return (uint8_t *)this; } 628 uint8_t *payload() { return bytes() + size(); } 629}; 630 631class UdpPtr 632{ 633 protected: 634 EthPacketPtr p; 635 int _off; 636 637 void set(const EthPacketPtr &ptr, int offset) { p = ptr; _off = offset; } 638 void set(const IpPtr &ptr) 639 { 640 if (ptr && ptr->proto() == IP_PROTO_UDP) 641 set(ptr.p, ptr.pstart()); 642 else 643 set(0, 0); 644 } 645 void set(const Ip6Ptr &ptr) 646 { 647 if (ptr && ptr->proto() == IP_PROTO_UDP) 648 set(ptr.p, ptr.pstart()); 649 else 650 set(0, 0); 651 } 652 653 public: 654 UdpPtr() : p(0), _off(0) {} 655 UdpPtr(const IpPtr &ptr) : p(0), _off(0) { set(ptr); } 656 UdpPtr(const Ip6Ptr &ptr) : p(0), _off(0) { set(ptr); } 657 UdpPtr(const UdpPtr &ptr) : p(ptr.p), _off(ptr._off) {} 658 659 UdpHdr *get() { return (UdpHdr *)(p->data + _off); } 660 UdpHdr *operator->() { return get(); } 661 UdpHdr &operator*() { return *get(); } 662 663 const UdpHdr *get() const { return (const UdpHdr *)(p->data + _off); } 664 const UdpHdr *operator->() const { return get(); } 665 const UdpHdr &operator*() const { return *get(); } 666 667 const UdpPtr &operator=(const IpPtr &i) { set(i); return *this; } 668 const UdpPtr &operator=(const UdpPtr &t) 669 { set(t.p, t._off); return *this; } 670 671 const EthPacketPtr packet() const { return p; } 672 EthPacketPtr packet() { return p; } 673 bool operator!() const { return !p; } 674 operator bool() const { return p; } 675 int off() const { return _off; } 676 int pstart() const { return off() + get()->size(); } 677}; 678 679uint16_t __tu_cksum6(const Ip6Ptr &ip6); 680uint16_t __tu_cksum(const IpPtr &ip); 681uint16_t cksum(const UdpPtr &ptr); 682 683int hsplit(const EthPacketPtr &ptr); 684 685} // namespace Net 686 687#endif // __BASE_INET_HH__
|