Pure Swift solution for socket programming
(Remark: I am using println() for diagnostic output in this review instead of your
log.atLevelDebug(). The reason is that I wanted to test the code before posting
an answer.)

That seems to be working code (with one exception, see below), but there are some things that can be simplified
or improved.

nil is a possible value for any UnsafeMutablePointer&lt;T&gt;, so you can simplify your
initialization, for example:

var hints = addrinfo(
    ai_flags: AI_PASSIVE,       // Assign the address of my local host to the socket structures
    ai_family: AF_UNSPEC,       // Either IPv4 or IPv6
    ai_socktype: SOCK_STREAM,   // TCP
    ai_protocol: 0,
    ai_addrlen: 0,
    ai_canonname: nil,
    ai_addr: nil,
    ai_next: nil)




You traverse the address list from getaddrinfo with

var info = servinfo
while info != UnsafeMutablePointer&lt;addrinfo&gt;.null() {
    // ...
    info = info.memory.ai_next
}


Writing this as a for-loop might be easier to read:

for (var info = servinfo; info != nil; info = info.memory.ai_next) {
    // ...
}




Your printing of the numerical IP addresses with inet_ntop() does not work correctly,
the second argument must be the address of a struct in_addr/in6_addr
and not the address of struct sockaddr, for example:

var sin4addr = UnsafePointer&lt;sockaddr_in&gt;(info.memory.ai_addr).memory.sin_addr
var ipAddressString = [CChar](count:Int(INET_ADDRSTRLEN), repeatedValue: 0)
inet_ntop(
    info.memory.ai_family,
    &amp;sin4addr,
    &amp;ipAddressString,
    socklen_t(INET_ADDRSTRLEN))
let addressStr = String.fromCString(&amp;ipAddressString)


But the more modern interface is getnameinfo() (which works for both IPv4 and IPv6
addresses). Written as a separate utility function:

func sockaddrDescription(addr: UnsafePointer&lt;sockaddr&gt;) -&gt; String
{
    var host : String?
    var port : String?

    var hostBuffer = [CChar](count: Int(NI_MAXHOST), repeatedValue: 0)
    var servBuffer = [CChar](count: Int(NI_MAXSERV), repeatedValue: 0)

    if (getnameinfo(addr, socklen_t(addr.memory.sa_len),
                    &amp;hostBuffer, socklen_t(hostBuffer.count),
                    &amp;servBuffer, socklen_t(servBuffer.count),
                    NI_NUMERICHOST | NI_NUMERICSERV) == 0) {
            host = String.fromCString(hostBuffer)
            port = String.fromCString(servBuffer)
    }
    return "host: " + (host ?? "?") + " port: " + (port ?? "?")
}


which you could use as

for (var info = servinfo; info != nil; info = info.memory.ai_next) {
    let addrInfo = info.memory 

    let desc = sockaddrDescription(addrInfo.ai_addr)
    println(desc)
}




Instead of errno you could log strerror(errno) if any of the socket functions fails.
The error message string would be more instructive than a error number. For example:

status = bind(...)
if status == -1 {
    println("bind failed: " + String(UTF8String: strerror(errno))!)
}    




Your function prints all found IP addresses in debug mode, but binds the socket
only to the first one. The recommended practice (if I remember correctly, and I will
try to find a reference) is to


try all IP addresses until socket/bind/listen is successful, or
try to listen on all IP addresses.


is successful. In the first case, your main loop would look like

var socketDescriptor : Int32 = -1 // Invalid socket

for (var info = servinfo; info != nil; info = info.memory.ai_next) {
    let addrInfo = info.memory 

    let sd = socket(addrInfo.ai_family, addrInfo.ai_socktype, addrInfo.ai_protocol)
    if sd == -1 {
        println("socket failed: " + String(UTF8String: strerror(errno))!)
    } else {
        status = bind(sd, addrInfo.ai_addr, addrInfo.ai_addrlen)
        if status == -1 {
            println("bind failed: " + String(UTF8String: strerror(errno))!)
        } else {
            status = listen(sd, 1)
            if status == -1 {
                println("listen failed: " + String(UTF8String: strerror(errno))!)
            } else {
                // SUCCESS !!
                socketDescriptor = sd
                break
            }
        }
        close(sd)
    }
}


and then socketDescriptor is -1 or a valid socket descriptor which is bound and
listening.

The more Swifty way however would be to define an optional 

var socketDescriptor : Int32?


which is set to a valid socket descriptor or stays nil in the error case.