def get_signature(self, ith_witness, request, reply_queue): request.witnessCount = ith_witness serialized_request = request.SerializeToString() witness = self.select_witness(request.transaction, ith_witness) socket = gevent.socket.create_connection(self.addressList[witness]) send_msg(socket, b'\x10' + serialized_request) try: if select.select([socket], [], [], 1)[0]: data = recv_msg(socket) if not data: socket.close() else: if data[:1] == b'\x11': result = data[1:] reply_queue.put(result) socket.shutdown(gevent.socket.SHUT_RDWR) else: # self.log("signature collection handler timed out") socket.close() reply_queue.put(None) except (ConnectionAbortedError, ConnectionResetError) as e: reply_queue.put(None)
def handler( socket, address ): qid = self.start_query( 0 ) #print "Connection accepted" conn = RedisProtocol.RedisProtocol( socket ) try: while True: data = conn.receive() if not data: break (status, response) = self.execute( qid, data ) if status: conn.send_response( response ) else: conn.send_error( response ) #print status, response except gevent.socket.error: #print sys.exc_info() #print "Connection closed" pass self.end_query( qid ) socket.close()
def delete(MAC, socket, connection, cursor, task): """删除设备命令,这个命令由用户通过移动应用发送,从全局变量`greenlets`以及数据库删除这个设备 :param MAC: 设备的物理地址(唯一标志) :param socket: 设备和程序之间的链接 :param connection: 当前协程的数据库链接(每个协程使用独立的数据库链接) :param cursor: 当前协程的数据库游标(每个协程使用独立的数据库游标) :param task: 删除设备命令的具体内容(json类型) :return: 无返回值 """ del greenlets[MAC] cursor.execute("DELETE FROM device WHERE mac = %s", MAC) logging.debug(cursor._last_executed) logging.info("%s 设备已被删除" % MAC) return_status(task["id"], 0, "%s 设备已被删除" % MAC) cursor.close() connection.close() socket.close()
def server_thread(): for num in xrange(2): socket, addr = self.server_socket.accept() if num == 1: server = ServerConnection(socket, addr) server.send_message(("second", )) socket.close()
def message_handler(self, socket, addres): while True: inputready, outputready, exceptready = select.select([socket], [], [], 0.1) if inputready: data = recv_msg(socket) if not data: socket.close() break if data[:1] == b"\xf0": socket.shutdown(gevent.socket.SHUT_WR) received_node = trustchain_pb2.Node() received_node.ParseFromString(data[1:]) if addres[0] == "127.0.0.1": received_node.IP = self.myIP else: received_node.IP = addres[0] self.nodeList.nodes.add().CopyFrom(received_node) print("{} connected from {}".format( received_node.friendlyName, received_node.IP)) else: print("Tiny master timeout, but that's oke ;)") socket.close() break self.send_peerlist()
def status(socket, addr): pool = lb.pool status = pool.status() writer = socket.makefile('w') writer.write(json.dumps(status) + '\n') writer.close() socket.close()
def handle(sock, addr): print 'new client:', addr socket = pwrtls.wrap_socket(sock, server_side=True, **state) socket.do_handshake() print 'remote longpub', socket.remote_longpub.encode('hex') forward(socket, sys.stdout) print 'client gone', addr socket.close()
def close(self): if not self.is_connected: return socket = self.socket self.socket = None self.buffer = b'' socket.close()
def sigkill(sig, frame): for nfqueue in nf_queues: nfqueue.unbind() for socket in sockets: socket.close() print("closing") sys.exit(0)
def client_service(): for socket in client_list: print("2") data = socket.recv(1024) if not data: socket.close() return else: send_data = "return : ".encode("gb2312")+ data socket.send(send_data)
def send_to_master(self, payload): socket = gevent.socket.create_connection(self.master_address) send_msg(socket, b'\xf1' + payload.encode('utf-8')) if select.select([socket], [], [], 1)[0]: data = recv_msg(socket) socket.shutdown(gevent.socket.SHUT_RDWR) if not data: socket.close() self.state = 0 return
def client_service(socket): while True: print("2") data = socket.recv(1024) if not data: socket.close() return else: send_data = "return : ".encode("gb2312") + data socket.send(send_data)
def __call__(self, socket, address): ("__call__(" "socket:gevent.socket.socket, " "address:Tuple[str, int]" ") -> None") reader = socket.makefile(mode='rb') try: while 1: with gevent.Timeout(header_parsing_timeout): try: environ = new_environ(reader, server_side=True) except: if self.verbose and \ logging.DEBUG >= gvars.levels[self.verbose]: raise else: return environ['REMOTE_ADDR'] = address[0] environ['REMOTE_PORT'] = address[1] rw = self.file_type(socket, reader, environ) try: self.handler(rw) except: if self.verbose and \ logging.DEBUG >= gvars.levels[self.verbose]: raise else: return if not rw.closed or rw.disconnected: return if environ.get('HTTP_CONNECTION', '') \ .lower() == 'keep_alive': keep_alive = environ.get('HTTP_KEEP_ALIVE', '300') else: keep_alive = environ.get('HTTP_KEEP_ALIVE') if keep_alive is None or \ not regx_keep_alive.match(keep_alive): return left = rw.left if 8192 > left > 0: reader.read(left) if left != 0: return n_keep_alive = min(int(keep_alive), max_keep_alive) try: gevent.socket.wait_read(socket.fileno(), n_keep_alive) except: if self.verbose and \ logging.DEBUG >= gvars.levels[self.verbose]: raise else: return finally: reader.close() socket.close()
def on_handle(socket, address): try: fileobj = socket.makefile() while True: data = fileobj.readline() if not data: # client disconnected break socket.sendall(data) finally: socket.close()
def on_handle(socket, address): try: fileobj = socket.makefile() #encoding="utf-8", errors="ignore" while True: data = fileobj.readline() if not data: # client disconnected break socket.sendall(bytes(data, "utf-8")) finally: socket.close()
def app(socket, address): checked_order, filepath = get_order(socket) print checked_order if not checked_order: ss = socket.send('No file need send.') socket.close() return ss = socket.send(json.dumps(checked_order)) for file in checked_order: status = trans_file(socket, os.path.join(filepath, file[0]), file[1], file[2]) print status socket.close() return
def handle(self, socket, address): fd = socket.makefile() while True: line = fd.readline() if not line: break name, value, timestamp = line.split() ds = self.context.get_data_source(name) ds.submit(int(timestamp), float(value)) socket.shutdown(gevent.socket.SHUT_RDWR) socket.close()
def do_request(): siteid = random.choice(siteids) oids = set( int(random.gauss(0, settings.objects_per_site/4)) for i in range(settings.objects_per_request) ) socket = gevent.socket.create_connection(waddr) try: socket.sendall( request_template % dict( data='_'.join(map(str, oids)), host='h%s' % siteid, ) ) response = '' while '\r\n\r\n' not in response: data = socket.recv(9999) if not data: stats.truncated += 1 return response += data headers, body = response.split('\r\n\r\n') headers = headers.split('\r\n') status = headers.pop(0) headers = dict(l.strip().lower().split(':', 1) for l in headers if ':' in l) content_length = int(headers['content-length']) while len(body) < content_length: data = socket.recv(9999) if not data: stats.truncated += 1 return body += data pid, n, nhit, nmiss, nevict = map(int, body.strip().split()) stats.requests += 1 stats.nobs += n stats.nhits += nhit bypid = stats.bypid.get(pid) if bypid is None: bypid = stats.bypid[pid] = dict(nr=0, n=0, nhit=0) bypid['nr'] += 1 bypid['n'] += n bypid['nhit'] += nhit logger.info(' '.join(map(str, ( 100*stats.nhits/stats.nobs, pid, n, nhit, 100*nhit/n, )))) finally: socket.close()
def NewChunk(self, arg): print type(arg) guids = self.registry.keys() x = random.choice(guids) print "Relay NewChunk to ", x ckinfo = self.registry[x] socket = gevent.socket.socket() socket.connect((ckinfo.ServiceAddress, ckinfo.ServicePort)) try: ret = self.stub.callMethod("NewChunk", arg, socket) finally: socket.close() print "Got response: ", ret return ret
def handle_connection(socket, address): request_line = read_line(socket) try: request_type, request_path, http_version = request_line.split(" ") except: socket.close() print "new request", request_line headers = {} while (True): l = read_line(socket) if (l == '\r\n'): break if (not l): return header_type, data = l.split(": ", 1) headers[header_type] = data post_data = None if (request_type == "POST" and headers.get("Content-Length", None)): n = int(headers.get("Content-Length", "0").strip(" \r\n")) if (n > 0): data = "" while (len(data) < n): bts = socket.recv(n) if (not bts): break data += bts post_data = urlparse.parse_qs(data) ##app specific headers auth_key = headers.get("auth-key", None) user = None if (auth_key): #decode and get user auth_key = urllib.unquote(auth_key).strip() user = User.objects.get( pk=decode_signed_value(config.SERVER_SECRET, "auth_key", auth_key)) for handler in request_handlers: args = handler[0].match(request_path) func = handler[1] kwargs = {"user": user} if (post_data != None): kwargs["post"] = post_data if (args != None): fargs = args.groups() if (fargs): func(socket, *fargs, **kwargs) else: func(socket, **kwargs)
def handle_connection(socket, address): request_line = read_line(socket) try: request_type , request_path , http_version = request_line.split(" ") except: socket.close() print "new request", request_line headers = {} while(True): l = read_line(socket) if(l=='\r\n'): break if( not l): return header_type , data = l.split(": ",1) headers[header_type] = data post_data = None if(request_type == "POST" and headers.get("Content-Length", None)): n = int(headers.get("Content-Length","0").strip(" \r\n")) if(n>0): data = "" while(len(data) < n): bts = socket.recv(n) if(not bts): break data +=bts post_data = urlparse.parse_qs(data) ##app specific headers auth_key = headers.get("auth-key", None) user = None if(auth_key): #decode and get user auth_key = urllib.unquote(auth_key).strip() user = User.objects.get(pk = decode_signed_value(config.SERVER_SECRET , "auth_key", auth_key)) for handler in request_handlers: args = handler[0].match(request_path) func = handler[1] kwargs = {"user":user} if(post_data!=None): kwargs["post"] = post_data if(args!=None): fargs = args.groups() if(fargs): func(socket, *fargs , **kwargs) else: func(socket, **kwargs)
def handle(self, socket, address): fd = socket.makefile() while True: line = fd.readline() if not line: break name, value, timestamp = line.split() _, _, datapoint = name.partition('.') ds = self.context.get_data_source( 'localhost.{0}'.format(datapoint)) ds.submit(int(timestamp), float(value)) socket.shutdown(gevent.socket.SHUT_RDWR) socket.close()
def connect(self, addr, workletts, version): try: while addr in self.worker_addrs: try: socket = gevent.socket.create_connection(addr) Worker(self.pool, socket, addr, version) except gevent.GreenletExit, v: try: socket.close() except: pass raise except Exception, v: logger.exception('lb connecting to %r', addr) gevent.sleep(self.connect_sleep)
def handle_api_request(socket, address): stats['api_request_cnt'] += 1 timeout = Timeout.start_new(rpc_timeout) try: req = msgpack_unpack_msg_from_socket(socket) logger.info('%s %s', address, req['endpoint']) handler = api_request_handlers.get(req['endpoint']) if handler is not None: handler(socket, address, req) else: logger.info('-> %s unknown request', address) socket.sendall(msgpack.packb('UNKNOWN')) except Timeout: stats['api_request_timeout_cnt'] += 1 logger.info('-> %s timeout', address) socket.sendall(msgpack.packb('TIMEOUT')) finally: timeout.cancel() socket.close()
def status(socket, addr): pool = lb.pool writer = socket.makefile('w') writer.write(json.dumps( dict( backlog = pool.backlog, mean_backlog = pool.mbacklog, workers = [ (worker.__name__, worker.backlog, worker.mbacklog, (int(worker.oldest_time) if worker.oldest_time else None), ) for worker in sorted( pool.workers, key=lambda w: w.__name__) ] ))+'\n') writer.close() socket.close()
def connect_to_master(self): peer = trustchain_pb2.Node() peer.friendlyName = self.id peer.ID = bytes(self.signing_key.verify_key) peer.IP = "127.0.0.1" peer.port = self.port print(self.master_address) # self.log("{} started: {}".format(self.id, peer.SerializeToString())) socket = gevent.socket.create_connection(self.master_address) send_msg(socket, b'\xf0' + peer.SerializeToString()) if select.select([socket], [], [], 1)[0]: data = recv_msg(socket) if not data: socket.close() self.state = 0 return else: logging.warning("Message Handler Timed out") socket.close()
def handle_connection(self, socket, address): start = datetime.datetime.now() data = socket.recv(104857600) end = datetime.datetime.now() data = data.split('\n') if self.debug: print("New incoming {} connection from {}".format(data[0], address)) if data[0] == 'ECHO': socket.send(data[0]) socket.close() elif data[0] == 'UPDATE': data = json.loads(data[1]) self.handle_update(data) self.propagate_update(data) socket.close() elif data[0] == 'DATA': print start print end delay = (((end - start) / 2).microseconds) / 1000.0 print delay data = json.loads(data[1]) self.handle_data(data) self.propagate_data(data) socket.close(); elif data[0] == 'STATUS': status = 'Node: ' + self.this_node + '\n' status += 'Connected nodes: ' + str(self.g.nodes()) + '\n' for a,b in self.g.edges(): status += str(a) + ' ' + str(b) + ' ' + str(self.g[a][b]['weight']) + '\n' if self.debug: print status socket.send(status) socket.close() else: print 'UNRECOG: ' print data
def handle_api_request(socket, address): metrics.incr('api_request_cnt') timeout = Timeout.start_new(rpc_timeout) try: req = msgpack_unpack_msg_from_socket(socket) if not req: logger.warning('Couldn\'t get msgpack data from %s', address) socket.close() return access_logger.info('%s %s', address, req['endpoint']) handler = api_request_handlers.get(req['endpoint']) if handler is not None: handler(socket, address, req) else: logger.info('-> %s unknown request', address) socket.sendall(msgpack.packb('UNKNOWN')) except Timeout: metrics.incr('api_request_timeout_cnt') logger.warning('-> %s timeout', address) socket.sendall(msgpack.packb('TIMEOUT')) finally: timeout.cancel() socket.close()
def handler(socket, address): host = peek_http_host(socket) hostname = host.split(':')[0] if not hostname: logging.debug("!no hostname, closing") socket.close() return redirect_url = lookup_txt_attribute(hostname, 'location', '_redirect') if redirect_url: # only append path in request if redirect location # is completely pathless. ex: http://example.com # however, we don't pass query params... if redirect_url.count('/') == 2: req_tip = socket.recv(256) method, path, _ = req_tip.split(' ', 2) redirect_url = '{0}{1}'.format(redirect_url, urlparse.urlparse(path).path) resp = """ HTTP/1.1 301 Moved Permanently\r\nLocation: {0}\r\nConnection: close\r\nContent-Length: 0\r\n\r\n """.format(redirect_url).strip() socket.sendall(resp) socket.close() return proxy_to = lookup_txt_attribute(hostname, 'address', '_proxy') if proxy_to: address = proxy_to.split(':') if len(address) == 1: address = (address[0], 80) try: backend = gevent.socket.create_connection(address) # TODO: insert headers: Via, X-Forwarded-For, Host join_sockets(socket, backend) except IOError: socket.close() return
def main(): parser = argparse.ArgumentParser(description='pwrcall nacl test.') parser.add_argument('action', help='connect/listen', choices=['connect', 'listen', 'c', 'l']) parser.add_argument('--state', dest='state', help='path to state file', default='pwr.state') parser.add_argument('--sock', dest='sock', help='where to connect / what to bind', required=True) parser.add_argument('--rpub', dest='rpub', help='remove public key for verification') args = parser.parse_args() state = pwrtls.state_file(args.state) fdnonblock(sys.stdin.fileno()) fdnonblock(sys.stdout.fileno()) if args.rpub: args.rpub = args.rpub.decode('hex') if args.action[0] == 'c': ip, port = args.sock.split(':', 1) port = int(port) socket = gevent.socket.create_connection((ip, port)) socket = pwrtls.wrap_socket(socket, **state) socket.do_handshake() print 'remote longpub', socket.remote_longpub.encode('hex') g1 = gevent.spawn(forward, sys.stdin, socket) forward(socket, sys.stdout) print 'server gone' socket.close() elif args.action[0] == 'l': if ':' in args.sock: ip, port = args.sock.split(':', 1) else: ip, port = '0.0.0.0', args.sock port = int(port) lsocket = gevent.socket.socket() lsocket.setsockopt(gevent.socket.SOL_SOCKET, gevent.socket.SO_REUSEADDR, 1) lsocket.bind((ip, port)) lsocket.listen(1) socket, addr = lsocket.accept() lsocket.close() print 'new client:', addr socket = pwrtls.wrap_socket(socket, server_side=True, **state) socket.do_handshake() print 'remote longpub', socket.remote_longpub.encode('hex') g1 = gevent.spawn(forward, sys.stdin, socket) forward(socket, sys.stdout) print 'client gone', addr socket.close() elif args.action[0] == 's': if ':' in args.sock: ip, port = args.sock.split(':', 1) else: ip, port = '0.0.0.0', args.sock port = int(port) def handle(sock, addr): print 'new client:', addr socket = pwrtls.wrap_socket(sock, server_side=True, **state) socket.do_handshake() print 'remote longpub', socket.remote_longpub.encode('hex') forward(socket, sys.stdout) print 'client gone', addr socket.close() server = gevent.server.StreamServer((ip, port), handle) server.serve_forever() return 0
def handle(socket, address): """每个协程运行的主函数,每当某个设备发起链接,服务器创建一个新的协程运行该函数 这个函数首先检测是否是有效设备发起的链接,正常设备发起链接,首先需要上报该设备的物理地址,通过这个检测之后,然后使用全局变量`greenlets`以及数据库来确定该设备的具体情况 接下来是这个函数的主要部分: 一个无限循环,在循环过程中转发用户命令,监控设备状态,处理设备上报信息 单次循环具体流程描述如下: 首先检查`redis`是否含有发向当前设备的命令: 如果有,执行相应命令; 如果没有,则尝试接收设备的上报信息(具体流程参见`send_command`); 执行下次循环; :param socket: 设备和程序之间的链接 :param address: 设备具体`IP`地址以及端口 :return: 无返回值 """ logging.info("设备接入: %s" % socket) try: MAC = socket.recv(4096) except: logging.critical(sys.exc_info()[1][1]) logging.critical("接收数据失败") socket.close() return if not re.match("[0-9A-F]{12}", MAC): logging.critical("物理地址无效: %s" % MAC) socket.close() return logging.info("物理地址: %s" % MAC) # time.sleep(2) # # logging.info("发送测试命令: %s" % MAC) # # # test_connection(MAC, socket, connection, cursor) # connection = pymysql.connect(host="", user="", passwd="", db="") connection.autocommit(1) cursor = connection.cursor() if MAC not in greenlets: greenlets[MAC] = gevent.getcurrent() cursor.execute("SELECT id FROM device WHERE mac = %s", MAC) logging.debug(cursor._last_executed) if not cursor.fetchall(): logging.info("新的设备: %s" % MAC) logging.info("发送测试命令: %s" % MAC) # test_connection(MAC, socket, connection, cursor) # current_time = str(datetime.now()).split('.')[0] cursor.execute("INSERT INTO device (mac, online, ctime, utime, ip) VALUES (%s, %s, %s, %s, %s)", (MAC, 1, current_time, current_time, address[0])) logging.debug(cursor._last_executed) else: logging.info("程序重启") cursor.execute("UPDATE device SET online = 1 WHERE mac = %s", MAC) logging.debug(cursor._last_executed) else: greenlets[MAC] = gevent.getcurrent() logging.info("旧的设备: %s" % MAC) cursor.execute("UPDATE device SET online = 1 WHERE mac = %s", MAC) logging.debug(cursor._last_executed) while 1: connection.ping() task = redis_client.rpop(MAC) if not task: cursor.execute("SELECT online FROM device WHERE mac = %s", MAC) logging.debug(cursor._last_executed) online = cursor.fetchone()[0] logging.info("%s 设备当前状态: %s" % (MAC, online)) if online: logging.info("%s 尝试接收数据" % MAC) try: data = socket.recv(4096) except gevent.socket.timeout: continue except gevent.socket.error: cursor.execute("UPDATE device SET online = 0 WHERE mac = %s", MAC) logging.debug(cursor._last_executed) logging.critical(sys.exc_info()[1][1]) cursor.close() connection.close() socket.close() return logging.info("%s 发送 %s" % (MAC, data)) if data: handle_report(MAC, socket, connection, cursor, data) else: cursor.execute("UPDATE device SET online = 0 WHERE mac = %s", MAC) logging.debug(cursor._last_executed) logging.critical("设备返回空值") cursor.close() connection.close() socket.close() return else: logging.critical("设备已经离线") cursor.close() connection.close() socket.close() return else: task = ast.literal_eval(task) logging.info("命令: %s" % str(task)) if task["type"] == -1: delete(MAC, socket, connection, cursor, task) return elif task["type"] == 0: turnof(MAC, socket, connection, cursor, task) continue elif task["type"] == 1: turnon(MAC, socket, connection, cursor, task) continue elif task["type"] == 2: heartbeat(MAC, socket, connection, cursor, task) continue elif task["type"] == 4: read_temperature_humidity(MAC, socket, connection, cursor, task) continue elif task["type"] == 6: check_status(MAC, socket, connection, cursor, task) continue elif task["type"] == 7: read_remaining_potion(MAC, socket, connection, cursor, task) continue
def send_command(MAC, socket, connection, cursor, command, response_length=0, response_type=0, times=5): """通过链接发送命令,等待响应,返回有效响应数据 这个函数默认发送五次命令,如果其中有一次发送成功,同时没有其它错误,则返回有效响应数据(删除响应头,命令类型以及校验和),结束循环,函数返回. 下面介绍每次循环的流程: 首先通过链接尝试发送数据,如果出现异常,关闭连接,清理资源; 然后通过链接尝试接收数据,如果出现异常,关闭连接,清理资源,如果等待超时,进入下次循环,重新发送命令; 获得响应数据,如果响应数据为空,关闭连接,清理资源; 然后检验响应数据类型是否与期望相符,如果相符,则验证校验和,如果校验通过,返回有效响应数据,否则进入下次循环,重新发送命令; 如果响应数据类型与期望不符,把设备响应信息当作上报信息处理 *因为处理上报信息过程中发送的命令无需返回,所以发送之后,函数直接返回,不进行后续操作* 如果五次循环过后,仍未获得有效响应数据,关闭链接,清理资源 :param MAC: 设备的物理地址(唯一标志) :param socket: 设备和程序之间的链接 :param connection: 当前协程的数据库链接(每个协程使用独立的数据库链接) :param cursor: 当前协程的数据库游标(每个协程使用独立的数据库游标) :param command: 待发送的命令 :param response_length: 因为设备返回的响应数据不遵循标准,所以需要根据协议手动获取有效响应数据 :param response_type: 期望的响应数据的类型,用来检查响应数据是否是上报信息 :param times: 循环发送命令的次数,默认值`5` :return: 如果一切正常,返回有效响应数据;如果指定循环次数过后,仍未获得有效响应数据,返回`None` """ for _ in xrange(times): try: socket.send(set_checksum(command)) except: cursor.execute("UPDATE device SET online = 0 WHERE mac = %s", MAC) logging.debug(cursor._last_executed) logging.critical(sys.exc_info()[1][1]) cursor.close() connection.close() socket.close() return if response_length == 0 and response_type == 0: return else: while 1: logging.info("%s 尝试接收数据" % MAC) try: response = socket.recv(4096) except gevent.socket.timeout: break except gevent.socket.error: cursor.execute("UPDATE device SET online = 0 WHERE mac = %s", MAC) logging.debug(cursor._last_executed) logging.critical(sys.exc_info()[1][1]) cursor.close() connection.close() socket.close() return logging.info("%s 发送 %s" % (MAC, str(hexlify(response[:response_length])))) if response: data = translate(response, "client") if data[2] != response_type: handle_report(MAC, socket, connection, cursor, response) break else: if not get_checksum(response[:response_length]): logging.error("%s 响应校验出错" % MAC) break else: return data[3:-1] else: cursor.execute("UPDATE device SET online = 0 WHERE mac = %s", MAC) logging.debug(cursor._last_executed) logging.critical("%s 设备返回空值" % MAC) cursor.close() connection.close() socket.close() return cursor.execute("UPDATE device SET online = 0 WHERE mac = %s", MAC) logging.debug(cursor._last_executed) logging.critical("%s 等待响应超时" % MAC) cursor.close() connection.close() socket.close() return None
# NON SSL nntp_server = NNTPSocketServer(secure=False, ) # Append file to map nntp_server.map( '3', 'alt.bin.test', join(NNTP_TEST_VAR_PATH, '00000005.ntx'), ) # Exit the server thread when the main thread terminates # nntp_server.daemon = True nntp_server.start() # Acquire a client connection socket = nntp_server.get_client() socket.put("AUTHINFO USER valid") socket.put("AUTHINFO PASS user") socket.put("READ FILE 3") socket.put("GROUP alt.bin.test") socket.put("ARTICLE 3") socket.put("Hello World 3") # Close our client socket.close() # Shutdown our server nntp_server.shutdown()
def server_thread(): socket, addr = self.server_socket.accept() server = ServerConnection(socket, addr) server_messages.put(server.recv_message()) server.send_message(("hello", "client")) socket.close()
def close(self): socket = self.socket del self.socket socket.close()
def handle(self, socket, address): if select.select([socket], [], [], 10)[0]: data, addr = socket.recvfrom(1024) # buffer size is 1024 bytes print(data) socket.send(b"HOI!\n") socket.close()
def handle(socket, address): """每个协程运行的主函数,每当某个设备发起链接,服务器创建一个新的协程运行该函数 这个函数首先检测是否是有效设备发起的链接,正常设备发起链接,首先需要上报该设备的物理地址,通过这个检测之后,然后使用全局变量`greenlets`以及数据库来确定该设备的具体情况 接下来是这个函数的主要部分: 一个无限循环,在循环过程中转发用户命令,监控设备状态,处理设备上报信息 单次循环具体流程描述如下: 首先检查`redis`是否含有发向当前设备的命令: 如果有,执行相应命令; 如果没有,则尝试接收设备的上报信息(具体流程参见`send_command`); 执行下次循环; :param socket: 设备和程序之间的链接 :param address: 设备具体`IP`地址以及端口 :return: 无返回值 """ logging.info("设备接入: %s" % socket) try: MAC = socket.recv(4096) except: logging.critical(sys.exc_info()[1][1]) logging.critical("接收数据失败") socket.close() return if not re.match("[0-9A-F]{12}", MAC): logging.critical("物理地址无效: %s" % MAC) socket.close() return logging.info("物理地址: %s" % MAC) # time.sleep(2) # # logging.info("发送测试命令: %s" % MAC) # # # test_connection(MAC, socket, connection, cursor) # connection = pymysql.connect(host="", user="", passwd="", db="") connection.autocommit(1) cursor = connection.cursor() if MAC not in greenlets: greenlets[MAC] = gevent.getcurrent() cursor.execute("SELECT id FROM device WHERE mac = %s", MAC) logging.debug(cursor._last_executed) if not cursor.fetchall(): logging.info("新的设备: %s" % MAC) logging.info("发送测试命令: %s" % MAC) # test_connection(MAC, socket, connection, cursor) # current_time = str(datetime.now()).split('.')[0] cursor.execute( "INSERT INTO device (mac, online, ctime, utime, ip) VALUES (%s, %s, %s, %s, %s)", (MAC, 1, current_time, current_time, address[0])) logging.debug(cursor._last_executed) else: logging.info("程序重启") cursor.execute("UPDATE device SET online = 1 WHERE mac = %s", MAC) logging.debug(cursor._last_executed) else: greenlets[MAC] = gevent.getcurrent() logging.info("旧的设备: %s" % MAC) cursor.execute("UPDATE device SET online = 1 WHERE mac = %s", MAC) logging.debug(cursor._last_executed) while 1: connection.ping() task = redis_client.rpop(MAC) if not task: cursor.execute("SELECT online FROM device WHERE mac = %s", MAC) logging.debug(cursor._last_executed) online = cursor.fetchone()[0] logging.info("%s 设备当前状态: %s" % (MAC, online)) if online: logging.info("%s 尝试接收数据" % MAC) try: data = socket.recv(4096) except gevent.socket.timeout: continue except gevent.socket.error: cursor.execute( "UPDATE device SET online = 0 WHERE mac = %s", MAC) logging.debug(cursor._last_executed) logging.critical(sys.exc_info()[1][1]) cursor.close() connection.close() socket.close() return logging.info("%s 发送 %s" % (MAC, data)) if data: handle_report(MAC, socket, connection, cursor, data) else: cursor.execute( "UPDATE device SET online = 0 WHERE mac = %s", MAC) logging.debug(cursor._last_executed) logging.critical("设备返回空值") cursor.close() connection.close() socket.close() return else: logging.critical("设备已经离线") cursor.close() connection.close() socket.close() return else: task = ast.literal_eval(task) logging.info("命令: %s" % str(task)) if task["type"] == -1: delete(MAC, socket, connection, cursor, task) return elif task["type"] == 0: turnof(MAC, socket, connection, cursor, task) continue elif task["type"] == 1: turnon(MAC, socket, connection, cursor, task) continue elif task["type"] == 2: heartbeat(MAC, socket, connection, cursor, task) continue elif task["type"] == 4: read_temperature_humidity(MAC, socket, connection, cursor, task) continue elif task["type"] == 6: check_status(MAC, socket, connection, cursor, task) continue elif task["type"] == 7: read_remaining_potion(MAC, socket, connection, cursor, task) continue
def send_command(MAC, socket, connection, cursor, command, response_length=0, response_type=0, times=5): """通过链接发送命令,等待响应,返回有效响应数据 这个函数默认发送五次命令,如果其中有一次发送成功,同时没有其它错误,则返回有效响应数据(删除响应头,命令类型以及校验和),结束循环,函数返回. 下面介绍每次循环的流程: 首先通过链接尝试发送数据,如果出现异常,关闭连接,清理资源; 然后通过链接尝试接收数据,如果出现异常,关闭连接,清理资源,如果等待超时,进入下次循环,重新发送命令; 获得响应数据,如果响应数据为空,关闭连接,清理资源; 然后检验响应数据类型是否与期望相符,如果相符,则验证校验和,如果校验通过,返回有效响应数据,否则进入下次循环,重新发送命令; 如果响应数据类型与期望不符,把设备响应信息当作上报信息处理 *因为处理上报信息过程中发送的命令无需返回,所以发送之后,函数直接返回,不进行后续操作* 如果五次循环过后,仍未获得有效响应数据,关闭链接,清理资源 :param MAC: 设备的物理地址(唯一标志) :param socket: 设备和程序之间的链接 :param connection: 当前协程的数据库链接(每个协程使用独立的数据库链接) :param cursor: 当前协程的数据库游标(每个协程使用独立的数据库游标) :param command: 待发送的命令 :param response_length: 因为设备返回的响应数据不遵循标准,所以需要根据协议手动获取有效响应数据 :param response_type: 期望的响应数据的类型,用来检查响应数据是否是上报信息 :param times: 循环发送命令的次数,默认值`5` :return: 如果一切正常,返回有效响应数据;如果指定循环次数过后,仍未获得有效响应数据,返回`None` """ for _ in xrange(times): try: socket.send(set_checksum(command)) except: cursor.execute("UPDATE device SET online = 0 WHERE mac = %s", MAC) logging.debug(cursor._last_executed) logging.critical(sys.exc_info()[1][1]) cursor.close() connection.close() socket.close() return if response_length == 0 and response_type == 0: return else: while 1: logging.info("%s 尝试接收数据" % MAC) try: response = socket.recv(4096) except gevent.socket.timeout: break except gevent.socket.error: cursor.execute( "UPDATE device SET online = 0 WHERE mac = %s", MAC) logging.debug(cursor._last_executed) logging.critical(sys.exc_info()[1][1]) cursor.close() connection.close() socket.close() return logging.info("%s 发送 %s" % (MAC, str(hexlify(response[:response_length])))) if response: data = translate(response, "client") if data[2] != response_type: handle_report(MAC, socket, connection, cursor, response) break else: if not get_checksum(response[:response_length]): logging.error("%s 响应校验出错" % MAC) break else: return data[3:-1] else: cursor.execute( "UPDATE device SET online = 0 WHERE mac = %s", MAC) logging.debug(cursor._last_executed) logging.critical("%s 设备返回空值" % MAC) cursor.close() connection.close() socket.close() return cursor.execute("UPDATE device SET online = 0 WHERE mac = %s", MAC) logging.debug(cursor._last_executed) logging.critical("%s 等待响应超时" % MAC) cursor.close() connection.close() socket.close() return None
def handle_echo(socket, address): expression = receive(socket, 'request') print 'Got one task from client: %s' % expression result = calculate(expression) send(socket, result, 'response') socket.close()
def get_resume(addr): socket = gevent.socket.create_connection(addr) rno, data = zc.resumelb.util.read_message(socket) socket.close() assert rno == 0, rno return data
def tcp_handler(socket, address, conn_data, accept_count): need_to_close = False need_to_send_data = False accepted_name = conn_data['name'] + '-%d' % accept_count conn_greenlets[accepted_name] = { 'greenlet': Greenlet.getcurrent(), 'result': None, 'data': None } DBG('new tcp accepted from %s:%s conn_data = %r' % (address[0], address[1], conn_data)) data_pack = dict(name=conn_data['name'], accepted_name=accepted_name, op="accepted", remote_ip=address[0], remote_port=address[1], local_port=conn_data['specific_port'], type='tcpserver') re = guifeeder_socket.sendto(json.dumps(data_pack), GUIFEEDER_ADDRESS) DBG("sent to gui feeder %r" % re) while True: try: if need_to_close: DBG('tcp_handler need_to_close') socket.close() conn_greenlets[accepted_name]['result'].set({'result': 'ok'}) return if need_to_send_data: try: re = socket.send( base64.b64decode( conn_greenlets[accepted_name]['data'])) conn_greenlets[accepted_name]['result'].set('ok') DBG("sent to remote %r" % re) need_to_send_data = False except: DBG_TRACE() conn_greenlets[accepted_name]['result'].set('error') data = socket.recv(8012) if not data: # closed by remote DBG('tcp_handler got nothing') socket.close() data_pack = {"name": accepted_name, "op": "disconnected"} re = guifeeder_socket.sendto(json.dumps(data_pack), GUIFEEDER_ADDRESS) del conn_greenlets[accepted_name] DBG("sent to gui feeder %r" % re) return # die else: DBG(type(data)) DBG('tcp_handler %s got %r' % (time.ctime(), bytearray(data))) data_pack = { "name": accepted_name, "op": "recvdata", "text": base64.b64encode(bytearray(data)) } # socket.send('hi') re = guifeeder_socket.sendto(json.dumps(data_pack), GUIFEEDER_ADDRESS) DBG("sent to gui feeder %r" % re) except CloseSocket: DBG("tcp_handler CloseSocket") need_to_close = True except SendData: DBG("tcp_handler SendData") need_to_send_data = True except: DBG_TRACE() data_pack = { "name": conn_data['name'], 'type': conn_data['type'], "op": "error", 'msg': base64.b64encode(str(sys.exc_info()[1])) } socket.close() del conn_greenlets[conn_data['name']] re = guifeeder_socket.sendto(json.dumps(data_pack), GUIFEEDER_ADDRESS) DBG("sent to gui feeder %r" % re) return
def handle(socket, address): socket.send("Hello from a telnet!") socket.close()
# NON SSL nntp_server = NNTPSocketServer( secure=False, ) # Append file to map nntp_server.map( '3', 'alt.bin.test', join(NNTP_TEST_VAR_PATH, '00000005.ntx'), ) # Exit the server thread when the main thread terminates # nntp_server.daemon = True nntp_server.start() # Acquire a client connection socket = nntp_server.get_client() socket.put("AUTHINFO USER valid") socket.put("AUTHINFO PASS user") socket.put("READ FILE 3") socket.put("GROUP alt.bin.test") socket.put("ARTICLE 3") socket.put("Hello World 3") # Close our client socket.close() # Shutdown our server nntp_server.shutdown()
def handleTCP(socket, address): global ttl, httpData socket.settimeout(ttl) httpFlag = False ip, port = address buf = "" dport = 0 try: dport = int(os.popen("grep \"src=%s\" /proc/net/nf_conntrack | grep tcp | grep \"sport=%d\"| tail -n 1" % (ip, port,)).read().split("dport=", 1)[1].split(" ", 1)[0]) except: pass if dport == 0: try: dport = int(os.popen("grep \"src=%s\" /proc/net/ip_conntrack | grep tcp | grep \"sport=%d\"| tail -n 1" % (ip, port,)).read().split("dport=", 1)[1].split(" ", 1)[0]) except: pass log = "[+] TCP Connection on Port: %d from %s:%d Time: %s\n" % (dport, ip, port, datetime.utcnow().isoformat()) print log, with open("logs.txt", "a") as f: f.write(log) f.close() try: if dport in [443] or 443 == dport%1000: context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH) context.load_cert_chain(certfile="ssl.crt", keyfile="ssl.key") context.options = ssl.OP_ALL try: sslsock = context.wrap_socket(socket, server_side=True) while True: buffer = sslsock.read() if not buffer: sslsock.send(httpData) break buf+=buffer if checkHTTP(buf): httpFlag = True except Exception as e: print "[-] Error: %s" % (e,) finally: try: sslsock.close() except: pass elif dport in [23]: socket.send("login: "******"\n": buf+= buffer break else: buf+=buffer if not socket.closed: socket.send("Password: "******"\n": buf+= buffer socket.send("XM# ") break else: buf+=buffer while not socket.closed: buffer = recv(socket) if not buffer: socket.close() break elif buffer == "\n": tosend = telnetparse(buf.split("\n")[-1]) if tosend <> None: socket.send(tosend) socket.send("\n") buf+= buffer socket.send("XM# ") else: buf+= buffer else: while not socket.closed: buffer = recv(socket) if not buffer: if httpFlag: socket.send(httpData) socket.close() break else: buf+= buffer if checkHTTP(buf): httpFlag = True except Exception as e: print "[-] Error : %s " % (e,) with open("captures/tcp/%d_%s_%d_%s.txt" % (dport, ip, port, datetime.utcnow().isoformat().replace(":", "-").replace(".", "-"),) , "wb") as file: file.write(buf) file.close()