1

#  Multicast DNS Service Discovery for Python, v0.12

     2

#     Copyright (C) 2003, Paul Scott-Murphy

     3

#

     4

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

     5

#     using IP multicast.  It has been tested against the JRendezvous

     6

#     implementation from <a href="http://strangeberry.com">StrangeBerry</a>,

     7

#     and against the mDNSResponder from Mac OS X 10.3.8.

     8

     9

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

    10

#     modify it under the terms of the GNU Lesser General Public

    11

#     License as published by the Free Software Foundation; either

    12

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

    13

    14

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

    15

#     but WITHOUT ANY WARRANTY; without even the implied warranty of

    16

#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

    17

#     Lesser General Public License for more details.

    18

    19

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

    20

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

    21

#     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

    22

#

    23

#

    24

#

    25

# 0.12 update - allow selection of binding interface

    26

#          typo fix - Thanks A. M. Kuchlingi

    27

#          removed all use of word 'Rendezvous' - this is an API change

    28

#

    29

# 0.11 update - correction to comments for addListener method

    30

#                  support for new record types seen from OS X

    31

#                   - IPv6 address

    32

#                   - hostinfo

    33

#                  ignore unknown DNS record types

    34

#                  fixes to name decoding

    35

#                  works alongside other processes using port 5353 (e.g. on Mac OS X)

    36

#                  tested against Mac OS X 10.3.2's mDNSResponder

    37

#                  corrections to removal of list entries for service browser

    38

#

    39

# 0.10 update - Jonathon Paisley contributed these corrections:

    40

#                  always multicast replies, even when query is unicast

    41

#                  correct a pointer encoding problem

    42

#                  can now write records in any order

    43

#                  traceback shown on failure

    44

#                  better TXT record parsing

    45

#                  server is now separate from name

    46

#                  can cancel a service browser

    47

#

    48

#                  modified some unit tests to accommodate these changes

    49

#

    50

# 0.09 update - remove all records on service unregistration

    51

#                  fix DOS security problem with readName

    52

#

    53

# 0.08 update - changed licensing to LGPL

    54

#

    55

# 0.07 update - faster shutdown on engine

    56

#                  pointer encoding of outgoing names

    57

#                  ServiceBrowser now works

    58

#                  new unit tests

    59

#

    60

# 0.06 update - small improvements with unit tests

    61

#                  added defined exception types

    62

#                  new style objects

    63

#                  fixed hostname/interface problem

    64

#                  fixed socket timeout problem

    65

#                  fixed addServiceListener() typo bug

    66

#                  using select() for socket reads

    67

#                  tested on Debian unstable with Python 2.2.2

    68

#

    69

# 0.05 update - ensure case insensitivty on domain names

    70

#                  support for unicast DNS queries

    71

#

    72

# 0.04 update - added some unit tests

    73

#                  added __ne__ adjuncts where required

    74

#                  ensure names end in '.local.'

    75

#                  timeout on receiving socket for clean shutdown

    76

    77

    78

from __future__ import print_function

    79

import string

    80

import time

    81

import struct

    82

import socket

    83

import threading

    84

import select

    85

import traceback

    86

    87

    88

__author__ = "Paul Scott-Murphy"

    89

__email__ = "paul at scott dash murphy dot com"

    90

__version__ = "0.12"

    91

    92

    93

__all__ = ["Zeroconf", "ServiceInfo", "ServiceBrowser"]

    94

    95

# hook for threads

    96

    97

globals()['_GLOBAL_DONE'] = 0

    98

    99

# Some timing constants

   100

   101

_UNREGISTER_TIME = 125

   102

_CHECK_TIME = 175

   103

_REGISTER_TIME = 225

   104

_LISTENER_TIME = 200

   105

_BROWSER_TIME = 500

   106

   107

# Some DNS constants

   108

   109

_MDNS_ADDR = '224.0.0.251'

   110

_MDNS_PORT = 5353

   111

_DNS_PORT = 53

   112

_DNS_TTL = 60 * 60  # one hour default TTL

   113

   114

_MAX_MSG_TYPICAL = 1460  # unused

   115

