space::PortMapping Class Reference

Owns an automatically created UPnP or NAT-PMP port mapping. More...

#include <examples/asteroids-net/port_mapping.hpp>

Public Member Functions
void	open (const std::string &port)
	Attempts to expose a local UDP port through the router.
PortMapping &	operator= (const PortMapping &)=delete
	PortMapping ()=default
	Creates an inactive port mapping.
	PortMapping (const PortMapping &)=delete
const std::string &	status () const
	Returns a human-readable description of the mapping result.
	~PortMapping ()
	Removes the active mapping, if one was created.

Detailed Description

Owns an automatically created UPnP or NAT-PMP port mapping.

Destroying the object removes any mapping successfully created by open().

Definition at line 20 of file port_mapping.hpp.

Constructor & Destructor Documentation

PortMapping() [1/2]

space::PortMapping::PortMapping ( )

default

Creates an inactive port mapping.

~PortMapping()

space::PortMapping::~PortMapping

(

)

Removes the active mapping, if one was created.

Definition at line 75 of file port_mapping.cpp.

                              {
        if (private_port == 0 || public_port == 0)
            return;
        const std::string port = std::to_string(public_port);
#if defined(ASTEROIDS_NET_HAS_MINIUPNPC)
        if (method == Method::Upnp) {
            int error = 0;
            UPNPDev *devices = upnpDiscover(1000, nullptr, nullptr, 0, 0, 2, &error);
            UPNPUrls urls{};
            IGDdatas data{};
            char local_address[64]{};
            char external_address[64]{};
            if (devices != nullptr &&
                get_valid_igd(devices, urls, data, local_address, sizeof(local_address), external_address, sizeof(external_address)) > 0) {
                UPNP_DeletePortMapping(urls.controlURL, data.first.servicetype, port.c_str(), "UDP", nullptr);
                FreeUPNPUrls(&urls);
            }
            if (devices != nullptr)
                freeUPNPDevlist(devices);
            return;
        }
#endif
#if defined(ASTEROIDS_NET_HAS_NATPMP)
        if (method == Method::NatPmp) {
            natpmp_t natpmp{};
            if (initnatpmp(&natpmp, 0, 0) >= 0) {
                sendnewportmappingrequest(&natpmp, NATPMP_PROTOCOL_UDP, private_port, public_port, 0);
                natpmpresp_t response{};
                wait_for_natpmp(natpmp, response);
                closenatpmp(&natpmp);
            }
        }
#endif
    }

PortMapping() [2/2]

space::PortMapping::PortMapping ( const PortMapping & )

delete

Member Function Documentation

open()

void space::PortMapping::open

(

const std::string &

port

)

Attempts to expose a local UDP port through the router.

Parameters

port	Decimal UDP port number to map.

Definition at line 110 of file port_mapping.cpp.

                                                     {
        if (!parse_port(port_text, private_port)) {
            private_port = 0;
            status_message = "Invalid port; automatic router mapping skipped.";
            return;
        }
        public_port = private_port;
        const std::string port = std::to_string(private_port);
        std::string upnp_failure = "UPnP support was not built";
        std::string natpmp_failure = "NAT-PMP support was not built";
 
#if defined(ASTEROIDS_NET_HAS_MINIUPNPC)
        int error = 0;
        UPNPDev *devices = upnpDiscover(1500, nullptr, nullptr, 0, 0, 2, &error);
        UPNPUrls urls{};
        IGDdatas data{};
        char local_address[64]{};
        char external_address[64]{};
        const int igd_result = devices == nullptr
                                   ? 0
                                   : get_valid_igd(devices, urls, data, local_address, sizeof(local_address), external_address,
                                                   sizeof(external_address));
        if (igd_result > 0) {
            const int result = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype, port.c_str(), port.c_str(),
                                                   local_address, "asteroids-net", "UDP", nullptr,
                                                   std::to_string(MAPPING_LIFETIME_SECONDS).c_str());
            if (result == UPNPCOMMAND_SUCCESS) {
                if (external_address[0] == '\0')
                    UPNP_GetExternalIPAddress(urls.controlURL, data.first.servicetype, external_address);
                method = Method::Upnp;
                status_message = std::string("UPnP mapped UDP ") + port;
                if (external_address[0] != '\0')
                    status_message += std::string(" at ") + external_address + ":" + port;
                status_message += "; waiting for players...";
                FreeUPNPUrls(&urls);
                freeUPNPDevlist(devices);
                return;
            }
            upnp_failure = std::string("UPnP mapping failed: ") + strupnperror(result);
            FreeUPNPUrls(&urls);
        } else if (devices == nullptr) {
            upnp_failure = "no UPnP devices responded";
        } else {
            upnp_failure = "no valid UPnP internet gateway";
        }
        if (devices != nullptr)
            freeUPNPDevlist(devices);
#endif
 
#if defined(ASTEROIDS_NET_HAS_NATPMP)
        natpmp_t natpmp{};
        const int init_result = initnatpmp(&natpmp, 0, 0);
        if (init_result >= 0) {
            const int sent = sendnewportmappingrequest(&natpmp, NATPMP_PROTOCOL_UDP, private_port, public_port, MAPPING_LIFETIME_SECONDS);
            natpmpresp_t response{};
            const int response_result = sent < 0 ? sent : wait_for_natpmp(natpmp, response);
            if (response_result >= 0) {
                public_port = response.pnu.newportmapping.mappedpublicport;
                method = Method::NatPmp;
                status_message = "NAT-PMP mapped UDP " + std::to_string(public_port) + "; waiting for players...";
                closenatpmp(&natpmp);
                return;
            }
            natpmp_failure = natpmp_error(response_result);
            closenatpmp(&natpmp);
        } else {
            natpmp_failure = natpmp_error(init_result);
        }
#endif
 
        private_port = 0;
        public_port = 0;
        status_message = upnp_failure + "; " + natpmp_failure + ". Forward UDP " + port + " manually.";
    }

operator=()

PortMapping & space::PortMapping::operator= ( const PortMapping & )

delete

status()

const std::string & space::PortMapping::status ( ) const

nodiscard

Returns a human-readable description of the mapping result.

Definition at line 185 of file port_mapping.cpp.

{ return status_message; }

---

The documentation for this class was generated from the following files:

• examples/asteroids-net/port_mapping.hpp
• examples/asteroids-net/port_mapping.cpp