def get_device_info(self):
with self.do_get_request('status_device.html') as fobj:
content = fobj.read()
dev_info = {u'vendor': VENDOR}
cur_pos = content.find('MAC address:')
if cur_pos == -1:
logger.warning('could not find "MAC address:" string')
return
m = self._MAC_REGEX.search(content, cur_pos)
if not m:
logger.warning('could not find MAC address')
return
raw_mac = m.group()
cur_pos = m.end()
dev_info[u'mac'] = norm_mac(raw_mac.decode('ascii'))
if hasattr(self, '_VERSION_REGEX'):
cur_pos = content.find('Firmware version:', cur_pos)
if cur_pos == -1:
logger.warning('could not find "Firmware version:" string')
return
m = self._VERSION_REGEX.search(content, cur_pos)
if not m:
logger.warning('could not find firmware version')
return
raw_version = m.group(1)
dev_info[u'version'] = raw_version.decode('ascii')
return dev_info
def _extract_from_ua(self, ua):
# HTTP User-Agent:
# "Yealink SIP-T20P 9.72.0.30 00:15:65:5e:16:7c"
# "Yealink SIP-T21P 34.72.0.1 00:15:65:4c:4c:26"
# "Yealink SIP-T21P_E2 52.80.0.3 00:15:65:4c:4c:26"
# "Yealink SIP-T22P 7.72.0.30 00:15:65:39:31:fc"
# "Yealink SIP-T23G 44.80.0.60 00:15:65:93:70:f2"
# "Yealink SIP-T31G 124.85.257.55 80:5e:c0:d5:7d:72"
# "Yealink SIP-T33G 124.85.257.55 80:5e:c0:bd:ea:ef"
for UA_REGEX in self._UA_REGEX_LIST:
m = UA_REGEX.match(ua)
if m:
raw_model, raw_version, raw_mac = m.groups()
try:
mac = norm_mac(raw_mac.decode('ascii'))
except ValueError as e:
logger.warning('Could not normalize MAC address "%s": %s',
raw_mac, e)
return {
u'vendor': u'Yealink',
u'model': raw_model.decode('ascii'),
u'version': raw_version.decode('ascii'),
}
else:
return {
u'vendor': u'Yealink',
u'model': raw_model.decode('ascii'),
u'version': raw_version.decode('ascii'),
u'mac': mac,
}
return None
def _extract_from_ua(self, ua):
# HTTP User-Agent:
# "Htek UC903 2.0.4.2 00:1f:c1:1c:22:a9"
for UA_REGEX in self._UA_REGEX_LIST:
m = UA_REGEX.match(ua)
if m:
raw_model, raw_version, raw_mac = m.groups()
try:
mac = norm_mac(raw_mac.decode('ascii'))
except ValueError as e:
logger.warning('Could not normalize MAC address "%s": %s',
raw_mac, e)
return {
u'vendor': u'Htek',
u'model': raw_model.decode('ascii'),
u'version': raw_version.decode('ascii')
}
else:
return {
u'vendor': u'Htek',
u'model': raw_model.decode('ascii'),
u'version': raw_version.decode('ascii'),
u'mac': mac
}
return None
def _extract_from_ua(self, ua):
# HTTP User-Agent:
# "Aastra6731i MAC:00-08-5D-23-74-29 V:2.6.0.1008-SIP"
# "Aastra6731i MAC:00-08-5D-23-74-29 V:2.6.0.2010-SIP"
# "Aastra6731i MAC:00-08-5D-23-74-29 V:3.2.0.70-SIP"
# "Aastra6731i MAC:00-08-5D-23-73-01 V:3.2.0.1011-SIP"
# "Aastra55i MAC:00-08-5D-20-DA-5B V:2.6.0.1008-SIP"
# "Aastra57i MAC:00-08-5D-19-E4-01 V:2.6.0.1008-SIP"
m = self._UA_REGEX.match(ua)
if m:
raw_model, raw_mac, raw_version = m.groups()
try:
mac = norm_mac(raw_mac.decode('ascii'))
except ValueError, e:
logger.warning('Could not normalize MAC address: %s', e)
else:
if raw_model in self._UA_MODELS_MAP:
model = self._UA_MODELS_MAP[raw_model]
else:
model = raw_model.decode('ascii')
return {
u'vendor': u'Aastra',
u'model': model,
u'version': raw_version.decode('ascii'),
u'mac': mac
}
def _test_sepfile(self, filename):
# Test if filename is "SEPMAC.cnf.xml".
m = self._SEPFILE_REGEX.match(filename)
if m:
raw_mac = m.group(1)
return {u'mac': norm_mac(raw_mac.decode('ascii'))}
return None
def _test_sepfile(self, filename):
# Test if filename is "SEPMAC.cnf.xml".
m = self._SEPFILE_REGEX.match(filename)
if m:
raw_mac = m.group(1)
return {u'mac': norm_mac(raw_mac.decode('ascii'))}
return None
def get_device_info(self):
with self.do_get_request('status_device.html') as fobj:
content = fobj.read()
dev_info = {u'vendor': VENDOR}
cur_pos = content.find('MAC address:')
if cur_pos == -1:
logger.warning('could not find "MAC address:" string')
return
m = self._MAC_REGEX.search(content, cur_pos)
if not m:
logger.warning('could not find MAC address')
return
raw_mac = m.group()
cur_pos = m.end()
dev_info[u'mac'] = norm_mac(raw_mac.decode('ascii'))
if hasattr(self, '_VERSION_REGEX'):
cur_pos = content.find('Firmware version:', cur_pos)
if cur_pos == -1:
logger.warning('could not find "Firmware version:" string')
return
m = self._VERSION_REGEX.search(content, cur_pos)
if not m:
logger.warning('could not find firmware version')
return
raw_version = m.group(1)
dev_info[u'version'] = raw_version.decode('ascii')
return dev_info
def _extract_from_ua(self, ua):
# HTTP User-Agent:
# "Mozilla/4.0 (compatible; snom lid 3605)" --> Snom 6.5.xx
# "Mozilla/4.0 (compatible; snom320-SIP 6.5.20; snom320 jffs2 v3.36; snom320 linux 3.38)"
# "Mozilla/4.0 (compatible; snom320-SIP 7.3.30 1.1.3-u)"
# "Mozilla/4.0 (compatible; snom320-SIP 8.4.18 1.1.3-s)"
# "Mozilla/4.0 (compatible; snom710-SIP 8.7.3.19 1.1.5-IFX-05.01.12)"
# "Mozilla/4.0 (compatible; snom710-SIP 8.7.5.35 1.1.5-IFX-05.01.12 000413741767)"
# "Mozilla/4.0 (compatible; snom760-SIP 8.7.3.19 2010.06)"
# "Mozilla/4.0 (compatible; snom820-SIP 8.4.35 1.1.4-IFX-26.11.09)"
# "Mozilla/4.0 (compatible; snom870-SIP 8.4.35 SPEAr300 SNOM 1.4)"
# "Mozilla/4.0 (compatible; snomPA1-SIP 8.4.35 1.1.3-s)"
# "Mozilla/4.0 (compatible; snomD785-SIP 10.1.33.33 2010.12-00004-g9ba52f5 000413922D24 SXM:0 UXM:0)"
m = self._UA_REGEX_MAC.search(ua)
if m:
raw_model, raw_version, _, raw_mac = m.groups()
return {
u'vendor': u'Snom',
u'model': raw_model.decode('ascii'),
u'mac': norm_mac(raw_mac.decode('ascii')),
u'version': raw_version.decode('ascii')
}
# if the complete regex did not match, match a smaller one
m = self._UA_REGEX.search(ua)
if m:
raw_model, raw_version = m.groups()
return {
u'vendor': u'Snom',
u'model': raw_model.decode('ascii'),
u'version': raw_version.decode('ascii')
}
return None
def _extract_from_ua(self, ua):
# HTTP User-Agent:
# "Aastra6731i MAC:00-08-5D-23-74-29 V:2.6.0.1008-SIP"
# "Aastra6731i MAC:00-08-5D-23-74-29 V:2.6.0.2010-SIP"
# "Aastra6731i MAC:00-08-5D-23-74-29 V:3.2.0.70-SIP"
# "Aastra6731i MAC:00-08-5D-23-73-01 V:3.2.0.1011-SIP"
# "Aastra6739i MAC:00-08-5D-13-CA-05 V:3.0.1.2024-SIP"
# "Aastra6739i MAC:00-08-5D-13-CA-05 V:3.2.1.1013-SIP"
# "Aastra55i MAC:00-08-5D-20-DA-5B V:2.6.0.1008-SIP"
# "Aastra57i MAC:00-08-5D-19-E4-01 V:2.6.0.1008-SIP"
# "Aastra6735i MAC:00-08-5D-2E-A0-94 V:3.2.2.6038-SIP"
# "Aastra6737i MAC:00-08-5D-30-A6-CE V:3.2.2.6038-SIP"
# "Aastra6863i MAC:00-08-5D-40-90-5F V:4.1.0.128-SIP"
m = self._UA_REGEX.match(ua)
if m:
raw_model, raw_mac, raw_version = m.groups()
try:
mac = norm_mac(raw_mac.decode('ascii'))
except ValueError, e:
logger.warning('Could not normalize MAC address: %s', e)
else:
if raw_model in self._UA_MODELS_MAP:
model = self._UA_MODELS_MAP[raw_model]
else:
model = raw_model.decode('ascii')
return {u'vendor': u'Aastra',
u'model': model,
u'version': raw_version.decode('ascii'),
u'mac': mac}
def _extract_from_ua(self, ua):
# HTTP User-Agent:
# "Yealink CP960 73.83.0.30 00:15:65:8a:37:86"
# "yealink SIP-T29G 46.83.0.120 00:15:65:13:ae:0b"
# "Yealink SIP-T41P 36.83.0.120 00:15:65:53:83:22"
# "Yealink SIP-T42G 29.83.0.120 00:15:65:4c:3b:b0"
# "Yealink SIP-T46G 28.83.0.120 00:15:65:4a:a9:37"
# "Yealink SIP-T48G 35.83.0.120 00:15:65:5c:60:82"
# "Yealink SIP-T49G 51.80.0.10 00:15:65:9b:5a:44"
# "Yealink SIP-T58A 58.83.0.15 00:15:65:9b:5b:22"
# "Yealink W60B 77.81.0.35 80:5e:c0:09:ab:dc"
# "Yealink W80B 103.83.0.70 80:5e:c0:71:01:38"
for UA_REGEX in self._UA_REGEX_LIST:
m = UA_REGEX.match(ua)
if m:
raw_model, raw_version, raw_mac = m.groups()
try:
mac = norm_mac(raw_mac.decode('ascii'))
except ValueError as e:
logger.warning('Could not normalize MAC address "%s": %s',
raw_mac, e)
return {
u'vendor': u'Yealink',
u'model': raw_model.decode('ascii'),
u'version': raw_version.decode('ascii')
}
else:
return {
u'vendor': u'Yealink',
u'model': raw_model.decode('ascii'),
u'version': raw_version.decode('ascii'),
u'mac': mac
}
return None
def _extract_from_ua(self, ua):
# HTTP User-Agent:
# "Aastra6731i MAC:00-08-5D-23-74-29 V:3.2.0.70-SIP"
# "Aastra6731i MAC:00-08-5D-23-73-01 V:3.2.0.1011-SIP"
# "Aastra6739i MAC:00-08-5D-13-CA-05 V:3.0.1.2024-SIP"
# "Aastra6739i MAC:00-08-5D-13-CA-05 V:3.2.1.1013-SIP"
# "Aastra6735i MAC:00-08-5D-2E-A0-94 V:3.2.2.6038-SIP"
# "Aastra6737i MAC:00-08-5D-30-A6-CE V:3.2.2.6038-SIP"
# "Aastra6863i MAC:00-08-5D-40-90-5F V:4.1.0.128-SIP"
m = self._UA_REGEX.match(ua)
if m:
raw_model, raw_mac, raw_version = m.groups()
try:
mac = norm_mac(raw_mac.decode('ascii'))
except ValueError, e:
logger.warning('Could not normalize MAC address: %s', e)
else:
if raw_model in self._UA_MODELS_MAP:
model = self._UA_MODELS_MAP[raw_model]
else:
model = raw_model.decode('ascii')
return {
u'vendor': u'Aastra',
u'model': model,
u'version': raw_version.decode('ascii'),
u'mac': mac
}
def _extract_from_ua(self, ua):
# HTTP User-Agent:
# "Yealink CP860 37.72.0.5 00:15:65:8a:37:86"
# "yealink SIP-T18 18.0.0.80 00:15:65:27:3e:05"
# "Yealink SIP-T19P_E2 53.80.0.3 00:15:65:4c:4c:26"
# "Yealink SIP-T20P 9.72.0.30 00:15:65:5e:16:7c"
# "Yealink SIP-T21P 34.72.0.1 00:15:65:4c:4c:26"
# "Yealink SIP-T21P_E2 52.80.0.3 00:15:65:4c:4c:26"
# "Yealink SIP-T22P 7.72.0.30 00:15:65:39:31:fc"
# "Yealink SIP-T23G 44.80.0.60 00:15:65:93:70:f2"
# "Yealink SIP-T26P 6.72.0.30 00:15:65:4b:57:d2"
# "Yealink SIP-T27P 45.80.0.25 00:15:65:8c:48:12"
# "yealink SIP-T28P 2.70.0.140 00:15:65:13:ae:0b"
# "Yealink SIP-T38G 38.70.0.125 00:15:65:2f:c3:5e"
# "Yealink SIP-T40P 54.80.0.10 00:15:65:94:86:64"
# "Yealink SIP-T41P 36.72.0.1 00:15:65:53:83:22"
# "Yealink SIP-T42G 29.72.0.1 00:15:65:4c:3b:b0"
# "Yealink SIP-T46G 28.72.0.1 00:15:65:4a:a9:37"
# "Yealink SIP-T48G 35.72.0.6 00:15:65:5c:60:82"
# "Yealink SIP VP-T49G 51.80.0.10 00:15:65:9b:5a:44"
# "Yealink SIP-W52P 25.73.0.20 00:15:65:40:ae:35"
# "W52P 25.30.0.2 00:15:65:44:b3:7c"
# "Yealink W52P 25.80.0.15 00:15:65:b8:60:05"
# "Yealink CP960 73.83.0.30 00:15:65:8a:37:86"
# "yealink SIP-T29G 46.83.0.120 00:15:65:13:ae:0b"
# "Yealink SIP-T41P 36.83.0.120 00:15:65:53:83:22"
# "Yealink SIP-T42G 29.83.0.120 00:15:65:4c:3b:b0"
# "Yealink SIP-T46G 28.83.0.120 00:15:65:4a:a9:37"
# "Yealink SIP-T48G 35.83.0.120 00:15:65:5c:60:82"
# "Yealink SIP-T49G 51.80.0.10 00:15:65:9b:5a:44"
# "Yealink SIP-T58A 58.83.0.15 00:15:65:9b:5b:22"
# "Yealink W60B 77.81.0.35 80:5e:c0:09:ab:dc"
# "Yealink-T46G 28.71.0.81 28.1.0.128.0.0.0"
# "VP530P 23.70.0.40 00:15:65:31:4b:c0"
# "VP530 23.70.0.41 00:15:65:3d:58:e3"
# "Yealink W80B 103.83.0.90 80:5e:c0:71:01:38"
for UA_REGEX in self._UA_REGEX_LIST:
m = UA_REGEX.match(ua)
if m:
raw_model, raw_version, raw_mac = m.groups()
try:
mac = norm_mac(raw_mac.decode('ascii'))
except ValueError as e:
logger.warning('Could not normalize MAC address "%s": %s',
raw_mac, e)
return {
u'vendor': u'Yealink',
u'model': raw_model.decode('ascii'),
u'version': raw_version.decode('ascii')
}
else:
return {
u'vendor': u'Yealink',
u'model': raw_model.decode('ascii'),
u'version': raw_version.decode('ascii'),
u'mac': mac
}
return None
def _extract_from_path(self, request):
if 'f0C00620000.cfg' in request.path:
return {u'vendor': u'Fanvil', u'model': u'C62'}
m = self._PATH_REGEX.search(request.path)
if m:
raw_mac = m.group(1)
mac = norm_mac(raw_mac.decode('ascii'))
return {u'vendor': u'Fanvil', u'mac': mac}
return None
def _do_extract(self, request):
match = self._PATH_REGEX.match(request.path)
if match:
dev_info = {u'vendor': u'Digium'}
raw_mac = match.group(1)
if raw_mac and raw_mac != '000000000000':
mac = norm_mac(raw_mac.decode('ascii'))
dev_info[u'mac'] = mac
return dev_info
def _extract_from_path(self, path, dev_info):
m = self._PATH_REGEX.search(path)
if m:
raw_mac = m.group(1)
dev_info[u'mac'] = norm_mac(raw_mac.decode('ascii'))
else:
filename = os.path.basename(path)
if filename in _FILENAME_MAP:
dev_info[u'model'] = _FILENAME_MAP[filename]
def _extract_from_path(self, path, dev_info):
m = self._PATH_REGEX.search(path)
if m:
raw_mac = m.group(1)
dev_info[u'mac'] = norm_mac(raw_mac.decode('ascii'))
else:
filename = os.path.basename(path)
if filename in _FILENAME_MAP:
dev_info[u'model'] = _FILENAME_MAP[filename]
def _do_extract(self, request):
match = self._PATH_REGEX.match(request.path)
if match:
dev_info = {u'vendor': u'Digium'}
raw_mac = match.group(1)
if raw_mac and raw_mac != '000000000000':
mac = norm_mac(raw_mac.decode('ascii'))
dev_info[u'mac'] = mac
return dev_info
def _extract_from_ua(self, ua):
# Fanvil X4 2.10.2.6887 0c383e07e16c
dev_info = {}
m = self._UA_REGEX.search(ua)
if m:
dev_info['vendor'] = 'Fanvil'
dev_info['model'] = m.group('model').decode('ascii')
dev_info['version'] = m.group('version').decode('ascii')
dev_info['mac'] = norm_mac(m.group('mac').decode('ascii'))
return dev_info
def _extract_cisco_from_ua(self, ua, dev_info):
# Pre: ua.startswith('Cisco/')
m = self._CISCO_UA_REGEX.match(ua)
if m:
model, version, raw_mac, sn = m.groups()
dev_info[u'model'] = model.decode('ascii')
dev_info[u'version'] = version.decode('ascii')
if raw_mac:
dev_info[u'mac'] = norm_mac(raw_mac.decode('ascii'))
dev_info[u'sn'] = sn.decode('ascii')
def _test_macfile(self, filename):
# Test if filename is "/$MA.xml".
m = self._MACFILE_REGEX.match(filename)
if m:
raw_mac = m.group(1)
try:
mac = norm_mac(raw_mac.decode('ascii'))
except ValueError, e:
logger.warning('Could not normalize MAC address: %s', e)
return {u'mac': mac}
def _extract_cisco_from_ua(self, ua, dev_info):
# Pre: ua.startswith('Cisco/')
m = self._CISCO_UA_REGEX.match(ua)
if m:
model, version, raw_mac, sn = m.groups()
dev_info[u'model'] = model.decode('ascii')
dev_info[u'version'] = version.decode('ascii')
if raw_mac:
dev_info[u'mac'] = norm_mac(raw_mac.decode('ascii'))
dev_info[u'sn'] = sn.decode('ascii')
def render_POST(self, request, content):
try:
raw_dhcp_info = content[u'dhcp_info']
op = raw_dhcp_info[u'op']
ip = norm_ip(raw_dhcp_info[u'ip'])
if op == u'commit':
mac = norm_mac(raw_dhcp_info[u'mac'])
options = self._transform_options(raw_dhcp_info[u'options'])
except (KeyError, TypeError, ValueError), e:
logger.warning('Invalid DHCP info content: %s', e)
return respond_error(request, e)
def _extract_from_path(self, request):
if 'f0C00620000.cfg' in request.path:
return {u'vendor': u'Fanvil',
u'model' : u'C62'}
m = self._PATH_REGEX.search(request.path)
if m:
raw_mac = m.group(1)
mac = norm_mac(raw_mac.decode('ascii'))
return {u'vendor': u'Fanvil',
u'mac': mac}
return None
def _extract_from_path(self, request):
if request.path.startswith('/001565'):
raw_mac = path[1:-4]
try:
mac = norm_mac(raw_mac.decode('ascii'))
except ValueError as e:
logger.warning('Could not normalize MAC address "%s": %s',
raw_mac, e)
else:
return {u'mac': mac}
return None
def _extract_from_path(self, path, dev_info):
# try to extract MAC address from path
m = self._PATH_REGEX.search(path)
if m:
raw_mac = m.group(1)
try:
mac = norm_mac(raw_mac.decode('ascii'))
except ValueError, e:
logger.warning('Could not normalize MAC address: %s', e)
else:
dev_info[u'mac'] = mac
def _extract_from_path(self, path, dev_info):
# try to extract MAC address from path
m = self._PATH_REGEX.search(path)
if m:
raw_mac = m.group(1)
try:
mac = norm_mac(raw_mac.decode('ascii'))
except ValueError, e:
logger.warning('Could not normalize MAC address: %s', e)
else:
dev_info[u'mac'] = mac
def _extract_from_ua(self, ua, dev_info):
# HTTP User-Agent:
# Note: the last group of digit is the serial number;
# the first, if present, is the MAC address
# Cisco-CP-7832-3PCC/11.0.1 (00562b043615)
m = self._CISCO_UA_REGEX.match(ua)
if m:
model, version, raw_mac = m.groups()
dev_info[u'model'] = model.decode('ascii')
dev_info[u'version'] = version.decode('ascii')
if raw_mac:
dev_info[u'mac'] = norm_mac(raw_mac.decode('ascii'))
def _do_extract(self, request):
device_info = {}
ua = request.getHeader('User-Agent')
raw_mac = request.args.get('mac', [None])[0]
if raw_mac:
logger.debug('Got MAC from URL: "%s"', raw_mac)
device_info[u'mac'] = norm_mac(raw_mac.decode('ascii'))
if ua:
info_from_ua = self._extract_from_ua(ua)
if info_from_ua:
device_info.update(info_from_ua)
return device_info
def _extract_from_path(self, request):
filename = os.path.basename(request.path)
device_info = self._COMMON_FILES.get(filename)
if device_info:
return {u'vendor': u'Fanvil', u'model': device_info[0]}
m = self._PATH_REGEX.search(request.path)
if m:
raw_mac = m.group(1)
mac = norm_mac(raw_mac.decode('ascii'))
return {u'mac': mac}
return {}
def _extract_from_ua(self, ua):
# HTTP User-Agent:
# "Mozilla/4.0 (compatible; Snom M900 05.20.0001 000413b60680)"
m = self._UA_REGEX_MAC.search(ua)
if m:
raw_model, raw_version, raw_mac = m.groups()
return {
u'vendor': u'Snom',
u'model': raw_model.decode('ascii'),
u'mac': norm_mac(raw_mac.decode('ascii')),
u'version': raw_version.decode('ascii')
}
return None
def _do_extract(self, request):
packet = request['packet']
filename = packet['filename']
for regex in self._FILENAME_REGEXES:
m = regex.match(filename)
if m:
dev_info = {u'vendor': u'Cisco'}
if m.lastindex == 1:
try:
dev_info[u'mac'] = norm_mac(m.group(1).decode('ascii'))
except ValueError, e:
logger.warning('Could not normalize MAC address: %s', e)
return dev_info
def _extract_from_path(self, request):
if request.path.startswith('/001565'):
raw_mac = path[1:-4]
try:
mac = norm_mac(raw_mac.decode('ascii'))
except ValueError as e:
logger.warning('Could not normalize MAC address "%s": %s', raw_mac, e)
else:
return {u'mac': mac}
if request.path.startswith('/y000000000025.cfg'):
return {u'vendor': u'Yealink',
u'model' : u'W52P'}
return None
def _extract_from_ua(self, ua):
for UA_REGEX in self._UA_REGEX_LIST:
m = UA_REGEX.match(ua)
if m:
raw_model, raw_version, raw_mac = m.groups()
try:
mac = norm_mac(raw_mac.decode('ascii'))
except ValueError, e:
logger.warning('Could not normalize MAC address "%s": %s', raw_mac, e)
else:
return {u'vendor': u'Grandstream',
u'model': raw_model.decode('ascii'),
u'version': raw_version.decode('ascii'),
u'mac': mac}
def _do_extract(self, request):
if self._CIPC_REGEX.match(request.path):
return {u'vendor': u'Cisco', u'model': u'CIPC'}
for regex in self._FILENAME_REGEXES:
m = regex.match(request.path)
if m:
dev_info = {u'vendor': u'Cisco'}
if m.lastindex == 1:
try:
dev_info[u'mac'] = norm_mac(m.group(1).decode('ascii'))
except ValueError, e:
logger.warning('Could not normalize MAC address: %s',
e)
return dev_info
def _extract_from_ua(self, ua):
m = self._UA_REGEX.match(ua)
if m:
raw_model, raw_mac, raw_version = m.groups()
try:
mac = norm_mac(raw_mac.decode('ascii'))
except ValueError, e:
logger.warning('Could not normalize MAC address: %s', e)
else:
model = raw_model.decode('ascii')
return {u'vendor': u'Mitel',
u'model': model,
u'version': raw_version.decode('ascii'),
u'mac': mac}
def _do_extract(self, request):
packet = request["packet"]
filename = packet["filename"]
if self._CIPC_REGEX.match(filename):
return {u"vendor": u"Cisco", u"model": u"CIPC"}
for regex in self._FILENAME_REGEXES:
m = regex.match(filename)
if m:
dev_info = {u"vendor": u"Cisco"}
if m.lastindex == 1:
try:
dev_info[u"mac"] = norm_mac(m.group(1).decode("ascii"))
except ValueError, e:
logger.warning("Could not normalize MAC address: %s", e)
return dev_info
def _extract_from_ua(self, ua):
new_ua = re.sub("( V[0-9]\.[0-9][A-Z] )", '', ua)
m = self._UA_REGEX.match(new_ua)
if m:
raw_model, raw_version, raw_mac= m.groups()
try:
mac = norm_mac(raw_mac.decode('ascii'))
except ValueError, e:
logger.warning('Could not normalize MAC address "%s": %s', raw_mac, e)
else:
return {u'vendor': u'Grandstream',
u'model': raw_model.decode('ascii'),
u'version': raw_version.decode('ascii'),
u'mac': mac}
def _extract_from_ua(self, ua):
# HTTP User-Agent:
# "Panasonic_KX-UT113/01.133 (0080f0c8c381)"
m = self._UA_REGEX.match(ua)
if m:
raw_model, raw_version, raw_mac = m.groups()
try:
mac = norm_mac(raw_mac.decode('ascii'))
except ValueError, e:
logger.warning('Could not normalize MAC address: %s', e)
else:
return {u'vendor': u'Panasonic',
u'model': raw_model.decode('ascii'),
u'version': raw_version.decode('ascii'),
u'mac': mac}
def _extract_from_ua(self, ua):
# HTTP User-Agent:
# "Gigaset N870 IP PRO/83.V2.11.0+build.a546b91;7C2F80E0D605"
m = self._UA_REGEX.search(ua)
dev_info = {}
if m:
dev_info = {
u'vendor': VENDOR,
u'model': m.group('model').decode('ascii'),
u'version': m.group('version').decode('ascii')
}
if 'mac' in m.groupdict():
dev_info[u'mac'] = norm_mac(m.group('mac').decode('ascii'))
return dev_info
def _do_extract(self, request):
ua = request.getHeader('User-Agent')
raw_mac = request.args.get('mac', [None])[0]
dev_info = {}
if raw_mac:
dev_info[u'mac'] = norm_mac(raw_mac.decode('ascii'))
logger.debug('Got MAC from URL: %s', dev_info[u'mac'])
if ua:
self._extract_from_ua(ua, dev_info)
if dev_info:
dev_info[u'vendor'] = u'Cisco'
if u'mac' not in dev_info or u'model' not in dev_info:
self._extract_from_path(request.path, dev_info)
return dev_info
return None
def _extract_from_ua(self, ua):
# HTTP User-Agent:
# "ALE M3-CE 2.11.01.1604 3c28a620089e"
m = self._UA_REGEX_MAC.search(ua)
if m:
device_info = m.groupdict()
raw_model = device_info['model']
raw_version = device_info['version']
raw_mac = device_info['mac']
return {
u'vendor': u'Alcatel-Lucent',
u'model': raw_model.decode('ascii'),
u'mac': norm_mac(raw_mac.decode('ascii')),
u'version': raw_version.decode('ascii'),
}
def _extract_from_ua(self, ua):
# HTTP User-Agent:
# "SmartNode (Model:SN4112/JS/EUI; Serial:00A0BA08933C; Software Version:R6.2 2012-09-11 H323 SIP FXS FXO; Hardware Version:4.4)"
# "yealink SIP-T28P 2.60.0.110 00:15:65:13:ae:0b"
m = self._UA_REGEX.match(ua)
if m:
raw_model, raw_mac, raw_version= m.groups()
try:
mac = norm_mac(raw_mac.decode('ascii'))
except ValueError, e:
logger.warning('Could not normalize MAC address "%s": %s', raw_mac, e)
else:
return {u'vendor': u'Patton',
u'model': raw_model.decode('ascii'),
u'version': raw_version.decode('ascii'),
u'mac': mac}
def _do_extract(self, request):
# filename:
# "ipst_config.cfg"
# "ipst_config_01_02_03_04_05_ab.cfg"
filename = request['packet']['filename']
m = self._FILENAME_REGEX.match(filename)
if m:
dev_info = {u'vendor': u'Zenitel', u'model': u'IP station'}
raw_mac = m.group(1)
if raw_mac:
raw_mac = raw_mac.replace('_', '')
try:
dev_info[u'mac'] = norm_mac(raw_mac.decode('ascii'))
except ValueError, e:
logger.warning('Could not normalize MAC address: %s', e)
return dev_info
def _extract_from_ua(self, ua):
# HTTP User-Agent:
# "Panasonic_KX-UT113/01.133 (0080f0c8c381)"
m = self._UA_REGEX.match(ua)
if m:
raw_model, raw_version, raw_mac = m.groups()
try:
mac = norm_mac(raw_mac.decode('ascii'))
except ValueError, e:
logger.warning('Could not normalize MAC address: %s', e)
else:
return {
u'vendor': u'Panasonic',
u'model': raw_model.decode('ascii'),
u'version': raw_version.decode('ascii'),
u'mac': mac
}
def _extract_from_ua(self, ua):
# HTTP User-Agent:
# "SmartNode (Model:SN4112/JS/EUI; Serial:00A0BA08933C; Software Version:R6.2 2012-09-11 H323 SIP FXS FXO; Hardware Version:4.4)"
# "SmartNode (Model:SN4316/JS; Serial:00A0BA0BA9A5; Software Version:R6.9 2016-07-05 H323 SIP FXS FXO; Hardware Version:2.3)"
m = self._UA_REGEX.match(ua)
if m:
raw_model, raw_mac, raw_version = m.groups()
try:
mac = norm_mac(raw_mac.decode('ascii'))
except ValueError as e:
logger.warning('Could not normalize MAC address: %s', e)
else:
return {u'vendor': u'Patton',
u'model': raw_model.decode('ascii'),
u'version': raw_version.decode('ascii'),
u'mac': mac}
return None
def _extract_from_ua(self, ua):
for UA_REGEX in self._UA_REGEX_LIST:
m = UA_REGEX.match(ua)
if m:
raw_model, raw_version, raw_mac = m.groups()
try:
mac = norm_mac(raw_mac.decode('ascii'))
except ValueError, e:
logger.warning('Could not normalize MAC address "%s": %s',
raw_mac, e)
else:
return {
u'vendor': u'Grandstream',
u'model': raw_model.decode('ascii'),
u'version': raw_version.decode('ascii'),
u'mac': mac
}
def _do_extract(self, request):
# filename:
# "ipst_config.cfg"
# "ipst_config_01_02_03_04_05_ab.cfg"
filename = request['packet']['filename']
m = self._FILENAME_REGEX.match(filename)
if m:
dev_info = {u'vendor': u'Zenitel',
u'model': u'IP station'}
raw_mac = m.group(1)
if raw_mac:
raw_mac = raw_mac.replace('_', '')
try:
dev_info[u'mac'] = norm_mac(raw_mac.decode('ascii'))
except ValueError, e:
logger.warning('Could not normalize MAC address: %s', e)
return dev_info
def _extract_from_ua(self, ua):
new_ua = re.sub("( V[0-9]\.[0-9][A-Z] )", '', ua)
m = self._UA_REGEX.match(new_ua)
if m:
raw_model, raw_version, raw_mac = m.groups()
try:
mac = norm_mac(raw_mac.decode('ascii'))
except ValueError, e:
logger.warning('Could not normalize MAC address "%s": %s',
raw_mac, e)
else:
return {
u'vendor': u'Grandstream',
u'model': raw_model.decode('ascii'),
u'version': raw_version.decode('ascii'),
u'mac': mac
}
def _extract_from_ua(self, ua):
# HTTP User-Agent:
# "SmartNode (Model:SN4112/JS/EUI; Serial:00A0BA08933C; Software Version:R6.2 2012-09-11 H323 SIP FXS FXO; Hardware Version:4.4)"
# "SmartNode (Model:SN4316/JS; Serial:00A0BA0BA9A5; Software Version:R6.9 2016-07-05 H323 SIP FXS FXO; Hardware Version:2.3)"
m = self._UA_REGEX.match(ua)
if m:
raw_model, raw_mac, raw_version = m.groups()
try:
mac = norm_mac(raw_mac.decode('ascii'))
except ValueError as e:
logger.warning('Could not normalize MAC address: %s', e)
else:
return {
u'vendor': u'Patton',
u'model': raw_model.decode('ascii'),
u'version': raw_version.decode('ascii'),
u'mac': mac
}
def _extract_from_ua(self, ua):
# HTTP User-Agent:
# "Yealink CP860 37.72.0.5 00:15:65:8a:37:86"
# "yealink SIP-T18 18.0.0.80 00:15:65:27:3e:05"
# "Yealink SIP-T19P_E2 53.80.0.3 00:15:65:4c:4c:26"
# "Yealink SIP-T20P 9.72.0.30 00:15:65:5e:16:7c"
# "Yealink SIP-T21P 34.72.0.1 00:15:65:4c:4c:26"
# "Yealink SIP-T21P_E2 52.80.0.3 00:15:65:4c:4c:26"
# "Yealink SIP-T22P 7.72.0.30 00:15:65:39:31:fc"
# "Yealink SIP-T23G 44.80.0.60 00:15:65:93:70:f2"
# "Yealink SIP-T26P 6.72.0.30 00:15:65:4b:57:d2"
# "Yealink SIP-T27P 45.80.0.25 00:15:65:8c:48:12"
# "yealink SIP-T28P 2.70.0.140 00:15:65:13:ae:0b"
# "Yealink SIP-T38G 38.70.0.125 00:15:65:2f:c3:5e"
# "Yealink SIP-T40P 54.80.0.10 00:15:65:94:86:64"
# "Yealink SIP-T41P 36.72.0.1 00:15:65:53:83:22"
# "Yealink SIP-T42G 29.72.0.1 00:15:65:4c:3b:b0"
# "Yealink SIP-T46G 28.72.0.1 00:15:65:4a:a9:37"
# "Yealink SIP-T48G 35.72.0.6 00:15:65:5c:60:82"
# "Yealink SIP VP-T49G 51.80.0.10 00:15:65:9b:5a:44"
# "Yealink SIP-W52P 25.73.0.20 00:15:65:40:ae:35"
# "W52P 25.30.0.2 00:15:65:44:b3:7c"
# "Yealink W52P 25.80.0.15 00:15:65:b8:60:05"
# "Yealink-T46G 28.71.0.81 28.1.0.128.0.0.0"
# "VP530P 23.70.0.40 00:15:65:31:4b:c0"
# "VP530 23.70.0.41 00:15:65:3d:58:e3"
for UA_REGEX in self._UA_REGEX_LIST:
m = UA_REGEX.match(ua)
if m:
raw_model, raw_version, raw_mac = m.groups()
try:
mac = norm_mac(raw_mac.decode('ascii'))
except ValueError as e:
logger.warning('Could not normalize MAC address "%s": %s', raw_mac, e)
return {u'vendor': u'Yealink',
u'model': raw_model.decode('ascii'),
u'version': raw_version.decode('ascii')}
else:
return {u'vendor': u'Yealink',
u'model': raw_model.decode('ascii'),
u'version': raw_version.decode('ascii'),
u'mac': mac}
return None
def _extract_info_from_ua(self, ua):
# HTTP User-Agent:
# "THOMSON ST2022 hw2 fw3.54 00-18-F6-B5-00-00" (from web)
# "THOMSON ST2022 hw2 fw4.68 00-14-7F-E1-FC-6D" (from web)
# "THOMSON ST2030 hw5 fw2.72 00-14-7F-E1-47-B3"
# "THOMSON ST2030 hw5 fw2.74 00-14-7F-E1-47-B3"
# "Thomson TB30 hw1 fw1.72.0 00-1F-9F-84-F1-80"
# "Thomson TB30 hw1 fw1.74.0 00-1F-9F-84-F1-80"
m = self._UA_REGEX.match(ua)
if m:
raw_model, raw_version, raw_mac = m.groups()
try:
mac = norm_mac(raw_mac.decode('ascii'))
except ValueError, e:
logger.warning('Could not normalize MAC address "%s": %s', raw_mac, e)
else:
return {u'vendor': u'Technicolor',
u'model': raw_model.decode('ascii'),
u'version': raw_version.decode('ascii'),
u'mac': mac}
def using_mac(self, mac):
normalized_mac = norm_mac(mac)
return self._new_device_group_from_selector({u'mac': normalized_mac})
def _extract_from_path(self, path, dev_info):
m = self._PATH_REGEX.search(path)
if m:
raw_mac = m.group(1)
dev_info[u'mac'] = norm_mac(raw_mac.decode('ascii'))
def _extract_mac_from_path(self, path, dev_info):
# Extract the MAC address from the requested path if possible
m = self._PATH_REGEX.search(path)
if m:
raw_mac = m.group(1)
dev_info[u'mac'] = norm_mac(raw_mac.decode('ascii'))
