#pragma once

#include <sys/types.h>

#include <array>

#include <cstdint>

#include <string>

#include "envoy/common/platform.h"

#include "envoy/network/address.h"

#include "envoy/network/socket.h"

#include "source/common/common/assert.h"

#include "source/common/common/cleanup.h"

#include "source/common/common/statusor.h"

namespace Envoy {

namespace Network {

namespace Address {

/**

 * Check whether we are a) on Android or an Apple platform and b) configured via runtime to always

 * use v6 sockets.

 * This appears to be what Android OS does for all platform sockets.

 */

bool forceV6();

/**

 * Convert an address in the form of the socket address struct defined by Posix, Linux, etc. into

 * a Network::Address::Instance and return a pointer to it. Raises an EnvoyException on failure.

 * @param ss a valid address with family AF_INET, AF_INET6 or AF_UNIX.

 * @param len length of the address (e.g. from accept, getsockname or getpeername). If len > 0,

 *        it is used to validate the structure contents; else if len == 0, it is ignored.

 * @param v6only disable IPv4-IPv6 mapping for IPv6 addresses?

 * @return InstanceConstSharedPtr the address.

 */

StatusOr<InstanceConstSharedPtr> addressFromSockAddr(const sockaddr_storage& ss, socklen_t len,

                                                     bool v6only = true);

/**

 * Convert an address in the form of the socket address struct defined by Posix, Linux, etc. into

 * a Network::Address::Instance and return a pointer to it. Die on failure.

 * @param ss a valid address with family AF_INET, AF_INET6 or AF_UNIX.

 * @param len length of the address (e.g. from accept, getsockname or getpeername). If len > 0,

 *        it is used to validate the structure contents; else if len == 0, it is ignored.

 * @param fd the file descriptor for the created address instance.

 * @param v6only disable IPv4-IPv6 mapping for IPv6 addresses?

 * @return InstanceConstSharedPtr the address.

 */

InstanceConstSharedPtr addressFromSockAddrOrDie(const sockaddr_storage& ss, socklen_t ss_len,

                                                os_fd_t fd, bool v6only = true);

/**

 * Base class for all address types.

 */

class InstanceBase : public Instance {

public:

  // Network::Address::Instance

  // Default logical name is the human-readable name.

protected:

  InstanceBase(Type type, const SocketInterface* sock_interface)

  std::string friendly_name_;

  const SocketInterface& socket_interface_;

private:

  const Type type_;

};

// Create an address instance. Upon failure, return an error status without throwing.

class InstanceFactory {

public:

  template <typename InstanceType, typename... Args>

    // Use new instead of make_shared here because the instance constructors are private and must

    // be called directly here.

};

/**

 * Implementation of an IPv4 address.

 */

class Ipv4Instance : public InstanceBase {

public:

  /**

   * Construct from an existing unix IPv4 socket address (IP v4 address and port).

   */

  explicit Ipv4Instance(const sockaddr_in* address, const SocketInterface* sock_interface = nullptr,

                        absl::optional<std::string> network_namespace = absl::nullopt);

  /**

   * Construct from a string IPv4 address such as "1.2.3.4". Port will be unset/0.

   */

  explicit Ipv4Instance(const std::string& address, const SocketInterface* sock_interface = nullptr,

                        absl::optional<std::string> network_namespace = absl::nullopt);

  /**

   * Construct from a string IPv4 address such as "1.2.3.4" as well as a port.

   */

  Ipv4Instance(const std::string& address, uint32_t port,

               const SocketInterface* sock_interface = nullptr,

               absl::optional<std::string> network_namespace = absl::nullopt);

  /**

   * Construct from a port. The IPv4 address will be set to "any" and is suitable for binding

   * a port to any available address.

   */

  explicit Ipv4Instance(uint32_t port, const SocketInterface* sock_interface = nullptr,

                        absl::optional<std::string> network_namespace = absl::nullopt);

  /**

   * Copy and override the network namespace.

   */

  explicit Ipv4Instance(const Ipv4Instance& that,

                        const absl::optional<std::string>& network_namespace);

  // Network::Address::Instance

  bool operator==(const Instance& rhs) const override;

  /**

   * Convenience function to convert an IPv4 address to canonical string format.

   * @note This works similarly to inet_ntop() but is faster.

   * @param addr address to format.

   * @return the address in dotted-decimal string format.

   */

  static std::string sockaddrToString(const sockaddr_in& addr);

  // Validate that IPv4 is supported on this platform, raise an exception for the

  // given address if not.

  static absl::Status validateProtocolSupported();

  /**

   * For use in tests only.

   * Force validateProtocolSupported() to return false for IPv4.

   */

  static Envoy::Cleanup forceProtocolUnsupportedForTest(bool new_val);

private:

  /**

   * Construct from an existing unix IPv4 socket address (IP v4 address and port).

   * Store the status code in passed in parameter instead of throwing.

   * It is called by the factory method and the partially constructed instance will be discarded

   * upon error.

   */

  explicit Ipv4Instance(absl::Status& error, const sockaddr_in* address,

                        const SocketInterface* sock_interface = nullptr,

                        absl::optional<std::string> network_namespace = absl::nullopt);

  struct Ipv4Helper : public Ipv4 {

    sockaddr_in address_;

  };

  struct IpHelper : public Ip {

             // inlined IN_MULTICAST() to avoid byte swapping

      // Check if the address is in the link-local range: 169.254.0.0/16.

      // Unique Local Addresses (ULA) are not applicable to IPv4.

      // Site-Local Addresses are not applicable to IPv4.

      // Teredo addresses are not applicable to IPv4.

    Ipv4Helper ipv4_;

    std::string friendly_address_;

  };

  void initHelper(const sockaddr_in* address);

  IpHelper ip_;

  const absl::optional<std::string> network_namespace_;

  friend class InstanceFactory;

};

/**

 * Implementation of an IPv6 address.

 */

class Ipv6Instance : public InstanceBase {

public:

  /**

   * Construct from an existing unix IPv6 socket address (IP v6 address and port).

   */

  Ipv6Instance(const sockaddr_in6& address, bool v6only = true,

               const SocketInterface* sock_interface = nullptr,

               absl::optional<std::string> network_namespace = absl::nullopt);

  /**

   * Construct from a string IPv6 address such as "12:34::5". Port will be unset/0.

   */

  explicit Ipv6Instance(const std::string& address, const SocketInterface* sock_interface = nullptr,

                        absl::optional<std::string> network_namespace = absl::nullopt);

  /**

   * Construct from a string IPv6 address such as "12:34::5" as well as a port.

   */

  Ipv6Instance(const std::string& address, uint32_t port,

               const SocketInterface* sock_interface = nullptr, bool v6only = true,

               absl::optional<std::string> network_namespace = absl::nullopt);

  /**

   * Construct from a port. The IPv6 address will be set to "any" and is suitable for binding

   * a port to any available address.

   */

  explicit Ipv6Instance(uint32_t port, const SocketInterface* sock_interface = nullptr,

                        absl::optional<std::string> network_namespace = absl::nullopt);

  /**

   * Copy and override the network namespace.

   */

  explicit Ipv6Instance(const Ipv6Instance& that,

                        const absl::optional<std::string>& network_namespace);

  // Network::Address::Instance

  bool operator==(const Instance& rhs) const override;

  /**

   * Convenience function to convert an IPv6 address to canonical string format.

   * @param addr address to format.

   * @return the address in dotted-decimal string format.

   */

  static std::string sockaddrToString(const sockaddr_in6& addr);

  // Validate that IPv6 is supported on this platform

  static absl::Status validateProtocolSupported();

  /**

   * For use in tests only.

   * Force validateProtocolSupported() to return false for IPv6.

   */

  static Envoy::Cleanup forceProtocolUnsupportedForTest(bool new_val);

private:

  /**

   * Construct from an existing unix IPv6 socket address (IP v6 address and port).

   * Store the status code in passed in parameter instead of throwing.

   * It is called by the factory method and the partially constructed instance will be discarded

   * upon error.

   */

