debug.py

#!/usr/bin/python
# coding: utf-8

# Copyright (c) 2013 Mountainstorm
# 
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
# 
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
# 
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.


from MobileDevice import *
from amdevice import *
from installationproxy import *
import os
import tempfile
import posixpath


class DebugServer(object):
	u'''Debugserver class; starts an instance of debugserver and spawns an lldb
	instance to talk to it'''

	def __init__(self, amdevice):
		self.s = amdevice.start_service(u'com.apple.debugserver')
		if self.s is None:
			raise RuntimeError(u'Unable to launch:', u'com.apple.debugserver')

	def disconnect(self):
		os.close(self.s)


class DebugAppList(object):
	u'''Debugserver class; starts an instance of debugserver and spawns an lldb
	instance to talk to it'''

	def __init__(self, amdevice):
		self.s = amdevice.start_service(u'com.apple.debugserver.applist')
		if self.s is None:
			raise RuntimeError(u'Unable to launch:', u'com.apple.debugserver.applist')

	def get_applist(self):
		u'''Retrieves an list of aplications on the device; with pids if their 
		running

		Returns:
		An array of dict's (pid is optional) e.g.
			<key>displayName</key>
			<string>Phone</string>
			<key>executablePath</key>
			<string>/Applications/MobilePhone.app/MobilePhone</string>
			<key>isFrontApp</key>
			<false/>
			<key>pid</key>
			<integer>87</integer>
		'''
		retval = ''
		os.write(self.s, u'ping') # XXX we need to prod it somehow
		while True:
			data = os.read(self.s, 4096)
			if len(data) == 0:
				break
			retval += data
		return dict_from_plist_encoding(retval, kCFPropertyListXMLFormat_v1_0)

	def disconnect(self):
		os.close(self.s)


class GDB(object):
	def __init__(self, dev, device_support_path, local_path, remote_path=None):
		self.dev = dev
		self._file = None
		self._substitutions = []
		self._runcmds = u''

		if device_support_path is None:
			device_support_path = dev.find_device_support_path()		

		self._set_file(local_path, remote_path)
		# add standard substitutions
		root = os.path.join(device_support_path, u'Symbols')
		for f in os.listdir(root):
			if os.path.isdir(os.path.join(root, f)):
				self._add_substitution(
					u'/' + f, 
					posixpath.join(root, f)
				)

	def find_gdb(self):
		return u'/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/usr/libexec/gdb/gdb-arm-apple-darwin'

	def _set_debugserver_fd(self, fd):
		# now gdb's remote protocol requires us to setup a unix socket; when you
		# specify 'target remote-mobile <unix socket path>' it then opens this
		# and reads a control message; containing the fd to use to actually 
		# talk to the debugserver.  It then tkes this and does a standard 
		# 'target remote-OSX filedesc:<fd>' command.
		#
		# As I'm lazy I'm just going to pass it the fd directly		
		self._debugserver_fd = fd

	def _get_bundleid(self, local_path):
		# open the app and get its id
		f = open(os.path.join(local_path, u'Info.plist'), u'rb')
		plist = f.read()
		f.close()
		info = dict_from_plist_encoding(plist)
		return info[u'CFBundleIdentifier']

	def _set_file(self, local_path, remote_path=None):
		import pprint 

		if remote_path is None:
			# we dont know where its gone; this should only apply for 
			# non-jailbroken devices i.e. where you can only debug apps
			# thus we can get the local appid, then lookup where on the device 
			# it is ... simples
			bundleid = self._get_bundleid(local_path)

			ip = InstallationProxy(self.dev)
			apps = ip.lookup_applications()
			ip.disconnect()
			#pprint.pprint(apps)
			for app in apps:
				if app[u'CFBundleIdentifier'] == bundleid:
					remote_path = app[u'Path']
					break
			if remote_path is None:
				raise RuntimeError(
					u'Application %s, not installed on device' % bundleid
				)
		else:
			# we want the remote path to be the directory; for a .app thats 
			# not a problem - but for a native macho we need adjust
			remote_path = posixpath.split(remote_path)[0]
		self._file = (local_path, remote_path)

		# we also want to add a substitution for our enclosing folder
		if local_path[-1] == u'/' or local_path[-1] == u'\\':
			local_path = local_path[:-1]
		local_folder = os.path.dirname(local_path)

		if remote_path[-1] == u'/' or remote_path[-1] == u'\\':
			remote_path = remote_path[:-1]
		remote_folder = posixpath.dirname(remote_path)
		self._add_substitution(local_folder, remote_folder)

	def _add_substitution(self, local_folder, remote_folder):
		self._substitutions.append((local_folder, remote_folder))		
		# we can get errors if the remote folder is in /private/var - its 
		# normally refered to by /var.  So add another substitution if need be.
		# there may be other cases of this but this it the only one I've seen
		if remote_folder.startswith(u'/private/var'):
			remote_folder = remote_folder.replace(u'/private/var', u'/var/')
			self._substitutions.append((local_folder, remote_folder))

	def _get_initial_cmds(self):
		retval = u'''
set auto-raise-load-levels 1
set mi-show-protections off
set trust-readonly-sections 1
set inferior-auto-start-dyld 0
set minimal-signal-handling 1

set env NSUnbufferedIO YES

set sharedlibrary check-uuids on
set sharedlibrary load-rules \\".*\\" \\".*\\" container

set shlib-path-substitutions'''
	
		# add all the path substitutions
		for s in self._substitutions:
			retval += u' "%s" "%s"' % s

		retval += u'''
set remote max-packet-size 4096
set remote executable-directory %s
set remote noack-mode 1
target remote-macosx filedesc: %u

mem 0x1000 0x3fffffff cache
mem 0x40000000 0xffffffff none
mem 0x00000000 0x0fff none
''' % (self._file[1], self._debugserver_fd)

		retval += self._runcmds

		retval += u'''
set minimal-signal-handling 0
set inferior-auto-start-cfm off
set sharedLibrary load-rules dyld ".*libobjc.*" all dyld ".*CoreFoundation.*" all dyld ".*Foundation.*" all dyld ".*libSystem.*" all dyld ".*AppKit.*" all dyld ".*PBGDBIntrospectionSupport.*" all dyld ".*/usr/lib/dyld.*" all dyld ".*CarbonDataFormatters.*" all dyld ".*libauto.*" all dyld ".*CFDataFormatters.*" all dyld "/System/Library/Frameworks\\\\\\\\|/System/Library/PrivateFrameworks\\\\\\\\|/usr/lib" extern dyld ".*" all exec ".*" all
sharedlibrary apply-load-rules all
set inferior-auto-start-dyld 1
'''
		#print(retval)
		return retval

	def set_run(self, args=None):
		# we specify file when running; we can't when doing attach
		runcmd = u'file "%s"\nrun' % (self._file[0])
		if args is not None:
			for arg in args:
				runcmd += u'"%s"' % arg
		runcmd += u'\n'
		self._runcmds = runcmd

	def set_attach(self, pid):
		# XXX figure out what we should use instead of file - perhaps exec-file?
		self._runcmds = u'attach %s' % pid

	def run(self):
		# create the temp file and fill it with the init commands
		cmdfd, path = tempfile.mkstemp()

		# start debug server
		dbg = DebugServer(self.dev)
		self._set_debugserver_fd(dbg.s)

		os.write(cmdfd, self._get_initial_cmds())
		os.close(cmdfd)

		# start gdb
		os.system(self.find_gdb() + u' --arch armv7 -q -x "%s"' % path)

		# cleanup
		dbg.disconnect()
		os.unlink(path)


def register_argparse_debugserver(cmdargs):
	import argparse
	import sys
	import imagemounter

	def load_developer_dmg(args, dev):
		if not args.advanced:
			# we only load in non-advanced mode
			try:
				# we're doing this as, for some reason, the checking load image
				# does isn;t very good - so if we don;t we end up transfering 
				# the image every time; which is slow and generates tonnes of 
				# log messages
				applist = DebugAppList(dev)
				applist.disconnect()
				# it's already loaded
			except:
				# its not ... so find and load the disk image
				im = imagemounter.ImageMounter(dev)
				imagepath = None
				if args.device_support_path:
					imagepath = dev.find_developer_disk_image_path(
						args.device_support_path.decode(u'utf-8')
					)
				im.mount(imagepath)
				im.disconnect()

	def cmd_applist(args, dev):
		load_developer_dmg(args, dev)

		applist = DebugAppList(dev)
		al = applist.get_applist()
		applist.disconnect()

		rows = []
		colmax = [0, 0, 0]
		for app in al:
			# pid
			pid = u'-'
			try:
				# XXX why does hasattr not work properly on this?
				pid = u'%u' % app[u'pid']
			except:
				pass
			if len(pid) > colmax[0]:
				colmax[0] = len(pid)

			# foreground
			foreground = u' '
			if app[u'isFrontApp']:
				foreground = u'*'

			# name
			name = app[u'displayName']
			if len(name) > colmax[1]:
				colmax[1] = len(name)

			# path
			path = app[u'executablePath']
			if len(path) > colmax[2]:
				colmax[2] = len(path)
			rows.append([pid, foreground, name, path])

		for row in rows:
			print(
				row[0].rjust(colmax[0]) + u' ' +
				row[1] + u' ' +
				row[2].ljust(colmax[1]) + u'  ' + 
				row[3].ljust(colmax[2])
			)

	def cmd_gdb(args, dev):
		load_developer_dmg(args, dev)

		remote = None
		if args.remote is not None:
			remote = args.remote.decode(u'utf-8')
		gdb = GDB(
			dev, 
			args.device_support_path.decode(u'utf-8'), 
			args.program.decode(u'utf-8'),
			remote
		)
		if args.p:
			gdb.set_attach(int(args.p)) # attach
		else:
			gdb.set_run() # spawn
		gdb.run()

	debugparser = cmdargs.add_parser(
		u'debug', 
		help=u'debugging commands; utilising debugserver in the developer .dmg'
	)
	debugparser.add_argument(
		u'-s',
		metavar=u'support-path',
		dest=u'device_support_path',
		help=u'specify a custom device support folder; instead of finding the default'
	)
	debugcmd = debugparser.add_subparsers()

	# applist command
	applistcmd = debugcmd.add_parser(
		u'applist',
		help=u'lists applications; which is front and pid if running'
	)
	applistcmd.set_defaults(func=cmd_applist)

	# gdb command
	gdbcmd = debugcmd.add_parser(
		u'gdb', 
		help=u'launches gdb; connected to the device'
	)
	gdbcmd.add_argument(
		u'-p',
		metavar=u'pid',
		help=u'if specified we attempt to connect to this process rather than start a new instance'
	)
	gdbcmd.add_argument(
		u'program', 
		help=u'local path to the program to debug; the file must already be on the device'
	)
	gdbcmd.add_argument(
		u'remote', 
		nargs=u'?',
		help=u'if the program is a plain mach-o rather than a .app you also need to specify where on the device the file resides'
	)
	gdbcmd.set_defaults(func=cmd_gdb)