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

__author__ = "Paul Scott-Murphy"

    78

__email__ = "paul at scott dash murphy dot com"

    79

__version__ = "0.12"

    80

    81

import string

    82

import time

    83

import struct

    84

import socket

    85

import threading

    86

import select

    87

import traceback

    88

    89

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

    90

    91

# hook for threads

    92

    93

globals()['_GLOBAL_DONE'] = 0

    94

    95

# Some timing constants

    96

    97

_UNREGISTER_TIME = 125

    98

_CHECK_TIME = 175

    99

_REGISTER_TIME = 225

   100

_LISTENER_TIME = 200

   101

_BROWSER_TIME = 500

   102

   103

# Some DNS constants

   104

   105

_MDNS_ADDR = '224.0.0.251'

   106

_MDNS_PORT = 5353;

   107

_DNS_PORT = 53;

   108

_DNS_TTL = 60 * 60;  # one hour default TTL

   109

   110

_MAX_MSG_TYPICAL = 1460  # unused

   111

_MAX_MSG_ABSOLUTE = 8972

   112

   113

_FLAGS_QR_MASK = 0x8000  # query response mask

   114

_FLAGS_QR_QUERY = 0x0000  # query

   115

_FLAGS_QR_RESPONSE = 0x8000  # response

   116

   117

_FLAGS_AA = 0x0400  # Authorative answer

   118

_FLAGS_TC = 0x0200  # Truncated

   119

_FLAGS_RD = 0x0100  # Recursion desired

   120

_FLAGS_RA = 0x8000  # Recursion available

   121

   122

_FLAGS_Z = 0x0040   # Zero

   123

_FLAGS_AD = 0x0020  # Authentic data

   124

_FLAGS_CD = 0x0010  # Checking disabled

   125

   126

_CLASS_IN = 1

   127

_CLASS_CS = 2

   128

_CLASS_CH = 3

   129

_CLASS_HS = 4

   130

_CLASS_NONE = 254

   131

_CLASS_ANY = 255

   132

_CLASS_MASK = 0x7FFF

   133

_CLASS_UNIQUE = 0x8000

   134

   135

_TYPE_A = 1

   136

_TYPE_NS = 2

   137

_TYPE_MD = 3

   138

_TYPE_MF = 4

   139

_TYPE_CNAME = 5

   140

_TYPE_SOA = 6

   141

_TYPE_MB = 7

   142

_TYPE_MG = 8

   143

_TYPE_MR = 9

   144

_TYPE_NULL = 10

   145

_TYPE_WKS = 11

   146

_TYPE_PTR = 12

   147

_TYPE_HINFO = 13

   148

_TYPE_MINFO = 14

   149

_TYPE_MX = 15

   150

_TYPE_TXT = 16

   151

_TYPE_AAAA = 28

   152

_TYPE_SRV = 33

   153

_TYPE_ANY =  255

   154

   155

# Mapping constants to names

   156

   157

_CLASSES = { _CLASS_IN:   "in",

   158

             _CLASS_CS:   "cs",

   159

             _CLASS_CH:   "ch",

   160

             _CLASS_HS:   "hs",

   161

             _CLASS_NONE: "none",

   163

   164

_TYPES = { _TYPE_A:     "a",

   165

           _TYPE_NS:    "ns",

   166

           _TYPE_MD:    "md",

   167

           _TYPE_MF:    "mf",

   168

           _TYPE_CNAME: "cname",

   169

           _TYPE_SOA:   "soa",

   170

           _TYPE_MB:    "mb",

   171

           _TYPE_MG:    "mg",

   172

           _TYPE_MR:    "mr",

   173

           _TYPE_NULL:  "null",

   174

           _TYPE_WKS:   "wks",

   175

           _TYPE_PTR:   "ptr",

   176

           _TYPE_HINFO: "hinfo",

   177

           _TYPE_MINFO: "minfo",

   178

           _TYPE_MX:    "mx",

   179

           _TYPE_TXT:   "txt",

   180

           _TYPE_AAAA:  "quada",

   181

           _TYPE_SRV:   "srv",

   183

   184

# utility functions

   185

   186

   187

def currentTimeMillis():

   188

    """Current system time in milliseconds"""

   189

    return time.time() * 1000

   190

   191

# Exceptions

   192

   193

   194

class NonLocalNameException(Exception):

   195

    pass

   196

   197

   198

class NonUniqueNameException(Exception):

   199

    pass

   200

   201

   202

class NamePartTooLongException(Exception):

   203

    pass

   204

   205

   206

class AbstractMethodException(Exception):

   207

    pass

   208

   209

   210

class BadTypeInNameException(Exception):

   211

    pass

   212

   213

# implementation classes

   214

   215

   216

class DNSEntry(object):

   217

    """A DNS entry"""

   218

   219

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

   220

        self.key = string.lower(name)

   221

        self.name = name

   222

        self.type = type

   223

        self.clazz = clazz & _CLASS_MASK

   224

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

   225

   226

    def __eq__(self, other):

   227

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

   228

        if isinstance(other, DNSEntry):

   229

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

   230

        return 0

   231

   232

    def __ne__(self, other):

   233

        """Non-equality test"""

   234

        return not self.__eq__(other)

   235

   236

    def getClazz(self, clazz):

   237

        """Class accessor"""

   238

        try:

   239

            return _CLASSES[clazz]

   240

        except:

   241

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

   242

   243

    def getType(self, type):

   244

        """Type accessor"""

   245

        try:

   246

            return _TYPES[type]

   247

        except:

   248

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

   249

   250

    def toString(self, hdr, other):

   251

        """String representation with additional information"""

   252

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

   253

        if self.unique:

   254

            result += "-unique,"

   255

        else:

   256

            result += ","

   257

        result += self.name

   258

        if other is not None:

   259

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

   260

        else:

   261

            result += "]"

   262

        return result

   263

   264

   265

class DNSQuestion(DNSEntry):

   266

    """A DNS question entry"""

   267

   268

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

   269

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

   270

            raise NonLocalNameException

   271

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

   272

   273

    def answeredBy(self, rec):

   274

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

   275

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

   276

   277

    def __repr__(self):

   278

        """String representation"""

   279

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

   280

   281

   282

class DNSRecord(DNSEntry):

   283

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

   284

   285

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

   286

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

   287

        self.ttl = ttl

   288

        self.created = currentTimeMillis()

   289

   290

    def __eq__(self, other):

   291

        """Tests equality as per DNSRecord"""

   292

        if isinstance(other, DNSRecord):

   293

            return DNSEntry.__eq__(self, other)

   294

        return 0

   295

   296

    def suppressedBy(self, msg):

   297

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

   298

        information held in this record."""

   299

        for record in msg.answers:

   300

            if self.suppressedByAnswer(record):

   301

                return 1

   302

        return 0

   303

   304

    def suppressedByAnswer(self, other):

   305

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

   306

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

   307

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

   308

            return 1

   309

        return 0

   310

   311

    def getExpirationTime(self, percent):

   312

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

   313

        by a certain percentage."""

   314

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

   315

   316

    def getRemainingTTL(self, now):

   317

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

   318

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

   319

   320

    def isExpired(self, now):

   321

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

   322

        return self.getExpirationTime(100) <= now

   323

   324

    def isStale(self, now):

   325

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

   326

        return self.getExpirationTime(50) <= now

   327

   328

    def resetTTL(self, other):

   329

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

   330

        another record."""

   331

        self.created = other.created

   332

        self.ttl = other.ttl

   333

   334

    def write(self, out):

   335

        """Abstract method"""

   336

        raise AbstractMethodException

   337

   338

    def toString(self, other):

   339

        """String representation with addtional information"""

   340

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

   341

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

   342

   343

   344

class DNSAddress(DNSRecord):

   345

    """A DNS address record"""

   346

   347

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

   348

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

   349

        self.address = address

   350

   351

    def write(self, out):

   352

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

   353

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

   354

   355

    def __eq__(self, other):

   356

        """Tests equality on address"""

   357

        if isinstance(other, DNSAddress):

   358

            return self.address == other.address

   359

        return 0

   360

   361

    def __repr__(self):

   362

        """String representation"""

   363

        try:

   364

            return socket.inet_ntoa(self.address)

   365

        except:

   366

            return self.address

   367

   368

   369

class DNSHinfo(DNSRecord):

   370

    """A DNS host information record"""

   371

   372

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

   373

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

   374

        self.cpu = cpu

   375

        self.os = os

   376

   377

    def write(self, out):

   378

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

   379

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

   380

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

   381

   382

    def __eq__(self, other):

   383

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

   384

        if isinstance(other, DNSHinfo):

   385

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

   386

        return 0

   387

   388

    def __repr__(self):

   389

        """String representation"""

   390

        return self.cpu + " " + self.os

   391

   392

   393

class DNSPointer(DNSRecord):

   394

    """A DNS pointer record"""

   395

   396

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

   397

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

   398

        self.alias = alias

   399

   400

    def write(self, out):

   401

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

   402

        out.writeName(self.alias)

   403

   404

    def __eq__(self, other):

   405

        """Tests equality on alias"""

   406

        if isinstance(other, DNSPointer):

   407

            return self.alias == other.alias

   408

        return 0

   409

   410

    def __repr__(self):

   411

        """String representation"""

   412

        return self.toString(self.alias)

   413

   414

   415

class DNSText(DNSRecord):

   416

    """A DNS text record"""

   417

   418

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

   419

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

   420

        self.text = text

   421

   422

    def write(self, out):

   423

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

   424

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

   425

   426

    def __eq__(self, other):

   427

        """Tests equality on text"""

   428

        if isinstance(other, DNSText):

   429

            return self.text == other.text

   430

        return 0

   431

   432

    def __repr__(self):

   433

        """String representation"""

   434

        if len(self.text) > 10:

   435

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

   436

        else:

   437

            return self.toString(self.text)

   438

   439

   440

class DNSService(DNSRecord):

   441

    """A DNS service record"""

   442

   443

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

   444

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

   445

        self.priority = priority

   446

        self.weight = weight

   447

        self.port = port

   448

        self.server = server

   449

   450

    def write(self, out):

   451

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

   452

        out.writeShort(self.priority)

   453

        out.writeShort(self.weight)

   454

        out.writeShort(self.port)

   455

        out.writeName(self.server)

   456

   457

    def __eq__(self, other):

   458

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

   459

        if isinstance(other, DNSService):

   460

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

   461

        return 0

   462

   463

    def __repr__(self):

   464

        """String representation"""

   465

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

   466

   467

   468

class DNSIncoming(object):

   469

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

   470

   471

    def __init__(self, data):

   472

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

   473

        self.offset = 0

   474

        self.data = data

   475

        self.questions = []

   476

        self.answers = []

   477

        self.numQuestions = 0

   478

        self.numAnswers = 0

   479

        self.numAuthorities = 0

   480

        self.numAdditionals = 0

   481

   482

        self.readHeader()

   483

        self.readQuestions()

   484

        self.readOthers()

   485

   486

    def readHeader(self):

   487

        """Reads header portion of packet"""

   488

        format = '!HHHHHH'

   489

        length = struct.calcsize(format)

   490

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

   491

        self.offset += length

   492

   493

        self.id = info[0]

   494

        self.flags = info[1]

   495

        self.numQuestions = info[2]

   496

        self.numAnswers = info[3]

   497

        self.numAuthorities = info[4]

   498

        self.numAdditionals = info[5]

   499