  Ipv6Instance(absl::Status& error, const sockaddr_in6& address, bool v6only = true,

               const SocketInterface* sock_interface = nullptr,

               absl::optional<std::string> network_namespace = absl::nullopt);

  struct Ipv6Helper : public Ipv6 {

    absl::uint128 address() const override;

    bool v6only() const override;

    uint32_t scopeId() const override;

    uint32_t port() const;

    InstanceConstSharedPtr v4CompatibleAddress() const override;

    InstanceConstSharedPtr addressWithoutScopeId() const override;

    std::string makeFriendlyAddress() const;

    static std::string makeFriendlyAddress(const sockaddr_in6& address);

    sockaddr_in6 address_;

    // Is IPv4 compatibility (https://tools.ietf.org/html/rfc3493#page-11) disabled?

    // Default initialized to true to preserve extant Envoy behavior where we don't explicitly set

    // this in the constructor.

    bool v6only_{true};

  };

  struct IpHelper : public Ip {

      // Check if the address is in the link-local range: fe80::/10 or in the v4 mapped link-local

      // range: [::ffff:169.254.0.0].

      // Unique Local Addresses (ULA) are in the range fc00::/7.

      // Site-Local Addresses are in the range fec0::/10.

      // Teredo addresses have the prefix 2001:0000::/32.

    Ipv6Helper ipv6_;

    std::string friendly_address_;

  };

  void initHelper(const sockaddr_in6& address, bool v6only);

  IpHelper ip_;

  const absl::optional<std::string> network_namespace_;

  friend class InstanceFactory;

};

/**

 * Implementation of a pipe address (unix domain socket on unix).

 */

class PipeInstance : public InstanceBase {

public:

  /**

   * Construct from an existing unix address.

   */

  static absl::StatusOr<std::unique_ptr<PipeInstance>>

  create(const sockaddr_un* address, socklen_t ss_len, mode_t mode = 0,

         const SocketInterface* sock_interface = nullptr);

  /**

   * Construct from a string pipe path.

   */

  static absl::StatusOr<std::unique_ptr<PipeInstance>>

  create(const std::string& pipe_path, mode_t mode = 0,

         const SocketInterface* sock_interface = nullptr);

  // Network::Address::Instance

  bool operator==(const Instance& rhs) const override;

private:

  explicit PipeInstance(const std::string& pipe_path, mode_t mode,

                        const SocketInterface* sock_interface, absl::Status& creation_status);

  /**

   * Construct from an existing unix address.

   * Store the error status code in passed in parameter instead of throwing.

   * It is called by the factory method and the partially constructed instance will be discarded

   * upon error.

   */

  PipeInstance(absl::Status& error, const sockaddr_un* address, socklen_t ss_len, mode_t mode = 0,

               const SocketInterface* sock_interface = nullptr);

  struct PipeHelper : public Pipe {

    sockaddr_un address_;

    // For abstract namespaces.

    bool abstract_namespace_{false};

    uint32_t address_length_{0};

    mode_t mode_{0};

  };

  absl::Status initHelper(const sockaddr_un* address, mode_t mode);

  PipeHelper pipe_;

  friend class InstanceFactory;

};

class EnvoyInternalInstance : public InstanceBase {

public:

  /**

   * Construct from a string name.

   */

  explicit EnvoyInternalInstance(const std::string& address_id, const std::string& endpoint_id = "",

                                 const SocketInterface* sock_interface = nullptr);

  // Network::Address::Instance

  bool operator==(const Instance& rhs) const override;

  // TODO(lambdai): Verify all callers accepts nullptr.

private:

  struct EnvoyInternalAddressImpl : public EnvoyInternalAddress {

    explicit EnvoyInternalAddressImpl(const std::string& address_id, const std::string& endpoint_id)

    const std::string address_id_;

    const std::string endpoint_id_;

  };

  EnvoyInternalAddressImpl internal_address_;

};

} // namespace Address

} // namespace Network

} // namespace Envoy