NET_MDNS.h

Go to the documentation of this file.

/*MIT License
 *
 * Copyright (c) 2020 Carlos Gomes Martinho
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#ifndef __NET_MDNS_H__
#define __NET_MDNS_H__

#include "NET_API.h"

#include <UT/UT_Array.h>
#include <UT/UT_NonCopyable.h>
#include <UT/UT_StringHolder.h>

#include <thread>
#include <chrono>

enum NET_mDNSRecordType
{
    MDNS_RECORDTYPE_IGNORE = 0,
    // Address
    MDNS_RECORDTYPE_A = 1,
    // Domain Name pointer
    MDNS_RECORDTYPE_PTR = 12,
    // Arbitrary text string
    MDNS_RECORDTYPE_TXT = 16,
    // IP6 Address [Thomson]
    MDNS_RECORDTYPE_AAAA = 28,
    // Server Selection [RFC2782]
    MDNS_RECORDTYPE_SRV = 33
};

enum NET_mDNSEntryType
{
    MDNS_ENTRYTYPE_QUESTION = 0,
    MDNS_ENTRYTYPE_ANSWER = 1,
    MDNS_ENTRYTYPE_AUTHORITY = 2,
    MDNS_ENTRYTYPE_ADDITIONAL = 3
};

enum NET_mDNSIpFilter
{
    IPV4_ONLY,
    IPV6_ONLY,
    IP_ANY
};

class NET_API NET_mDNSRecordSRV
{
public:
    UT_StringHolder myName;
    uint16_t myPort = 0;
    uint16_t myPriority = 0;
    uint16_t myWeight = 0;
};

class NET_API NET_mDNSQueryResult
{
public:
    // Identity is the service endpoint. myEntry cannot serve as one: the parse
    // callback rewrites it for every record in the datagram, so what it holds
    // afterwards is whichever record the responder happened to put last, not
    // the service that answered.
    bool operator==(const NET_mDNSQueryResult &other) const
    {
        return mySRV.myName == other.mySRV.myName
               && mySRV.myPort == other.mySRV.myPort;
    }
    bool operator!=(const NET_mDNSQueryResult &other) const
    {
        return !(*this == other);
    }

    NET_mDNSEntryType myEntryType = MDNS_ENTRYTYPE_QUESTION;
    UT_StringHolder myEntry;
    UT_StringHolder myFromAddr;
    NET_mDNSRecordSRV mySRV;
};

class NET_API NET_mDNS
{
public:
    NET_mDNS() :
        myHostname("nobody"),
        myName("_http._tcp.local."),
        myTxtRecord(),
        myHasIpv4(false),
        myHasIpv6(false),
        myServiceAddressIpv4(0)
    {
        memset(myServiceAddressIpv6, 0, sizeof(myServiceAddressIpv6));
    }
    ~NET_mDNS();

    UT_NON_COPYABLE(NET_mDNS)

#if 0
    bool isServiceRunning() { return myIsRunning; }
    void setServiceHostname(const UT_StringHolder &hostname)
    {
        myHostname = hostname;
    }
    void setServicePort(std::uint16_t port) { myPort = port; }
    void setServiceName(const UT_StringHolder &name) { myName = name; }
    void setServiceTxtRecord(const UT_StringHolder &txt_record)
    {
        myTxtRecord = txt_record;
    }
    void startService();
    void stopService();
#endif
    void executeQuery(
            const UT_StringHolder &service,
            UT_Array<NET_mDNSQueryResult> &results,
            const std::chrono::milliseconds &max_query_time,
            NET_mDNSIpFilter ip_filter = NET_mDNSIpFilter::IP_ANY);
#if 0
    void executeDiscovery();
#endif
private:
#if 0
    void runMainLoop();
    int openServiceSockets(int *sockets, int max_sockets);

    std::thread worker_thread_;
    std::uint16_t myPort;
    bool myIsRunning;
#endif
    int openClientSockets(
            int *sockets,
            int max_sockets,
            int port,
            NET_mDNSIpFilter ip_filter);

    UT_StringHolder myHostname;
    UT_StringHolder myName;
    UT_StringHolder myTxtRecord;

    bool myHasIpv4;
    bool myHasIpv6;

    uint32_t myServiceAddressIpv4;
    uint8_t myServiceAddressIpv6[16];
};

#endif // __NET_MDNS_H__