def handle_request(self, tar_dict, client_body):
'''
serviceid == 0:
local process. Generate the session and return;
just header and no body
serviceid == ***:
decrypt and just transfer this package to backend
'''
res_dict = {}
res_dict['errcode'] = -1
try:
mylist = []
#post_dict=ast.literal_eval(tar_dict.strip())
#b_dict=ast.literal_eval(client_body.strip())
h_str = re.findall('({.*}).*', tar_dict)[0]
b_str = re.findall('({.*}).*', client_body)[0]
post_dict = json.loads(h_str)
b_dict = json.loads(b_str)
if len(post_dict) != 14:
AgentModule.AgentRepSum(2912, 1)
return json.dumps(res_dict)
if len(b_dict) != 3:
AgentModule.AgentRepSum(2912, 1)
return json.dumps(res_dict)
for k, v in post_dict.items():
post_dict[k] = MySQLdb.escape_string(v)
for k, v in b_dict.items():
b_dict[k] = MySQLdb.escape_string(v)
device_id = post_dict['1']
os_version = post_dict['2']
xinghao = post_dict['3']
zhizaoshang = post_dict['4']
language = post_dict['5']
country = post_dict['6']
soft_version = post_dict['7']
mac_addr = post_dict['8']
ip_addr = post_dict['9']
qudao = post_dict['10']
yunyingshang = post_dict['11']
fenbianlv = post_dict['12']
soft_id = post_dict['13']
service_id = post_dict['14']
datet = b_dict['1']
email = b_dict['2']
content = b_dict['3']
sql = 'insert into `feedback` values(\"%s\",\"%s\",\"%s\",\"%s\",\"%s\",\"%s\",\"%s\",\"%s\",\"%s\",\"%s\",\"%s\",\"%s\",\"%s\",\"%s\",\"%s\",\"%s\",\"%s\")' % (
email, os_version, xinghao, device_id, soft_id, content,
language, country, zhizaoshang, datet, soft_version, mac_addr,
ip_addr, qudao, yunyingshang, fenbianlv, service_id)
self.cursor.execute(sql)
res_dict['errcode'] = 0
logger_d.info("get request and insert to sql")
return json.dumps(res_dict)
except:
logger_e.error(format_exc())
AgentModule.AgentRepSum(2913, 1)
return json.dumps(res_dict)
def _parse_request(self, data):
'''
packet = dwTotalLen + dwInnerHeaderLen + wType + InnerHeader + dwBodyTotalLen + wType + Info
'''
try:
h = data[0:4]
total_len = struct.unpack("!I", h)[0]
h = data[4:]
cur_len = 0
inner_header_len, w_type = struct.unpack("!IH",
h[cur_len:cur_len + 6])
cur_len += 6
inner_header_buf = h[cur_len:cur_len + inner_header_len]
cur_len += inner_header_len
tmp_len, tmp_type = struct.unpack("!IH", h[cur_len:cur_len + 6])
cur_len += 6
body_info = h[cur_len:]
return inner_header_buf, body_info
except:
logger_e.error("recv&parse packet failed: %s" %
traceback.format_exc())
return None, None
def _handle_packet_from_global_collector(self, info_buf):
try:
scan_result = scan_result_pb2.ScanResult()
scan_result.ParseFromString(info_buf)
logger.info("get global collector packet, md5: %s" %
(scan_result.md5))
#从cache中删除这个md5
self._del_md5_in_redis(scan_result.md5)
except:
logger_e.error("handle packet from global collector failed: %s" %
traceback.format_exc())
return
def __call__(self, data, address):
try:
#recv and parse request
inner_header_buf, info_buf = self._parse_request(data)
if inner_header_buf == None or info_buf == None:
return
inner_header = inner_header_pb2.InnerHeader()
inner_header.ParseFromString(inner_header_buf)
if inner_header.cmd == 171: #只处理从global collector转过来的包
self._handle_packet_from_global_collector(info_buf)
except:
logger_e.error("process error: %s" % traceback.format_exc())
def start_process(self, environ, start_response):
##set HTTP response header
status = '200 OK'
response_headers = [('Content-type', 'text/html'),
('Connection', 'Keep-Alive')]
##send response
start_response(status, response_headers)
try:
err_code = errcode.E_OK
#client ip
#str_cip = environ.get("REMOTE_ADDR", '0.0.0.0')
str_cip = environ.get("HTTP_X_REAL_IP", '0.0.0.0')
client_ip = struct.unpack("I", socket.inet_aton(str_cip))[0]
##get query parameters
request_method = environ.get("REQUEST_METHOD")
content_type = environ.get('CONTENT_TYPE')
AgentModule.AgentRepSum(2922, 1)
if request_method == None or content_type == None:
AgentModule.AgentRepSum(2924, 1)
return [self.get_response(errcode.E_FAIL)]
if request_method == "POST": # process post request
# data report
params = self.get_upload_params(environ)
if params == None:
AgentModule.AgentRepSum(2926, 1)
return [self.get_response(errcode.E_OK)]
err_code = self.handle_request(params, client_ip)
else:
logger_e.error("unknown request type: %s:%s from %s" %
(request_method, content_type, str_cip))
return [self.get_response(errcode.E_FAIL)]
#build response package
#response = self.get_response(err_code)
#return [response]
AgentModule.AgentRepSum(2923, 1)
return [err_code]
except:
logger_e.error(
"Service response unknown exception from clientip %s %s environ=== %s"
% (str_cip, format_exc(), environ))
return [self.get_response(errcode.E_FAIL)]
def parse_request(self, data):
try:
h = data
total_len, w_save = struct.unpack("!IH", h[0:6])
cur_len = 6
(inner_header_len, ) = struct.unpack("!I", h[cur_len:cur_len + 4])
cur_len += 4
inner_header_buf = h[cur_len:cur_len + inner_header_len]
cur_len += inner_header_len
(tmp_len, ) = struct.unpack("!I", h[cur_len:cur_len + 4])
cur_len += 4
body_info = h[cur_len:]
#return inner_header_buf, body_info
return total_len, tmp_len
except:
logger_e.error("recv&parse packet failed: %s" % format_exc())
return None, None
def handle_request(self, tar_dict, client_ip):
'''
serviceid == 0:
local process. Generate the session and return;
just header and no body
serviceid == ***:
decrypt and just transfer this package to backend
'''
res_dict = {}
res_dict['errcode'] = -1
try:
self.conn.lpush('taskq', tar_dict)
#addr_r=('10.205.27.53',9812)
#real_s=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
#real_s.sendto(tar_dict,addr_r)
res_dict['errcode'] = 0
return json.dumps(res_dict)
logger_d.info("get dataupload and write to queue")
except:
logger_e.error(format_exc())
AgentModule.AgentRepSum(2925, 1)
return json.dumps(res_dict)
def parse_request(self, data):
try:
if len(data) < 6:
return None, None
h = data
total_len, w_save = struct.unpack("!IH", h[0:6])
cur_len = 6
(inner_header_len, ) = struct.unpack("!I", h[cur_len:cur_len + 4])
cur_len += 4
inner_header_buf = h[cur_len:cur_len + inner_header_len]
cur_len += inner_header_len
(tmp_len, ) = struct.unpack("!I", h[cur_len:cur_len + 4])
cur_len += 4
body_info = h[cur_len:]
return inner_header_buf, body_info
except:
logger_e.error("recv&parse packet failed: %s" % format_exc())
AgentModule.AgentRepSum(2910, 1)
return None, None
def get_upload_params(self, environ):
"""
get POST Upload parameters from request,
return a dict "params" back.
"""
fieldstorage = cgi.FieldStorage(fp=environ['wsgi.input'],
environ=environ,
keep_blank_values=True)
field = fieldstorage.value
try:
ih, ib = self.parse_request(field)
if ih == None or ib == None:
return None, None
key = '58DAC89AA392C630'
IV = 'PKCS5Padding'
mode = AES.MODE_ECB
decryptor = AES.new(key, mode, IV=IV)
plain = decryptor.decrypt(ih)
n_body = decryptor.decrypt(ib)
return plain, n_body
except:
logger_e.error("jiemi packet failed: %s" % format_exc())
AgentModule.AgentRepSum(2911, 1)
return None, None
