def run(socket):
     socket.bind((address, port))
     socket.listen()
     launched_event.set()
     try:
         socket.accept(timeout=self.DEFAULT_TIMEOUT)
         self.end_event.wait()
         socket.free()
     except Exception, e:
         traceback.print_exc(e)
         self.network.close()

 def loop(self):
     while not self.stop or self.clientManager.clients:            
         read = []
         write = []
         error = []
         
         for client in self.clientManager.clients:
             if client.shouldSelectForRead:
                 read.append(client)
             
             if client.shouldSelectForWrite:
                 write.append(client)
             
             if client.shouldSelectForError:
                 error.append(client)
         
         if not self.stop:
             # Add the server only if we're not stopping it
             read.append(self.ssocket)
         
         readable, writable, errored = select(read, write, error)
         
         for socket in readable:
             if socket is self.ssocket:
                 self.clientManager.clientJoined(*socket.accept())
             else:
                 if not socket.read():
                     # Client left
                     self.clientManager.clientLeft(socket)

 def run(self):
     """main loop : accepts incoming connections and receive messages"""
     
     self.log("run")
     
     while True:
         sockets_to_read = select.select([self.server_socket] + self.connected_clients + list(self.logged_clients.values()), [], [])[0]            
         
         self.log("sockets_to_read : {}".format(sockets_to_read))
         
         for socket in sockets_to_read:                 
             if socket is self.server_socket:
                 self.log("new connection")
                 # accept the new connection
                 client_socket = socket.accept()[0]
                 # add it to the client sockets list
                 self.connected_clients.append(client_socket)     
             else:
                 self.log("new message")          
                 try:
                     message = self.read_message(socket)                            
                     if message:
                         self.log(message.decode(ENCODING))     
                         self.handle_message(message, socket)                   
                     else:                                     
                         # the client has properly disconnected                            
                         self.close_client(socket)
                 except ConnectionResetError:
                     # the client has abruptly disconnected 
                     self.error("connection reset for socket {}".format(socket))
                     self.close_client(socket)
             
     # clean up
     self.server_socket.close()            

  def serve(self):
    while True:
      try:
        inputready,outputready,exceptready = select.select(self.servers.keys(), [], [], 0)
      except e:
        print e
        break

      for socket in inputready:
        if socket == self.server:
          client, address = socket.accept()
          self.recvConnection(client, address)
        else:
          try:
            data = socket.recv(2048)
            if data:
              if self.servers[socket].ready:
                self.recvData(socket, data)
              else:
                self.recvHandshake(socket, data)
            else:
              self.dropConnection(socket)
          except:
            self.dropConnection(socket)

      time.sleep(0.05)

      for client in self.servers.keys():
        if client != self.server:
          frame = self.servers[client].popFrameBuffer()
          if frame != None:
            self.handler[frame.opcode](client, frame)

    self.server.close()

def main():
    print("[HTT] Start server")
    socket = HTTPSocket()
    print("[HTT] bind 8080")
    socket.bind(8080)

    # get connection
    conn, addr = socket.accept()

    while conn is not None:

        thread = HTTPMainThread(conn, 1024, addr[0], addr[1])

        thread.run()

        conn, addr = socket.accept()

 def serve(self):
     self._running = True
     socket = evtapi.tcp_listener((self.host,self.port))
     while self._running:
       client, _ = socket.accept()
       Dispatcher(client,self.mapper).dispatch()
     socket.close()

 def __init__(self,socket):
     Thread.__init__(self)
     (conn, (ip,port)) = socket.accept()
     self.conn = conn
     self.ip = ip
     self.port = port
     print "[+] New thread started for "+ ip+ ":"+port

