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 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 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 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 close(self):
if not self.is_connected:
return
socket = self.socket
self.socket = None
self.buffer = b''
socket.close()
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()
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 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 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 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 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 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()
def handle(socket, address):
socket.send("Hello from a telnet!")
socket.close()
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()
