def stopadvertise(sock): details = __advertised.get(id(sock)) if details is None: raise _lightbluecommon.BluetoothError("no service advertised") name, servicetype = details _socket.bt_advertise_service(name, sock._sock, False, servicetype)
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 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 advertise(name, sock, servicetype): if servicetype == _lightbluecommon.RFCOMM: servicetype = _socket.RFCOMM elif servicetype == _lightbluecommon.OBEX: servicetype = _socket.OBEX else: raise ValueError("servicetype must be either RFCOMM or OBEX") name = unicode(name) # advertise the service _socket.bt_advertise_service(name, sock._sock, True, servicetype) # note details, for if advertising needs to be stopped later __advertised[id(sock)] = (name, servicetype)
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 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()
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) try: app_lock.wait() except: pass
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: #(rr,ww,er) = select.select([watch_client,sys.stdin],[],[]) (rr,ww,er) = select.select([watch_client],[],[]) for r in rr: if r == watch_client: