def __init__(self, serviceName = u'FluidNexus', database = None, library="e32"):
"""Initialize the server be setting up the server socket and advertising the FluidNexus service."""
log.write("Starting Fluid Nexus Server")
# Save our database object
self.database = database
# Save our service name
self.serviceName = serviceName
self.mutex = thread.allocate_lock()
self.library = library
# Setup our server socket
if (self.library == "e32"):
self.serverSocket = socket.socket(socket.AF_BT, socket.SOCK_STREAM)
self.serverPort = socket.bt_rfcomm_get_available_server_channel(self.serverSocket)
self.serverSocket.bind(("", self.serverPort))
self.serverSocket.listen(self.numberConnections)
socket.bt_advertise_service(self.serviceName, self.serverSocket, True, socket.RFCOMM)
# Remove security protections
# @TODO@ Make sure this actually does what we want it to do!
socket.set_security(self.serverSocket, 0)
elif (self.library == "lightblue"):
self.serverSocket = lightblue.socket()
self.serverSocket.bind(("", 0))
self.serverSocket.listen(self.numberConnections)
lightblue.advertise(self.serviceName, self.serverSocket, lightblue.RFCOMM)
def listen(self, backlog):
self._sock.listen(backlog)
# when listen() is called, set a default security level since S60
# sockets are required to have a security level
# This should be changed later to allow to set security using
# setsockopt()
_socket.set_security(self._sock, _socket.AUTH)
def conectar(self, data):
print "bind done"
self.sock.bind((self.host, self.port))
self.sock.listen(1)
socket.bt_advertise_service(u"jurgen", self.sock, True, socket.RFCOMM)
socket.set_security(self.sock, socket.AUTH)
print "I am listening"
(self.conn, peer_addr) = self.sock.accept()
print "Connection from %s" % peer_addr
self.conn.send(self._tabuleiroString(data))
def chat_server():
server = socket.socket(socket.AF_BT, socket.SOCK_STREAM)
channel = socket.bt_rfcomm_get_available_server_channel(server)
server.bind(("", channel))
server.listen(1)
socket.bt_advertise_service(u"btchat", server, True, socket.RFCOMM)
socket.set_security(server, socket.AUTH | socket.AUTHOR)
print "Waiting for clients..."
conn, client_addr = server.accept()
print "Client connected!"
talk(conn, None)
def server_socket():
log("Attempting to create server")
try:
server = socket.socket(socket.AF_BT, socket.SOCK_STREAM)
server.bind(("", BT_CHANNEL))
server.listen(1)
socket.set_security(server, socket.AUTH | socket.AUTHOR)
socket.bt_advertise_service(BT_SERVICE_NAME, server, True, socket.RFCOMM)
conn, client_addr = server.accept()
return conn
except:
log("Failed to create connection")
return None
def server_socket():
log("Attempting to create server")
try:
server = socket.socket(socket.AF_BT, socket.SOCK_STREAM)
server.bind(("", BT_CHANNEL))
server.listen(1)
socket.set_security(server, socket.AUTH | socket.AUTHOR)
socket.bt_advertise_service(BT_SERVICE_NAME, server, True,
socket.RFCOMM)
conn, client_addr = server.accept()
return conn
except:
log("Failed to create connection")
return None
def start_two_player():
global two_player
global server
global connection
menu_message(u"Creating connection")
# OK, start the bluetooth server
try:
server_socket = socket.socket(socket.AF_BT, socket.SOCK_STREAM)
server_socket.bind(("", BT_CHANNEL))
menu_message(u"Waiting for opponent")
server_socket.listen(1)
socket.set_security(server_socket, socket.AUTH | socket.AUTHOR)
socket.bt_advertise_service(BT_SERVICE_NAME, server_socket, True, socket.RFCOMM)
connection, addr = server_socket.accept()
except:
menu_message(u"Failed to create connection")
print sys.exc_info()[0]
return
# Get the first command - should be 'start'
try:
start=connection.recv(1024)
if 'start'==start:
two_player=True
server=True
initialize_game()
play_game()
initialize_menu()
else:
initialize_menu()
menu_message(u"Recieved bad data")
except:
print sys.exc_info()[0]
initialize_menu()
menu_message(u"Connection failed")
connection.close()
server_socket.close()
app_lock.signal()
except:
pass
global server_socket, client_socket, connected, shutdown, timer, app_lock, heartbeat_timeout, heartbeat_start
connected = False
server_socket = socket.socket(socket.AF_BT, socket.SOCK_STREAM)
server_socket.setblocking(False)
port = socket.bt_rfcomm_get_available_server_channel(server_socket)
server_socket.bind(("", port))
server_socket.listen(5)
socket.bt_advertise_service(u"Bluetooth Server", server_socket, True,
socket.RFCOMM)
socket.set_security(server_socket, socket.AUTHOR)
while not shutdown:
timer.cancel()
if connected:
#print "heartbeat_timeout;", heartbeat_timeout, ",", "time.time()-heartbeat_start", time.time()-heartbeat_start
if (time.time() - heartbeat_start) > heartbeat_timeout:
disconnect_client()
continue
timer.after(0.1, recv_msg)
try:
app_lock.wait()
except:
pass
else:
from watch import parser
myparser = parser()
# Create server for clock to connect to
server = socket.socket(socket.AF_BT, socket.SOCK_STREAM, socket.BTPROTO_RFCOMM)
print server._sock
channel = socket.bt_rfcomm_get_available_server_channel(server._sock)
#channel = 1
print channel
server.bind(("", channel))
socket.bt_advertise_service(u"Serial", server._sock, True, socket.RFCOMM)
socket.set_security(server._sock, socket.AUTHOR)
server.listen(1)
print "Waiting..."
watch_client, client_info = server.accept()
print "Accepted connection from ", client_info
print dir(watch_client)
fd = None
try:
while True:
#(rr,ww,er) = select.select([watch_client,sys.stdin],[],[])
(rr,ww,er) = select.select([watch_client],[],[])
for r in rr:
if r == watch_client:
# if fd == None:
