from __future__ import absolute_import, division, print_function, unicode_literals

""" Multicast DNS Service Discovery for Python, v0.14-wmcbrine

Copyright 2003 Paul Scott-Murphy, 2014 William McBrine

This module provides a framework for the use of DNS Service Discovery

using IP multicast.

This library is free software; you can redistribute it and/or

modify it under the terms of the GNU Lesser General Public

License as published by the Free Software Foundation; either

version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public

License along with this library; if not, write to the Free Software

Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301

USA

"""

import errno

import logging

import os

import re

import select

import socket

import struct

import sys

import threading

import time

from functools import reduce

# Use ifaddr instead of ifcfg in order to ensure that we are always

# able to read outgoing addresses. ifcfg fails to do so on Windows

# in a non-English locale. This is critical for many of our users.

# On Android if certain so files are not properly bundled, this can

# lead to an import error, so we catch it so that we can carry on with

# our own Android specific code.

try:

import ifaddr

except ImportError:

ifaddr = None

from six import binary_type, indexbytes, int2byte, iteritems, text_type

from six.moves import xrange

import enum_compat as enum

__author__ = "Paul Scott-Murphy, William McBrine"

__maintainer__ = "Learning Equality <info@learningequality.org>"

__version__ = "0.19.17"

__license__ = "LGPL"

__all__ = [

"__version__",

"Zeroconf",

"ServiceInfo",

"ServiceBrowser",

"Error",

"InterfaceChoice",

"ServiceStateChange",

]

log = logging.getLogger(__name__)

log.addHandler(logging.NullHandler())

if log.level == logging.NOTSET:

log.setLevel(logging.WARN)

# Some timing constants

_UNREGISTER_TIME = 125

_CHECK_TIME = 175

_REGISTER_TIME = 225

_LISTENER_TIME = 200

_BROWSER_TIME = 500

# Some DNS constants

_MDNS_ADDR = "224.0.0.251"

_MDNS_PORT = 5353

_DNS_PORT = 53

_DNS_TTL = 120 # two minutes default TTL as recommended by RFC6762

_MAX_MSG_TYPICAL = 1460 # unused

_MAX_MSG_ABSOLUTE = 8966

_FLAGS_QR_MASK = 0x8000 # query response mask

_FLAGS_QR_QUERY = 0x0000 # query

_FLAGS_QR_RESPONSE = 0x8000 # response

_FLAGS_AA = 0x0400 # Authoritative answer

_FLAGS_TC = 0x0200 # Truncated

_FLAGS_RD = 0x0100 # Recursion desired

_FLAGS_RA = 0x8000 # Recursion available

_FLAGS_Z = 0x0040 # Zero

_FLAGS_AD = 0x0020 # Authentic data

_FLAGS_CD = 0x0010 # Checking disabled

_CLASS_IN = 1

_CLASS_CS = 2

_CLASS_CH = 3

_CLASS_HS = 4

_CLASS_NONE = 254

_CLASS_ANY = 255

_CLASS_MASK = 0x7FFF

_CLASS_UNIQUE = 0x8000

_TYPE_A = 1

_TYPE_NS = 2

_TYPE_MD = 3

_TYPE_MF = 4

_TYPE_CNAME = 5

_TYPE_SOA = 6

_TYPE_MB = 7

_TYPE_MG = 8

_TYPE_MR = 9

_TYPE_NULL = 10

_TYPE_WKS = 11

_TYPE_PTR = 12

_TYPE_HINFO = 13

_TYPE_MINFO = 14

_TYPE_MX = 15

_TYPE_TXT = 16

_TYPE_AAAA = 28

_TYPE_SRV = 33

_TYPE_ANY = 255

# Mapping constants to names

_CLASSES = {

_CLASS_IN: "in",

_CLASS_CS: "cs",

_CLASS_CH: "ch",

_CLASS_HS: "hs",

_CLASS_NONE: "none",

_CLASS_ANY: "any",

}

_TYPES = {

_TYPE_A: "a",

_TYPE_NS: "ns",

_TYPE_MD: "md",

_TYPE_MF: "mf",

_TYPE_CNAME: "cname",

_TYPE_SOA: "soa",

_TYPE_MB: "mb",

_TYPE_MG: "mg",

_TYPE_MR: "mr",

_TYPE_NULL: "null",

_TYPE_WKS: "wks",

_TYPE_PTR: "ptr",

_TYPE_HINFO: "hinfo",

_TYPE_MINFO: "minfo",

_TYPE_MX: "mx",

_TYPE_TXT: "txt",

_TYPE_AAAA: "quada",

_TYPE_SRV: "srv",

_TYPE_ANY: "any",

}

_HAS_A_TO_Z = re.compile(r"[A-Za-z]")

_HAS_ONLY_A_TO_Z_NUM_HYPHEN = re.compile(r"^[A-Za-z0-9\-]+$")

_HAS_ASCII_CONTROL_CHARS = re.compile(r"[\x00-\x1f\x7f]")

@enum.unique

class InterfaceChoice(enum.Enum):

Default = 1

All = 2

@enum.unique

class ServiceStateChange(enum.Enum):

Added = 1

Removed = 2

Updated = 3

HOST_ONLY_NETWORK_MASK = "255.255.255.255"

USE_IP_OF_OUTGOING_INTERFACE = socket.inet_aton("255.173.111.245")

# utility functions

def current_time_millis():

"""Current system time in milliseconds"""

return time.time() * 1000

def service_type_name(type_):

"""

Validate a fully qualified service name, instance or subtype. [rfc6763]

Returns fully qualified service name.

Domain names used by mDNS-SD take the following forms:

<sn> . <_tcp|_udp> . local.

<Instance> . <sn> . <_tcp|_udp> . local.

<sub>._sub . <sn> . <_tcp|_udp> . local.

1) must end with 'local.'

This is true because we are implementing mDNS and since the 'm' means

multi-cast, the 'local.' domain is mandatory.

2) local is preceded with either '_udp.' or '_tcp.'

3) service name <sn> precedes <_tcp|_udp>

The rules for Service Names [RFC6335] state that they may be no more

than fifteen characters long (not counting the mandatory underscore),

consisting of only letters, digits, and hyphens, must begin and end

with a letter or digit, must not contain consecutive hyphens, and

must contain at least one letter.

The instance name <Instance> and sub type <sub> may be up to 63 bytes.

The portion of the Service Instance Name is a user-

friendly name consisting of arbitrary Net-Unicode text [RFC5198]. It

MUST NOT contain ASCII control characters (byte values 0x00-0x1F and

0x7F) [RFC20] but otherwise is allowed to contain any characters,

without restriction, including spaces, uppercase, lowercase,

punctuation -- including dots -- accented characters, non-Roman text,

and anything else that may be represented using Net-Unicode.

:param type_: Type, SubType or service name to validate

:return: fully qualified service name (eg: _http._tcp.local.)

"""

if not (type_.endswith("._tcp.local.") or type_.endswith("._udp.local.")):

raise BadTypeInNameException(

"Type '%s' must end with '._tcp.local.' or '._udp.local.'" % type_

)

remaining = type_[: -len("._tcp.local.")].split(".")

name = remaining.pop()

if not name:

raise BadTypeInNameException("No Service name found")

if len(remaining) == 1 and len(remaining[0]) == 0:

raise BadTypeInNameException("Type '%s' must not start with '.'" % type_)

if name[0] != "_":

raise BadTypeInNameException("Service name (%s) must start with '_'" % name)

# remove leading underscore

name = name[1:]

if len(name) > 15:

raise BadTypeInNameException("Service name (%s) must be <= 15 bytes" % name)

if "--" in name:

raise BadTypeInNameException("Service name (%s) must not contain '--'" % name)

if "-" in (name[0], name[-1]):

raise BadTypeInNameException(

"Service name (%s) may not start or end with '-'" % name

)

if not _HAS_A_TO_Z.search(name):

raise BadTypeInNameException(

"Service name (%s) must contain at least one letter (eg: 'A-Z')" % name

)

if not _HAS_ONLY_A_TO_Z_NUM_HYPHEN.search(name):

raise BadTypeInNameException(

"Service name (%s) must contain only these characters: "

"A-Z, a-z, 0-9, hyphen ('-')" % name

)

if remaining and remaining[-1] == "_sub":

remaining.pop()

if len(remaining) == 0 or len(remaining[0]) == 0:

raise BadTypeInNameException("_sub requires a subtype name")

if len(remaining) > 1:

remaining = [".".join(remaining)]

if remaining:

length = len(remaining[0].encode("utf-8"))

