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 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 initMessageAdvertisements(self): """Initialize the advertisement of hashes that have been sent to us.""" # @TODO@ Use the correct database here :-) #self.database.query('select * from FluidNexusStigmergy') self.database.services() self.messageHashes = [] for item in self.database: # @TODO@ This can break if we change the database schema # Get the last item (the hash) self.messageHashes.append('%s' % item[-1]) # If there is nothing in the FluidNexusStigmergy database, return now if len(self.messageHashes) == 0: return # @HACK@ # For some reason we have to do this convoluted process below, otherwise sockets get reused or don't advertise properly. # Meaning, we have to create the sockets beforehand, and then loop through them to advertise with the desired hashes. # This seems strange, because we create the sockets anew before we advertise them, so it seems like some kind of race condition. # Get the number of hashes to advertise numAdvertise = len(self.messageHashes) # Create all of our advertisingSockets self.advertisingSockets = {} for counter in range(0, len(self.messageHashes)): if (self.library == "e32"): self.advertisingSockets[self.messageHashes[counter]] = socket.socket(socket.AF_BT, socket.SOCK_STREAM) elif (self.library == "lightblue"): self.advertisingSockets[self.messageHashes[counter]] = lightblue.socket() # Now, do what we need to with the sockets for item in self.advertisingSockets.items(): hash = item[0] s = item[1] if (self.library == "e32"): tempPort = socket.bt_rfcomm_get_available_server_channel(s) s.bind(("", tempPort)) s.listen(1) socket.bt_advertise_service(unicode(':' + hash), s, True, socket.RFCOMM) elif (self.library == "lightblue"): s.bind(("", 0)) s.listen(1) lightblue.advertise(unicode(':' + hash), s, lightblue.RFCOMM)
def advertiseNewHash(self, hash): """Advertise a new hash that we have just received.""" log.write(str(hash)) if (self.library == "e32"): newSocket = socket.socket(socket.AF_BT, socket.SOCK_STREAM) self.advertisingSockets[hash] = newSocket tempPort = socket.bt_rfcomm_get_available_server_channel(newSocket) newSocket.bind(("", tempPort)) newSocket.listen(1) socket.bt_advertise_service(unicode(':' + hash), newSocket, True, socket.RFCOMM) elif (self.library == "lightblue"): newSocket = lightblue.socket() self.advertisingSockets[hash] = newSocket newSocket.bind(("", 0)) newSocket.listen(1) lightblue.advertise(unicode(":" + hash), newSocket, lightblue.RFCOMM)
def _getavailableport(sock): # can just use bt_rfcomm_get_available_server_channel since only RFCOMM is # currently supported return _socket.bt_rfcomm_get_available_server_channel(sock._sock)
def __init__(self): self.sock = socket.socket(socket.AF_BT, socket.SOCK_STREAM) self.host = "" self.port = socket.bt_rfcomm_get_available_server_channel(self.sock)
connected = False if msg: heartbeat_start = time.time() eval_msg(msg) try: 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)
#from bluetooth import * import socket import select import sys import time 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: