|
Server : Apache/2.2.2 (Fedora) System : Linux App1.pathumtani.go.th 2.6.20-1.2320.fc5smp #1 SMP Tue Jun 12 19:40:16 EDT 2007 i686 User : apache ( 48) PHP Version : 5.2.9 Disable Function : NONE Directory : /usr/share/printconf/util/ |
Upload File : |
#!/usr/bin/python
import re
def _hexstring2int(str):
i = 0
while str[i] == ' ':
i = i + 1
return eval(r'0x' + str[i:])
_parse_interface_descriptor_line_regex = re.compile(
r'.*If#=(?P<interface_number>\s*\S*)' + \
r'\s*Alt=(?P<alternate_setting_number>\s*\S*)' + \
r'\s*#EPs=(?P<number_of_endpoints>\s*\S*)' + \
r'\s*Cls=(?P<interface_class_number>[^(]*)\((?P<interface_class_name>[^)]*)\)' + \
r'\s*Sub=(?P<interface_subclass>\s*\S*)' + \
r'\s*Prot=(?P<interface_protocol>\s*\S*)' + \
r'\s*Driver=(?P<interface_driver_name>\s*\S*)'
)
def _parse_interface_descriptor_line(line):
m_dict = _parse_interface_descriptor_line_regex.search(line).groupdict()
return {
'interface_number' : int(m_dict['interface_number']),
'alternate_setting_number' : int(m_dict['alternate_setting_number']),
'number_of_endpoints' : int(m_dict['number_of_endpoints']),
'interface_class' : ( _hexstring2int(m_dict['interface_class_number']),
m_dict['interface_class_name']),
'interface_subclass' : _hexstring2int(m_dict['interface_subclass']),
'interface_protocol' : _hexstring2int(m_dict['interface_protocol']),
'interface_driver_name' : m_dict['interface_driver_name']
}
_parse_string_descriptor_line_regex = re.compile(
r'S:\s*(?P<key>\S*)=(?P<value>.*)'
)
def _parse_string_descriptor_line(line):
m_dict = _parse_string_descriptor_line_regex.search(line).groupdict()
return { m_dict['key'] : m_dict['value'] }
_parse_product_id_line_regex = re.compile(
r'.*Vendor=(?P<vendor_id>\s*\S*)' + \
r'\s*ProdID=(?P<product_id>\s*\S*)' + \
r'\s*Rev=(?P<product_revision_a>[^.]*).(?P<product_revision_b>\S*)'
)
def _parse_product_id_line(line):
m_dict = _parse_product_id_line_regex.search(line).groupdict()
return {
'vendor_id' : _hexstring2int(m_dict['vendor_id']),
'product_id' : _hexstring2int(m_dict['product_id']),
'product_revision' : ( _hexstring2int(m_dict['product_revision_a']),
_hexstring2int(m_dict['product_revision_b']))
}
_parse_topology_line_regex = re.compile(
r'.*Bus=(?P<bus_number>\s*\S*)' + \
r'\s*Lev=(?P<level>\s*\S*)' + \
r'\s*Prnt=(?P<parent_device_number>\s*\S*)' + \
r'\s*Port=(?P<parent_connection_port>\s*\S*)' + \
r'\s*Cnt=(?P<sibling_count>\s*\S*)' + \
r'\s*Dev#=(?P<device_number>\s*\S*)' + \
r'\s*Spd=(?P<device_speed>\s*\S*)' + \
r'\s*MxCh=(?P<max_children>\s*\S*)'
)
def _parse_topology_line(line):
m_dict = _parse_topology_line_regex.search(line).groupdict()
return {
'bus_number' : int(m_dict['bus_number']),
'level' : int(m_dict['level']),
'parent_device_number' : int(m_dict['parent_device_number']),
'parent_connection_port' : int(m_dict['parent_connection_port']),
'sibling_count' : int(m_dict['sibling_count']),
'device_number' : int(m_dict['device_number']),
'device_speed' : float(m_dict['device_speed']),
'max_children' : int(m_dict['max_children']),
}
_parse_endpoint_line_regex = re.compile(
r'.*Ad=(?P<endpoint_address_number>[^(]*)\((?P<endpoint_address_char>\S)\)' + \
r'\s*Atr=(?P<attributes_number>[^(]*)\((?P<attributes_string>[^)]*)\)' + \
r'\s*MxPS=(?P<endpoint_max_packet_size>\s*\S*)' + \
r'\s*Ivl=(?P<interval>\s*\S*)ms'
)
def _parse_endpoint_line(line):
m_dict = _parse_endpoint_line_regex.search(line).groupdict()
return {
'endpoint_address' : ( int(m_dict['endpoint_address_number']),
m_dict['endpoint_address_char']),
'attributes' : ( int(m_dict['attributes_number']),
m_dict['attributes_string']),
'endpoint_max_packet_size' : int(m_dict['endpoint_max_packet_size']),
'interval' : int(m_dict['interval']),
}
_parse_device_descriptor_line_regex = re.compile(
r'.*Ver=(?P<device_usb_version_a>\s*\S*)\.(?P<device_usb_version_b>\s*\S*)' + \
r'\s*Cls=(?P<device_class_number>[^(]*)\((?P<device_class_name>[^)]*)\)' + \
r'\s*Sub=(?P<device_subclass>\s*\S*)' + \
r'\s*Prot=(?P<device_protocol>\s*\S*)' + \
r'\s*MxPS=(?P<default_endpoint_max_packet_size>\s*\S*)' + \
r'\s*#Cfgs=(?P<number_of_configs>\s*\S*)'
)
def _parse_device_descriptor_line(line):
m_dict = _parse_device_descriptor_line_regex.search(line).groupdict()
return {
'device_usb_version' : ( _hexstring2int(m_dict['device_usb_version_a']),
_hexstring2int(m_dict['device_usb_version_b'])),
'device_class' : ( _hexstring2int(m_dict['device_class_number']),
m_dict['device_class_name']),
'device_subclass' : _hexstring2int(m_dict['device_subclass']),
'device_protocol' : _hexstring2int(m_dict['device_protocol']),
'default_endpoint_max_packet_size' : int(m_dict['default_endpoint_max_packet_size']),
'number_of_configs' : _hexstring2int(m_dict['number_of_configs']),
}
_parse_bandwidth_line_regex = re.compile(
r'.*Alloc=(?P<allocation_a>[^/]*)/(?P<allocation_b>\s*\S*)\s*us\s*\((?P<allocation_percent>\s*\S*)%\),' + \
r'\s*#Int=(?P<number_of_interupts>\s*\S*),' + \
r'\s*#Iso=(?P<number_of_isochronous_requests>\s*\S*)'
)
def _parse_bandwidth_line(line):
m_dict = _parse_bandwidth_line_regex.search(line).groupdict()
return {
'allocation' : ( int(m_dict['allocation_a']),
int(m_dict['allocation_b']),
_hexstring2int(m_dict['allocation_percent'])),
'number_of_interupts' : int(m_dict['number_of_interupts']),
'number_of_isochronous_requests': int(m_dict['number_of_isochronous_requests']),
}
_parse_config_line_regex = re.compile(
r'C:(?P<active>.)' + \
r'\s*#Ifs=(?P<number_of_interfaces>\s*\S*)' + \
r'\s*Cfg#=(?P<configuration_number>\s*\S*)' + \
r'\s*Atr=(?P<attributes>\s*\S*)' + \
r'\s*MxPwr=(?P<max_power>\s*\S*)mA'
)
def _parse_config_line(line):
m_dict = _parse_config_line_regex.search(line).groupdict()
return {
'active' : (m_dict['active'] == '*'),
'number_of_interfaces' : int(m_dict['number_of_interfaces']),
'configuration_number' : int(m_dict['configuration_number']),
'attributes' : _hexstring2int(m_dict['attributes']),
'max_power' : int(m_dict['max_power'])
}
def scan_usb_devices():
lines = open("/proc/bus/usb/devices").readlines()
devices = []
interfaces = []
def line_type(lines = lines):
if lines[0][0] == '\n':
pop_line ()
return lines[0][0]
def pop_line(lines = lines):
return lines.pop(0)
def scan_endpoint(lines=lines, line_type=line_type, pop_line=pop_line):
if line_type() != 'E':
raise ValueError, "Scaning endpoint, found '%s' line" % line_type()
endpoint = _parse_endpoint_line(pop_line())
def scan_interface(device=None, lines=lines, interfaces=interfaces, line_type=line_type,
pop_line=pop_line, scan_endpoint=scan_endpoint):
if line_type() != 'I':
raise ValueError, "Scaning interface, found '%s' line" % line_type()
interface = _parse_interface_descriptor_line(pop_line())
interface['endpoints'] = []
interface['device'] = device
interfaces.append(interface)
for i in range(interface['number_of_endpoints']):
interface['endpoints'].append(scan_endpoint())
return interface
def scan_config(device, lines=lines, line_type=line_type,
pop_line=pop_line, scan_interface=scan_interface):
if line_type() != 'C':
raise ValueError, "Scaning config, found '%s' line" % line_type()
config = _parse_config_line(pop_line())
config['interfaces'] = []
for i in range(config['number_of_interfaces']):
config['interfaces'].append(scan_interface(device))
device = None
while len(lines):
if line_type() == "T":
device = _parse_topology_line(pop_line())
device.update({
'configs' : [],
})
device['configs'] = []
devices.append(device)
elif line_type() == 'B':
device.update(_parse_bandwidth_line(pop_line()))
elif line_type() == 'D':
device.update(_parse_device_descriptor_line(pop_line()))
elif line_type() == 'P':
device.update(_parse_product_id_line(pop_line()))
elif line_type() == 'S':
device.update(_parse_string_descriptor_line(pop_line()))
elif line_type() == 'C':
device['configs'].append(scan_config(device))
elif line_type() == 'I':
scan_interface()
else:
raise ValueError, "Expecting Topology line 'T', found '%s'" % line_type()
return (devices, interfaces)