telemetry: android: use both methods to access protected files

build/android/pylib/android_commands.py

 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Provides an interface to communicate with the device via the adb command.
 
 Assumes adb binary is currently on system path.
 """
 # pylint: disable-all
 
@@ skipping 279 matching lines @@
     self._potential_push_size = 0
     self._actual_push_size = 0
     self._external_storage = ''
     self._util_wrapper = ''
     self._system_properties = system_properties.SystemProperties(self.Adb())
     self._push_if_needed_cache = {}
     self._control_usb_charging_command = {
         'command': None,
         'cached': False,
     }
+    self._protected_file_access_method = None
 
   @property
   def system_properties(self):
     return self._system_properties
 
   def _LogShell(self, cmd):
     """Logs the adb shell command."""
     if self._device:
       device_repr = self._device[-4:]
     else:
@@ skipping 786 matching lines @@
   def _GetDeviceTempFileName(self, base_name):
     i = 0
     while self.FileExistsOnDevice(
         self.GetExternalStorage() + '/' + base_name % i):
       i += 1
     return self.GetExternalStorage() + '/' + base_name % i
 
   def RunShellCommandWithSU(self, command, timeout_time=20, log_result=False):
     return self.RunShellCommand('su -c %s' % command, timeout_time, log_result)
 
+  _ACCESS_METHOD_NO_ACCESS = 0

[bulach, 2014/04/29 10:21:39]

nit: you may as well start with 1 (and if you like starting 0, have a
_ACCESS_METHOD_UNDEFINED value), so that can remove is not None from 1129..
totally optional, but in general python treads 0, None, False, [] and '' as the
same boolean value.

+  _ACCESS_METHOD_AS_ROOT = 1
+  _ACCESS_METHOD_WITH_SU = 2
+
   def CanAccessProtectedFileContents(self):
-    """Returns True if Get/SetProtectedFileContents would work via "su".
+    """Returns True if Get/SetProtectedFileContents would work via "su" or adb
+    shell running as root.
 
     Devices running user builds don't have adb root, but may provide "su" which
     can be used for accessing protected files.
     """
-    r = self.RunShellCommandWithSU('cat /dev/null')
-    return r == [] or r[0].strip() == ''
+    return (self._ProtectedFileAccessMethod() !=
+        AndroidCommands._ACCESS_METHOD_NO_ACCESS)
+
+  def _ProtectedFileAccessMethod(self):
+    """Tests for the best method to access protected files on the device.
+
+    Returns:
+      _ACCESS_METHOD_NO_ACCESS: if protected files cannot be accessed
+      _ACCESS_METHOD_AS_ROOT:   if the adb shell has root privileges
+      _ACCESS_METHOD_WITH_SU:   if the 'su' command properly works on the device
+    """
+    if self._protected_file_access_method is not None:
+      return self._protected_file_access_method
+
+    def IsValidAuxContents(contents):

[bulach, 2014/04/29 10:21:39]

I'm not sure it'd be more readable, but how about:

def ValidateContents(self, contents, method):
  if len(contents) > 0 ...:
   self._protected_file_access_method = method
   return True
  return False

then later on it can have less indentation, like:
self._protected_file_access_method = ...NO_ACCESS
contents = self.RunShellCommand(...)
if not ValidateContents(contents, ...AS_ROOT):
  contents = self.RunShellCommandWithSU(...)
  ValidateContent(contents, ...WITH_SU)

return self._protected_file_access_method

...no idea if it's any clearer..

[pasko, 2014/04/29 12:57:38]

Maybe. This method is elegant, but introduces a side effect, and I could not
find a good name for it. So not taking this valuable recommendation :)

+      # The leading 4 or 8-bytes of auxv vector is a_type. There are not many
+      # reserved a_type values, hence byte 2 must always be '\0' for a realistic
+      # auxv. See /usr/include/elf.h.
+      return len(contents) > 0 and (contents[0][2] == '\0')
+
+    self._protected_file_access_method = (
+        AndroidCommands._ACCESS_METHOD_NO_ACCESS)
+
+    # Get contents of the auxv vector for the init(8) process from a small
+    # binary file that always exists on linux and is always read-protected.
+    contents = self.RunShellCommand('cat /proc/1/auxv')
+    if IsValidAuxContents(contents):
+      # Protected data is available without SU, hence adb is running as root.
+      self._protected_file_access_method = (
+          AndroidCommands._ACCESS_METHOD_AS_ROOT)
+    else:
+      contents = self.RunShellCommandWithSU('cat /proc/1/auxv')
+      if IsValidAuxContents(contents):
+        # Protected data is available when asked with SU.
+        self._protected_file_access_method = (
+            AndroidCommands._ACCESS_METHOD_WITH_SU)
+    return self._protected_file_access_method
 
   def GetProtectedFileContents(self, filename):
     """Gets contents from the protected file specified by |filename|.
 
-    This is less efficient than GetFileContents, but will work for protected
-    files and device files.
+    This is potentially less efficient than GetFileContents.
     """
-    # Run the script as root
-    return self.RunShellCommandWithSU('cat "%s" 2> /dev/null' % filename)
+    command = 'cat "%s" 2> /dev/null' % filename
+    access_method = self._ProtectedFileAccessMethod()
+    if access_method == AndroidCommands._ACCESS_METHOD_WITH_SU:
+      return self.RunShellCommandWithSU(command)
+    elif access_method == AndroidCommands._ACCESS_METHOD_AS_ROOT:
+      return self.RunShellCommand(command)
+    else:
+      logging.warning('Could not access protected file: %s' % filename)
+      return []
 
   def SetProtectedFileContents(self, filename, contents):
     """Writes |contents| to the protected file specified by |filename|.
 
-    This is less efficient than SetFileContents, but will work for protected
-    files and device files.
+    This is less efficient than SetFileContents.
     """
     temp_file = self._GetDeviceTempFileName(AndroidCommands._TEMP_FILE_BASE_FMT)
     temp_script = self._GetDeviceTempFileName(
         AndroidCommands._TEMP_SCRIPT_FILE_BASE_FMT)
 
     # Put the contents in a temporary file
     self.SetFileContents(temp_file, contents)
     # Create a script to copy the file contents to its final destination
     self.SetFileContents(temp_script, 'cat %s > %s' % (temp_file, filename))
-    # Run the script as root
-    self.RunShellCommandWithSU('sh %s' % temp_script)
+
+    command = 'sh %s' % temp_script
+    access_method = self._ProtectedFileAccessMethod()
+    if access_method == AndroidCommands._ACCESS_METHOD_WITH_SU:
+      return self.RunShellCommandWithSU(command)
+    elif access_method == AndroidCommands._ACCESS_METHOD_AS_ROOT:
+      return self.RunShellCommand(command)
+    else:
+      logging.warning('Could not set contents of protected file: %s' % filename)
+
     # And remove the temporary files
     self.RunShellCommand('rm ' + temp_file)
     self.RunShellCommand('rm ' + temp_script)
 
   def RemovePushedFiles(self):
     """Removes all files pushed with PushIfNeeded() from the device."""
     for p in self._pushed_files:
       self.RunShellCommand('rm -r %s' % p, timeout_time=2 * 60)
 
   def ListPathContents(self, path):
@@ skipping 774 matching lines @@
   """
   def __init__(self, output):
     self._output = output
 
   def write(self, data):
     data = data.replace('\r\r\n', '\n')
     self._output.write(data)
 
   def flush(self):
     self._output.flush()