Resumed GCD socket Source won't fire - macos

Question

I can't seem to accept TCP connections Grand Central Dispatch sources (dispatch_source_t) and I can't understand what I could possibly be doing wrong. I've gone through a lot of material and I'm still nowhere close (Apple's own documentation, Mike Ash's blog, etc.)
Of course, I could simply use third-party libraries (plenty on GitHub) but I'm trying to learn from this. Thank you.
I know the server is listening on the port since using telnet 127.0.0.1 6666 times out (but never actually connects) whereas any other port immediatly fails. The piece of code where I would accept() connections is never run.
class MyServer {
func startServing(#port: UInt16 = 6666) {
// Create a listeningSocket on TCP/IPv4.
println("\nStarting TCP server.\nCreating a listening Socket.")
let listeningSocket = socket(AF_INET, SOCK_STREAM, 0 /*IPPROTO_TCP*/)
if listeningSocket == -1 {
println("Failed!")
return
}
// Prepare an socket address.
var no_sig_pipe: Int32 = 1
setsockopt(listeningSocket, SOL_SOCKET, SO_NOSIGPIPE, &no_sig_pipe, socklen_t(sizeof(Int32)))
// Working around Swift's strict initialization policies
var addr = sockaddr_in( sin_len: __uint8_t(sizeof(sockaddr_in))
, sin_family: sa_family_t(AF_INET)
, sin_port: CFSwapInt16HostToBig(port)
, sin_addr: in_addr(s_addr: inet_addr("0.0.0.0"))
, sin_zero: (0, 0, 0, 0, 0, 0, 0, 0) )
var sock_addr = sockaddr( sa_len: 0
, sa_family: 0
, sa_data: (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0) )
memcpy(&sock_addr, &addr, UInt(sizeof(sockaddr_in)))
// bind() the socket to the address.
println("Binding socket to \(port).")
if bind(listeningSocket, &sock_addr, socklen_t(sizeof(sockaddr_in))) == POSIXSocketError {
println("Failed!")
close(listeningSocket)
return
}
// If we still have a working socket at this point...
if listeningSocket >= 0 {
println("Creating GCD Source.")
connectionSource = dispatch_source_create(DISPATCH_SOURCE_TYPE_READ, UInt(listeningSocket), 0, dispatch_get_global_queue(0,0) /*serverQueue*/)
if connectionSource == .None {
println("Failed!")
close(listeningSocket)
return
}
let myself = self
dispatch_source_set_event_handler( connectionSource, {
// *** This NEVER gets called!! ***
dispatch_async(dispatch_get_main_queue(), { println("GCD Src fired.") })
println("GCD Source triggered.")
myself.acceptConnections(listeningSocket)
})
dispatch_resume(connectionSource)
}
} // end func
} // end class

Answer 1

It looks like you just forgot to listen after you called bind. From Mike Ash's blog:
With the socket bound, the next step is to tell the system to listen
on it. This is done with, you guessed it, the listen function. It
takes two parameters: the socket to operate on, and the desired length
of the queue used for listening. This queue length tells the system
how many incoming connections you want it to sit on while trying to
hand those connections off to your program. Unless you have a good
reason to use something else, passing the SOMAXCONN gives you a safe,
large value.
So, after your bind call and error checking, and before you create your dispatch source, add something like:
if listen(listeningSocket, SOMAXCONN) != 0 {
println("Listen Failed!")
close(listeningSocket)
return
}
I cobbled a quick test together with your code and the above change and this fires off a slew of GCD Src fired. and GCD Source triggered. messages when a connection to the socket is made.