---
title: llarp/net/net.hpp

---

# llarp/net/net.hpp



## Namespaces

| Name           |
| -------------- |
| **[llarp](Namespaces/namespacellarp.md)** <br>[crypto.hpp] |
| **[llarp::net](Namespaces/namespacellarp_1_1net.md)**  |

## Classes

|                | Name           |
| -------------- | -------------- |
| class | **[llarp::net::Platform](Classes/classllarp_1_1net_1_1Platform.md)** <br>network platform (all methods virtual so it can be mocked by unit tests)  |

## Functions

|                | Name           |
| -------------- | -------------- |
| bool | **[operator==](Files/net_8hpp.md#function-operator==)**(const sockaddr & a, const sockaddr & b) |
| bool | **[operator==](Files/net_8hpp.md#function-operator==)**(const sockaddr_in & a, const sockaddr_in & b) |
| bool | **[operator==](Files/net_8hpp.md#function-operator==)**(const sockaddr_in6 & a, const sockaddr_in6 & b) |
| bool | **[operator<](Files/net_8hpp.md#function-operator<)**(const sockaddr_in6 & a, const sockaddr_in6 & b) |
| bool | **[operator<](Files/net_8hpp.md#function-operator<)**(const in6_addr & a, const in6_addr & b) |
| bool | **[operator==](Files/net_8hpp.md#function-operator==)**(const in6_addr & a, const in6_addr & b) |


## Functions Documentation

### function operator==

```cpp
bool operator==(
    const sockaddr & a,
    const sockaddr & b
)
```


### function operator==

```cpp
bool operator==(
    const sockaddr_in & a,
    const sockaddr_in & b
)
```


### function operator==

```cpp
bool operator==(
    const sockaddr_in6 & a,
    const sockaddr_in6 & b
)
```


### function operator<

```cpp
bool operator<(
    const sockaddr_in6 & a,
    const sockaddr_in6 & b
)
```


### function operator<

```cpp
bool operator<(
    const in6_addr & a,
    const in6_addr & b
)
```


### function operator==

```cpp
bool operator==(
    const in6_addr & a,
    const in6_addr & b
)
```




## Source code

```cpp
#pragma once

#include "uint128.hpp"
#include "address_info.hpp"
#include "ip_address.hpp"
#include "net_int.hpp"
#include "net.h"
#include "ip_range.hpp"
#include <llarp/util/mem.hpp>
#include <llarp/util/bits.hpp>

#include <functional>
#include <cstdlib>  // for itoa
#include <vector>

// for addrinfo
#ifndef _WIN32
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#else
#include <winsock2.h>
#include <ws2tcpip.h>
#include <wspiapi.h>
#define inet_aton(x, y) inet_pton(AF_INET, x, y)
#endif

#ifndef _WIN32
#include <arpa/inet.h>
#endif

bool
operator==(const sockaddr& a, const sockaddr& b);

bool
operator==(const sockaddr_in& a, const sockaddr_in& b);

bool
operator==(const sockaddr_in6& a, const sockaddr_in6& b);

bool
operator<(const sockaddr_in6& a, const sockaddr_in6& b);

bool
operator<(const in6_addr& a, const in6_addr& b);

bool
operator==(const in6_addr& a, const in6_addr& b);

namespace llarp
{
  bool
  IsIPv4Bogon(const huint32_t& addr);

  inline bool
  IsIPv4Bogon(const nuint32_t& addr)
  {
    return IsIPv4Bogon(ToHost(addr));
  }

  bool
  IsBogon(const in6_addr& addr);

  bool
  IsBogon(const huint128_t addr);

  bool
  IsBogonRange(const in6_addr& host, const in6_addr& mask);

  namespace net
  {
    class Platform
    {
     public:
      Platform() = default;
      virtual ~Platform() = default;
      Platform(const Platform&) = delete;
      Platform(Platform&&) = delete;

      static const Platform*
      Default_ptr();

      virtual std::optional<SockAddr>
      AllInterfaces(SockAddr pubaddr) const = 0;

      virtual SockAddr
      Wildcard(int af = AF_INET) const = 0;

      inline SockAddr
      WildcardWithPort(port_t port, int af = AF_INET) const
      {
        auto addr = Wildcard(af);
        addr.setPort(port);
        return addr;
      }

      virtual std::string
      LoopbackInterfaceName() const = 0;

      virtual bool
      HasInterfaceAddress(ipaddr_t ip) const = 0;

      virtual bool
      IsLoopbackAddress(ipaddr_t ip) const = 0;

      virtual bool
      IsWildcardAddress(ipaddr_t ip) const = 0;

      virtual std::optional<std::string>
      GetBestNetIF(int af = AF_INET) const = 0;

      inline std::optional<SockAddr>
      MaybeInferPublicAddr(port_t default_port, int af = AF_INET) const
      {
        std::optional<SockAddr> maybe_addr;
        if (auto maybe_ifname = GetBestNetIF(af))
          maybe_addr = GetInterfaceAddr(*maybe_ifname, af);

        if (maybe_addr)
          maybe_addr->setPort(default_port);
        return maybe_addr;
      }

      virtual std::optional<IPRange>
      FindFreeRange() const = 0;

      virtual std::optional<std::string>
      FindFreeTun() const = 0;

      virtual std::optional<SockAddr>
      GetInterfaceAddr(std::string_view ifname, int af = AF_INET) const = 0;

      inline std::optional<huint128_t>
      GetInterfaceIPv6Address(std::string_view ifname) const
      {
        if (auto maybe_addr = GetInterfaceAddr(ifname, AF_INET6))
          return maybe_addr->asIPv6();
        return std::nullopt;
      }

      virtual bool
      IsBogon(const SockAddr& addr) const = 0;

      virtual std::optional<int>
      GetInterfaceIndex(ipaddr_t ip) const = 0;
    };

  }  // namespace net

}  // namespace llarp
```


-------------------------------

Updated on 2022-08-30 at 18:09:28 +0000