if length > 63:

raise BadTypeInNameException("Too long: '%s'" % remaining[0])

if _HAS_ASCII_CONTROL_CHARS.search(remaining[0]):

raise BadTypeInNameException(

"Ascii control character 0x00-0x1F and 0x7F illegal in '%s'"

% remaining[0]

)

return "_" + name + type_[-len("._tcp.local.") :]

# Exceptions

class Error(Exception):

pass

class IncomingDecodeError(Error):

pass

class NonUniqueNameException(Error):

pass

class NamePartTooLongException(Error):

pass

class AbstractMethodException(Error):

pass

class BadTypeInNameException(Error):

pass

# implementation classes

class QuietLogger(object):

_seen_logs = {}

@classmethod

def log_exception_warning(cls, logger_data=None):

exc_info = sys.exc_info()

exc_str = str(exc_info[1])

if exc_str not in cls._seen_logs:

# log at warning level the first time this is seen

cls._seen_logs[exc_str] = exc_info

logger = log.warning

else:

logger = log.debug

if logger_data is not None:

logger(*logger_data)

logger("Exception occurred:", exc_info=exc_info)

@classmethod

def log_warning_once(cls, *args):

msg_str = args[0]

if msg_str not in cls._seen_logs:

cls._seen_logs[msg_str] = 0

logger = log.warning

else:

logger = log.debug

cls._seen_logs[msg_str] += 1

logger(*args)

class DNSEntry(object):

"""A DNS entry"""

def __init__(self, name, type_, class_):

self.key = name.lower()

self.name = name

self.type = type_

self.class_ = class_ & _CLASS_MASK

self.unique = (class_ & _CLASS_UNIQUE) != 0

def __eq__(self, other):

"""Equality test on name, type, and class"""

return (

isinstance(other, DNSEntry)

and self.name == other.name

and self.type == other.type

and self.class_ == other.class_

)

def __ne__(self, other):

"""Non-equality test"""

return not self.__eq__(other)

@staticmethod

def get_class_(class_):

"""Class accessor"""

return _CLASSES.get(class_, "?(%s)" % class_)

@staticmethod

def get_type(t):

"""Type accessor"""

return _TYPES.get(t, "?(%s)" % t)

def to_string(self, hdr, other):

"""String representation with additional information"""

result = "%s[%s,%s" % (

hdr,

self.get_type(self.type),

self.get_class_(self.class_),

)

if self.unique:

result += "-unique,"

else:

result += ","

result += self.name

if other is not None:

result += ",%s]" % other

else:

result += "]"

return result

class DNSQuestion(DNSEntry):

"""A DNS question entry"""

def __init__(self, name, type_, class_):

DNSEntry.__init__(self, name, type_, class_)

def answered_by(self, rec):

"""Returns true if the question is answered by the record"""

return (

self.class_ == rec.class_

and (self.type == rec.type or self.type == _TYPE_ANY)

and self.name == rec.name

)

def __repr__(self):

"""String representation"""

return DNSEntry.to_string(self, "question", None)

class DNSRecord(DNSEntry):

"""A DNS record - like a DNS entry, but has a TTL"""

def __init__(self, name, type_, class_, ttl):

DNSEntry.__init__(self, name, type_, class_)

self.ttl = ttl

self.created = current_time_millis()

def __eq__(self, other):

"""Abstract method"""

raise AbstractMethodException

def __ne__(self, other):

"""Non-equality test"""

return not self.__eq__(other)

def suppressed_by(self, msg):

"""Returns true if any answer in a message can suffice for the

information held in this record."""

for record in msg.answers:

if self.suppressed_by_answer(record):

return True

return False

def suppressed_by_answer(self, other):

"""Returns true if another record has same name, type and class,

and if its TTL is at least half of this record's."""

return self == other and other.ttl > (self.ttl / 2)

def get_expiration_time(self, percent):

"""Returns the time at which this record will have expired

by a certain percentage."""

return self.created + (percent * self.ttl * 10)

def get_remaining_ttl(self, now):

"""Returns the remaining TTL in seconds."""

return max(0, (self.get_expiration_time(100) - now) / 1000.0)

def is_expired(self, now):

"""Returns true if this record has expired."""

return self.get_expiration_time(100) <= now

def is_stale(self, now):

"""Returns true if this record is at least half way expired."""

