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",

   162

             _CLASS_ANY : "any" }

   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",

   182

           _TYPE_ANY : "any" }

   183

   184

# utility functions

   185

   186

def currentTimeMillis():

   187

    """Current system time in milliseconds"""

   188

    return time.time() * 1000

   189

   190

# Exceptions

   191

   192

class NonLocalNameException(Exception):

   193

    pass

   194

   195

class NonUniqueNameException(Exception):

   196

    pass

   197

   198

class NamePartTooLongException(Exception):

   199

    pass

   200

   201

class AbstractMethodException(Exception):

   202

    pass

   203

   204

class BadTypeInNameException(Exception):

   205

    pass

   206

   207

# implementation classes

   208

   209

class DNSEntry(object):

   210

    """A DNS entry"""

   211

   212

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

   213

        self.key = string.lower(name)

   214

        self.name = name

   215

        self.type = type

   216

        self.clazz = clazz & _CLASS_MASK

   217

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

   218

   219

    def __eq__(self, other):

   220

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

   221

        if isinstance(other, DNSEntry):

   222

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

   223

        return 0

   224

   225

    def __ne__(self, other):

   226

        """Non-equality test"""

   227

        return not self.__eq__(other)

   228

   229

    def getClazz(self, clazz):

   230

        """Class accessor"""

   231

        try:

   232

            return _CLASSES[clazz]

   233

        except:

   234

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

   235

   236

    def getType(self, type):

   237

        """Type accessor"""

   238

        try:

   239

            return _TYPES[type]

   240

        except:

   241

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

   242

   243

    def toString(self, hdr, other):

   244

        """String representation with additional information"""

   245

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

   246

        if self.unique:

   247

            result += "-unique,"

   248

        else:

   249

            result += ","

   250

        result += self.name

   251

        if other is not None:

   252

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

   253

        else:

   254

            result += "]"

   255

        return result

   256

   257

class DNSQuestion(DNSEntry):

   258

    """A DNS question entry"""

   259

   260

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

   261

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

   262

            raise NonLocalNameException

   263

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

   264

   265

    def answeredBy(self, rec):

   266

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

   267

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

   268

   269

    def __repr__(self):

   270

        """String representation"""

   271

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

   272

   273

   274

class DNSRecord(DNSEntry):

   275

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

   276

   277

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

   278

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

   279

        self.ttl = ttl

   280

        self.created = currentTimeMillis()

   281

   282

    def __eq__(self, other):

   283

        """Tests equality as per DNSRecord"""

   284

        if isinstance(other, DNSRecord):

   285

            return DNSEntry.__eq__(self, other)

   286

        return 0

   287

   288

    def suppressedBy(self, msg):

   289

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

   290

        information held in this record."""

   291

        for record in msg.answers:

   292

            if self.suppressedByAnswer(record):

   293

                return 1

   294

        return 0

   295

   296

    def suppressedByAnswer(self, other):

   297

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

   298

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

   299

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

   300

            return 1

   301

        return 0

   302

   303

    def getExpirationTime(self, percent):

   304

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

   305

        by a certain percentage."""

   306

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

   307

   308

    def getRemainingTTL(self, now):

   309

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

   310

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

   311

   312

    def isExpired(self, now):

   313

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

   314

        return self.getExpirationTime(100) <= now

   315

   316

    def isStale(self, now):

   317

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

   318

        return self.getExpirationTime(50) <= now

   319

   320

    def resetTTL(self, other):

   321

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

   322

        another record."""

   323

        self.created = other.created

   324

        self.ttl = other.ttl

   325

   326

    def write(self, out):

   327

        """Abstract method"""

   328

        raise AbstractMethodException

   329

   330

    def toString(self, other):

   331

        """String representation with addtional information"""

   332

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

   333

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

   334

   335

class DNSAddress(DNSRecord):

   336

    """A DNS address record"""

   337

   338

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

   339

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

   340

        self.address = address

   341

   342

    def write(self, out):

   343

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

   344

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

   345

   346

    def __eq__(self, other):

   347

        """Tests equality on address"""

   348

        if isinstance(other, DNSAddress):

   349

            return self.address == other.address

   350

        return 0

   351

   352

    def __repr__(self):

   353

        """String representation"""

   354

        try:

   355

            return socket.inet_ntoa(self.address)

   356

        except:

   357

            return self.address

   358

   359

class DNSHinfo(DNSRecord):

   360

    """A DNS host information record"""

   361

   362

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

   363

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

   364

        self.cpu = cpu

   365

        self.os = os

   366

   367

    def write(self, out):

   368

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

   369

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

   370

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

   371

   372

    def __eq__(self, other):

   373

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

   374

        if isinstance(other, DNSHinfo):

   375

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

   376

        return 0

   377

   378

    def __repr__(self):

   379

        """String representation"""

   380

        return self.cpu + " " + self.os

   381

   382

class DNSPointer(DNSRecord):

   383

    """A DNS pointer record"""

   384

   385

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

   386

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

   387

        self.alias = alias

   388

   389

    def write(self, out):

   390

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

   391

        out.writeName(self.alias)

   392

   393

    def __eq__(self, other):

   394

        """Tests equality on alias"""

   395

        if isinstance(other, DNSPointer):

   396

            return self.alias == other.alias

   397

        return 0

   398

   399

    def __repr__(self):

   400

        """String representation"""

   401

        return self.toString(self.alias)

   402

   403

class DNSText(DNSRecord):

   404

    """A DNS text record"""

   405

   406

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

   407

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

   408

        self.text = text

   409

   410

    def write(self, out):

   411

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

   412

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

   413

   414

    def __eq__(self, other):

   415

        """Tests equality on text"""

   416

        if isinstance(other, DNSText):

   417

            return self.text == other.text

   418

        return 0

   419

   420

    def __repr__(self):

   421

        """String representation"""

   422

        if len(self.text) > 10:

   423

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

   424

        else:

   425

            return self.toString(self.text)

   426

   427

class DNSService(DNSRecord):

   428

    """A DNS service record"""

   429

   430

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

   431

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

   432

        self.priority = priority

   433

        self.weight = weight

   434

        self.port = port

   435

        self.server = server

   436

   437

    def write(self, out):

   438

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

   439

        out.writeShort(self.priority)

   440

        out.writeShort(self.weight)

   441

        out.writeShort(self.port)

   442

        out.writeName(self.server)

   443

   444

    def __eq__(self, other):

   445

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

   446

        if isinstance(other, DNSService):

   447

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

   448

        return 0

   449

   450

    def __repr__(self):

   451

        """String representation"""

   452

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

   453

   454

class DNSIncoming(object):

   455

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

   456

   457

    def __init__(self, data):

   458

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

   459

        self.offset = 0

   460

        self.data = data

   461

        self.questions = []

   462

        self.answers = []

   463

        self.numQuestions = 0

   464

        self.numAnswers = 0

   465

        self.numAuthorities = 0

   466

        self.numAdditionals = 0

   467

   468

        self.readHeader()

   469

        self.readQuestions()

   470

        self.readOthers()

   471

   472

    def readHeader(self):

   473

        """Reads header portion of packet"""

   474

        format = '!HHHHHH'

   475

        length = struct.calcsize(format)

   476

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

   477

        self.offset += length

   478

   479

        self.id = info[0]

   480

        self.flags = info[1]

   481

        self.numQuestions = info[2]

   482

        self.numAnswers = info[3]

   483

        self.numAuthorities = info[4]

   484

        self.numAdditionals = info[5]

   485

   486

    def readQuestions(self):

   487

        """Reads questions section of packet"""

   488

        format = '!HH'

   489

        length = struct.calcsize(format)

   490

        for i in range(0, self.numQuestions):

   491

            name = self.readName()

   492

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

   493

            self.offset += length

   494

   495

            question = DNSQuestion(name, info[0], info[1])

   496

            self.questions.append(question)

   497

   498

    def readInt(self):

   499

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

   500

        format = '!I'

   501

        length = struct.calcsize(format)

   502

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

   503

        self.offset += length

   504

        return info[0]