def run(self):
self._running = True
print("starting...")
mux = usbmux.USBMux()
print("Waiting for devices...")
if not mux.devices:
mux.process() # search for devices with timeout=1.0?
if not mux.devices:
print("No device found")
dev = mux.devices[0] # get device found
print("connecting to device %s" % str(dev))
self._psock = mux.connect(dev,
2333) # connect to device with port 2333
self._psock.setblocking(0) # set to non-block
self._psock.settimeout(2) # set timeout = 2
self.timeSync()
print("listening")
while self._running:
try:
header = self._psock.recv(16)
if len(header) == 0: continue
payload = None
peerTime = None
if len(header) > 0:
print("received header of length", len(header))
unpackedHeader = readPeerTalkHeader(header)
size = unpackedHeader.payloadSize
if size > 0:
payload = self._psock.recv(size)
print("received payload of length", len(payload))
if self._bufferMs is not None:
peerTime = timestampFromPeerData(payload)
if (peerTime is not None and self._bufferMs is not None
and self._busyWaitingThread is not None
and self._timeOffset is not None):
print(peerTime, self._timeOffset, (self._bufferMs / 1000),
time.time())
print("need to wait (ms)",
(peerTime + self._timeOffset +
(self._bufferMs / 1000) - time.time()) * 1000)
self._busyWaitingThread.doTaskAfter(
lambda: self._onReceive(header, payload, self._psock,
self._timeOffset),
peerTime + self._timeOffset + (self._bufferMs / 1000))
else:
self._onReceive(header, payload, self._psock,
self._timeOffset)
except:
pass
def do_list():
mux = usbmux.USBMux()
print "Listing devices..."
devcount = len(mux.devices)
while True:
mux.process(0.1)
cnt = len(mux.devices)
if cnt > devcount:
devcount = cnt
else:
break
for dev in mux.devices:
print dev
def handle(self):
print "Incoming connection to %d" % self.server.server_address[1]
if globals().has_key('options'):
sockpath = options.sockpath
else:
sockpath = None
mux = usbmux.USBMux(sockpath)
print "Waiting for devices..."
mux.process(1.0)
dev = None
if globals().has_key('options'):
udid = options.udid
else:
udid = self.server.udid
if udid:
for device in mux.devices:
print device
if device.serial == udid:
dev = device
break
if not dev:
for _ in xrange(20):
mux.process(0.5)
for device in mux.devices:
if device.serial == udid:
dev = device
break
if dev:
break
else:
dev = mux.devices[0]
if not mux.devices:
print "No device found"
self.request.close()
return
print "Connecting to device %s" % str(dev)
dsock = mux.connect(dev, self.server.rport)
lsock = self.request
print "Connection established, relaying data"
try:
fwd = SocketRelay(dsock, lsock, self.server.bufsize * 1024)
fwd.handle()
finally:
dsock.close()
lsock.close()
print "Connection closed"
def handle(self):
print "Incoming connection to %d" % self.server.server_address[1]
mux = usbmux.USBMux(options.sockpath)
print "Discovering devices..."
devcount = len(mux.devices)
while True:
mux.process(0.1)
cnt = len(mux.devices)
if cnt > devcount:
devcount = cnt
else:
break
if not mux.devices:
print "No devices found"
self.request.close()
return
# select a device
dev = None
if self.server.device:
for d in mux.devices:
if d.serial == self.server.device:
dev = d
break
if not dev:
print "Unable to find device: %s" % self.server.device
self.request.close()
return
else:
dev = mux.devices[0]
print "Connecting to device %s" % str(dev)
dsock = mux.connect(dev, self.server.rport)
lsock = self.request
print "Connection established, relaying data"
try:
fwd = SocketRelay(dsock, lsock, self.server.bufsize * 1024)
fwd.handle()
finally:
dsock.close()
lsock.close()
print "Connection closed"
def handle(self):
print "Incoming connection to {0}".format(
self.server.server_address[1])
mux = usbmux.USBMux(options.sockpath)
print "Waiting for devices..."
lastLength = len(mux.devices)
while True:
mux.process(0.1)
if len(mux.devices) == lastLength: break
lastLength = len(mux.devices)
if not mux.devices:
print "No device found"
self.request.close()
return
dev = None
if options.udid is None:
# Default to the first available device if no udid was specified
dev = mux.devices[0]
else:
for device in mux.devices:
# Look for the specified device UDID
if device.serial == options.udid:
dev = device
break
if not dev:
raise Exception(
"Could not detect specified device UDID: {0}".format(
repr(options.udid)))
print "Connecting to device {0}".format(dev)
dsock = mux.connect(dev, self.server.remotePort)
lsock = self.request
print "Connection established, relaying data"
try:
fwd = SocketRelay(dsock, lsock, self.server.bufferSize * 1024)
fwd.handle()
finally:
dsock.close()
lsock.close()
print "Connection closed"
def handle(self):
#print "Incoming connection to %d"%self.server.server_address[1]
mux = usbmux.USBMux(options.sockpath)
#print "Waiting for devices..."
if not mux.devices:
mux.process(1.0)
if not mux.devices:
#print "No device found"
self.request.close()
return
dev = mux.devices[0]
#print "Connecting to device %s"%str(dev)
dsock = mux.connect(dev, self.server.rport)
lsock = self.request
#print "Connection established, relaying data"
try:
fwd = SocketRelay(dsock, lsock, self.server.bufsize * 1024)
fwd.handle()
finally:
dsock.close()
lsock.close()
def start(self):
print "peertalk starting"
self.mux = usbmux.USBMux()
print "Waiting for devices..."
if not self.mux.devices:
self.mux.process(1.0)
if not self.mux.devices:
print "No device found"
self.dev = self.mux.devices[0]
print "connecting to device %s" % str(self.dev)
self.psock = self.mux.connect(self.dev, 2345)
self.psock.setblocking(0)
self.psock.settimeout(2)
self.ptthread = PeerTalkThread(self.psock)
# This stops the App from hanging on exit
self.ptthread.start()
QCoreApplication.instance().aboutToQuit.connect(self.ptthread.stop)
def handle(self) -> None:
print("Incoming connection to %d" % self.server.server_address[1])
mux = usbmux.USBMux(None)
print("Waiting for devices...")
if not mux.devices:
mux.process(1.0)
if not mux.devices:
print("No device found")
self.request.close(true)
return
dev = mux.devices[0]
print("Connecting to device %s" % str(dev))
d_sock = mux.connect(dev, self.server.r_port)
l_sock = self.request
print("Connection established, relaying data")
try:
fwd = SocketRelay(d_sock, l_sock, self.server.buffer_size * 1024)
fwd.handle(true)
finally:
d_sock.close(false)
l_sock.close(false)
print("Connection closed")
except:
parser.print_help()
sys.exit(1)
servers = []
for localHost, localPort, deviceUDID, remotePort in ports:
print "Forwarding {0}:{1} ==> {2}:{3}".format(localHost, localPort, deviceUDID, remotePort)
server = serverClass((localHost, localPort), TCPRelay)
server.deviceUDID = deviceUDID
server.remotePort = remotePort
server.bufferSize = options.bufsize
servers.append(server)
mux = usbmux.USBMux(options.sockpath)
for i in range(1, len(ports)):
mux.process(0.1)
alive = True
while alive:
try:
rl, wl, xl = select.select(servers, [], [])
for server in rl:
server.handle_request()
except KeyboardInterrupt:
quit()
except:
traceback.print_exc()
alive = False
help="target specific device by its 40-digit serial UDID")
parser.add_option("-p",
"--port",
dest='port',
action='store',
type='int',
default=22,
help="ssh port on device, defaults to 22")
options, args = parser.parse_args()
serial = options.serial
port = options.port
if serial == '-':
serial = None
# wait up to 1s for a matching device
mux = usbmux.USBMux(None)
dev = None
timeout = time.time() + 1.0
while True:
devs = (mux.devices
if not serial else [x for x in mux.devices if x.serial == serial])
if devs:
dev = devs[0]
break
rem = timeout - time.time()
if rem <= 0:
sys.stderr.write("No device found" if not serial else
("Device %s not found" % serial) + "\n")
exit(1)
mux.process(rem)
except:
pass
def stop(self):
self._running = False
class KeyStrokeThread(threading.Thread):
def press(self, keycode):
PressKey(keycode)
time.sleep(0.02)
ReleaseKey(keycode)
print "peertalk starting"
mux = usbmux.USBMux()
print "Waiting for devices..."
if not mux.devices:
mux.process() # search for devices with timeout=1.0?
if not mux.devices:
print "No device found"
dev = mux.devices[0] # get device found
print "connecting to device %s" % str(dev)
psock = mux.connect(dev, 2333) # connect to device with port 2333
psock.setblocking(0) # set to non-block
psock.settimeout(2) # set timeout = 2
ptthread = PeerTalkThread(psock)
ptthread.start()
