File indexing completed on 2024-04-14 14:10:27

 /*
     SPDX-FileCopyrightText: 2016 Alex Spataru
     SPDX-License-Identifier: MIT
 */
 
 #include "qMDNS.h"
 
 #include <QHostInfo>
 #include <QUdpSocket>
 #include <QHostAddress>
 #include <QNetworkInterface>
 
 #ifdef Q_OS_LINUX
 #include <sys/socket.h>
 #endif
 
 #include "kstars_debug.h"
 /*
  * DNS port and mutlicast addresses
  */
 const quint16 MDNS_PORT = 5353;
 const QHostAddress IPV6_ADDRESS = QHostAddress ("FF02::FB");
 const QHostAddress IPV4_ADDRESS = QHostAddress ("224.0.0.251");
 
 /*
  * mDNS/DNS operation flags
  */
 const quint16 kQR_Query       = 0x0000;
 const quint16 kQR_Response    = 0x8000;
 const quint16 kRecordA        = 0x0001;
 const quint16 kRecordAAAA     = 0x001C;
 const quint16 kNsecType       = 0x002F;
 const quint16 kFQDN_Separator = 0x0000;
 const quint16 kFQDN_Length    = 0xC00C;
 const quint16 kIN_BitFlush    = 0x8001;
 const quint16 kIN_Normal      = 0x0001;
 
 /*
  * DNS query properties
  */
 const quint16 kQuery_QDCOUNT = 0x02;
 const quint16 kQuery_ANCOUNT = 0x00;
 const quint16 kQuery_NSCOUNT = 0x00;
 const quint16 kQuery_ARCOUNT = 0x00;
 
 /*
  * DNS response properties
  */
 const quint16 kResponse_QDCOUNT = 0x00;
 const quint16 kResponse_ANCOUNT = 0x01;
 const quint16 kResponse_NSCOUNT = 0x00;
 const quint16 kResponse_ARCOUNT = 0x02;
 
 /* Packet constants */
 const int MIN_LENGTH = 13;
 const int IPI_LENGTH = 10;
 const int IP4_LENGTH = IPI_LENGTH + 4;
 const int IP6_LENGTH = IPI_LENGTH + 16;
 
 /**
  * Encodes the 16-bit \a number as two 8-bit numbers in a byte array
  */
 QByteArray ENCODE_16_BIT (quint16 number)
 {
     QByteArray data;
     data.append ((number & 0xff00) >> 8);
     data.append ((number & 0xff));
     return data;
 }
 
 /**
  * Encodes the 32-bit \a number as four 8-bit numbers
  */
 QByteArray ENCODE_32_BIT (quint32 number)
 {
     QByteArray data;
     data.append ((number & 0xff000000UL) >> 24);
     data.append ((number & 0x00ff0000UL) >> 16);
     data.append ((number & 0x0000ff00UL) >>  8);
     data.append ((number & 0x000000ffUL));
     return data;
 }
 
 /**
  * Obtains the 16-bit number stored in the \a upper and \a lower 8-bit numbers
  */
 quint16 DECODE_16_BIT (quint8 upper, quint8 lower)
 {
     return (quint16) ((upper << 8) | lower);
 }
 
 /**
  * Binds the given \a socket to the given \a address and \a port.
  * Under GNU/Linux, this function implements a workaround of QTBUG-33419.
  */
 bool BIND (QUdpSocket* socket, const QHostAddress &address, const int port)
 {
     if (!socket)
         return false;
 
 #ifdef Q_OS_LINUX
     int reuse = 1;
     int domain = PF_UNSPEC;
 
     if (address.protocol() == QAbstractSocket::IPv4Protocol)
         domain = PF_INET;
     else if (address.protocol() == QAbstractSocket::IPv6Protocol)
         domain = PF_INET6;
 
     socket->setSocketDescriptor (::socket (domain, SOCK_DGRAM, 0),
                                  QUdpSocket::UnconnectedState);
 
     setsockopt (socket->socketDescriptor(), SOL_SOCKET, SO_REUSEADDR,
                 &reuse, sizeof (reuse));
 #endif
 
     return socket->bind (address, port,
                          QUdpSocket::ShareAddress |
                          QUdpSocket::ReuseAddressHint);
 }
 
 qMDNS::qMDNS()
 {
     /* Set default TTL to 4500 seconds */
     m_ttl = 4500;
 
     /* Initialize sockets */
     m_IPv4Socket = new QUdpSocket (this);
     m_IPv6Socket = new QUdpSocket (this);
 
     /* Read and interpret data received from mDNS group */
     connect (m_IPv4Socket, &QUdpSocket::readyRead, this, &qMDNS::onReadyRead);
     connect (m_IPv6Socket, &QUdpSocket::readyRead, this, &qMDNS::onReadyRead);
 
     /* Bind the sockets to the mDNS multicast group */
     if (BIND (m_IPv4Socket, QHostAddress::AnyIPv4, MDNS_PORT))
         m_IPv4Socket->joinMulticastGroup (IPV4_ADDRESS);
     if (BIND (m_IPv6Socket, QHostAddress::AnyIPv6, MDNS_PORT))
         m_IPv6Socket->joinMulticastGroup (IPV6_ADDRESS);
 }
 
 qMDNS::~qMDNS()
 {
     delete m_IPv4Socket;
     delete m_IPv6Socket;
 }
 
 /**
  * Returns the only running instance of this class
  */
 qMDNS* qMDNS::getInstance()
 {
     static qMDNS instance;
     return &instance;
 }
 
 /**
  * Returns the mDNS name assigned to the client computer
  */
 QString qMDNS::hostName() const
 {
     return m_hostName;
 }
 
 /**
  * Ensures that the given \a string is a valid mDNS/DNS address.
  */
 QString qMDNS::getAddress (const QString &string)
 {
     QString address = string;
 
     if (!string.endsWith (".local") && !string.contains ("."))
         address = string + ".local";
 
     if (string.endsWith ("."))
         return "";
 
     return address;
 }
 
 /**
  * Changes the TTL send to other computers in the mDNS network
  */
 void qMDNS::setTTL (const quint32 ttl)
 {
     m_ttl = ttl;
 }
 
 /**
  * Performs a mDNS lookup to find the given host \a name.
  * If \a preferIPv6 is set to \c true, then this function will generate a
  * packet that requests an AAAA-type Resource Record instead of an A-type
  * Resource Record.
  */
 void qMDNS::lookup (const QString &name)
 {
     /* The host name is empty, abort lookup */
     if (name.isEmpty())
     {
         qCWarning(KSTARS) << Q_FUNC_INFO << "Empty host name specified";
         return;
     }
 
     qCInfo(KSTARS) << "Starting lookup for service" << name;
 
     m_serviceName = name;
 
     /* Ensure that we host name is a valid DNS address */
     QString address = getAddress (name);
     if (address.isEmpty())
         return;
 
     /* Check if we are dealing with a normal DNS address */
     if (!address.endsWith (".local", Qt::CaseInsensitive))
     {
         QHostInfo::lookupHost (address, this, SIGNAL (hostFound(QHostInfo)));
         return;
     }
 
     /* Perform a mDNS lookup */
     else
     {
         QByteArray data;
 
         /* Get the host name and domain */
         QString host = address.split (".").first();
         QString domain = address.split (".").last();
 
         /* Check that domain length is valid */
         if (host.length() > 255)
         {
             qWarning() << Q_FUNC_INFO << host << "is too long!";
             return;
         }
 
         /* Create header & flags */
         data.append (ENCODE_16_BIT (0));
         data.append (ENCODE_16_BIT (kQR_Query));
         data.append (ENCODE_16_BIT (kQuery_QDCOUNT));
         data.append (ENCODE_16_BIT (kQuery_ANCOUNT));
         data.append (ENCODE_16_BIT (kQuery_NSCOUNT));
         data.append (ENCODE_16_BIT (kQuery_ARCOUNT));
 
         /* Add name data */
         data.append (host.length());
         data.append (host.toUtf8());
 
         /* Add domain data */
         data.append (domain.length());
         data.append (domain.toUtf8());
 
         /* Add FQDN/TLD separator */
         data.append ((char) kFQDN_Separator);
 
         /* Add IPv4 record type */
         data.append (ENCODE_16_BIT (kRecordA));
         data.append (ENCODE_16_BIT (kIN_Normal));
 
         /* Add FQDN length */
         data.append (ENCODE_16_BIT (kFQDN_Length));
 
         /* Add IPv6 record type */
         data.append (ENCODE_16_BIT (kRecordAAAA));
         data.append (ENCODE_16_BIT (kIN_Normal));
 
         /* Send the datagram */
         sendPacket (data);
     }
 }
 
 /**
  * Changes the host name of the client computer
  */
 void qMDNS::setHostName (const QString &name)
 {
     if (name.contains (".") && !name.endsWith (".local"))
     {
         qWarning() << "Invalid domain name";
         return;
     }
 
     m_hostName = getAddress (name);
 }
 
 /**
  * Called when we receive data from a mDNS client on the network.
  */
 void qMDNS::onReadyRead()
 {
     QByteArray data;
     QUdpSocket* socket = qobject_cast<QUdpSocket*> (sender());
 
     /* Read data from the socket */
     if (socket)
     {
         while (socket->hasPendingDatagrams())
         {
             data.resize (socket->pendingDatagramSize());
             socket->readDatagram (data.data(), data.size());
         }
     }
 
     /* Packet is a valid mDNS datagram */
     if (data.length() > MIN_LENGTH)
     {
         quint16 flag = DECODE_16_BIT (data.at (2), data.at (3));
 
         if (flag == kQR_Query)
             readQuery (data);
 
         else if (flag >= kQR_Response)
             readResponse (data);
     }
 }
 
 /**
  * Reads the given query \a data and instructs the class to send a response
  * packet if the query is looking for the host name assigned to this computer.
  */
 void qMDNS::readQuery (const QByteArray &data)
 {
     /* Query packet is invalid */
     if (data.length() < MIN_LENGTH)
         return;
 
     /* Get the lengths of the host name and domain */
     int n = 12;
     int hostLength = data.at (n);
     int domainLength = data.at (n + hostLength + 1);
 
     /* Read the host name until we stumble with the domain length character */
     QString name;
     int h = n + 1;
     while (data.at (h) != (char) domainLength)
     {
         name.append (data.at (h));
         ++h;
     }
 
     /* Read domain length until we stumble with the FQDN/TLD separator */
     QString domain;
     int d = n + hostLength + 2;
     while (data.at (d) != kFQDN_Separator)
     {
         domain.append (data.at (d));
         ++d;
     }
 
     /* Construct the full host name (name + domain) */
     QString host = getAddress (name + "." + domain);
 
     /* The query packet wants to know more about us */
     if (host.toLower() == hostName().toLower())
         sendResponse (DECODE_16_BIT (data.at (0), data.at (1)));
 }
 
 /**
  * Sends the given \a data to both the IPv4 and IPv6 mDNS multicast groups
  */
 void qMDNS::sendPacket (const QByteArray &data)
 {
     if (!data.isEmpty())
     {
         m_IPv4Socket->writeDatagram (data, IPV4_ADDRESS, MDNS_PORT);
         m_IPv6Socket->writeDatagram (data, IPV6_ADDRESS, MDNS_PORT);
     }
 }
 
 /**
  * Reads the given \a data of a response packet and obtains:
  * - The remote host name
  * - The remote IPv4
  * - The remote IPv6
  */
 void qMDNS::readResponse (const QByteArray &data)
 {
     if (data.length() < MIN_LENGTH)
         return;
 
     qCDebug(KSTARS) << data;
 
     // data must contain service name
     if (data.contains(m_serviceName.toLatin1()) == false)
         return;
 
     QString host = getHostNameFromResponse (data);
     QList<QHostAddress> addresses = getAddressesFromResponse (data, host);
 
     if (!host.isEmpty() && !addresses.isEmpty())
     {
         QHostInfo info;
         info.setHostName (host);
         info.setAddresses (addresses);
         info.setError (QHostInfo::NoError);
 
         qCInfo(KSTARS) << "Found service on" << host;
 
         emit hostFound (info);
     }
 }
 
 /**
  * Sends a response packet with:
  * - Our mDNS host name
  * - Our IPv4 address
  * - Our IPv6 address
  */
 void qMDNS::sendResponse (const quint16 query_id)
 {
     if (!hostName().isEmpty() && hostName().endsWith (".local"))
     {
         QByteArray data;
 
         /* Get the host name and domain */
         QString host = hostName().split (".").first();
         QString domain = hostName().split (".").last();
 
         /* Get local IPs */
         quint32 ipv4 = 0;
         QList<QIPv6Address> ipv6;
         foreach (QHostAddress address, QNetworkInterface::allAddresses())
         {
             if (!address.isLoopback())
             {
                 if (address.protocol() == QAbstractSocket::IPv4Protocol)
                     ipv4 = (ipv4 == 0 ? address.toIPv4Address() : ipv4);
 
                 if (address.protocol() == QAbstractSocket::IPv6Protocol)
                     ipv6.append (address.toIPv6Address());
             }
         }
 
         /* Check that domain length is valid */
         if (host.length() > 255)
         {
             qCWarning(KSTARS) << Q_FUNC_INFO << host << "is too long!";
             return;
         }
 
         /* Create header and flags */
         data.append (ENCODE_16_BIT (query_id));
         data.append (ENCODE_16_BIT (kQR_Response));
         data.append (ENCODE_16_BIT (kResponse_QDCOUNT));
         data.append (ENCODE_16_BIT (kResponse_ANCOUNT));
         data.append (ENCODE_16_BIT (kResponse_NSCOUNT));
         data.append (ENCODE_16_BIT (kResponse_ARCOUNT));
 
         /* Add name data */
         data.append (host.length());
         data.append (host.toUtf8());
 
         /* Add domain data and FQDN/TLD separator */
         data.append (domain.length());
         data.append (domain.toUtf8());
         data.append ((char) kFQDN_Separator);
 
         /* Add IPv4 address header */
         data.append (ENCODE_16_BIT (kRecordA));
         data.append (ENCODE_16_BIT (kIN_BitFlush));
         data.append (ENCODE_32_BIT (m_ttl));
         data.append (ENCODE_16_BIT (sizeof (ipv4)));
 
         /* Add IPv4 bytes */
         data.append (ENCODE_32_BIT (ipv4));
 
         /* Add FQDN offset */
         data.append (ENCODE_16_BIT (kFQDN_Length));
 
         /* Add IPv6 addresses */
         foreach (QIPv6Address ip, ipv6)
         {
             data.append (ENCODE_16_BIT (kRecordAAAA));
             data.append (ENCODE_16_BIT (kIN_BitFlush));
             data.append (ENCODE_32_BIT (m_ttl));
             data.append (ENCODE_16_BIT (sizeof (ip.c)));
 
             /* Add IPv6 bytes */
             for (unsigned long i = 0; i < sizeof (ip.c); ++i)
                 data.append (ip.c [i]);
 
             /* Add FQDN offset */
             data.append (ENCODE_16_BIT (kFQDN_Length));
         }
 
         /* TODO: Generate NSEC code block */
         int nsec_length = 0;
 
         /* Add NSEC data */
         data.append (ENCODE_16_BIT (kNsecType));
         data.append (ENCODE_16_BIT (kIN_BitFlush));
         data.append (ENCODE_32_BIT (m_ttl));
         data.append (ENCODE_16_BIT (nsec_length));
 
         /* Send the response */
         sendPacket (data);
     }
 }
 
 /**
  * Extracts the host name from the \a data received from the mDNS network.
  * The host name begins at byte #12 (when the header and flags end) and ends
  * with a mandatory NUL character after the domain.
  *
  * The host name is constructed in the following way (without spaces):
  * \c NAME_LENGTH + \c NAME + \c DOMAIN_LENGTH + \c DOMAIN + \c NUL
  *
  * For example, appletv.local would be formatted as:
  * \c 0x07 + \c appletv + \c 0x05 + \c local + \c 0x00
  *
  * Or, if you prefer hex data:
  * \c { 07 61 70 70 6c 65 74 76 05 6c 6f 63 61 6c 00 }
  * \c {  7 a  p  p  l  e  t  v   5 l  o  c  a  l   0 }
  *
  * In order to obtain the full host name (and its mDNS domain), we construct
  * the string backwards. When the code notices that the current character is
  * the same as the domain length, we know that the domain name has been
  * extracted, and thus we can replace the domain length with a dot (.) and
  * begin extracting the host name.
  */
 QString qMDNS::getHostNameFromResponse (const QByteArray &data)
 {
     QList<char> list;
     QString address = "";
 
     /* Begin reading host name at byte 13 (byte 12 is the host name length) */
     int n = 13;
 
     /* Read the host name until we stumble with the FQDN/TLD separator */
     while (data.at (n) != kFQDN_Separator)
     {
         list.append (data.at (n));
         ++n;
     }
 
     /* Construct the string backwards (to replace domain length with a dot) */
     for (int i = 0; i < list.count(); ++i)
     {
         char character = list.at (list.count() - i - 1);
 
         if (character == (char) address.length())
             address.prepend (".");
         else
             address.prepend (character);
     }
 
     return address;
 }
 
 /**
  * Extracts the IPv4 from the \a data received from the mDNS network.
  * The IPv4 data begins when the host name data ends.
  *
  * For the packet to contain IPv4 information, the DNS Record Type code must
  * be "A" (IPv4) and the DNS Class code should correspond to "IN" (Internet).
  *
  * Here is the layout of the IPv4 section of the packet:
  *
  * - DNS Record Type
  * - DNS Class Code
  * - TTL
  * - IP length
  * - IP address bytes
  *
  * This is an example IPv4 section:
  * \c {00 01 80 01 00 00 78 00 00 04 99 6d 07 5a}
  *
  * Data in example section:
  * - \c {00 01} Type Codes
  * - \c {80 01} Class Codes
  * - \c {00 00 78 00} IP TTL
  * - \c {00 04} Number of address bytes (length in layman's terms)
  * - \c {99 6d 07 5a} IPv4 Address bytes (153, 109, 7, 90)
  */
 QString qMDNS::getIPv4FromResponse (const QByteArray &data,
                                     const QString &host)
 {
     QString ip = "";
 
     /* n stands for the byte index in which the host name data ends */
     int n = MIN_LENGTH + host.length();
 
     /* Packet is too small */
     if (data.length() < n + IP4_LENGTH)
         return ip;
 
     /* Get the IP type and class codes */
     quint16 typeCode  = DECODE_16_BIT (data.at (n + 1), data.at (n + 2));
     quint16 classCode = DECODE_16_BIT (data.at (n + 3), data.at (n + 4));
 
     /* Check if type and class codes are good */
     if (typeCode != kRecordA || classCode != kIN_BitFlush)
         return ip;
 
     /* Skip TTL indicator and obtain the number of address bytes */
     quint8 length = data.at (n + IPI_LENGTH);
 
     /* Append each IPv4 address byte (and decimal dots) to the IP string */
     for (int i = 1; i < length + 1; ++i)
     {
         ip += QString::number ((quint8) data.at (n + IPI_LENGTH + i));
         ip += (i < length) ? "." : "";
     }
 
     return ip;
 }
 
 /**
  * Extracts the IPv6 from the \a data received from the mDNS network.
  * The IPv6 data begins when the host name data ends.
  *
  * For the packet to contain IPv6 information, the DNS Record Type code must
  * be "AAAA" (IPv6) and the DNS Class code should correspond to "IN" (Internet).
  *
  * Here is the layout of the IPv4 section of the packet:
  *
  * - DNS Record Type
  * - DNS Class Code
  * - TTL
  * - IP length
  * - IP address bytes
  *
  * This is an example IPv6 section:
  * \c { 00 1c 80 01 00 00 78 00 00 10 fe 80 00 00 00 00 00 00 02 23 32 ff fe b1 21 52 }
  *
  * Data in example section:
  * - \c {00 1c} Type Codes
  * - \c {80 01} Class Codes
  * - \c {00 00 78 00} IP TTL
  * - \c {00 10} Number of address bytes (length in layman's terms)
  * - \c {fe 80 00 00 ... 52} IPv6 Address bytes (there are 16 of them)
  */
 QStringList qMDNS::getIPv6FromResponse (const QByteArray &data,
                                         const QString &host)
 {
     QStringList list;
 
     /* Skip the FQDN and IPv4 section */
     int n = MIN_LENGTH + IP4_LENGTH + host.length();
 
     /* Get the IPv6 list */
     bool isIPv6 = true;
     while (isIPv6)
     {
         /* Skip FQDN bytes */
         n += 2;
 
         /* Packet is invalid */
         if (data.length() < n + IP6_LENGTH)
             break;
 
         /* Get the IP type and class codes */
         quint16 typeCode  = DECODE_16_BIT (data.at (n + 1), data.at (n + 2));
         quint16 classCode = DECODE_16_BIT (data.at (n + 3), data.at (n + 4));
         isIPv6 = (typeCode == kRecordAAAA && classCode == kIN_BitFlush);
 
         /* IP type and class codes are OK, extract IP */
         if (isIPv6)
         {
             /* Skip TTL indicator and obtain the number of address bytes */
             quint8 length = data.at (n + IPI_LENGTH);
 
             /* Append each IPv6 address byte (encoded as hex) to the IP string */
             QString ip = "";
             for (int i = 1; i < length + 1; ++i)
             {
                 /* Get the hexadecimal representation of the byte */
                 QString byte;
                 byte.setNum ((quint8) data.at (n + i + IPI_LENGTH), 16);
 
                 /* Add the obtained string */
                 ip += byte;
 
                 /* Append colons after even indexes (except in the last byte) */
                 if ((i & 1) == 0 && (i < length))
                     ip += ":";
             }
 
             /* Increase the counter to 'jump' to the next section */
             n += 26;
 
             /* Append the obtained IP to the list */
             if (!list.contains (ip))
                 list.append (ip);
         }
     }
 
     return list;
 }
 
 /**
  * Obtains the IPv4 and IPv6 addresses from the received data.
  * \note This function will only generate a list with the valid IP addresses.
  */
 QList<QHostAddress> qMDNS::getAddressesFromResponse (const QByteArray &data,
         const QString &host)
 {
     QList<QHostAddress> list;
 
     /* Add IPv4 address */
     QHostAddress IPv4Address = QHostAddress (getIPv4FromResponse (data, host));
     if (!IPv4Address.isNull())
         list.append (IPv4Address);
 
     /* Add IPv6 addresses */
     foreach (QString ip, getIPv6FromResponse (data, host))
     {
         QHostAddress address = QHostAddress (ip);
         if (!address.isNull())
             list.append (address);
     }
 
     return list;
 }