inet.hh revision 11320
12SN/A/* 22188SN/A * Copyright (c) 2013 ARM Limited 32SN/A * All rights reserved 42SN/A * 52SN/A * The license below extends only to copyright in the software and shall 62SN/A * not be construed as granting a license to any other intellectual 72SN/A * property including but not limited to intellectual property relating 82SN/A * to a hardware implementation of the functionality of the software 92SN/A * licensed hereunder. You may use the software subject to the license 102SN/A * terms below provided that you ensure that this notice is replicated 112SN/A * unmodified and in its entirety in all distributions of the software, 122SN/A * modified or unmodified, in source code or in binary form. 132SN/A * 142SN/A * Copyright (c) 2002-2005 The Regents of The University of Michigan 152SN/A * Copyright (c) 2010 Advanced Micro Devices, Inc. 162SN/A * All rights reserved. 172SN/A * 182SN/A * Redistribution and use in source and binary forms, with or without 192SN/A * modification, are permitted provided that the following conditions are 202SN/A * met: redistributions of source code must retain the above copyright 212SN/A * notice, this list of conditions and the following disclaimer; 222SN/A * redistributions in binary form must reproduce the above copyright 232SN/A * notice, this list of conditions and the following disclaimer in the 242SN/A * documentation and/or other materials provided with the distribution; 252SN/A * neither the name of the copyright holders nor the names of its 262SN/A * contributors may be used to endorse or promote products derived from 272665SN/A * this software without specific prior written permission. 282665SN/A * 292665SN/A * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 302665SN/A * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 312665SN/A * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 322SN/A * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 332SN/A * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 342SN/A * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 352SN/A * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 362465SN/A * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 373565Sgblack@eecs.umich.edu * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 385529Snate@binkert.org * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 398777Sgblack@eecs.umich.edu * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 401917SN/A * 411070SN/A * Authors: Nathan Binkert 421917SN/A * Steve Reinhardt 432188SN/A * Gabe Black 448777Sgblack@eecs.umich.edu * Geoffrey Blake 458777Sgblack@eecs.umich.edu */ 461917SN/A 472290SN/A#ifndef __BASE_INET_HH__ 488777Sgblack@eecs.umich.edu#define __BASE_INET_HH__ 498777Sgblack@eecs.umich.edu 508706Sandreas.hansson@arm.com#include <iosfwd> 518799Sgblack@eecs.umich.edu#include <string> 528809Sgblack@eecs.umich.edu#include <utility> 538793Sgblack@eecs.umich.edu#include <vector> 548777Sgblack@eecs.umich.edu 551070SN/A#include "base/types.hh" 561917SN/A#include "dev/net/etherpkt.hh" 572519SN/A#include "dnet/os.h" 582SN/A#include "dnet/eth.h" 592SN/A#include "dnet/ip.h" 602SN/A#include "dnet/ip6.h" 612SN/A#include "dnet/addr.h" 628820Sgblack@eecs.umich.edu#include "dnet/arp.h" 638820Sgblack@eecs.umich.edu#include "dnet/icmp.h" 649384SAndreas.Sandberg@arm.com#include "dnet/tcp.h" 659384SAndreas.Sandberg@arm.com#include "dnet/udp.h" 669384SAndreas.Sandberg@arm.com#include "dnet/intf.h" 678766Sgblack@eecs.umich.edu#include "dnet/route.h" 688766Sgblack@eecs.umich.edu#include "dnet/fw.h" 698766Sgblack@eecs.umich.edu#include "dnet/blob.h" 708766Sgblack@eecs.umich.edu#include "dnet/rand.h" 719377Sgblack@eecs.umich.edu 722683Sktlim@umich.edunamespace Net { 736022Sgblack@eecs.umich.edu 749384SAndreas.Sandberg@arm.com/* 759384SAndreas.Sandberg@arm.com * Ethernet Stuff 769384SAndreas.Sandberg@arm.com */ 772SN/Astruct EthAddr : protected eth_addr 782683Sktlim@umich.edu{ 792190SN/A protected: 802680SN/A void parse(const std::string &addr); 812290SN/A 826316Sgblack@eecs.umich.edu public: 831917SN/A EthAddr(); 848735Sandreas.hanson@arm.com EthAddr(const uint8_t ea[ETH_ADDR_LEN]); 851982SN/A EthAddr(const eth_addr &ea); 861917SN/A EthAddr(const std::string &addr); 872683Sktlim@umich.edu const EthAddr &operator=(const eth_addr &ea); 882683Sktlim@umich.edu const EthAddr &operator=(const std::string &addr); 891917SN/A 901917SN/A int size() const { return sizeof(eth_addr); } 911917SN/A 921917SN/A const uint8_t *bytes() const { return &data[0]; } 931917SN/A uint8_t *bytes() { return &data[0]; } 941917SN/A 951917SN/A const uint8_t *addr() const { return &data[0]; } 961917SN/A bool unicast() const { return !(data[0] & 0x01); } 972521SN/A bool multicast() const { return !unicast() && !broadcast(); } 985482Snate@binkert.org bool broadcast() const 993548Sgblack@eecs.umich.edu { 1002SN/A bool isBroadcast = true; 1012862Sktlim@umich.edu for (int i = 0; i < ETH_ADDR_LEN; ++i) { 1022683Sktlim@umich.edu isBroadcast = isBroadcast && data[i] == 0xff; 1031070SN/A } 1042680SN/A 1051070SN/A return isBroadcast; 1061070SN/A } 1071917SN/A 1082683Sktlim@umich.edu std::string string() const; 109180SN/A 110180SN/A operator uint64_t() const 1118793Sgblack@eecs.umich.edu { 1128793Sgblack@eecs.umich.edu uint64_t reg = 0; 1132235SN/A reg |= ((uint64_t)data[0]) << 40; 114180SN/A reg |= ((uint64_t)data[1]) << 32; 1152862Sktlim@umich.edu reg |= ((uint64_t)data[2]) << 24; 1168793Sgblack@eecs.umich.edu reg |= ((uint64_t)data[3]) << 16; 1178793Sgblack@eecs.umich.edu reg |= ((uint64_t)data[4]) << 8; 1188793Sgblack@eecs.umich.edu reg |= ((uint64_t)data[5]) << 0; 1198793Sgblack@eecs.umich.edu return reg; 1208793Sgblack@eecs.umich.edu } 1218793Sgblack@eecs.umich.edu 1228793Sgblack@eecs.umich.edu}; 1238793Sgblack@eecs.umich.edu 1248793Sgblack@eecs.umich.edustd::ostream &operator<<(std::ostream &stream, const EthAddr &ea); 1258793Sgblack@eecs.umich.edubool operator==(const EthAddr &left, const EthAddr &right); 1268793Sgblack@eecs.umich.edu 1278793Sgblack@eecs.umich.edustruct EthHdr : public eth_hdr 1288793Sgblack@eecs.umich.edu{ 1298793Sgblack@eecs.umich.edu bool isVlan() const { return (ntohs(eth_type) == ETH_TYPE_8021Q); } 1308793Sgblack@eecs.umich.edu uint16_t type() const { 1312313SN/A if (!isVlan()) 132180SN/A return ntohs(eth_type); 133180SN/A else 134180SN/A // L3 type is now 16 bytes into the hdr with 802.1Q 1356029Ssteve.reinhardt@amd.com // instead of 12. dnet/eth.h only supports 802.1 136180SN/A return ntohs(*((uint16_t*)(((uint8_t *)this) + 16))); 137180SN/A } 1382SN/A uint16_t vlanId() const { 1392864Sktlim@umich.edu if (isVlan()) 1402864Sktlim@umich.edu return ntohs(*((uint16_t*)(((uint8_t *)this) + 14))); 1412864Sktlim@umich.edu else 1422864Sktlim@umich.edu return 0x0000; 1438793Sgblack@eecs.umich.edu } 1448793Sgblack@eecs.umich.edu 1458793Sgblack@eecs.umich.edu const EthAddr &src() const { return *(EthAddr *)ð_src; } 1468793Sgblack@eecs.umich.edu const EthAddr &dst() const { return *(EthAddr *)ð_dst; } 1478793Sgblack@eecs.umich.edu 1488793Sgblack@eecs.umich.edu int size() const { 1498793Sgblack@eecs.umich.edu if (!isVlan()) 1508793Sgblack@eecs.umich.edu return sizeof(eth_hdr); 1518793Sgblack@eecs.umich.edu else 1522864Sktlim@umich.edu return (sizeof(eth_hdr)+4); 1532864Sktlim@umich.edu } 1542864Sktlim@umich.edu 1552864Sktlim@umich.edu const uint8_t *bytes() const { return (const uint8_t *)this; } 1562862Sktlim@umich.edu const uint8_t *payload() const { return bytes() + size(); } 1572862Sktlim@umich.edu uint8_t *bytes() { return (uint8_t *)this; } 1582862Sktlim@umich.edu uint8_t *payload() { return bytes() + size(); } 1592862Sktlim@umich.edu}; 1602862Sktlim@umich.edu 1618793Sgblack@eecs.umich.educlass EthPtr 1628793Sgblack@eecs.umich.edu{ 1635714Shsul@eecs.umich.edu protected: 1645715Shsul@eecs.umich.edu friend class IpPtr; 1655714Shsul@eecs.umich.edu friend class Ip6Ptr; 1662862Sktlim@umich.edu EthPacketPtr p; 1672862Sktlim@umich.edu 1682862Sktlim@umich.edu public: 1692683Sktlim@umich.edu EthPtr() {} 170217SN/A EthPtr(const EthPacketPtr &ptr) : p(ptr) { } 1712862Sktlim@umich.edu 1729428SAndreas.Sandberg@ARM.com EthHdr *operator->() { return (EthHdr *)p->data; } 173217SN/A EthHdr &operator*() { return *(EthHdr *)p->data; } 174217SN/A operator EthHdr *() { return (EthHdr *)p->data; } 175217SN/A 176217SN/A const EthHdr *operator->() const { return (const EthHdr *)p->data; } 1772683Sktlim@umich.edu const EthHdr &operator*() const { return *(const EthHdr *)p->data; } 178217SN/A operator const EthHdr *() const { return (const EthHdr *)p->data; } 1792862Sktlim@umich.edu 1809428SAndreas.Sandberg@ARM.com const EthPtr &operator=(const EthPacketPtr &ptr) { p = ptr; return *this; } 181217SN/A 182217SN/A const EthPacketPtr packet() const { return p; } 1832683Sktlim@umich.edu EthPacketPtr packet() { return p; } 1842683Sktlim@umich.edu bool operator!() const { return !p; } 1852683Sktlim@umich.edu operator bool() const { return (p != nullptr); } 1868735Sandreas.hanson@arm.com int off() const { return 0; } 1878735Sandreas.hanson@arm.com int pstart() const { return off() + ((const EthHdr*)p->data)->size(); } 1882683Sktlim@umich.edu}; 1892683Sktlim@umich.edu 190217SN/A/* 191217SN/A * IP Stuff 1929180Sandreas.hansson@arm.com */ 1932SN/Astruct IpAddress 1942680SN/A{ 1952SN/A protected: 1962SN/A uint32_t _ip; 1977823Ssteve.reinhardt@amd.com 1982188SN/A public: 1994400Srdreslin@umich.edu IpAddress() : _ip(0) 2005715Shsul@eecs.umich.edu {} 2015543Ssaidi@eecs.umich.edu IpAddress(const uint32_t __ip) : _ip(__ip) 2024400Srdreslin@umich.edu {} 2032290SN/A 2042680SN/A uint32_t ip() const { return _ip; } 2052290SN/A 2062290SN/A std::string string() const; 2078735Sandreas.hanson@arm.com}; 208393SN/A 209393SN/Astd::ostream &operator<<(std::ostream &stream, const IpAddress &ia); 210393SN/Abool operator==(const IpAddress &left, const IpAddress &right); 2112683Sktlim@umich.edu 212393SN/Astruct IpNetmask : public IpAddress 2132680SN/A{ 214393SN/A protected: 215393SN/A uint8_t _netmask; 2167823Ssteve.reinhardt@amd.com 2177823Ssteve.reinhardt@amd.com public: 2182680SN/A IpNetmask() : IpAddress(), _netmask(0) 2198735Sandreas.hanson@arm.com {} 2202SN/A IpNetmask(const uint32_t __ip, const uint8_t __netmask) : 2212SN/A IpAddress(__ip), _netmask(__netmask) 222393SN/A {} 223393SN/A 2242683Sktlim@umich.edu uint8_t netmask() const { return _netmask; } 225393SN/A 2262680SN/A std::string string() const; 227393SN/A}; 228393SN/A 2292680SN/Astd::ostream &operator<<(std::ostream &stream, const IpNetmask &in); 2308735Sandreas.hanson@arm.combool operator==(const IpNetmask &left, const IpNetmask &right); 231393SN/A 232393SN/Astruct IpWithPort : public IpAddress 233393SN/A{ 234393SN/A protected: 2352683Sktlim@umich.edu uint16_t _port; 2362SN/A 2378793Sgblack@eecs.umich.edu public: 2382341SN/A IpWithPort() : IpAddress(), _port(0) 2392SN/A {} 240716SN/A IpWithPort(const uint32_t __ip, const uint16_t __port) : 241716SN/A IpAddress(__ip), _port(__port) 2422683Sktlim@umich.edu {} 2432190SN/A 2442680SN/A uint8_t port() const { return _port; } 2452190SN/A 2462190SN/A 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 != nullptr); } 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 != nullptr); } 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 != nullptr); } 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 != nullptr); } 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__ 688