_MAX_MSG_ABSOLUTE = 8972

   116

   117

_FLAGS_QR_MASK = 0x8000  # query response mask

   118

_FLAGS_QR_QUERY = 0x0000  # query

   119

_FLAGS_QR_RESPONSE = 0x8000  # response

   120

   121

_FLAGS_AA = 0x0400  # Authorative answer

   122

_FLAGS_TC = 0x0200  # Truncated

   123

_FLAGS_RD = 0x0100  # Recursion desired

   124

_FLAGS_RA = 0x8000  # Recursion available

   125

   126

_FLAGS_Z = 0x0040   # Zero

   127

_FLAGS_AD = 0x0020  # Authentic data

   128

_FLAGS_CD = 0x0010  # Checking disabled

   129

   130

_CLASS_IN = 1

   131

_CLASS_CS = 2

   132

_CLASS_CH = 3

   133

_CLASS_HS = 4

   134

_CLASS_NONE = 254

   135

_CLASS_ANY = 255

   136

_CLASS_MASK = 0x7FFF

   137

_CLASS_UNIQUE = 0x8000

   138

   139

_TYPE_A = 1

   140

_TYPE_NS = 2

   141

_TYPE_MD = 3

   142

_TYPE_MF = 4

   143

_TYPE_CNAME = 5

   144

_TYPE_SOA = 6

   145

_TYPE_MB = 7

   146

_TYPE_MG = 8

   147

_TYPE_MR = 9

   148

_TYPE_NULL = 10

   149

_TYPE_WKS = 11

   150

_TYPE_PTR = 12

   151

_TYPE_HINFO = 13

   152

_TYPE_MINFO = 14

   153

_TYPE_MX = 15

   154

_TYPE_TXT = 16

   155

_TYPE_AAAA = 28

   156

_TYPE_SRV = 33

   157

_TYPE_ANY = 255

   158

   159

# Mapping constants to names

   160

   161

_CLASSES = {

   162

    _CLASS_IN:   "in",

   163

    _CLASS_CS:   "cs",

   164

    _CLASS_CH:   "ch",

   165

    _CLASS_HS:   "hs",

   166

    _CLASS_NONE: "none",

   167

    _CLASS_ANY:  "any"

   168

}

   169

   170

_TYPES = {

   171

    _TYPE_A:     "a",

   172

    _TYPE_NS:    "ns",

   173

    _TYPE_MD:    "md",

   174

    _TYPE_MF:    "mf",

   175

    _TYPE_CNAME: "cname",

   176

    _TYPE_SOA:   "soa",

   177

    _TYPE_MB:    "mb",

   178

    _TYPE_MG:    "mg",

   179

    _TYPE_MR:    "mr",

   180

    _TYPE_NULL:  "null",

   181

    _TYPE_WKS:   "wks",

   182

    _TYPE_PTR:   "ptr",

   183

    _TYPE_HINFO: "hinfo",

   184

    _TYPE_MINFO: "minfo",

   185

    _TYPE_MX:    "mx",

   186

    _TYPE_TXT:   "txt",

   187

    _TYPE_AAAA:  "quada",

   188

    _TYPE_SRV:   "srv",

   189

    _TYPE_ANY:   "any"

   190

}

   191

   192

# utility functions

   193

   194

   195

def currentTimeMillis():

   196

    """Current system time in milliseconds"""

   197

    return time.time() * 1000

   198

   199

# Exceptions

   200

   201

   202

class NonLocalNameException(Exception):

   203

    pass

   204

   205

   206

class NonUniqueNameException(Exception):

   207

    pass

   208

   209

   210

class NamePartTooLongException(Exception):

   211

    pass

   212

   213

   214

class AbstractMethodException(Exception):

   215

    pass

   216

   217

   218

class BadTypeInNameException(Exception):

   219

    pass

   220

   221

# implementation classes

   222

   223

   224

class DNSEntry(object):

   225

    """A DNS entry"""

   226

   227

    def __init__(self, name, type, clazz):

   228

        self.key = string.lower(name)

   229

        self.name = name

   230

        self.type = type

   231

        self.clazz = clazz & _CLASS_MASK

   232

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

   233

   234

    def __eq__(self, other):

   235

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

   236

        if isinstance(other, DNSEntry):

   237

            return self.name == other.name and self.type == other.type and self.clazz == other.clazz

   238

        return 0

   239

   240

    def __ne__(self, other):

   241

        """Non-equality test"""

   242

        return not self.__eq__(other)

   243

   244

    def getClazz(self, clazz):

   245

        """Class accessor"""

   246

        try:

   247

            return _CLASSES[clazz]

   248

        except Exception:

   249

            return "?(%s)" % (clazz)

   250

   251

    def getType(self, type):

   252

        """Type accessor"""

   253

        try:

   254

            return _TYPES[type]

   255

        except Exception:

   256

            return "?(%s)" % (type)

   257

   258

    def toString(self, hdr, other):

   259

        """String representation with additional information"""

   260

        result = "%s[%s,%s" % (hdr, self.getType(self.type), self.getClazz(self.clazz))

   261

        if self.unique:

   262

            result += "-unique,"

   263

        else:

   264

            result += ","

   265

        result += self.name

   266

        if other is not None:

   267

            result += ",%s]" % (other)

   268

        else:

   269

            result += "]"

   270

        return result

   271

   272

   273

class DNSQuestion(DNSEntry):

   274

    """A DNS question entry"""

   275

   276

    def __init__(self, name, type, clazz):

   277

        if not name.endswith(".local."):

   278

            raise NonLocalNameException

   279

        DNSEntry.__init__(self, name, type, clazz)

   280

   281

    def answeredBy(self, rec):

   282

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

   283

        return self.clazz == rec.clazz and (self.type == rec.type or self.type == _TYPE_ANY) and self.name == rec.name

   284

   285

    def __repr__(self):

   286

        """String representation"""

   287

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

   288

   289

   290

class DNSRecord(DNSEntry):

   291

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

   292

   293

    def __init__(self, name, type, clazz, ttl):

   294

        DNSEntry.__init__(self, name, type, clazz)

   295

        self.ttl = ttl

   296

        self.created = currentTimeMillis()

   297

   298

    def __eq__(self, other):

   299

        """Tests equality as per DNSRecord"""

   300

        if isinstance(other, DNSRecord):

   301

            return DNSEntry.__eq__(self, other)

   302

        return 0

   303

   304

    def suppressedBy(self, msg):

   305

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

   306

        information held in this record."""

   307

        for record in msg.answers:

   308

            if self.suppressedByAnswer(record):

   309

                return 1

   310

        return 0

   311

   312

    def suppressedByAnswer(self, other):

   313

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

   314

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

   315

        if self == other and other.ttl > (self.ttl / 2):

   316

            return 1

   317

        return 0

   318

   319

    def getExpirationTime(self, percent):

   320

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

   321

        by a certain percentage."""

   322

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

   323

   324

    def getRemainingTTL(self, now):

   325

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

   326

        return max(0, (self.getExpirationTime(100) - now) / 1000)

   327

   328

    def isExpired(self, now):

   329

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

   330

        return self.getExpirationTime(100) <= now

   331

   332

    def isStale(self, now):

   333

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

   334

        return self.getExpirationTime(50) <= now

   335

   336

    def resetTTL(self, other):

   337

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

   338

        another record."""

   339

        self.created = other.created

   340

        self.ttl = other.ttl

   341

   342

    def write(self, out):

   343

        """Abstract method"""

   344

        raise AbstractMethodException

   345

   346

    def toString(self, other):

   347

        """String representation with addtional information"""

   348

        arg = "%s/%s,%s" % (self.ttl, self.getRemainingTTL(currentTimeMillis()), other)

   349

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

   350

   351

   352

class DNSAddress(DNSRecord):

   353

    """A DNS address record"""

   354

   355

    def __init__(self, name, type, clazz, ttl, address):

   356

        DNSRecord.__init__(self, name, type, clazz, ttl)

   357

        self.address = address

   358

   359

    def write(self, out):

   360

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

   361

        out.writeString(self.address, len(self.address))

   362

   363

    def __eq__(self, other):

   364

        """Tests equality on address"""

   365

        if isinstance(other, DNSAddress):

   366

            return self.address == other.address

   367

        return 0

   368

   369

    def __repr__(self):

   370

        """String representation"""

   371

        try:

   372

            return socket.inet_ntoa(self.address)

   373

        except Exception:

   374

            return self.address

   375

   376

   377

class DNSHinfo(DNSRecord):

   378

    """A DNS host information record"""

   379

   380

    def __init__(self, name, type, clazz, ttl, cpu, os):

   381

        DNSRecord.__init__(self, name, type, clazz, ttl)

   382

        self.cpu = cpu

   383

        self.os = os

   384

   385

    def write(self, out):

   386

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

   387

        out.writeString(self.cpu, len(self.cpu))

   388

        out.writeString(self.os, len(self.os))

   389

   390

    def __eq__(self, other):

   391

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

   392

        if isinstance(other, DNSHinfo):

   393

            return self.cpu == other.cpu and self.os == other.os

   394

        return 0

   395

   396

    def __repr__(self):

   397

        """String representation"""

   398

        return self.cpu + " " + self.os

   399

   400

   401

class DNSPointer(DNSRecord):

   402

    """A DNS pointer record"""

   403

   404

    def __init__(self, name, type, clazz, ttl, alias):

   405

        DNSRecord.__init__(self, name, type, clazz, ttl)

   406

        self.alias = alias

   407

   408

    def write(self, out):

   409

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

   410

        out.writeName(self.alias)

   411

   412

    def __eq__(self, other):

   413

        """Tests equality on alias"""

   414

        if isinstance(other, DNSPointer):

   415

            return self.alias == other.alias

   416

        return 0

   417

   418

    def __repr__(self):

   419

        """String representation"""

   420

        return self.toString(self.alias)

   421

   422

   423

class DNSText(DNSRecord):

   424

    """A DNS text record"""

   425

   426

    def __init__(self, name, type, clazz, ttl, text):

   427

        DNSRecord.__init__(self, name, type, clazz, ttl)

   428

        self.text = text

   429

   430

    def write(self, out):

   431

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

   432

        out.writeString(self.text, len(self.text))

   433

   434

    def __eq__(self, other):

   435

        """Tests equality on text"""

   436

        if isinstance(other, DNSText):

   437

            return self.text == other.text

   438

        return 0

   439

   440

    def __repr__(self):

   441

        """String representation"""

   442

        if len(self.text) > 10:

   443

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

   444

        else:

   445

            return self.toString(self.text)

   446

   447

   448

class DNSService(DNSRecord):

   449

    """A DNS service record"""

   450

   451

    def __init__(self, name, type, clazz, ttl, priority, weight, port, server):

   452

        DNSRecord.__init__(self, name, type, clazz, ttl)

   453

        self.priority = priority

   454

        self.weight = weight

   455

        self.port = port

   456

        self.server = server

   457

   458

    def write(self, out):

   459

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

   460

        out.writeShort(self.priority)

   461

        out.writeShort(self.weight)

   462

        out.writeShort(self.port)

   463

        out.writeName(self.server)

   464

   465

    def __eq__(self, other):

   466

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

   467

        if isinstance(other, DNSService):

   468

            return self.priority == other.priority and self.weight == other.weight and self.port == other.port and self.server == other.server

   469

        return 0

   470

   471

    def __repr__(self):

   472

        """String representation"""

   473

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

   474

   475

   476

class DNSIncoming(object):

   477

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

   478

   479

    def __init__(self, data):

   480

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

   481

        self.offset = 0

   482

        self.data = data

   483

        self.questions = []

   484

        self.answers = []

   485

        self.numQuestions = 0

   486

        self.numAnswers = 0

   487

        self.numAuthorities = 0

   488

        self.numAdditionals = 0

   489

   490

        self.readHeader()

   491

        self.readQuestions()

   492

        self.readOthers()

   493

   494

    def readHeader(self):

   495

        """Reads header portion of packet"""

   496

        format = '!HHHHHH'