def _on_connect(self):
self.notify_handles = []
self._init_driver()
if not self.device:
raise usb.USBError("No supported logitech headphones found on USB bus")
if self.device == None:
raise usb.USBError("WARNING: Found no " + self.model + " Logitech headphone, Giving up")
def __init__(self, reset_on_start=False):
self._lcd_device = self._find_device(0x046d, 0xc229)
if not self._lcd_device:
raise usb.USBError("G19 LCD not found on USB bus")
self._kbd_device = self._find_device(0x046d, 0xc228)
if not self._kbd_device:
raise usb.USBError("G19 keyboard not found on USB bus")
self.handle_if_0 = self._lcd_device.open()
if reset_on_start:
self.handle_if_0.reset()
self.handle_if_0 = self._lcd_device.open()
self.handle_if_1 = self._lcd_device.open()
config = self._lcd_device.configurations[0]
iface0 = config.interfaces[0][0]
iface1 = config.interfaces[0][1]
try:
self.handle_if_1.detachKernelDriver(iface1)
except usb.USBError:
pass
self.handle_if_0.setConfiguration(1)
self.handle_if_1.setConfiguration(1)
self.handle_if_0.claimInterface(iface0)
self.handle_if_1.claimInterface(iface1)
def bulkRead(self, chan, length, timeout=1):
'''
In standard USB fashion, bulkRead() handles the "IN" communication, whereby the "host"
pulls information back from the "device". ie. our responses to commands.
RfCat polls this function repeatedly, to provide the illusion of bi-directional
communication, when in fact USB (pre-v3) is completely host-driven. If a USB device
gets to talk, it's because the host asked for information.
For our purposes, bulkRead() simply pops data out of the EP5 Bulk "queue" and returns.
This has *nothing* to do with "reading" from the memory. bulkRead() gives the dongle
the "talking stick"
'''
starttime = time.time()
while time.time() - starttime < timeout:
try:
out = self.bulk5.get_nowait()
logger.debug('<= fakeDoer.bulkRead(5, %r) == %r', length, out)
return b"@" + out
except queue.Empty:
time.sleep(.05)
logger.debug('<= fakeDoer.bulkRead(5, %r) == <EmptyQueue>', length)
raise usb.USBError('Operation timed out (FakeDongle)')
def read(self, size):
try:
outstring = self.dh.interruptRead(self.input_endpoint.address, 64,
HIDDevice._timeout)
except usb.USBError(e):
pass
return outstring
def write(self, buffer):
"""Write to the interrupt output endpoint"""
try:
self.dh.interruptWrite(
self.output_endpoint.address,
buffer + chr(0xff) * (64 - len(buffer)),
HIDDevice._timeout
)
except usb.USBError():
raise
def __init__(self, resetOnStart=False):
self.__lcd_device = self._find_device(0x046d, 0xc229)
if not self.__lcd_device:
raise usb.USBError("G19 LCD not found on USB bus")
self.__kbd_device = self._find_device(0x046d, 0xc228)
if not self.__kbd_device:
raise usb.USBError("G19 keyboard not found on USB bus")
self.handleIf0 = self.__lcd_device.open()
if resetOnStart:
self.handleIf0.reset()
self.handleIf0 = self.__lcd_device.open()
self.handleIf1 = self.__lcd_device.open()
self.handleIfMM = self.__kbd_device.open()
config = self.__lcd_device.configurations[0]
iface0 = config.interfaces[0][0]
iface1 = config.interfaces[1][0]
try:
self.handleIfMM.setConfiguration(1)
except usb.USBError:
pass
try:
self.handleIf1.detachKernelDriver(iface1)
except usb.USBError:
pass
try:
self.handleIfMM.detachKernelDriver(1)
except usb.USBError:
pass
try:
self.handleIf0.setConfiguration(1)
self.handleIf1.setConfiguration(1)
self.handleIf0.claimInterface(iface0)
self.handleIf1.claimInterface(iface1)
self.handleIfMM.claimInterface(1)
except usb.USBError as e:
print "Device is in use."
print e
sys.exit(0)
def submit(self, loop):
done_event = loop.submit(self.transfer)
done_event.wait()
if self.transfer.contents.status == LIBUSB_TRANSFER_COMPLETED:
ret = self.transfer.contents.actual_length
else:
status = int(self.transfer.contents.status)
raise usb.USBError(_str_transfer_error[status], status,
_transfer_errno[status])
return ret
def bulkRead(self, chan, length, timeout=1):
starttime = time.time()
while time.time() - starttime < timeout:
try:
out = self.bulk5.get_nowait()
logger.debug('<= fakeDoer.bulkRead(5, %r) == %r', length, out)
return "@" + out
except queue.Empty:
time.sleep(.05)
logger.debug('<= fakeDoer.bulkRead(5, %r) == <EmptyQueue>', length)
raise usb.USBError('Operation timed out (FakeDongle)')
def bulkRead(self, ep, size, timeout=0):
data = memoryview(bytes())
start_time = time.time()
while (not timeout) or (time.time() - start_time) * 1000 < timeout:
try:
data = self._write_queue.get(timeout=0.01)
break
except queue.Empty:
pass
if ambit.FLAGS.debug:
print('[F] Handle.bulkRead()', ep, size, timeout, '=>', ambit.message_decode(data))
if not data:
raise usb.USBError('no data to read')
return data
def connect(self, reset=True):
"""
:param reset: send a USB RESET command to the sign.
This seems to cause problems in VMware.
:exception usb.USBError: on USB-related errors
"""
if self._conn:
return
device = self._get_device()
if not device:
raise usb.USBError("failed to find USB device %04x:%04x" %
(self.vendor_id, self.product_id))
interface = device.configurations[0].interfaces[0][0]
self._read_endpoint, self._write_endpoint = interface.endpoints
self._conn = device.open()
if reset:
self._conn.reset()
self._conn.claimInterface(interface)
def __init__(self, resetOnStart=False, enable_mm_keys=False, resetWait=0):
self.enable_mm_keys = enable_mm_keys
logger.info("Looking for LCD device")
self.__lcd_device = self._find_device(0x046d, 0xc229)
if not self.__lcd_device:
raise usb.USBError("G19 LCD not found on USB bus")
# Reset
self.handleIf0 = self.__lcd_device.open()
if resetOnStart:
logger.info("Resetting LCD device")
self.handleIf0.reset()
time.sleep(float(resetWait) / 1000.0)
logger.info("Re-opening LCD device")
self.handleIf0 = self.__lcd_device.open()
logger.info("Re-opened LCD device")
self.handleIf1 = self.__lcd_device.open()
config = self.__lcd_device.configurations[0]
display_interface = config.interfaces[0][0]
# This is to cope with a difference in pyusb 1.0 compatibility layer
if len(config.interfaces) > 1:
macro_and_backlight_interface = config.interfaces[1][0]
else:
macro_and_backlight_interface = config.interfaces[0][1]
try:
logger.debug("Detaching kernel driver for LCD device")
# Use .interfaceNumber for pyusb 1.0 compatibility layer
self.handleIf0.detachKernelDriver(
display_interface.interfaceNumber)
logger.debug("Detached kernel driver for LCD device")
except usb.USBError as e:
logger.debug("Detaching kernel driver for LCD device failed.",
exc_info=e)
try:
logger.debug(
"Detaching kernel driver for macro / backlight device")
# Use .interfaceNumber for pyusb 1.0 compatibility layer
self.handleIf1.detachKernelDriver(
macro_and_backlight_interface.interfaceNumber)
logger.debug("Detached kernel driver for macro / backlight device")
except usb.USBError as e:
logger.debug(
"Detaching kernel driver for macro / backlight device failed.",
exc_info=e)
logger.debug("Setting configuration")
# self.handleIf0.setConfiguration(1)
# self.handleIf1.setConfiguration(1)
logger.debug("Claiming LCD interface")
self.handleIf0.claimInterface(display_interface.interfaceNumber)
logger.info("Claimed LCD interface")
logger.debug("Claiming macro interface")
self.handleIf1.claimInterface(
macro_and_backlight_interface.interfaceNumber)
logger.info("Claimed macro interface")
if self.enable_mm_keys:
logger.debug("Looking for multimedia keys device")
self.__kbd_device = self._find_device(0x046d, 0xc228)
if not self.__kbd_device:
raise usb.USBError("G19 keyboard not found on USB bus")
self.handleIfMM = self.__kbd_device.open()
if resetOnStart:
logger.debug("Resetting multimedia keys device")
self.handleIfMM.reset()
logger.debug("Re-opening multimedia keys device")
self.handleIfMM = self.__kbd_device.open()
logger.debug("Re-opened multimedia keys device")
config = self.__kbd_device.configurations[0]
ifac_mm = config.interfaces[1][0]
try:
self.handleIfMM.setConfiguration(1)
except usb.USBError as e:
logger.debug("Error when trying to set configuration",
exc_info=e)
pass
try:
logger.debug(
"Detaching kernel driver for multimedia keys device")
self.handleIfMM.detachKernelDriver(ifac_mm)
logger.debug(
"Detached kernel driver for multimedia keys device")
except usb.USBError as e:
logger.debug(
"Detaching kernel driver for multimedia keys device failed.",
exc_info=e)
logger.debug("Claiming multimedia interface")
self.handleIfMM.claimInterface(1)
logger.info("Claimed multimedia keys interface")