return self.get_expiration_time(50) <= now

def reset_ttl(self, other):

"""Sets this record's TTL and created time to that of

another record."""

self.created = other.created

self.ttl = other.ttl

def write(self, out):

"""Abstract method"""

raise AbstractMethodException

def to_string(self, other):

"""String representation with additional information"""

arg = "%s/%s,%s" % (

self.ttl,

self.get_remaining_ttl(current_time_millis()),

other,

)

return DNSEntry.to_string(self, "record", arg)

class DNSAddress(DNSRecord):

"""A DNS address record"""

def __init__(self, name, type_, class_, ttl, address):

DNSRecord.__init__(self, name, type_, class_, ttl)

self.address = address

def write(self, out):

"""Used in constructing an outgoing packet"""

out.write_string(self.address)

def __eq__(self, other):

"""Tests equality on address"""

return (

isinstance(other, DNSAddress)

and DNSEntry.__eq__(self, other)

and self.address == other.address

)

def __ne__(self, other):

"""Non-equality test"""

return not self.__eq__(other)

def __repr__(self):

"""String representation"""

try:

return str(socket.inet_ntoa(self.address))

except Exception: # TODO stop catching all Exceptions

return str(self.address)

class DNSHinfo(DNSRecord):

"""A DNS host information record"""

def __init__(self, name, type_, class_, ttl, cpu, os):

DNSRecord.__init__(self, name, type_, class_, ttl)

try:

self.cpu = cpu.decode("utf-8")

except AttributeError:

self.cpu = cpu

try:

self.os = os.decode("utf-8")

except AttributeError:

self.os = os

def write(self, out):

"""Used in constructing an outgoing packet"""

out.write_character_string(self.cpu.encode("utf-8"))

out.write_character_string(self.os.encode("utf-8"))

def __eq__(self, other):

"""Tests equality on cpu and os"""

return (

isinstance(other, DNSHinfo)

and DNSEntry.__eq__(self, other)

and self.cpu == other.cpu

and self.os == other.os

)

def __ne__(self, other):

"""Non-equality test"""

return not self.__eq__(other)

def __repr__(self):

"""String representation"""

return self.cpu + " " + self.os

class DNSPointer(DNSRecord):

"""A DNS pointer record"""

def __init__(self, name, type_, class_, ttl, alias):

DNSRecord.__init__(self, name, type_, class_, ttl)

self.alias = alias

def write(self, out):

"""Used in constructing an outgoing packet"""

out.write_name(self.alias)

def __eq__(self, other):

"""Tests equality on alias"""

return (

isinstance(other, DNSPointer)

and DNSEntry.__eq__(self, other)

and self.alias == other.alias

)

def __ne__(self, other):

"""Non-equality test"""

return not self.__eq__(other)

def __repr__(self):

"""String representation"""

return self.to_string(self.alias)

class DNSText(DNSRecord):

"""A DNS text record"""

def __init__(self, name, type_, class_, ttl, text):

assert isinstance(text, (bytes, type(None)))

DNSRecord.__init__(self, name, type_, class_, ttl)

self.text = text

def write(self, out):

"""Used in constructing an outgoing packet"""

out.write_string(self.text)

def __eq__(self, other):

"""Tests equality on text"""

return (

isinstance(other, DNSText)

and DNSEntry.__eq__(self, other)

and self.text == other.text

)

def __ne__(self, other):

"""Non-equality test"""

return not self.__eq__(other)

def __repr__(self):

"""String representation"""

if len(self.text) > 10:

return self.to_string(self.text[:7]) + "..."

else:

return self.to_string(self.text)

class DNSService(DNSRecord):

"""A DNS service record"""

def __init__(self, name, type_, class_, ttl, priority, weight, port, server):

DNSRecord.__init__(self, name, type_, class_, ttl)

self.priority = priority

self.weight = weight

self.port = port

self.server = server

def write(self, out):

"""Used in constructing an outgoing packet"""

out.write_short(self.priority)

out.write_short(self.weight)

out.write_short(self.port)

out.write_name(self.server)

def __eq__(self, other):

"""Tests equality on priority, weight, port and server"""

return (

isinstance(other, DNSService)

and DNSEntry.__eq__(self, other)

and self.priority == other.priority

and self.weight == other.weight

and self.port == other.port

and self.server == other.server

)

def __ne__(self, other):

"""Non-equality test"""

return not self.__eq__(other)

def __repr__(self):

"""String representation"""

return self.to_string("%s:%s" % (self.server, self.port))

class DNSIncoming(QuietLogger):

"""Object representation of an incoming DNS packet"""

def __init__(self, data):

"""Constructor from string holding bytes of packet"""

self.offset = 0

self.data = data

self.questions = []

self.answers = []

self.id = 0

self.flags = 0

self.num_questions = 0

self.num_answers = 0

self.num_authorities = 0

self.num_additionals = 0

self.valid = False

try:

self.read_header()

self.read_questions()

self.read_others()

self.valid = True

except (IndexError, struct.error, IncomingDecodeError):

self.log_exception_warning(

("Choked at offset %d while unpacking %r", self.offset, data)

)

def unpack(self, format_):

length = struct.calcsize(format_)

info = struct.unpack(format_, self.data[self.offset : self.offset + length])

self.offset += length

return info

def read_header(self):

"""Reads header portion of packet"""

(

self.id,

self.flags,

self.num_questions,

self.num_answers,

self.num_authorities,

self.num_additionals,

) = self.unpack(b"!6H")

def read_questions(self):

"""Reads questions section of packet"""

for i in xrange(self.num_questions):

name = self.read_name()

type_, class_ = self.unpack(b"!HH")

question = DNSQuestion(name, type_, class_)

self.questions.append(question)

# def read_int(self):

# """Reads an integer from the packet"""

# return self.unpack(b'!I')[0]

def read_character_string(self):

"""Reads a character string from the packet"""

length = indexbytes(self.data, self.offset)

self.offset += 1

return self.read_string(length)

def read_string(self, length):

"""Reads a string of a given length from the packet"""

info = self.data[self.offset : self.offset + length]

self.offset += length

return info

def read_unsigned_short(self):

"""Reads an unsigned short from the packet"""

return self.unpack(b"!H")[0]

def read_others(self):

"""Reads the answers, authorities and additionals section of the

packet"""

n = self.num_answers + self.num_authorities + self.num_additionals

for i in xrange(n):

domain = self.read_name()

type_, class_, ttl, length = self.unpack(b"!HHiH")

rec = None

if type_ == _TYPE_A:

rec = DNSAddress(domain, type_, class_, ttl, self.read_string(4))

elif type_ == _TYPE_CNAME or type_ == _TYPE_PTR:

rec = DNSPointer(domain, type_, class_, ttl, self.read_name())

elif type_ == _TYPE_TXT:

rec = DNSText(domain, type_, class_, ttl, self.read_string(length))

elif type_ == _TYPE_SRV:

rec = DNSService(

domain,

type_,

class_,

ttl,

self.read_unsigned_short(),

self.read_unsigned_short(),

self.read_unsigned_short(),

self.read_name(),

)

elif type_ == _TYPE_HINFO:

rec = DNSHinfo(

domain,

type_,

class_,

ttl,

self.read_character_string(),

self.read_character_string(),

)

elif type_ == _TYPE_AAAA:

rec = DNSAddress(domain, type_, class_, ttl, self.read_string(16))

else:

# Try to ignore types we don't know about

# Skip the payload for the resource record so the next

# records can be parsed correctly

self.offset += length

if rec is not None:

self.answers.append(rec)

def is_query(self):

"""Returns true if this is a query"""

return (self.flags & _FLAGS_QR_MASK) == _FLAGS_QR_QUERY

def is_response(self):

"""Returns true if this is a response"""

return (self.flags & _FLAGS_QR_MASK) == _FLAGS_QR_RESPONSE

def read_utf(self, offset, length):

"""Reads a UTF-8 string of a given length from the packet"""

return text_type(self.data[offset : offset + length], "utf-8", "replace")

def read_name(self):

"""Reads a domain name from the packet"""

result = ""

off = self.offset

next_ = -1

first = off

while True:

length = indexbytes(self.data, off)

off += 1

if length == 0:

break

t = length & 0xC0

if t == 0x00:

result = "".join((result, self.read_utf(off, length) + "."))

off += length

elif t == 0xC0:

if next_ < 0:

next_ = off + 1

off = ((length & 0x3F) << 8) | indexbytes(self.data, off)

if off >= first:

raise IncomingDecodeError(

"Bad domain name (circular) at %s" % (off,)

)

