def connect(self,
ssid,
timeout=120,
authentication="",
encryption="",
key="",
key_index=1):
"""
按照指定的ssid及其加密模式连接无线AP
"""
key_index = int(key_index)
timeout = int(timeout)
if timeout <= 0:
log_data = u'timout<=0,请设置>0的值。'
log.user_err(log_data)
raise RuntimeError(log_data)
if self.obj.connect(ssid,
timeout=timeout,
authentication=authentication,
encryption=encryption,
key=key,
keyIndex=key_index) == WLAN_OK:
log_data = u'无线网卡连接成功'
log.user_info(log_data)
else:
log_data = u'连接失败。'
raise RuntimeError(log_data)
def _check_input_str_unicode(self, str_or_unicode):
"""
函数功能：检查输入的参数是不是str或者unicode，并去掉前后的空格
参数：
str_or_unicode 字符串
返回值：
str_or_unicode 经过转换后的字符串
"""
err_data = ""
if isinstance(str_or_unicode, str) or\
isinstance(str_or_unicode, unicode):
str_or_unicode = str_or_unicode.strip()
if str_or_unicode:
str_or_unicode = str_or_unicode.lower()
else:
err_data = u"输入的信息格式 %s 不合法！" % str_or_unicode
if err_data:
log.user_err(err_data)
raise RuntimeError(err_data)
return str_or_unicode
def query_wlan_show_interface(self, key):
"""
根据需求获取无线接口信息参数;
"""
result = self._exec_cmd('netsh wlan show interface')
result = result.decode(sys.getfilesystemencoding())
result = result.split("\r\n")
# 将获取的信息转换为标准的列表格式
if u'已连接' in result[7]:
result = result[3:20]
list_result = []
for i in result:
tmp = i.replace(' ', '')
list_result.append(tmp)
# 将获取的信息已字典格式存储
dict_result = {}
for var in list_result:
tmp_key = var.split(':', 1)[0]
tmp_value = var.split(':', 1)[1]
dict_result.update({tmp_key: tmp_value})
# 判断key是否存在
if dict_result.has_key(key):
return dict_result[key]
else:
log_data = u'输入的无线接口信息参数不存在'
log.user_err(log_data)
raise RuntimeError(log_data)
elif u'已断开连接' in result[7]:
log_data = u'当前无线网卡状态是已断开连接'
log.user_err(log_data)
raise RuntimeError(log_data)
def switch_ping_site(self, alias):
"""
功能描述：切换当前ping操作所在的主机
参数：alias，别名
返回值：无
Example:
| Init Ping Site | 1 |
| Should Ping Ipv4 Success By Count | 192.168.1.1 | 4 |
| Init Ping Site | 2 | 10.10.10.84 |
| Should Ping Ipv4 Fail By Count | 192.168.1.1 | 4 |
| Switch Ping Site | 1 |
| Should Ping Ipv4 Success By Time | 192.168.1.1 | 10 |
| Switch Ping Site | 2 |
| Should Ping Ipv4 Fail By Time | 192.168.1.1 | 4 |
"""
try:
cls = self._cache.switch(alias)
if (isinstance(cls, Remote)):
# remote class do switch
auto_do_remote(cls)
else:
log_data = u'成功切换到别名为：%s 的主机下，后续Ping操作都是针对该主机，直到下一个初始化或切换动作' % alias
log.user_info(log_data)
except (RuntimeError, DataError): # RF 2.6 uses RE, earlier DE
log_data = "No remotelocal with alias '%s' found." % alias
log.user_err(log_data)
raise RuntimeError(log_data)
def auto_connect(self, ssid, timeout=120, key="", key_index=1):
"""
"""
#
if self.obj.delete_profile(ssid) == WLAN_OK:
log_data = u'删除名称为 %s 的无线Profile成功' % ssid
log.user_info(log_data)
else:
log_data = u'删除名称为 %s 的无线Profile失败' % ssid
log.user_err(log_data)
#
s = self.query_security_info(ssid)
authentication = ""
encryption = ""
t = self._security_convert(s)
authentication = t[0]
encryption = t[1]
log_data = u"采用连接模式：authentication=%s, encryption=%s" % (
authentication, encryption)
log.user_info(log_data)
if self.obj.connect(ssid, timeout, authentication, encryption, key,
key_index) == WLAN_OK:
log_data = u'无线网卡连接成功'
log.user_info(log_data)
else:
log_data = u'连接失败。'
raise RuntimeError(log_data)
def start_library(library_name=""):
try:
RobotRemoteServer(ATTInterfaceUnit())
return None
except Exception, e:
log_data = "start %s library fail!\n message:%s" % (library_name, e)
log.user_err(log_data)
raise RuntimeError(log_data)
def ssid_should_not_in_available_network_list(self, ssid):
"""无线SSID应在可用的无线网络列表中查询不到"""
if ssid not in self.get_available_network_list():
log_data = u'SSID %s 不在当前可用的无线网络列表中' % ssid
log.user_info(log_data)
else:
log_data = u'SSID %s 在当前可用的无线网络列表中' % ssid
log.user_err(log_data)
raise RuntimeError(log_data)
def should_be_connected(self):
"""无线网卡当前应处于连接状态"""
if self.query_interface_status() == 'wlan_interface_state_connected':
log_data = u'当前无线网卡处于连接状态'
log.user_info(log_data)
else:
log_data = u'当前无线网卡没有连接成功'
log.user_err(log_data)
raise RuntimeError(log_data)
def wireshark_capture_success(self, flag_pid):
"""
功能描述: 成功抓到报文关键字执行成功，报文为空，关键字执行失败
参数：
flag_pid: Start WireShark 关键字执行成功后的返回值
"""
ret = WIRESHARK_FAIL
str_data = ""
dict_data = self.dict_process_obj.get(flag_pid)
if dict_data:
popen = dict_data.get("popen")
file_path = dict_data.get("temp_packet_file_path")
obj_parse_pcap = dict_data.get("obj_parse_pcap")
if popen and popen.poll() == None:
if dict_data.get("flag_2_stop"):
err_data = u"停止抓包服务器失败，判断 %s 服务器成功与否失败！" % flag_pid
raise RuntimeError(err_data)
else:
dict_data["flag_2_stop"] = True
self.dict_process_obj.update({flag_pid: dict_data})
ret = WIRESHARK_NO_STOP
return ret
if file_path is None:
str_data = u"获取 %s 相应的抓包文件失败！" % flag_pid
elif os.path.exists(file_path):
if not obj_parse_pcap:
obj_parse_pcap = ParsePcapFile(self.wireshark_install_path,
file_path)
dict_data["obj_parse_pcap"] = obj_parse_pcap
self.dict_process_obj.update({flag_pid: dict_data})
else:
obj_parse_pcap = dict_data.get("obj_parse_pcap")
if obj_parse_pcap.check_file_empty(
file_path) != PARSE_PCAP_FILE_F:
ret = WIRESHARK_SUCCESS
str_data = u"成功捕获到报文"
else:
str_data = u"捕获到报文为空"
else:
str_data = u"捕获到报文为空"
else:
str_data = u"%s 相应抓包服务器不存在，不能判定成功捕获到报文！" % flag_pid
if ret == WIRESHARK_FAIL:
log.user_err(str_data)
raise RuntimeError(str_data)
else:
log.user_info(str_data)
def ssid_should_in_available_network_list(self, ssid):
"""无线SSID应在可用的无线网络列表中可以查询到"""
check_status = 0
if ssid in self.get_available_network_list():
log_data = u'SSID %s 在当前可用的无线网络列表中' % ssid
log.user_info(log_data)
else:
log_data = u'SSID %s 不在当前可用的无线网络列表中' % ssid
log.user_err(log_data)
raise RuntimeError(log_data)
def delete_profile(self, ssid):
"""
删除指定SSID的profile。
"""
if self.obj.delete_profile(ssid) == WLAN_OK:
log_data = u'删除名称为 %s 的无线Profile成功' % ssid
log.user_info(log_data)
else:
log_data = u'删除名称为 %s 的无线Profile失败' % ssid
log.user_err(log_data)
raise RuntimeError(log_data)
def delete_all_profile(self):
"""
删除所有profile。
"""
if self.obj.delete_all_profile() == WLAN_OK:
log_data = u'删除所有profile成功'
log.user_info(log_data)
else:
log_data = u'删除所有无线Profile失败'
log.user_err(log_data)
raise RuntimeError(log_data)
def query_interface_status(self):
"""
查询并返回当前无线网卡状态。
"""
if self.obj.query_interface_status() == WLAN_OK:
interface_status = self.obj.get_return()
if interface_status[:1] == '{' and interface_status[-1:] == '}':
interface_status = interface_status[1:-1]
return interface_status
else:
log_data = u'查询网卡状态失败'
log.user_err(log_data)
raise RuntimeError(log_data)
def get_available_network_list(self):
"""
查询可用的无线网络连接，返回可用的无线网络列表。
"""
ret = self.obj.get_available_network_list()
if ret != WLAN_OK:
log_data = u'查询可用的无线网络连接失败。'
log.user_err(log_data)
raise RuntimeError(log_data)
else:
#return self.obj.get_desc().decode(sys.getfilesystemencoding()).split('\n')
# default unicode
return self.obj.get_return().split('\n')
def telnet_close_all_connections(self):
"""
功能描述：关闭所有打开的telnet连接,包括本端和远端所有打开的telnet连接
参数：
无；
返回值：
无；
备注：
此关键字常用于拆除里面作清理操作，对所有已打开的telnet连接进行关闭，如果打开连接失败
再在拆除里面执行此关键字，此关键字也会报关闭已打开的所有telnet连接成功；
Example:
| Init Telnet Connection | local | 192.168.1.1 |
| Telnet Open Connection | 23 | 3 | > |
| Telnet Login | admin | admin |
| Init Telnet Connection | remote | 192.168.1.1 | http://172.16.28.55 |
| Telnet Open Connection | 23 | 3 | > |
| Telnet Login | admin | admin |
| Switch Telnet Connection | local |
| Telnet Execute Command | help |
| Switch Telnet Connection | remote |
| Telnet Execute Command | ps |
| Telnet Close All Connections |
"""
# 重新封装telnet_close_all_connections函数，增加log输出，方便用户查看 lwb:2013-05-02
if 0 == len(self.list_cls_remote) and 0 == len(self.list_cls_local):
return
# 判断有没有远端实例 lwb: 2013-04-20
for cls in self.list_cls_remote:
if (isinstance(cls, Remote)):
auto_do_remote(cls)
# 关闭所有打开的连接,如果list_cls_local列表中没有数据，就不进行关闭 lwb: 2013-04-22
for cls in self.list_cls_local:
cls.telnet_close_all_connections()
# 如果只有本端，则在本端进行log输出 lwb:2013-05-02
if len(self.list_cls_remote) > 0:
pass
elif len(self.list_cls_remote) == 0 and len(self.list_cls_local) > 0:
log_data = u"关闭所有telnet连接,包括本端和远端"
log.user_err(log_data)
def _check_wireshark_stop(self, flag_pid):
"""
"""
cls = self._current_remotelocal()
dict_data = cls.dict_capture_obj.get(flag_pid)
if not dict_data:
err_data = u"没有找到相应抓包服务器"
log.user_err(err_data)
raise RuntimeError(err_data)
elif dict_data.get("flag_stop"):
return True
else:
return False
def ssid_connect_by_none(self, ssid, timeout=120):
"""采用不加密模式连接SSID（只下发连接命令，不关注连接结果）。"""
timeout = int(timeout)
if timeout <= 0:
log_data = u'timout<=0,请设置>0的值。'
log.user_err(log_data)
raise RuntimeError(log_data)
if self.obj.connect(ssid,
timeout=timeout,
authentication='open',
encryption='none') == WLAN_OK:
log_data = u'无线网卡采用不加密模式连接SSID %s 连接成功。' % ssid
else:
log_data = u'无线网卡采用不加密模式连接SSID %s 连接失败。' % ssid
log.user_info(log_data)
def ssid_should_connect_by_none_fail(self, ssid, timeout=120):
"""采用不加密模式连接SSID，应连接不成功。"""
timeout = int(timeout)
if timeout <= 0:
log_data = u'timout<=0,请设置>0的值。'
log.user_err(log_data)
raise RuntimeError(log_data)
if self.obj.connect(
ssid, timeout=timeout, authentication='open',
encryption='none') != WLAN_OK:
log_data = u'无线网卡采用不加密模式连接SSID %s 应该连接失败，实际连接失败。' % ssid
log.user_info(log_data)
else:
log_data = u'无线网卡采用不加密模式连接SSID %s 应该连接失败，实际连接成功。' % ssid
log.user_err(log_data)
raise RuntimeError(log_data)
def ssid_connect_by_WPA2_PSK_TKIP(self, ssid, key, timeout=120):
"""采用WPA2_PSK_TKIP模式连接SSID（只下发连接命令，不关注连接结果）。"""
timeout = int(timeout)
if timeout <= 0:
log_data = u'timout<=0,请设置>0的值。'
log.user_err(log_data)
raise RuntimeError(log_data)
if self.obj.connect(ssid,
timeout=timeout,
authentication='WPA2PSK',
encryption='TKIP',
key=key) == WLAN_OK:
log_data = u'无线网卡采用WPA2_PSK_TKIP模式连接SSID %s 连接成功。' % ssid
else:
log_data = u'无线网卡采用WPA2_PSK_TKIP模式连接SSID %s 连接失败。' % ssid
log.user_info(log_data)
def ssid_should_connect_by_WPA2_PSK_AES_fail(self, ssid, key, timeout=120):
"""采用WPA2_PSK_AES模式连接SSID，应连接不成功。"""
timeout = int(timeout)
if timeout <= 0:
log_data = u'timout<=0,请设置>0的值。'
log.user_err(log_data)
raise RuntimeError(log_data)
if self.obj.connect(ssid,
timeout=timeout,
authentication='WPA2PSK',
encryption='AES',
key=key) != WLAN_OK:
log_data = u'无线网卡采用WPA2_PSK_AES模式连接SSID %s 应该连接失败，实际连接失败。' % ssid
log.user_info(log_data)
else:
log_data = u'无线网卡采用WPA2_PSK_AES模式连接SSID %s 应该连接失败，实际连接成功。' % ssid
log.user_err(log_data)
raise RuntimeError(log_data)
def ssid_connect_by_open_wep(self, ssid, key, key_index=1, timeout=120):
"""采用open wep模式连接SSID（只下发连接命令，不关注连接结果）。"""
key_index = int(key_index)
timeout = int(timeout)
if timeout <= 0:
log_data = u'timout<=0,请设置>0的值。'
log.user_err(log_data)
raise RuntimeError(log_data)
if self.obj.connect(ssid,
timeout=timeout,
authentication='open',
encryption='WEP',
key=key,
keyIndex=key_index) == WLAN_OK:
log_data = u'无线网卡采用open wep模式连接SSID %s 连接成功。' % ssid
else:
log_data = u'无线网卡采用open wep模式连接SSID %s 连接失败。' % ssid
log.user_info(log_data)
def _pingprocess_by_time(self, ip_url, total_time = 3600, psize = 32):
"""子进程中持续ping，ICMP包长默认为32，默认时间为3600秒"""
if psize == "":
psize = 32
if total_time == "":
total_time = 3600
psize,count,total_time = self._check_ping_para(psize,None,total_time)
ret = PING_SUCCESS
counter = 0
for i in [1]:
try:
pid = PingProcess(node=ip_url, total_time = total_time, size=psize)
pid.start()
except Exception, e:
err_info = "Starting PingProcess Error:%s" % e
ret_data = err_info
log.user_err(ret_data)
ret = PING_FAIL
break
# 修改偶现长时间临时文件生成失败的问题，这里延长等待时间
# modify by shenlige 2014-1-13
while not isfile(pid.get_ping_tmp_file()) and counter < 120:
# 等待ping文件正常生成，这里默认等待15秒，若超过15秒则报错退出 modify by shenlige 2013-4-9
time.sleep(1)
counter += 1
if counter >= 120:
ret_data = u"等待120s后，进程执行ping还是存在异常，请确认"
log.user_err(ret_data)
ret = PING_FAIL
break
# wait a moment to check whether the ping pid is ok
if not pid.is_alive:
ret_data = pid.err_info
ret = PING_FAIL
def disconnect(self):
"""
断开无线网卡连接。
"""
# Change by jxy 2013/3/15 断开连接之后，增加查询无线网卡状态，如果状态不是断开状态，重复三次。
i = 0
while i < 3:
i += 1
try:
nret = self.obj.disconnect()
time.sleep(3)
status = self.query_interface_status()
if status == 'wlan_interface_state_disconnected':
log_data = u'断开无线网卡连接成功'
log.user_info(log_data)
break
except Exception, e:
log_data = u"多次断开无线网卡连接失败。错误信息如下：%s" % e
log.user_err(log_data)
raise RuntimeError(log_data)
def _check_extension(self, file_name):
"""
函数功能：检查输入的文件名称是否是正确的扩展名pcap
参数：
file_name 文件名称
返回值：
pcap_file 返回正确的pcap路径
"""
err_data = ""
file_extension = os.path.split(file_name)[1]
if ".pcap" in file_extension:
pcap_file = file_name
else:
err_data = u"输入的信息格式 %s 不合法！" % file_name
if err_data:
log.user_err(err_data)
raise RuntimeError(err_data)
return pcap_file
def pingNode(node,number=5,size=ICMP_DATA_STR,total_time=None):
"""
功能描述：ping接口
"""
ret = PING_SUCCESS
counter = 0
for i in [1]:
try:
if not exists(ATTROBOT_TEMP_FILE_PAHT):
os.makedirs(ATTROBOT_TEMP_FILE_PAHT)
PING_TMP_FILE = os.path.join(ATTROBOT_TEMP_FILE_PAHT,"ping_temp_file.txt")
except Exception,e:
log_data = u"生成平台的临时目录发生错误： %s" % e
raise RuntimeError(log_data)
try:
# 修改可执行文件路径 modify by shenlige 2013-5-22
# 默认使用ping次数
if total_time:
number = 2592000
cmd_smg = " -l %s -n %s %s" % (size,number,node)
cmd = "\"" + EXE_PATH + "\"" + cmd_smg
with open(PING_TMP_FILE,"w") as file_tmp:
popen = subprocess.Popen(cmd,shell=True,
stdin=subprocess.PIPE,
stdout=file_tmp,
stderr=subprocess.PIPE)
except Exception, e:
log_data = u"执行ping.exe发生异常,message:%s" % e
log.user_err(log_data)
ret = PING_FAIL
break
def ssid_should_connect_by_shared_wep_success(self,
ssid,
key,
key_index=1,
timeout=120):
"""采用shared wep模式连接SSID，应连接成功。"""
key_index = int(key_index)
timeout = int(timeout)
if timeout <= 0:
log_data = u'timout<=0,请设置>0的值。'
log.user_err(log_data)
raise RuntimeError(log_data)
if self.obj.connect(ssid,
timeout=timeout,
authentication='shared',
encryption='WEP',
key=key,
keyIndex=key_index) == WLAN_OK:
log_data = u'无线网卡采用shared wep模式连接SSID %s 应该连接成功，实际连接成功。' % ssid
log.user_info(log_data)
else:
log_data = u'无线网卡采用shared wep模式连接SSID %s 应该连接成功，实际连接失败。' % ssid
log.user_err(log_data)
raise RuntimeError(log_data)
def ssid_should_connect_by_open_wep_fail(self,
ssid,
key,
key_index=1,
timeout=120):
"""采用open wep模式连接SSID，应连接不成功。"""
timeout = int(timeout)
if timeout <= 0:
log_data = u'timout<=0,请设置>0的值。'
log.user_err(log_data)
raise RuntimeError(log_data)
key_index = int(key_index)
if self.obj.connect(ssid,
timeout=timeout,
authentication='open',
encryption='WEP',
key=key,
keyIndex=key_index) != WLAN_OK:
log_data = u'无线网卡采用open wep模式连接SSID %s 应该连接失败，实际连接失败。' % ssid
log.user_info(log_data)
else:
log_data = u'无线网卡采用open wep模式连接SSID %s 应该连接失败，实际连接成功。' % ssid
log.user_err(log_data)
raise RuntimeError(log_data)
ret = cls.get_nic_name_or_mac(name_or_mac)
return ret
def start_library(host="172.0.0.1", port=REMOTE_PORT, library_name=""):
try:
log.start_remote_process_log(library_name)
except ImportError, e:
raise RuntimeError(u"创建log模块失败，失败信息：%" % e)
try:
RobotRemoteServer(NetConfig(), host, port)
return None
except Exception, e:
log_data = "start %s library fail!\n message:%s" % (library_name, e)
log.user_err(log_data)
raise RuntimeError(log_data)
def test():
cls1 = NetConfig()
cls1.init_nic_card("1", u"办公网")
cls1.get_nic_ipv4_address()
cls1.init_nic_card("1", u"本地连接 2", "http://10.10.10.6:58007")
cls1.get_nic_ipv4_address()
'''
#cls1.get_ip_by_mac("44-37-E6-99-46-C1")
#cls1.get_ip_by_mac("00-19-E0-03-20-C3")
cls1.open_netconfig_remotelocal("local")
cls1.get_ip_by_mac(mac_address="00-1A-A0-C0-0F-96")
class WireShark():
ROBOT_LIBRARY_SCOPE = 'GLOBAL'
ROBOT_LIBRARY_VERSION = VERSION
def __init__(self):
self._cache = ConnectionCache()
self.dict_alias = {}
self.flag_stop_all = False
self.dict_all_capture_pid_and_cls = {} # 保存所有启动的抓包服务器的pid和cls
def _register_alias(self, alias, name, mac_address, remote_url):
# 对别名判断做了修改 zsj 2013-3-28
# 改成以别名为健（当前要求别名唯一） change by yzm @ 20130328
# 因前面已经保证了alias唯一，则直接对alias进行赋值（赋新值可保证网卡信息为最新的信息）
self.dict_alias[alias] = ((name, mac_address), remote_url)
def _is_init(self, name_or_mac, remote_url, alias):
"""
return alias
"""
# 先判断别名是否被使用过
_value = self.dict_alias.get(alias)
if _value:
# 如果被使用过，需要判断是否被当前对象使用（相同的remote_url以及name或者mac）
if remote_url in _value and name_or_mac in _value[0]:
# 如果相符，则可以直接返回alias
return alias
else:
raise RuntimeError(u"别名 %s 正在被另外的对象使用，请选择另外的别名！" % alias)
else:
# 如果没被使用过，需判断当前的对象是否曾经被初始化过
for key, tuple_value in self.dict_alias.items():
if remote_url in tuple_value and name_or_mac in tuple_value[0]:
# 如果相符，则可以直接返回_key（只要找到即可返回）
return key
# 两种情况都不包含，则返回None
return None
def init_wireshark_network_card(self,
alias,
name_or_mac,
remote_url=False):
"""
功能描述：初始化网卡，为网卡配置别名；
参数：
alias:别名\n
name_or_mac:网卡名称或者是MAC地址\n
remote_url：是否要进行远程控制。（默认不进行远程）。\n
remote_url格式为：http://remote_IP.可以用以下的几种方式进行初始化。注意别名请设置为
不同的别名，切换的时候用别名进行切换。
返回值：无
Example:
| Init WireShark Network Card | One | 本地连接1 |
| Init WireShark Network Card | two | 本地连接1 | http://10.10.10.84 |
| Init WireShark Network Card | 3 | 44-37-E6-99-7C-B9 |
| Init WireShark Network Card | 4 | 44:37:E6:99:7C:B9 |
"""
# 输入的name_or_mac做转换，除去格式的差异
name_or_mac = modified_name_or_mac(name_or_mac)
# 对用户输入的remote_url做处理转换，添加http://头等
remote_url = modified_remote_url(remote_url)
if (is_remote(remote_url)):
# already init?
ret_alias = self._is_init(name_or_mac, remote_url, alias)
if (ret_alias):
reallib = self._cache.switch(ret_alias)
else:
reallib = Remote(remote_url)
reallib._client.set_timeout(
REMOTE_TIMEOUT) # add connection remote timeout zsj 2013-3-28
network_name, network_mac = auto_do_remote(reallib)
else:
# already init?
ret_alias = self._is_init(name_or_mac, remote_url, alias)
if (ret_alias):
reallib = self._cache.switch(ret_alias)
else:
reallib = ATTWireShark(name_or_mac)
network_name = reallib.get_network_name()
network_mac = reallib.get_network_mac()
tag = self._cache.register(reallib, alias)
self._register_alias(alias, network_name, network_mac, remote_url)
return network_name, network_mac
def _current_remotelocal(self):
if not self._cache.current:
raise RuntimeError('No remotelocal is open')
return self._cache.current
def switch_wireshark_network_card(self, alias):
"""
功能描述：使用alias在当前已存在的网卡对象中进行切换
参数：alias,别名。
返回值：无
Example:
| Init WireShark Network Card | 1 | 本地连接1 |
| Init WireShark Network Card | 2 | 本地连接1 | http://10.10.10.84 |
| Switch WireShark Network Card | 1 |
| Switch WireShark Network Card | 2 |
"""
try:
cls = self._cache.switch(alias)
if (isinstance(cls, Remote)):
# remote class do switch
auto_do_remote(cls)
else:
log_data = u'成功切换到别名为：%s 的网卡下，后续抓包操作都是针对该网卡，直到下一个切换动作' % alias
log.user_info(log_data)
except (RuntimeError, DataError): # RF 2.6 uses RE, earlier DE
raise RuntimeError("No remotelocal with alias '%s' found." % alias)
def set_wireshark_install_path(self, file_path):
"""
功能描述：设置抓包电脑上wireshark的安装路径；\n
参数：\n
file_path: wireshark软件的安装路径
Example:
| Set Wireshark Install Path | c:\\\\Program Files\\\\WireShark |
"""
cls = self._current_remotelocal()
if (isinstance(cls, Remote)):
auto_do_remote(cls)
else:
cls.set_wireshark_install_path(file_path)
def start_wireshark_capture(self,
capture_filter="",
prefix="ATT",
file_path="default"):
"""
功能描述: 开始当前网卡设备的抓包
参数：\n
capture_filter: 抓包过滤器表达式,不下发表示抓取所有包\n\n
perfix： 保存抓包文件的前缀\n
file_path： 保存抓包文件的路径\n
返回值：\n
flag_pid: 启动成功返回进程标识
Example:
| ${flag_pid1} | Start WireShark Capture | | ATT |
| ${flag_pid2} | Start WireShark Capture | tcp | ATT |
| ${flag_pid3} | Start WireShark Capture | tcp | ATT | c:\\\\wireshark |
"""
if IS_LOCAL:
self._check_prefix(prefix)
cls = self._current_remotelocal()
if (isinstance(cls, Remote)):
ret = auto_do_remote(cls)
else:
ret = cls.start_wireshark_capture(capture_filter, prefix,
file_path)
self.dict_all_capture_pid_and_cls.update({ret: cls})
return ret
def get_wireshark_flag_pid(self, pcap_file):
"""
功能描述: 获取已抓到数据报文flag_pid
参数：\n
pcap_file： 已抓到数据报文的路径\n
返回值：\n
flag_pid: 启动成功返回进程标识
Example:
| ${flag_pid} | Get WireShark Flag Pid | D:\\\\capture |
"""
ret = None
cls = self._current_remotelocal()
if (isinstance(cls, Remote)):
ret = auto_do_remote(cls)
else:
ret = cls.get_wireshark_flag_pid(pcap_file)
self.dict_all_capture_pid_and_cls.update({ret: cls})
return ret
def stop_wireshark_capture(self, flag_pid):
"""
功能描述: 停止当前网卡设备的抓包
参数：\n
flag_pid: Start WireShark Capture关键字执行成功后的返回值
返回值：无
*注意：flag_pid传入为空或者None时不进行关闭动作。
Example:
| ${flag_pid} | Start WireShark Capture | | ATT |
| Stop WireShark Capture | ${flag_pid} |
"""
# 当同时开启多个抓包的时候会有抓不到包的情况，如果加1s延时效果好点 zsj2013/12/23
if not self.flag_stop_all:
time.sleep(1)
cls = self.dict_all_capture_pid_and_cls.get(flag_pid)
if not cls:
str_warn = u"没有找到相应抓包服务器%s" % flag_pid
log.user_warn(str_warn)
return
if (isinstance(cls, Remote)):
ret, ret_data = auto_do_remote(cls)
else:
ret, ret_data = cls.stop_wireshark_capture(flag_pid)
if not IS_LOCAL: # 如果是如果不运行后面的保存文件等，直接返回
return ret, ret_data
# 根据停止返回的数据保存抓包文件
if ret == WIRESHARK_SUCCESS:
self._save_pcap_file_and_link_file(ret_data)
# 删除已关闭的抓包服务器的存储
if self.dict_all_capture_pid_and_cls.get(flag_pid):
self.dict_all_capture_pid_and_cls.pop(flag_pid)
def wireshark_query_option_str_value(self,
flag_pid,
option_name_or_offset,
read_filter=""):
"""
功能描述: 查询抓到数据包中某个字段的值
参数：\n
flag_pid: Start WireShark Capture关键字执行成功后的返回值\n
option_name_or_offset: 所要查询的字段名\n
read_filter: 读取过滤器表达式\n
返回值：\n
list_data: 查询成功返回列表形式option_name字段值或None
Example:
| ${list_data} | Wireshark Query Option Str Value | ${flag_pid} | ip.version | tcp |
| ${list_data} | Wireshark Query Option Str Value | ${flag_pid} | frame[58:34] | tcp |
"""
ret = None
cls = self._current_remotelocal()
if (isinstance(cls, Remote)):
ret = auto_do_remote(cls)
else:
ret = cls.wireshark_query_option_str_value(flag_pid,
option_name_or_offset,
read_filter)
if IS_LOCAL and ret == WIRESHARK_NO_STOP:
str_data = u"抓包服务器未停止，开始自动停止抓包服务器！"
log.user_warn(str_data)
self.stop_wireshark_capture(flag_pid)
ret = self.wireshark_query_option_str_value(
flag_pid, option_name_or_offset, read_filter)
else:
pass
return ret
def wireshark_query_option_byte_value(self,
flag_pid,
option_name_or_offset,
read_filter=""):
"""
功能描述: 查询抓到数据包中某个字段的十六进制值。
参数：\n
flag_pid: Start WireShark Capture关键字执行成功后的返回值\n
option_name_or_offset: 所要查询的字段名\n
read_filter: 读取过滤器表达式\n
返回值：\n
list_data: 查询成功返回列表形式option_name字段值或None
Example:
| ${list_data} | Wireshark Query Option Byte Value | ${flag_pid} | ip.version | tcp |
| ${list_data} | Wireshark Query Option Byte Value | ${flag_pid} | frame[58:34] | tcp |
"""
ret = None
cls = self._current_remotelocal()
if (isinstance(cls, Remote)):
ret = auto_do_remote(cls)
else:
ret = cls.wireshark_query_option_byte_value(
flag_pid, option_name_or_offset, read_filter)
if IS_LOCAL and ret == WIRESHARK_NO_STOP:
str_data = u"抓包服务器未停止，开始自动停止抓包服务器！"
log.user_warn(str_data)
self.stop_wireshark_capture(flag_pid)
ret = self.wireshark_query_option_byte_value(
flag_pid, option_name_or_offset, read_filter)
else:
pass
return ret
def stop_all_wireshark_capture(self):
"""
功能描述: 关闭所有开启的抓包浏览器并保存.\n
参数：无
返回值：无
Example:
| Init WireShark Network Card | One | 本地连接1 |
| ${flag_pid1} | Start WireShark Capture | | ATT |
| ${flag_pid2} | Start WireShark Capture | tcp | ATT |
| ${flag_pid3} | Start WireShark Capture | tcp | ATT | c:\\\\wireshark |
| Stop All WireShark Capture |
"""
# 当同时开启多个抓包的时候会有抓不到包的情况，如果加2s延时效果好点 zsj2013/12/23
time.sleep(2)
self.flag_stop_all = True
for flag_pid in self.dict_all_capture_pid_and_cls.keys():
try:
self.stop_wireshark_capture(flag_pid)
except:
pass
self.flag_stop_all = False
def wireshark_capture_packet_success(self, flag_pid):
"""
功能描述: 成功抓到报文关键字执行成功，报文为空，关键字执行失败.\n
参数：\n
flag_pid: Start WireShark Capture关键字执行成功后的返回值
返回值：无
Example:
| Wireshark Capture Packet Success | ${flag_pid} |
"""
ret = None
cls = self._current_remotelocal()
if (isinstance(cls, Remote)):
ret = auto_do_remote(cls)
else:
ret = cls.wireshark_capture_success(flag_pid)
if IS_LOCAL and ret == WIRESHARK_NO_STOP:
str_data = u"抓包服务器未停止，开始自动停止抓包服务器！"
log.user_warn(str_data)
self.stop_wireshark_capture(flag_pid)
self.wireshark_capture_packet_success(flag_pid)
else:
return ret
def _save_pcap_file_and_link_file(self, tuple_data):
"""
"""
ret = FLAG_SUCCEED
packet_data = tuple_data[0]
if packet_data is None: # 如果停止的时候没有找到数据文件，返回成功
return ret
ret, str_data = self._get_packet_file_path(tuple_data[1])
if ret == FLAG_SUCCEED:
file_path = str_data
try:
with open(file_path, "wb") as obj_file2:
obj_file2.write(base64.b64decode(packet_data))
str_data = u"保存抓包数据到指定路径 %s 成功！" % file_path
self._link_wireshark_file(file_path)
except Exception, e:
ret = FLAG_FAIL
str_data = "%s" % e
if ret == FLAG_SUCCEED:
log.user_info(str_data)
else:
err_data = u"把抓包文件保存到用户指定文件错误，错误信息：%s" % str_data
log.user_err(err_data)
dict_data["file_path"] = file_path
dict_data["temp_packet_file_path"] = temp_packet_file_path
dict_data["popen_stdout_path"] = popen_stdout_path
self.dict_process_obj.update({flag_pid: dict_data})
cmd_pid_with_tshark_path = os.path.join(ATTROBOT_TEMP_FILE_PAHT,
"cmd_pid_with_tshark.txt")
try:
with open(cmd_pid_with_tshark_path, "a+") as file_obj:
file_obj.write("%s\n" % popen.pid)
except Exception, e:
debug_msg = u"保存抓包服务器flag_pid=%s失败，该服务器不能自动关闭" % popen.pid
log.debug_warn(debug_msg)
else:
log.user_err(ret_data)
raise RuntimeError(ret_data)
return flag_pid
def get_wireshark_flag_pid(self, pcap_file):
"""
功能描述: 获取已抓到数据报文flag_pid
参数：\n
pcap_file： 已抓到数据报文的路径\n
"""
if not self.wireshark_install_path:
self.wireshark_install_path = self._get_default_install_path()
