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

    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'