def Serve(socket, upload=True, download=True):
  while True:
    (s, addr) = socket.accept()
    if upload:
      thread.start_new_thread(Spew, (s,))
    if download:
      thread.start_new_thread(Sink, (s,))

 def run(self):
     while not self._stop_event.is_set():
         events = self._poller.poll()
         for fd, flag in events:
             if fd == self._pipe[0]:
                 # Stop requested
                 for client in (client for client in self.fd_map.values() if client is not self.server):
                     self._poller.unregister(client)
                     client.close()
                 self.fd_map = {}
                 break
             socket = self.fd_map[fd]
             if flag & (select.POLLIN | select.POLLPRI):
                 # Ready to read
                 if socket is self.server:
                     sock, addr = socket.accept()
                     if self.use_ssl:
                         try:
                             client_sock = ssl.wrap_socket(sock,
                                                           server_side=True,
                                                           certfile=self.cert,
                                                           keyfile=self.key)
                         except ssl.SSLError:
                             sock.close()
                             continue
                     else:
                         client_sock = sock
                     client = self.client_cls(client_sock, self.handler)
                     self.fd_map[client.fileno()] = client
                     self._poller.register(client, READ_WRITE)
                 else:
                     data = socket.recv(1024)
                     if data:
                         socket.data_received(data)
                     else:
                         self.fd_map.pop(fd)
                         self._poller.unregister(socket)
                         socket.close()
             elif flag & select.POLLHUP:
                 # Client hung up
                 self.fd_map.pop(fd)
                 self._poller.unregister(socket)
                 socket.close()
             elif flag & select.POLLOUT:
                 # Ready to send
                 try:
                     data = socket.write_queue.get_nowait()
                 except Queue.Empty:
                     pass
                 else:
                     if data is WSClientClose:
                         socket.close()
                     else:
                         socket.send(data)
             elif flag & select.POLLERR:
                 # Error
                 self.fd_map.pop(fd)
                 self._poller.unregister(socket)
                 socket.close()

def newConnections(socket):
    while True:
        sock, address = socket.accept()
        global total_connections
        connections.append(Client(sock, address, total_connections, "Name", True))
        connections[len(connections) - 1].start()
        print("New connection at ID " + str(connections[len(connections) - 1]))
        total_connections += 1

 def handle_request(self, socket):
     request, client_address = socket.accept()
     request = ssl.wrap_socket(request, keyfile=server_pkey, certfile=server_cert,
                               server_side=True)
     self.log(client_address)
     prox = Proxy()
     prox.connect(request)
     self.proxy.append(prox)

 def __prepare_read(self, input_id):
     input_format, socket, conn, file_like = self.inputs[input_id]
     if not conn:
         socket.listen(1)
         c = socket.accept()
         new_conn, addr = c
         conn = new_conn
         self.inputs[input_id] = (input_format, socket, conn, conn.makefile())

 def Accept( q, socket, port, id ):
   conn, addr = socket.accept()
   message = Message.fromRaw( conn.recv(1024) )
   if message.type == MessageType.AUTH:
     response = Message( MessageType.CONNECT, { "port" : port, "id" : id, "name" : message.get("name") } )
     q.put( response )
     conn.send( response.raw() )
     conn.close()

def get_player_connections(socket, connections):
    while(len(connections) < MAX_PLAYERS):
        connection, client_addr = socket.accept()
        if connection and client_addr:
            connections.append([connection, client_addr])
            msg = connection.recv(MAX_MSG_SIZE)
            print("player connected with message:" + msg)
            connection.sendall("\"ok\"")

def main():
    print "Starting server..."
    options.read_configuration()
    socket = get_socket()
    while True:
        print "Waiting for clients on TCP port " + globals.port
        sock, addr = socket.accept()
        Connect(sock, addr).start()

    def _accept_cb():
        connection, client_address = socket.accept()
        # Note: We don't have to put this socket in non blocking mode.
        #       This can cause crashes when sending big packets on OS X.

        posix_connection = PosixSocketConnection(connection)

        accept_callback(posix_connection)

 def accept(self, socket):
     while True:
         try:
             conn, addr = socket.accept()
             print "connected from ", addr
             t = ServerWorker(conn, addr)
             t.start()
         except KeyboardInterrupt:
             break

 def socket_callback(self, socket, cond):
     assert socket == self.socket
     if cond == GObject.IO_IN:
         (clientsocket, address) = socket.accept()
         log.info('connected: %s', address)
         self.listen_to_file(clientsocket.makefile('r', 1))
     else:
         log.info('cmdin_callback: %s %s', cmdin, cond)
     return True

 def listen(self):
   self.socket.listen(5) # max queue connect requests
   while True:
     (client_socket, address) = socket.accept()
     client_socket.setblocking(0)
     # save file descriptor for later use
     fd = client_socket.fileno()
     sockets[fd] = client_socket
     write_to_file()

def bob_get_from_alice(socket,debug):
	
	#wait to accept a connection - blocking call
	alice_socket, addr = socket.accept()
	data = alice_socket.recv(getReadSizeFromBuffer())
	
	if(debug):
		print '	this received from Alice:	'+data		
	return (alice_socket,data)