first = off

else:

raise IncomingDecodeError("Bad domain name at %s" % (off,))

if next_ >= 0:

self.offset = next_

else:

self.offset = off

return result

class DNSOutgoing(object):

"""Object representation of an outgoing packet"""

def __init__(self, flags, multicast=True):

self.finished = False

self.id = 0

self.multicast = multicast

self.flags = flags

self.names = {}

self.data = []

self.size = 12

self.state = self.State.init

self.questions = []

self.answers = []

self.authorities = []

self.additionals = []

def __repr__(self):

return "<DNSOutgoing:{%s}>" % ", ".join(

[

"multicast=%s" % self.multicast,

"flags=%s" % self.flags,

"questions=%s" % self.questions,

"answers=%s" % self.answers,

"authorities=%s" % self.authorities,

"additionals=%s" % self.additionals,

]

)

class State(enum.Enum):

init = 0

finished = 1

def add_question(self, record):

"""Adds a question"""

self.questions.append(record)

def add_answer(self, inp, record):

"""Adds an answer"""

if not record.suppressed_by(inp):

self.add_answer_at_time(record, 0)

def add_answer_at_time(self, record, now):

"""Adds an answer if it does not expire by a certain time"""

if record is not None:

if now == 0 or not record.is_expired(now):

self.answers.append((record, now))

def add_authorative_answer(self, record):

"""Adds an authoritative answer"""

self.authorities.append(record)

def add_additional_answer(self, record):

""" Adds an additional answer

From: RFC 6763, DNS-Based Service Discovery, February 2013

12. DNS Additional Record Generation

DNS has an efficiency feature whereby a DNS server may place

additional records in the additional section of the DNS message.

These additional records are records that the client did not

explicitly request, but the server has reasonable grounds to expect

that the client might request them shortly, so including them can

save the client from having to issue additional queries.

This section recommends which additional records SHOULD be generated

to improve network efficiency, for both Unicast and Multicast DNS-SD

responses.

12.1. PTR Records

When including a DNS-SD Service Instance Enumeration or Selective

Instance Enumeration (subtype) PTR record in a response packet, the

server/responder SHOULD include the following additional records:

o The SRV record(s) named in the PTR rdata.

o The TXT record(s) named in the PTR rdata.

o All address records (type "A" and "AAAA") named in the SRV rdata.

12.2. SRV Records

When including an SRV record in a response packet, the

server/responder SHOULD include the following additional records:

o All address records (type "A" and "AAAA") named in the SRV rdata.

"""

self.additionals.append(record)

def pack(self, format_, value):

self.data.append(struct.pack(format_, value))

self.size += struct.calcsize(format_)

def write_byte(self, value):

"""Writes a single byte to the packet"""

self.pack(b"!c", int2byte(value))

def insert_short(self, index, value):

"""Inserts an unsigned short in a certain position in the packet"""

self.data.insert(index, struct.pack(b"!H", value))

self.size += 2

def write_short(self, value):

"""Writes an unsigned short to the packet"""

self.pack(b"!H", value)

def write_int(self, value):

"""Writes an unsigned integer to the packet"""

self.pack(b"!I", int(value))

def write_string(self, value):

"""Writes a string to the packet"""

assert isinstance(value, bytes)

self.data.append(value)

self.size += len(value)

def write_utf(self, s):

"""Writes a UTF-8 string of a given length to the packet"""

utfstr = s.encode("utf-8")

length = len(utfstr)

if length > 64:

raise NamePartTooLongException

self.write_byte(length)

self.write_string(utfstr)

def write_character_string(self, value):

assert isinstance(value, bytes)

length = len(value)

if length > 256:

raise NamePartTooLongException

self.write_byte(length)

self.write_string(value)

def write_name(self, name):

"""

Write names to packet

18.14. Name Compression

When generating Multicast DNS messages, implementations SHOULD use

name compression wherever possible to compress the names of resource

records, by replacing some or all of the resource record name with a

compact two-byte reference to an appearance of that data somewhere

earlier in the message [RFC1035].

"""

# split name into each label

parts = name.split(".")

if not parts[-1]:

parts.pop()

# construct each suffix

name_suffices = [".".join(parts[i:]) for i in range(len(parts))]

# look for an existing name or suffix

for count, sub_name in enumerate(name_suffices):

if sub_name in self.names:

break

else: