The Ruby code to advertise a service is just a few lines:

require 'dnssd'
registration = DNSSD.register("", "_http._tcp", nil, 8080) do |register_reply|
  puts "Registration result: #{register_reply.inspect}"
end
puts "Registration started"
sleep 30
registration.stop
puts "Registration stopped"

This code:

If you save this file as register.rb and run it, you should see something like this:

% ruby register.rb
Registration started
Registration result: #<DNSSD::RegisterReply Stuart32Cheshire's32PowerBook
032G4._http._tcp.local.>
Registration stopping

If you’re new to Ruby, some explanation is called for. Ruby supports code blocks as first-class entities, much like integers or strings in other languages. The block of code from do to end is not equivalent to a similar block of code enclosed within curly braces in C. In C, lines of code in a routine execute more or less sequentially. The body of an if or for statement enclosed within curly braces may be executed zero, one, or more times, but it’s always executed before the lines that appear later in the routine. In Ruby , the block of code from do to end is actually a parameter passed to the DNSSD.register() routine. It doesn’t execute at all until DNSSD.register() decides it’s time to execute it, asynchronously, on an automatically created background thread. If you save the program above as register.rb and then run it by typing ruby register.rb, you’ll see that it prints the “Registration started” message before the “Registration result...” message.

Following the “do” keyword, you’ll see an identifier enclosed between a pair of vertical bar symbols (the same character as the Unix “pipe” symbol), which names the parameter that is passed to the code block when it executes, rather like the parameter list enclosed in parentheses when you declare a C function.

In some ways, a Ruby code block is somewhat similar to passing a function pointer in a C program—there’s some code to execute and a parameter that’s passed to that code—but there’s one important difference. A Ruby code block is what computer scientists call a closure. It’s not just the code but also its environment. Similar to the way the body of an if or for statement may access local variables declared in the enclosing function, the Ruby code block passed to DNSSD.register() may access local variables declared in the enclosing function, even though the code block might not even get to execute until after the function that created it has exited. The Ruby interpreter knows that there’s a code block that has access to those local variables and makes sure that they continue to remain valid even after the function that declared them has exited.

If you want to register a service with TXT record attributes, Ruby DNS-SD supports that too. The full signature of the DNSSD.register() function is as shown here:

DNSSD.register(name, type, domain, port,
   text_record=nil, flags=0, interface=DNSSD::InterfaceAny) {|reply| block }

Ruby supports automatic default values for unspecified parameters. In this example, we didn’t specify anything for text_record, flags or interface, so they automatically got the default values nil, 0, and DNSSD::InterfaceAny. If you want to register a service with TXT record attributes, you just need to pass a hash (key/value) or a string in the proper format for the text_record parameter.

The general structure of the Ruby code to browse for services follows the same outline as the code to register a service:

require 'dnssd'
browser = DNSSD.browse('_http._tcp') do |browse_reply|
  if (browse_reply.flags.to_i & DNSSD::Flags::Add) != 0
    puts "Add: #{browse_reply.inspect}"
  else
    puts "Rmv: #{browse_reply.inspect}"
  end
end
puts "Browsing started"
sleep 30
browser.stop
puts "Browsing stopped"

If you save this file as browse.rb and run it, you should see something like this:

% ruby browse.rb
Browsing started
Add: #<DNSSD:: BrowseReply Stuart32Cheshire's32PowerBook32G4._
http._tcp.local. interface:lo0>
Browsing stopping

When you’ve browsed to discover available services, and the user has picked one, the next step is to resolve the named service to its target host and port number:

require 'dnssd'
name = ARGV.shift
puts "Resolving: #{name}"
resolver = DNSSD.resolve(name, "_http._tcp", "local") do |resolve_reply|
  puts "Resolve result: #{resolve_reply.inspect}"
end
puts "Resolver started"
sleep 30
resolver.stop
puts "Resolver stopped"

If you save this file as resolve.rb and run it, you should see something like this:

% ruby resolve.rb "Stuart Cheshire's PowerBook G4"
Resolving: Stuart Cheshire's PowerBook G4
Resolver started
Resolve result: #<DNSSD::ResolveReply Stuart32Cheshire's32PowerBook32G4.
_http._tcp.local. interface:en0 target:chesh7.local.:123>
Resolver stopped

In a real program, you’d take the resolve results you get and use them to initiate connections, and as soon as one succeeds, you’d then cancel the ongoing resolve operation.

The Python code to advertise a service is a little longer than the Ruby code, but it’s still quite simple:

import sys
import time
import select
import socket
import bonjour

# Callback for service registration 

def RegisterCallback(sdRef, flags, errorCode, name, regtype, domain, context):
    print "Service registered:", name, regtype, domain

if len(sys.argv) < 4:
    print "Usage: register.py servicename regtype port"
    sys.exit(1)

servicename = sys.argv[1]
regtype = sys.argv[2]
port = int(sys.argv[3])

# Allocate a service discovery reference and register the specified service
flags = 0
interfaceIndex = 0
domain = ''
host = ''
txtLen = 0
txtRecord = ''
userdata = None
serviceRef = bonjour.AllocateDNSServiceRef()
ret = bonjour.pyDNSServiceRegister(serviceRef,
                                   flags,
                                   interfaceIndex,
                                   servicename,
                                   regtype,
                                   domain,
                                   host,
                                   port,
                                   txtLen,
                                   txtRecord,
                                   RegisterCallback,
                                   userdata)


if ret != bonjour.kDNSServiceErr_NoError:
    print "error %d returned; exiting" % ret
    sys.exit(ret)

# Get the socket and loop
fd = bonjour.DNSServiceRefSockFD(serviceRef)
while 1:
    ret = select.select([fd], [], [])
    ret = bonjour.DNSServiceProcessResult(serviceRef)

# Deallocate the service discovery ref
bonjour.DNSServiceRefDeallocate(serviceRef)

This code:

If you save this file as register.py and run it, you should see something like this:

% python register.py "" _http._tcp 123
Service registered: Stuart Cheshire's PowerBook G4 _http._tcp. local.

In this case, we’re just using an empty string name to advertise the service using the system default name, but as with the other APIs, if you want something else you can specify an explicit name instead.

It should be little surprise by now to see that the outline of the browsing code looks a lot like the service registration code:

import sys
import select
import bonjour

# Callback for service browsing
def BrowseCallback(sdRef, flags, interfaceIndex,
    errorCode, serviceName, regtype, replyDomain, userdata):
    if flags & bonjour.kDNSServiceFlagsAdd:
        print "Service added:   ", serviceName, regtype, replyDomain, interfaceIndex
    else:
        print "Service removed: ", serviceName, regtype, replyDomain, interfaceIndex

if len(sys.argv) < 2:
    print "Usage: browse.py regtype"
    sys.exit(1)

regtype = sys.argv[1]

# Allocate a service discovery ref and browse for the specified service type
flags = 0
interfaceIndex = 0
domain = ''
userdata = None
serviceRef = bonjour.AllocateDNSServiceRef()
ret = bonjour.pyDNSServiceBrowse(serviceRef,
                                    flags,
                                    interfaceIndex,
                                    regtype,
                                    domain,
                                    BrowseCallback,
                                    userdata)

if ret != bonjour.kDNSServiceErr_NoError:
    print "ret = %d; exiting" % ret
    sys.exit(1)

# Get socket descriptor and loop
fd = bonjour.DNSServiceRefSockFD(serviceRef)
while 1:
    ret = select.select([fd], [], [])
    ret = bonjour.DNSServiceProcessResult(serviceRef)

# Deallocate the service discovery ref
bonjour.DNSServiceRefDeallocate(serviceRef)

This code:

If you save this file as browse.py and run it, you should see something like this:

% python browse.py _http._tcp
Service added:    Stuart Cheshire's PowerBook G4 _http._tcp. local. 4

This browse operation will run indefinitely, reporting as services come and go, until you press Ctrl-C to stop it.

When you’ve browsed to discover available services, and the user has picked one, the next step is to resolve the named service to its target host and port number:

iimport sys
import select
import bonjour

# Callback for service resolving
def ResolveCallback(sdRef, flags, interfaceIndex,
                    errorCode, fullname, hosttarget,
                    port, txtLen, txtRecord, userdata):
    print "Service:", fullname
    print "is at", hosttarget, ":", port

if len(sys.argv) < 4:
    print "Usage: resolve.py serviceName serviceType serviceDomain"
    sys.exit(1)

serviceName   = sys.argv[1]
serviceType   = sys.argv[2]
serviceDomain = sys.argv[3]

# Allocate a service discovery ref and resolve the named service
flags = 0
interfaceIndex = 0
userdata = None
serviceRef = bonjour.AllocateDNSServiceRef()
ret = bonjour.pyDNSServiceResolve(serviceRef,
                                  flags,
                                  interfaceIndex,
                                  serviceName,
                                  serviceType,
                                  serviceDomain,
                                  ResolveCallback,
                                  userdata);

if ret != bonjour.kDNSServiceErr_NoError:
    print "ret = %d; exiting" % ret
    sys.exit(1)

# Get socket descriptor and loop
fd = bonjour.DNSServiceRefSockFD(serviceRef)
while 1:
    ret = select.select([fd], [], [])
    ret = bonjour.DNSServiceProcessResult(serviceRef)

# Deallocate the service discovery ref
bonjour.DNSServiceRefDeallocate(serviceRef)

If you save this file as resolve.py and run it, you should see something like this:

% python resolve.py "Stuart Cheshire's PowerBook G4" _http._tcp. local.
Service: Stuart32Cheshire's32PowerBook32G4._http._tcp.local.
is at chesh7.local. : 123

In a real program, you’d take the resolve results you get and use them to initiate connections, and as soon as one succeeds, you’d then cancel the ongoing resolve operation.