fdroidserver/common.py

   1 #!/usr/bin/env python3
   2 #
   3 # common.py - part of the FDroid server tools
   4 # Copyright (C) 2010-13, Ciaran Gultnieks, ciaran@ciarang.com
   5 # Copyright (C) 2013-2014 Daniel Martí <mvdan@mvdan.cc>
   6 #
   7 # This program is free software: you can redistribute it and/or modify
   8 # it under the terms of the GNU Affero General Public License as published by
   9 # the Free Software Foundation, either version 3 of the License, or
  10 # (at your option) any later version.
  11 #
  12 # This program is distributed in the hope that it will be useful,
  13 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 # GNU Affero General Public License for more details.
  16 #
  17 # You should have received a copy of the GNU Affero General Public License
  18 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19
  20 # common.py is imported by all modules, so do not import third-party
  21 # libraries here as they will become a requirement for all commands.
  22
  23 import collections
  24 import io
  25 import os
  26 import sys
  27 import re
  28 import shutil
  29 import glob
  30 import json
  31 import platform
  32 import stat
  33 import subprocess
  34 import time
  35 import operator
  36 import logging
  37 import hashlib
  38 import socket
  39 import base64
  40 import xml.etree.ElementTree as XMLElementTree
  41
  42 from binascii import hexlify
  43 from datetime import datetime
  44 from distutils.version import LooseVersion
  45 from queue import Queue
  46 from zipfile import ZipFile
  47
  48 from pyasn1.codec.der import decoder, encoder
  49 from pyasn1_modules import rfc2315
  50 from pyasn1.error import PyAsn1Error
  51
  52 import fdroidserver.metadata
  53 from .asynchronousfilereader import AsynchronousFileReader
  54
  55
  56 # A signature block file with a .DSA, .RSA, or .EC extension
  57 CERT_PATH_REGEX = re.compile(r'^META-INF/.*\.(DSA|EC|RSA)$')
  58
  59 XMLElementTree.register_namespace('android', 'http://schemas.android.com/apk/res/android')
  60
  61 config = None
  62 options = None
  63 env = None
  64 orig_path = None
  65
  66
  67 default_config = {
  68     'sdk_path': "$ANDROID_HOME",
  69     'ndk_paths': {
  70         'r9b': None,
  71         'r10e': None,
  72         'r11c': None,
  73         'r12b': "$ANDROID_NDK",
  74         'r13b': None,
  75         'r14': None,
  76     },
  77     'qt_sdk_path': None,
  78     'build_tools': "25.0.2",
  79     'force_build_tools': False,
  80     'java_paths': None,
  81     'ant': "ant",
  82     'mvn3': "mvn",
  83     'gradle': 'gradle',
  84     'accepted_formats': ['txt', 'yml'],
  85     'sync_from_local_copy_dir': False,
  86     'per_app_repos': False,
  87     'make_current_version_link': True,
  88     'current_version_name_source': 'Name',
  89     'update_stats': False,
  90     'stats_ignore': [],
  91     'stats_server': None,
  92     'stats_user': None,
  93     'stats_to_carbon': False,
  94     'repo_maxage': 0,
  95     'build_server_always': False,
  96     'keystore': 'keystore.jks',
  97     'smartcardoptions': [],
  98     'char_limits': {
  99         'Summary': 80,
 100         'Description': 4000,
 101     },
 102     'keyaliases': {},
 103     'repo_url': "https://MyFirstFDroidRepo.org/fdroid/repo",
 104     'repo_name': "My First FDroid Repo Demo",
 105     'repo_icon': "fdroid-icon.png",
 106     'repo_description': '''
 107         This is a repository of apps to be used with FDroid. Applications in this
 108         repository are either official binaries built by the original application
 109         developers, or are binaries built from source by the admin of f-droid.org
 110         using the tools on https://gitlab.com/u/fdroid.
 111         ''',
 112     'archive_older': 0,
 113 }
 114
 115
 116 def setup_global_opts(parser):
 117     parser.add_argument("-v", "--verbose", action="store_true", default=False,
 118                         help="Spew out even more information than normal")
 119     parser.add_argument("-q", "--quiet", action="store_true", default=False,
 120                         help="Restrict output to warnings and errors")
 121
 122
 123 def fill_config_defaults(thisconfig):
 124     for k, v in default_config.items():
 125         if k not in thisconfig:
 126             thisconfig[k] = v
 127
 128     # Expand paths (~users and $vars)
 129     def expand_path(path):
 130         if path is None:
 131             return None
 132         orig = path
 133         path = os.path.expanduser(path)
 134         path = os.path.expandvars(path)
 135         if orig == path:
 136             return None
 137         return path
 138
 139     for k in ['sdk_path', 'ant', 'mvn3', 'gradle', 'keystore', 'repo_icon']:
 140         v = thisconfig[k]
 141         exp = expand_path(v)
 142         if exp is not None:
 143             thisconfig[k] = exp
 144             thisconfig[k + '_orig'] = v
 145
 146     # find all installed JDKs for keytool, jarsigner, and JAVA[6-9]_HOME env vars
 147     if thisconfig['java_paths'] is None:
 148         thisconfig['java_paths'] = dict()
 149         pathlist = []
 150         pathlist += glob.glob('/usr/lib/jvm/j*[6-9]*')
 151         pathlist += glob.glob('/usr/java/jdk1.[6-9]*')
 152         pathlist += glob.glob('/System/Library/Java/JavaVirtualMachines/1.[6-9].0.jdk')
 153         pathlist += glob.glob('/Library/Java/JavaVirtualMachines/*jdk*[6-9]*')
 154         if os.getenv('JAVA_HOME') is not None:
 155             pathlist.append(os.getenv('JAVA_HOME'))
 156         if os.getenv('PROGRAMFILES') is not None:
 157             pathlist += glob.glob(os.path.join(os.getenv('PROGRAMFILES'), 'Java', 'jdk1.[6-9].*'))
 158         for d in sorted(pathlist):
 159             if os.path.islink(d):
 160                 continue
 161             j = os.path.basename(d)
 162             # the last one found will be the canonical one, so order appropriately
 163             for regex in [
 164                     r'^1\.([6-9])\.0\.jdk$',  # OSX
 165                     r'^jdk1\.([6-9])\.0_[0-9]+.jdk$',  # OSX and Oracle tarball
 166                     r'^jdk1\.([6-9])\.0_[0-9]+$',  # Oracle Windows
 167                     r'^jdk([6-9])-openjdk$',  # Arch
 168                     r'^java-([6-9])-openjdk$',  # Arch
 169                     r'^java-([6-9])-jdk$',  # Arch (oracle)
 170                     r'^java-1\.([6-9])\.0-.*$',  # RedHat
 171                     r'^java-([6-9])-oracle$',  # Debian WebUpd8
 172                     r'^jdk-([6-9])-oracle-.*$',  # Debian make-jpkg
 173                     r'^java-([6-9])-openjdk-[^c][^o][^m].*$',  # Debian
 174                     ]:
 175                 m = re.match(regex, j)
 176                 if not m:
 177                     continue
 178                 for p in [d, os.path.join(d, 'Contents', 'Home')]:
 179                     if os.path.exists(os.path.join(p, 'bin', 'javac')):
 180                         thisconfig['java_paths'][m.group(1)] = p
 181
 182     for java_version in ('7', '8', '9'):
 183         if java_version not in thisconfig['java_paths']:
 184             continue
 185         java_home = thisconfig['java_paths'][java_version]
 186         jarsigner = os.path.join(java_home, 'bin', 'jarsigner')
 187         if os.path.exists(jarsigner):
 188             thisconfig['jarsigner'] = jarsigner
 189             thisconfig['keytool'] = os.path.join(java_home, 'bin', 'keytool')
 190             break  # Java7 is preferred, so quit if found
 191
 192     for k in ['ndk_paths', 'java_paths']:
 193         d = thisconfig[k]
 194         for k2 in d.copy():
 195             v = d[k2]
 196             exp = expand_path(v)
 197             if exp is not None:
 198                 thisconfig[k][k2] = exp
 199                 thisconfig[k][k2 + '_orig'] = v
 200
 201
 202 def regsub_file(pattern, repl, path):
 203     with open(path, 'rb') as f:
 204         text = f.read()
 205     text = re.sub(bytes(pattern, 'utf8'), bytes(repl, 'utf8'), text)
 206     with open(path, 'wb') as f:
 207         f.write(text)
 208
 209
 210 def read_config(opts, config_file='config.py'):
 211     """Read the repository config
 212
 213     The config is read from config_file, which is in the current
 214     directory when any of the repo management commands are used. If
 215     there is a local metadata file in the git repo, then config.py is
 216     not required, just use defaults.
 217
 218     """
 219     global config, options
 220
 221     if config is not None:
 222         return config
 223
 224     options = opts
 225
 226     config = {}
 227
 228     if os.path.isfile(config_file):
 229         logging.debug("Reading %s" % config_file)
 230         with io.open(config_file, "rb") as f:
 231             code = compile(f.read(), config_file, 'exec')
 232             exec(code, None, config)
 233     elif len(get_local_metadata_files()) == 0:
 234         logging.critical("Missing config file - is this a repo directory?")
 235         sys.exit(2)
 236
 237     for k in ('mirrors', 'install_list', 'uninstall_list', 'serverwebroot', 'servergitroot'):
 238         if k in config:
 239             if not type(config[k]) in (str, list, tuple):
 240                 logging.warn('"' + k + '" will be in random order!'
 241                              + ' Use () or [] brackets if order is important!')
 242
 243     # smartcardoptions must be a list since its command line args for Popen
 244     if 'smartcardoptions' in config:
 245         config['smartcardoptions'] = config['smartcardoptions'].split(' ')
 246     elif 'keystore' in config and config['keystore'] == 'NONE':
 247         # keystore='NONE' means use smartcard, these are required defaults
 248         config['smartcardoptions'] = ['-storetype', 'PKCS11', '-providerName',
 249                                       'SunPKCS11-OpenSC', '-providerClass',
 250                                       'sun.security.pkcs11.SunPKCS11',
 251                                       '-providerArg', 'opensc-fdroid.cfg']
 252
 253     if any(k in config for k in ["keystore", "keystorepass", "keypass"]):
 254         st = os.stat(config_file)
 255         if st.st_mode & stat.S_IRWXG or st.st_mode & stat.S_IRWXO:
 256             logging.warn("unsafe permissions on {0} (should be 0600)!".format(config_file))
 257
 258     fill_config_defaults(config)
 259
 260     for k in ["keystorepass", "keypass"]:
 261         if k in config:
 262             write_password_file(k)
 263
 264     for k in ["repo_description", "archive_description"]:
 265         if k in config:
 266             config[k] = clean_description(config[k])
 267
 268     if 'serverwebroot' in config:
 269         if isinstance(config['serverwebroot'], str):
 270             roots = [config['serverwebroot']]
 271         elif all(isinstance(item, str) for item in config['serverwebroot']):
 272             roots = config['serverwebroot']
 273         else:
 274             raise TypeError('only accepts strings, lists, and tuples')
 275         rootlist = []
 276         for rootstr in roots:
 277             # since this is used with rsync, where trailing slashes have
 278             # meaning, ensure there is always a trailing slash
 279             if rootstr[-1] != '/':
 280                 rootstr += '/'
 281             rootlist.append(rootstr.replace('//', '/'))
 282         config['serverwebroot'] = rootlist
 283
 284     if 'servergitmirrors' in config:
 285         if isinstance(config['servergitmirrors'], str):
 286             roots = [config['servergitmirrors']]
 287         elif all(isinstance(item, str) for item in config['servergitmirrors']):
 288             roots = config['servergitmirrors']
 289         else:
 290             raise TypeError('only accepts strings, lists, and tuples')
 291         config['servergitmirrors'] = roots
 292
 293     return config
 294
 295
 296 def find_sdk_tools_cmd(cmd):
 297     '''find a working path to a tool from the Android SDK'''
 298
 299     tooldirs = []
 300     if config is not None and 'sdk_path' in config and os.path.exists(config['sdk_path']):
 301         # try to find a working path to this command, in all the recent possible paths
 302         if 'build_tools' in config:
 303             build_tools = os.path.join(config['sdk_path'], 'build-tools')
 304             # if 'build_tools' was manually set and exists, check only that one
 305             configed_build_tools = os.path.join(build_tools, config['build_tools'])
 306             if os.path.exists(configed_build_tools):
 307                 tooldirs.append(configed_build_tools)
 308             else:
 309                 # no configed version, so hunt known paths for it
 310                 for f in sorted(os.listdir(build_tools), reverse=True):
 311                     if os.path.isdir(os.path.join(build_tools, f)):
 312                         tooldirs.append(os.path.join(build_tools, f))
 313                 tooldirs.append(build_tools)
 314         sdk_tools = os.path.join(config['sdk_path'], 'tools')
 315         if os.path.exists(sdk_tools):
 316             tooldirs.append(sdk_tools)
 317         sdk_platform_tools = os.path.join(config['sdk_path'], 'platform-tools')
 318         if os.path.exists(sdk_platform_tools):
 319             tooldirs.append(sdk_platform_tools)
 320     tooldirs.append('/usr/bin')
 321     for d in tooldirs:
 322         path = os.path.join(d, cmd)
 323         if os.path.isfile(path):
 324             if cmd == 'aapt':
 325                 test_aapt_version(path)
 326             return path
 327     # did not find the command, exit with error message
 328     ensure_build_tools_exists(config)
 329
 330
 331 def test_aapt_version(aapt):
 332     '''Check whether the version of aapt is new enough'''
 333     output = subprocess.check_output([aapt, 'version'], universal_newlines=True)
 334     if output is None or output == '':
 335         logging.error(aapt + ' failed to execute!')
 336     else:
 337         m = re.match(r'.*v([0-9]+)\.([0-9]+)[.-]?([0-9.-]*)', output)
 338         if m:
 339             major = m.group(1)
 340             minor = m.group(2)
 341             bugfix = m.group(3)
 342             # the Debian package has the version string like "v0.2-23.0.2"
 343             if '.' not in bugfix and LooseVersion('.'.join((major, minor, bugfix))) < LooseVersion('0.2.2166767'):
 344                 logging.warning(aapt + ' is too old, fdroid requires build-tools-23.0.0 or newer!')
 345         else:
 346             logging.warning('Unknown version of aapt, might cause problems: ' + output)
 347
 348
 349 def test_sdk_exists(thisconfig):
 350     if 'sdk_path' not in thisconfig:
 351         if 'aapt' in thisconfig and os.path.isfile(thisconfig['aapt']):
 352             test_aapt_version(thisconfig['aapt'])
 353             return True
 354         else:
 355             logging.error("'sdk_path' not set in config.py!")
 356             return False
 357     if thisconfig['sdk_path'] == default_config['sdk_path']:
 358         logging.error('No Android SDK found!')
 359         logging.error('You can use ANDROID_HOME to set the path to your SDK, i.e.:')
 360         logging.error('\texport ANDROID_HOME=/opt/android-sdk')
 361         return False
 362     if not os.path.exists(thisconfig['sdk_path']):
 363         logging.critical('Android SDK path "' + thisconfig['sdk_path'] + '" does not exist!')
 364         return False
 365     if not os.path.isdir(thisconfig['sdk_path']):
 366         logging.critical('Android SDK path "' + thisconfig['sdk_path'] + '" is not a directory!')
 367         return False
 368     for d in ['build-tools', 'platform-tools', 'tools']:
 369         if not os.path.isdir(os.path.join(thisconfig['sdk_path'], d)):
 370             logging.critical('Android SDK path "%s" does not contain "%s/"!' % (
 371                 thisconfig['sdk_path'], d))
 372             return False
 373     return True
 374
 375
 376 def ensure_build_tools_exists(thisconfig):
 377     if not test_sdk_exists(thisconfig):
 378         sys.exit(3)
 379     build_tools = os.path.join(thisconfig['sdk_path'], 'build-tools')
 380     versioned_build_tools = os.path.join(build_tools, thisconfig['build_tools'])
 381     if not os.path.isdir(versioned_build_tools):
 382         logging.critical('Android Build Tools path "'
 383                          + versioned_build_tools + '" does not exist!')
 384         sys.exit(3)
 385
 386
 387 def write_password_file(pwtype, password=None):
 388     '''
 389     writes out passwords to a protected file instead of passing passwords as
 390     command line argments
 391     '''
 392     filename = '.fdroid.' + pwtype + '.txt'
 393     fd = os.open(filename, os.O_CREAT | os.O_TRUNC | os.O_WRONLY, 0o600)
 394     if password is None:
 395         os.write(fd, config[pwtype].encode('utf-8'))
 396     else:
 397         os.write(fd, password.encode('utf-8'))
 398     os.close(fd)
 399     config[pwtype + 'file'] = filename
 400
 401
 402 def get_local_metadata_files():
 403     '''get any metadata files local to an app's source repo
 404
 405     This tries to ignore anything that does not count as app metdata,
 406     including emacs cruft ending in ~ and the .fdroid.key*pass.txt files.
 407
 408     '''
 409     return glob.glob('.fdroid.[a-jl-z]*[a-rt-z]')
 410
 411
 412 def read_pkg_args(args, allow_vercodes=False):
 413     """
 414     Given the arguments in the form of multiple appid:[vc] strings, this returns
 415     a dictionary with the set of vercodes specified for each package.
 416     """
 417
 418     vercodes = {}
 419     if not args:
 420         return vercodes
 421
 422     for p in args:
 423         if allow_vercodes and ':' in p:
 424             package, vercode = p.split(':')
 425         else:
 426             package, vercode = p, None
 427         if package not in vercodes:
 428             vercodes[package] = [vercode] if vercode else []
 429             continue
 430         elif vercode and vercode not in vercodes[package]:
 431             vercodes[package] += [vercode] if vercode else []
 432
 433     return vercodes
 434
 435
 436 def read_app_args(args, allapps, allow_vercodes=False):
 437     """
 438     On top of what read_pkg_args does, this returns the whole app metadata, but
 439     limiting the builds list to the builds matching the vercodes specified.
 440     """
 441
 442     vercodes = read_pkg_args(args, allow_vercodes)
 443
 444     if not vercodes:
 445         return allapps
 446
 447     apps = {}
 448     for appid, app in allapps.items():
 449         if appid in vercodes:
 450             apps[appid] = app
 451
 452     if len(apps) != len(vercodes):
 453         for p in vercodes:
 454             if p not in allapps:
 455                 logging.critical("No such package: %s" % p)
 456         raise FDroidException("Found invalid app ids in arguments")
 457     if not apps:
 458         raise FDroidException("No packages specified")
 459
 460     error = False
 461     for appid, app in apps.items():
 462         vc = vercodes[appid]
 463         if not vc:
 464             continue
 465         app.builds = [b for b in app.builds if b.versionCode in vc]
 466         if len(app.builds) != len(vercodes[appid]):
 467             error = True
 468             allvcs = [b.versionCode for b in app.builds]
 469             for v in vercodes[appid]:
 470                 if v not in allvcs:
 471                     logging.critical("No such vercode %s for app %s" % (v, appid))
 472
 473     if error:
 474         raise FDroidException("Found invalid vercodes for some apps")
 475
 476     return apps
 477
 478
 479 def get_extension(filename):
 480     base, ext = os.path.splitext(filename)
 481     if not ext:
 482         return base, ''
 483     return base, ext.lower()[1:]
 484
 485
 486 def has_extension(filename, ext):
 487     _, f_ext = get_extension(filename)
 488     return ext == f_ext
 489
 490
 491 publish_name_regex = re.compile(r"^(.+)_([0-9]+)\.(apk|zip)$")
 492
 493
 494 def clean_description(description):
 495     'Remove unneeded newlines and spaces from a block of description text'
 496     returnstring = ''
 497     # this is split up by paragraph to make removing the newlines easier
 498     for paragraph in re.split(r'\n\n', description):
 499         paragraph = re.sub('\r', '', paragraph)
 500         paragraph = re.sub('\n', ' ', paragraph)
 501         paragraph = re.sub(' {2,}', ' ', paragraph)
 502         paragraph = re.sub('^\s*(\w)', r'\1', paragraph)
 503         returnstring += paragraph + '\n\n'
 504     return returnstring.rstrip('\n')
 505
 506
 507 def publishednameinfo(filename):
 508     filename = os.path.basename(filename)
 509     m = publish_name_regex.match(filename)
 510     try:
 511         result = (m.group(1), m.group(2))
 512     except AttributeError:
 513         raise FDroidException("Invalid name for published file: %s" % filename)
 514     return result
 515
 516
 517 def get_release_filename(app, build):
 518     if build.output:
 519         return "%s_%s.%s" % (app.id, build.versionCode, get_file_extension(build.output))
 520     else:
 521         return "%s_%s.apk" % (app.id, build.versionCode)
 522
 523
 524 def get_toolsversion_logname(app, build):
 525     return "%s_%s_toolsversion.log" % (app.id, build.versionCode)
 526
 527
 528 def getsrcname(app, build):
 529     return "%s_%s_src.tar.gz" % (app.id, build.versionCode)
 530
 531
 532 def getappname(app):
 533     if app.Name:
 534         return app.Name
 535     if app.AutoName:
 536         return app.AutoName
 537     return app.id
 538
 539
 540 def getcvname(app):
 541     return '%s (%s)' % (app.CurrentVersion, app.CurrentVersionCode)
 542
 543
 544 def get_build_dir(app):
 545     '''get the dir that this app will be built in'''
 546
 547     if app.RepoType == 'srclib':
 548         return os.path.join('build', 'srclib', app.Repo)
 549
 550     return os.path.join('build', app.id)
 551
 552
 553 def setup_vcs(app):
 554     '''checkout code from VCS and return instance of vcs and the build dir'''
 555     build_dir = get_build_dir(app)
 556
 557     # Set up vcs interface and make sure we have the latest code...
 558     logging.debug("Getting {0} vcs interface for {1}"
 559                   .format(app.RepoType, app.Repo))
 560     if app.RepoType == 'git' and os.path.exists('.fdroid.yml'):
 561         remote = os.getcwd()
 562     else:
 563         remote = app.Repo
 564     vcs = getvcs(app.RepoType, remote, build_dir)
 565
 566     return vcs, build_dir
 567
 568
 569 def getvcs(vcstype, remote, local):
 570     if vcstype == 'git':
 571         return vcs_git(remote, local)
 572     if vcstype == 'git-svn':
 573         return vcs_gitsvn(remote, local)
 574     if vcstype == 'hg':
 575         return vcs_hg(remote, local)
 576     if vcstype == 'bzr':
 577         return vcs_bzr(remote, local)
 578     if vcstype == 'srclib':
 579         if local != os.path.join('build', 'srclib', remote):
 580             raise VCSException("Error: srclib paths are hard-coded!")
 581         return getsrclib(remote, os.path.join('build', 'srclib'), raw=True)
 582     if vcstype == 'svn':
 583         raise VCSException("Deprecated vcs type 'svn' - please use 'git-svn' instead")
 584     raise VCSException("Invalid vcs type " + vcstype)
 585
 586
 587 def getsrclibvcs(name):
 588     if name not in fdroidserver.metadata.srclibs:
 589         raise VCSException("Missing srclib " + name)
 590     return fdroidserver.metadata.srclibs[name]['Repo Type']
 591
 592
 593 class vcs:
 594
 595     def __init__(self, remote, local):
 596
 597         # svn, git-svn and bzr may require auth
 598         self.username = None
 599         if self.repotype() in ('git-svn', 'bzr'):
 600             if '@' in remote:
 601                 if self.repotype == 'git-svn':
 602                     raise VCSException("Authentication is not supported for git-svn")
 603                 self.username, remote = remote.split('@')
 604                 if ':' not in self.username:
 605                     raise VCSException("Password required with username")
 606                 self.username, self.password = self.username.split(':')
 607
 608         self.remote = remote
 609         self.local = local
 610         self.clone_failed = False
 611         self.refreshed = False
 612         self.srclib = None
 613
 614     def repotype(self):
 615         return None
 616
 617     # Take the local repository to a clean version of the given revision, which
 618     # is specificed in the VCS's native format. Beforehand, the repository can
 619     # be dirty, or even non-existent. If the repository does already exist
 620     # locally, it will be updated from the origin, but only once in the
 621     # lifetime of the vcs object.
 622     # None is acceptable for 'rev' if you know you are cloning a clean copy of
 623     # the repo - otherwise it must specify a valid revision.
 624     def gotorevision(self, rev, refresh=True):
 625
 626         if self.clone_failed:
 627             raise VCSException("Downloading the repository already failed once, not trying again.")
 628
 629         # The .fdroidvcs-id file for a repo tells us what VCS type
 630         # and remote that directory was created from, allowing us to drop it
 631         # automatically if either of those things changes.
 632         fdpath = os.path.join(self.local, '..',
 633                               '.fdroidvcs-' + os.path.basename(self.local))
 634         fdpath = os.path.normpath(fdpath)
 635         cdata = self.repotype() + ' ' + self.remote
 636         writeback = True
 637         deleterepo = False
 638         if os.path.exists(self.local):
 639             if os.path.exists(fdpath):
 640                 with open(fdpath, 'r') as f:
 641                     fsdata = f.read().strip()
 642                 if fsdata == cdata:
 643                     writeback = False
 644                 else:
 645                     deleterepo = True
 646                     logging.info("Repository details for %s changed - deleting" % (
 647                         self.local))
 648             else:
 649                 deleterepo = True
 650                 logging.info("Repository details for %s missing - deleting" % (
 651                     self.local))
 652         if deleterepo:
 653             shutil.rmtree(self.local)
 654
 655         exc = None
 656         if not refresh:
 657             self.refreshed = True
 658
 659         try:
 660             self.gotorevisionx(rev)
 661         except FDroidException as e:
 662             exc = e
 663
 664         # If necessary, write the .fdroidvcs file.
 665         if writeback and not self.clone_failed:
 666             os.makedirs(os.path.dirname(fdpath), exist_ok=True)
 667             with open(fdpath, 'w+') as f:
 668                 f.write(cdata)
 669
 670         if exc is not None:
 671             raise exc
 672
 673     # Derived classes need to implement this. It's called once basic checking
 674     # has been performend.
 675     def gotorevisionx(self, rev):
 676         raise VCSException("This VCS type doesn't define gotorevisionx")
 677
 678     # Initialise and update submodules
 679     def initsubmodules(self):
 680         raise VCSException('Submodules not supported for this vcs type')
 681
 682     # Get a list of all known tags
 683     def gettags(self):
 684         if not self._gettags:
 685             raise VCSException('gettags not supported for this vcs type')
 686         rtags = []
 687         for tag in self._gettags():
 688             if re.match('[-A-Za-z0-9_. /]+$', tag):
 689                 rtags.append(tag)
 690         return rtags
 691
 692     # Get a list of all the known tags, sorted from newest to oldest
 693     def latesttags(self):
 694         raise VCSException('latesttags not supported for this vcs type')
 695
 696     # Get current commit reference (hash, revision, etc)
 697     def getref(self):
 698         raise VCSException('getref not supported for this vcs type')
 699
 700     # Returns the srclib (name, path) used in setting up the current
 701     # revision, or None.
 702     def getsrclib(self):
 703         return self.srclib
 704
 705
 706 class vcs_git(vcs):
 707
 708     def repotype(self):
 709         return 'git'
 710
 711     # If the local directory exists, but is somehow not a git repository, git
 712     # will traverse up the directory tree until it finds one that is (i.e.
 713     # fdroidserver) and then we'll proceed to destroy it! This is called as
 714     # a safety check.
 715     def checkrepo(self):
 716         p = FDroidPopen(['git', 'rev-parse', '--show-toplevel'], cwd=self.local, output=False)
 717         result = p.output.rstrip()
 718         if not result.endswith(self.local):
 719             raise VCSException('Repository mismatch')
 720
 721     def gotorevisionx(self, rev):
 722         if not os.path.exists(self.local):
 723             # Brand new checkout
 724             p = FDroidPopen(['git', 'clone', self.remote, self.local])
 725             if p.returncode != 0:
 726                 self.clone_failed = True
 727                 raise VCSException("Git clone failed", p.output)
 728             self.checkrepo()
 729         else:
 730             self.checkrepo()
 731             # Discard any working tree changes
 732             p = FDroidPopen(['git', 'submodule', 'foreach', '--recursive',
 733                              'git', 'reset', '--hard'], cwd=self.local, output=False)
 734             if p.returncode != 0:
 735                 raise VCSException("Git reset failed", p.output)
 736             # Remove untracked files now, in case they're tracked in the target
 737             # revision (it happens!)
 738             p = FDroidPopen(['git', 'submodule', 'foreach', '--recursive',
 739                              'git', 'clean', '-dffx'], cwd=self.local, output=False)
 740             if p.returncode != 0:
 741                 raise VCSException("Git clean failed", p.output)
 742             if not self.refreshed:
 743                 # Get latest commits and tags from remote
 744                 p = FDroidPopen(['git', 'fetch', 'origin'], cwd=self.local)
 745                 if p.returncode != 0:
 746                     raise VCSException("Git fetch failed", p.output)
 747                 p = FDroidPopen(['git', 'fetch', '--prune', '--tags', 'origin'], cwd=self.local, output=False)
 748                 if p.returncode != 0:
 749                     raise VCSException("Git fetch failed", p.output)
 750                 # Recreate origin/HEAD as git clone would do it, in case it disappeared
 751                 p = FDroidPopen(['git', 'remote', 'set-head', 'origin', '--auto'], cwd=self.local, output=False)
 752                 if p.returncode != 0:
 753                     lines = p.output.splitlines()
 754                     if 'Multiple remote HEAD branches' not in lines[0]:
 755                         raise VCSException("Git remote set-head failed", p.output)
 756                     branch = lines[1].split(' ')[-1]
 757                     p2 = FDroidPopen(['git', 'remote', 'set-head', 'origin', branch], cwd=self.local, output=False)
 758                     if p2.returncode != 0:
 759                         raise VCSException("Git remote set-head failed", p.output + '\n' + p2.output)
 760                 self.refreshed = True
 761         # origin/HEAD is the HEAD of the remote, e.g. the "default branch" on
 762         # a github repo. Most of the time this is the same as origin/master.
 763         rev = rev or 'origin/HEAD'
 764         p = FDroidPopen(['git', 'checkout', '-f', rev], cwd=self.local, output=False)
 765         if p.returncode != 0:
 766             raise VCSException("Git checkout of '%s' failed" % rev, p.output)
 767         # Get rid of any uncontrolled files left behind
 768         p = FDroidPopen(['git', 'clean', '-dffx'], cwd=self.local, output=False)
 769         if p.returncode != 0:
 770             raise VCSException("Git clean failed", p.output)
 771
 772     def initsubmodules(self):
 773         self.checkrepo()
 774         submfile = os.path.join(self.local, '.gitmodules')
 775         if not os.path.isfile(submfile):
 776             raise VCSException("No git submodules available")
 777
 778         # fix submodules not accessible without an account and public key auth
 779         with open(submfile, 'r') as f:
 780             lines = f.readlines()
 781         with open(submfile, 'w') as f:
 782             for line in lines:
 783                 if 'git@github.com' in line:
 784                     line = line.replace('git@github.com:', 'https://github.com/')
 785                 if 'git@gitlab.com' in line:
 786                     line = line.replace('git@gitlab.com:', 'https://gitlab.com/')
 787                 f.write(line)
 788
 789         p = FDroidPopen(['git', 'submodule', 'sync'], cwd=self.local, output=False)
 790         if p.returncode != 0:
 791             raise VCSException("Git submodule sync failed", p.output)
 792         p = FDroidPopen(['git', 'submodule', 'update', '--init', '--force', '--recursive'], cwd=self.local)
 793         if p.returncode != 0:
 794             raise VCSException("Git submodule update failed", p.output)
 795
 796     def _gettags(self):
 797         self.checkrepo()
 798         p = FDroidPopen(['git', 'tag'], cwd=self.local, output=False)
 799         return p.output.splitlines()
 800
 801     tag_format = re.compile(r'tag: ([^),]*)')
 802
 803     def latesttags(self):
 804         self.checkrepo()
 805         p = FDroidPopen(['git', 'log', '--tags',
 806                          '--simplify-by-decoration', '--pretty=format:%d'],
 807                         cwd=self.local, output=False)
 808         tags = []
 809         for line in p.output.splitlines():
 810             for tag in self.tag_format.findall(line):
 811                 tags.append(tag)
 812         return tags
 813
 814
 815 class vcs_gitsvn(vcs):
 816
 817     def repotype(self):
 818         return 'git-svn'
 819
 820     # If the local directory exists, but is somehow not a git repository, git
 821     # will traverse up the directory tree until it finds one that is (i.e.
 822     # fdroidserver) and then we'll proceed to destory it! This is called as
 823     # a safety check.
 824     def checkrepo(self):
 825         p = FDroidPopen(['git', 'rev-parse', '--show-toplevel'], cwd=self.local, output=False)
 826         result = p.output.rstrip()
 827         if not result.endswith(self.local):
 828             raise VCSException('Repository mismatch')
 829
 830     def gotorevisionx(self, rev):
 831         if not os.path.exists(self.local):
 832             # Brand new checkout
 833             gitsvn_args = ['git', 'svn', 'clone']
 834             if ';' in self.remote:
 835                 remote_split = self.remote.split(';')
 836                 for i in remote_split[1:]:
 837                     if i.startswith('trunk='):
 838                         gitsvn_args.extend(['-T', i[6:]])
 839                     elif i.startswith('tags='):
 840                         gitsvn_args.extend(['-t', i[5:]])
 841                     elif i.startswith('branches='):
 842                         gitsvn_args.extend(['-b', i[9:]])
 843                 gitsvn_args.extend([remote_split[0], self.local])
 844                 p = FDroidPopen(gitsvn_args, output=False)
 845                 if p.returncode != 0:
 846                     self.clone_failed = True
 847                     raise VCSException("Git svn clone failed", p.output)
 848             else:
 849                 gitsvn_args.extend([self.remote, self.local])
 850                 p = FDroidPopen(gitsvn_args, output=False)
 851                 if p.returncode != 0:
 852                     self.clone_failed = True
 853                     raise VCSException("Git svn clone failed", p.output)
 854             self.checkrepo()
 855         else:
 856             self.checkrepo()
 857             # Discard any working tree changes
 858             p = FDroidPopen(['git', 'reset', '--hard'], cwd=self.local, output=False)
 859             if p.returncode != 0:
 860                 raise VCSException("Git reset failed", p.output)
 861             # Remove untracked files now, in case they're tracked in the target
 862             # revision (it happens!)
 863             p = FDroidPopen(['git', 'clean', '-dffx'], cwd=self.local, output=False)
 864             if p.returncode != 0:
 865                 raise VCSException("Git clean failed", p.output)
 866             if not self.refreshed:
 867                 # Get new commits, branches and tags from repo
 868                 p = FDroidPopen(['git', 'svn', 'fetch'], cwd=self.local, output=False)
 869                 if p.returncode != 0:
 870                     raise VCSException("Git svn fetch failed")
 871                 p = FDroidPopen(['git', 'svn', 'rebase'], cwd=self.local, output=False)
 872                 if p.returncode != 0:
 873                     raise VCSException("Git svn rebase failed", p.output)
 874                 self.refreshed = True
 875
 876         rev = rev or 'master'
 877         if rev:
 878             nospaces_rev = rev.replace(' ', '%20')
 879             # Try finding a svn tag
 880             for treeish in ['origin/', '']:
 881                 p = FDroidPopen(['git', 'checkout', treeish + 'tags/' + nospaces_rev], cwd=self.local, output=False)
 882                 if p.returncode == 0:
 883                     break
 884             if p.returncode != 0:
 885                 # No tag found, normal svn rev translation
 886                 # Translate svn rev into git format
 887                 rev_split = rev.split('/')
 888
 889                 p = None
 890                 for treeish in ['origin/', '']:
 891                     if len(rev_split) > 1:
 892                         treeish += rev_split[0]
 893                         svn_rev = rev_split[1]
 894
 895                     else:
 896                         # if no branch is specified, then assume trunk (i.e. 'master' branch):
 897                         treeish += 'master'
 898                         svn_rev = rev
 899
 900                     svn_rev = svn_rev if svn_rev[0] == 'r' else 'r' + svn_rev
 901
 902                     p = FDroidPopen(['git', 'svn', 'find-rev', '--before', svn_rev, treeish], cwd=self.local, output=False)
 903                     git_rev = p.output.rstrip()
 904
 905                     if p.returncode == 0 and git_rev:
 906                         break
 907
 908                 if p.returncode != 0 or not git_rev:
 909                     # Try a plain git checkout as a last resort
 910                     p = FDroidPopen(['git', 'checkout', rev], cwd=self.local, output=False)
 911                     if p.returncode != 0:
 912                         raise VCSException("No git treeish found and direct git checkout of '%s' failed" % rev, p.output)
 913                 else:
 914                     # Check out the git rev equivalent to the svn rev
 915                     p = FDroidPopen(['git', 'checkout', git_rev], cwd=self.local, output=False)
 916                     if p.returncode != 0:
 917                         raise VCSException("Git checkout of '%s' failed" % rev, p.output)
 918
 919         # Get rid of any uncontrolled files left behind
 920         p = FDroidPopen(['git', 'clean', '-dffx'], cwd=self.local, output=False)
 921         if p.returncode != 0:
 922             raise VCSException("Git clean failed", p.output)
 923
 924     def _gettags(self):
 925         self.checkrepo()
 926         for treeish in ['origin/', '']:
 927             d = os.path.join(self.local, '.git', 'svn', 'refs', 'remotes', treeish, 'tags')
 928             if os.path.isdir(d):
 929                 return os.listdir(d)
 930
 931     def getref(self):
 932         self.checkrepo()
 933         p = FDroidPopen(['git', 'svn', 'find-rev', 'HEAD'], cwd=self.local, output=False)
 934         if p.returncode != 0:
 935             return None
 936         return p.output.strip()
 937
 938
 939 class vcs_hg(vcs):
 940
 941     def repotype(self):
 942         return 'hg'
 943
 944     def gotorevisionx(self, rev):
 945         if not os.path.exists(self.local):
 946             p = FDroidPopen(['hg', 'clone', self.remote, self.local], output=False)
 947             if p.returncode != 0:
 948                 self.clone_failed = True
 949                 raise VCSException("Hg clone failed", p.output)
 950         else:
 951             p = FDroidPopen(['hg', 'status', '-uS'], cwd=self.local, output=False)
 952             if p.returncode != 0:
 953                 raise VCSException("Hg status failed", p.output)
 954             for line in p.output.splitlines():
 955                 if not line.startswith('? '):
 956                     raise VCSException("Unexpected output from hg status -uS: " + line)
 957                 FDroidPopen(['rm', '-rf', line[2:]], cwd=self.local, output=False)
 958             if not self.refreshed:
 959                 p = FDroidPopen(['hg', 'pull'], cwd=self.local, output=False)
 960                 if p.returncode != 0:
 961                     raise VCSException("Hg pull failed", p.output)
 962                 self.refreshed = True
 963
 964         rev = rev or 'default'
 965         if not rev:
 966             return
 967         p = FDroidPopen(['hg', 'update', '-C', rev], cwd=self.local, output=False)
 968         if p.returncode != 0:
 969             raise VCSException("Hg checkout of '%s' failed" % rev, p.output)
 970         p = FDroidPopen(['hg', 'purge', '--all'], cwd=self.local, output=False)
 971         # Also delete untracked files, we have to enable purge extension for that:
 972         if "'purge' is provided by the following extension" in p.output:
 973             with open(os.path.join(self.local, '.hg', 'hgrc'), "a") as myfile:
 974                 myfile.write("\n[extensions]\nhgext.purge=\n")
 975             p = FDroidPopen(['hg', 'purge', '--all'], cwd=self.local, output=False)
 976             if p.returncode != 0:
 977                 raise VCSException("HG purge failed", p.output)
 978         elif p.returncode != 0:
 979             raise VCSException("HG purge failed", p.output)
 980
 981     def _gettags(self):
 982         p = FDroidPopen(['hg', 'tags', '-q'], cwd=self.local, output=False)
 983         return p.output.splitlines()[1:]
 984
 985
 986 class vcs_bzr(vcs):
 987
 988     def repotype(self):
 989         return 'bzr'
 990
 991     def gotorevisionx(self, rev):
 992         if not os.path.exists(self.local):
 993             p = FDroidPopen(['bzr', 'branch', self.remote, self.local], output=False)
 994             if p.returncode != 0:
 995                 self.clone_failed = True
 996                 raise VCSException("Bzr branch failed", p.output)
 997         else:
 998             p = FDroidPopen(['bzr', 'clean-tree', '--force', '--unknown', '--ignored'], cwd=self.local, output=False)
 999             if p.returncode != 0:
1000                 raise VCSException("Bzr revert failed", p.output)
1001             if not self.refreshed:
1002                 p = FDroidPopen(['bzr', 'pull'], cwd=self.local, output=False)
1003                 if p.returncode != 0:
1004                     raise VCSException("Bzr update failed", p.output)
1005                 self.refreshed = True
1006
1007         revargs = list(['-r', rev] if rev else [])
1008         p = FDroidPopen(['bzr', 'revert'] + revargs, cwd=self.local, output=False)
1009         if p.returncode != 0:
1010             raise VCSException("Bzr revert of '%s' failed" % rev, p.output)
1011
1012     def _gettags(self):
1013         p = FDroidPopen(['bzr', 'tags'], cwd=self.local, output=False)
1014         return [tag.split('   ')[0].strip() for tag in
1015                 p.output.splitlines()]
1016
1017
1018 def unescape_string(string):
1019     if len(string) < 2:
1020         return string
1021     if string[0] == '"' and string[-1] == '"':
1022         return string[1:-1]
1023
1024     return string.replace("\\'", "'")
1025
1026
1027 def retrieve_string(app_dir, string, xmlfiles=None):
1028
1029     if not string.startswith('@string/'):
1030         return unescape_string(string)
1031
1032     if xmlfiles is None:
1033         xmlfiles = []
1034         for res_dir in [
1035             os.path.join(app_dir, 'res'),
1036             os.path.join(app_dir, 'src', 'main', 'res'),
1037         ]:
1038             for r, d, f in os.walk(res_dir):
1039                 if os.path.basename(r) == 'values':
1040                     xmlfiles += [os.path.join(r, x) for x in f if x.endswith('.xml')]
1041
1042     name = string[len('@string/'):]
1043
1044     def element_content(element):
1045         if element.text is None:
1046             return ""
1047         s = XMLElementTree.tostring(element, encoding='utf-8', method='text')
1048         return s.decode('utf-8').strip()
1049
1050     for path in xmlfiles:
1051         if not os.path.isfile(path):
1052             continue
1053         xml = parse_xml(path)
1054         element = xml.find('string[@name="' + name + '"]')
1055         if element is not None:
1056             content = element_content(element)
1057             return retrieve_string(app_dir, content, xmlfiles)
1058
1059     return ''
1060
1061
1062 def retrieve_string_singleline(app_dir, string, xmlfiles=None):
1063     return retrieve_string(app_dir, string, xmlfiles).replace('\n', ' ').strip()
1064
1065
1066 def manifest_paths(app_dir, flavours):
1067     '''Return list of existing files that will be used to find the highest vercode'''
1068
1069     possible_manifests = \
1070         [os.path.join(app_dir, 'AndroidManifest.xml'),
1071          os.path.join(app_dir, 'src', 'main', 'AndroidManifest.xml'),
1072          os.path.join(app_dir, 'src', 'AndroidManifest.xml'),
1073          os.path.join(app_dir, 'build.gradle')]
1074
1075     for flavour in flavours:
1076         if flavour == 'yes':
1077             continue
1078         possible_manifests.append(
1079             os.path.join(app_dir, 'src', flavour, 'AndroidManifest.xml'))
1080
1081     return [path for path in possible_manifests if os.path.isfile(path)]
1082
1083
1084 def fetch_real_name(app_dir, flavours):
1085     '''Retrieve the package name. Returns the name, or None if not found.'''
1086     for path in manifest_paths(app_dir, flavours):
1087         if not has_extension(path, 'xml') or not os.path.isfile(path):
1088             continue
1089         logging.debug("fetch_real_name: Checking manifest at " + path)
1090         xml = parse_xml(path)
1091         app = xml.find('application')
1092         if app is None:
1093             continue
1094         if "{http://schemas.android.com/apk/res/android}label" not in app.attrib:
1095             continue
1096         label = app.attrib["{http://schemas.android.com/apk/res/android}label"]
1097         result = retrieve_string_singleline(app_dir, label)
1098         if result:
1099             result = result.strip()
1100         return result
1101     return None
1102
1103
1104 def get_library_references(root_dir):
1105     libraries = []
1106     proppath = os.path.join(root_dir, 'project.properties')
1107     if not os.path.isfile(proppath):
1108         return libraries
1109     with open(proppath, 'r', encoding='iso-8859-1') as f:
1110         for line in f:
1111             if not line.startswith('android.library.reference.'):
1112                 continue
1113             path = line.split('=')[1].strip()
1114             relpath = os.path.join(root_dir, path)
1115             if not os.path.isdir(relpath):
1116                 continue
1117             logging.debug("Found subproject at %s" % path)
1118             libraries.append(path)
1119     return libraries
1120
1121
1122 def ant_subprojects(root_dir):
1123     subprojects = get_library_references(root_dir)
1124     for subpath in subprojects:
1125         subrelpath = os.path.join(root_dir, subpath)
1126         for p in get_library_references(subrelpath):
1127             relp = os.path.normpath(os.path.join(subpath, p))
1128             if relp not in subprojects:
1129                 subprojects.insert(0, relp)
1130     return subprojects
1131
1132
1133 def remove_debuggable_flags(root_dir):
1134     # Remove forced debuggable flags
1135     logging.debug("Removing debuggable flags from %s" % root_dir)
1136     for root, dirs, files in os.walk(root_dir):
1137         if 'AndroidManifest.xml' in files:
1138             regsub_file(r'android:debuggable="[^"]*"',
1139                         '',
1140                         os.path.join(root, 'AndroidManifest.xml'))
1141
1142
1143 vcsearch_g = re.compile(r'''.*[Vv]ersionCode[ =]+["']*([0-9]+)["']*''').search
1144 vnsearch_g = re.compile(r'.*[Vv]ersionName *=* *(["\'])((?:(?=(\\?))\3.)*?)\1.*').search
1145 psearch_g = re.compile(r'.*(packageName|applicationId) *=* *["\']([^"]+)["\'].*').search
1146
1147
1148 def app_matches_packagename(app, package):
1149     if not package:
1150         return False
1151     appid = app.UpdateCheckName or app.id
1152     if appid is None or appid == "Ignore":
1153         return True
1154     return appid == package
1155
1156
1157 def parse_androidmanifests(paths, app):
1158     """
1159     Extract some information from the AndroidManifest.xml at the given path.
1160     Returns (version, vercode, package), any or all of which might be None.
1161     All values returned are strings.
1162     """
1163
1164     ignoreversions = app.UpdateCheckIgnore
1165     ignoresearch = re.compile(ignoreversions).search if ignoreversions else None
1166
1167     if not paths:
1168         return (None, None, None)
1169
1170     max_version = None
1171     max_vercode = None
1172     max_package = None
1173
1174     for path in paths:
1175
1176         if not os.path.isfile(path):
1177             continue
1178
1179         logging.debug("Parsing manifest at {0}".format(path))
1180         version = None
1181         vercode = None
1182         package = None
1183
1184         if has_extension(path, 'gradle'):
1185             with open(path, 'r') as f:
1186                 for line in f:
1187                     if gradle_comment.match(line):
1188                         continue
1189                     # Grab first occurence of each to avoid running into
1190                     # alternative flavours and builds.
1191                     if not package:
1192                         matches = psearch_g(line)
1193                         if matches:
1194                             s = matches.group(2)
1195                             if app_matches_packagename(app, s):
1196                                 package = s
1197                     if not version:
1198                         matches = vnsearch_g(line)
1199                         if matches:
1200                             version = matches.group(2)
1201                     if not vercode:
1202                         matches = vcsearch_g(line)
1203                         if matches:
1204                             vercode = matches.group(1)
1205         else:
1206             try:
1207                 xml = parse_xml(path)
1208                 if "package" in xml.attrib:
1209                     s = xml.attrib["package"]
1210                     if app_matches_packagename(app, s):
1211                         package = s
1212                 if "{http://schemas.android.com/apk/res/android}versionName" in xml.attrib:
1213                     version = xml.attrib["{http://schemas.android.com/apk/res/android}versionName"]
1214                     base_dir = os.path.dirname(path)
1215                     version = retrieve_string_singleline(base_dir, version)
1216                 if "{http://schemas.android.com/apk/res/android}versionCode" in xml.attrib:
1217                     a = xml.attrib["{http://schemas.android.com/apk/res/android}versionCode"]
1218                     if string_is_integer(a):
1219                         vercode = a
1220             except Exception:
1221                 logging.warning("Problem with xml at {0}".format(path))
1222
1223         # Remember package name, may be defined separately from version+vercode
1224         if package is None:
1225             package = max_package
1226
1227         logging.debug("..got package={0}, version={1}, vercode={2}"
1228                       .format(package, version, vercode))
1229
1230         # Always grab the package name and version name in case they are not
1231         # together with the highest version code
1232         if max_package is None and package is not None:
1233             max_package = package
1234         if max_version is None and version is not None:
1235             max_version = version
1236
1237         if vercode is not None \
1238            and (max_vercode is None or vercode > max_vercode):
1239             if not ignoresearch or not ignoresearch(version):
1240                 if version is not None:
1241                     max_version = version
1242                 if vercode is not None:
1243                     max_vercode = vercode
1244                 if package is not None:
1245                     max_package = package
1246             else:
1247                 max_version = "Ignore"
1248
1249     if max_version is None:
1250         max_version = "Unknown"
1251
1252     if max_package and not is_valid_package_name(max_package):
1253         raise FDroidException("Invalid package name {0}".format(max_package))
1254
1255     return (max_version, max_vercode, max_package)
1256
1257
1258 def is_valid_package_name(name):
1259     return re.match("[A-Za-z_][A-Za-z_0-9.]+$", name)
1260
1261
1262 class FDroidException(Exception):
1263
1264     def __init__(self, value, detail=None):
1265         self.value = value
1266         self.detail = detail
1267
1268     def shortened_detail(self):
1269         if len(self.detail) < 16000:
1270             return self.detail
1271         return '[...]\n' + self.detail[-16000:]
1272
1273     def get_wikitext(self):
1274         ret = repr(self.value) + "\n"
1275         if self.detail:
1276             ret += "=detail=\n"
1277             ret += "<pre>\n" + self.shortened_detail() + "</pre>\n"
1278         return ret
1279
1280     def __str__(self):
1281         ret = self.value
1282         if self.detail:
1283             ret += "\n==== detail begin ====\n%s\n==== detail end ====" % self.detail.strip()
1284         return ret
1285
1286
1287 class VCSException(FDroidException):
1288     pass
1289
1290
1291 class BuildException(FDroidException):
1292     pass
1293
1294
1295 # Get the specified source library.
1296 # Returns the path to it. Normally this is the path to be used when referencing
1297 # it, which may be a subdirectory of the actual project. If you want the base
1298 # directory of the project, pass 'basepath=True'.
1299 def getsrclib(spec, srclib_dir, subdir=None, basepath=False,
1300               raw=False, prepare=True, preponly=False, refresh=True,
1301               build=None):
1302
1303     number = None
1304     subdir = None
1305     if raw:
1306         name = spec
1307         ref = None
1308     else:
1309         name, ref = spec.split('@')
1310         if ':' in name:
1311             number, name = name.split(':', 1)
1312         if '/' in name:
1313             name, subdir = name.split('/', 1)
1314
1315     if name not in fdroidserver.metadata.srclibs:
1316         raise VCSException('srclib ' + name + ' not found.')
1317
1318     srclib = fdroidserver.metadata.srclibs[name]
1319
1320     sdir = os.path.join(srclib_dir, name)
1321
1322     if not preponly:
1323         vcs = getvcs(srclib["Repo Type"], srclib["Repo"], sdir)
1324         vcs.srclib = (name, number, sdir)
1325         if ref:
1326             vcs.gotorevision(ref, refresh)
1327
1328         if raw:
1329             return vcs
1330
1331     libdir = None
1332     if subdir:
1333         libdir = os.path.join(sdir, subdir)
1334     elif srclib["Subdir"]:
1335         for subdir in srclib["Subdir"]:
1336             libdir_candidate = os.path.join(sdir, subdir)
1337             if os.path.exists(libdir_candidate):
1338                 libdir = libdir_candidate
1339                 break
1340
1341     if libdir is None:
1342         libdir = sdir
1343
1344     remove_signing_keys(sdir)
1345     remove_debuggable_flags(sdir)
1346
1347     if prepare:
1348
1349         if srclib["Prepare"]:
1350             cmd = replace_config_vars(srclib["Prepare"], build)
1351
1352             p = FDroidPopen(['bash', '-x', '-c', cmd], cwd=libdir)
1353             if p.returncode != 0:
1354                 raise BuildException("Error running prepare command for srclib %s"
1355                                      % name, p.output)
1356
1357     if basepath:
1358         libdir = sdir
1359
1360     return (name, number, libdir)
1361
1362
1363 gradle_version_regex = re.compile(r"[^/]*'com\.android\.tools\.build:gradle:([^\.]+\.[^\.]+).*'.*")
1364
1365
1366 # Prepare the source code for a particular build
1367 #  'vcs'         - the appropriate vcs object for the application
1368 #  'app'         - the application details from the metadata
1369 #  'build'       - the build details from the metadata
1370 #  'build_dir'   - the path to the build directory, usually
1371 #                   'build/app.id'
1372 #  'srclib_dir'  - the path to the source libraries directory, usually
1373 #                   'build/srclib'
1374 #  'extlib_dir'  - the path to the external libraries directory, usually
1375 #                   'build/extlib'
1376 # Returns the (root, srclibpaths) where:
1377 #   'root' is the root directory, which may be the same as 'build_dir' or may
1378 #          be a subdirectory of it.
1379 #   'srclibpaths' is information on the srclibs being used
1380 def prepare_source(vcs, app, build, build_dir, srclib_dir, extlib_dir, onserver=False, refresh=True):
1381
1382     # Optionally, the actual app source can be in a subdirectory
1383     if build.subdir:
1384         root_dir = os.path.join(build_dir, build.subdir)
1385     else:
1386         root_dir = build_dir
1387
1388     # Get a working copy of the right revision
1389     logging.info("Getting source for revision " + build.commit)
1390     vcs.gotorevision(build.commit, refresh)
1391
1392     # Initialise submodules if required
1393     if build.submodules:
1394         logging.info("Initialising submodules")
1395         vcs.initsubmodules()
1396
1397     # Check that a subdir (if we're using one) exists. This has to happen
1398     # after the checkout, since it might not exist elsewhere
1399     if not os.path.exists(root_dir):
1400         raise BuildException('Missing subdir ' + root_dir)
1401
1402     # Run an init command if one is required
1403     if build.init:
1404         cmd = replace_config_vars(build.init, build)
1405         logging.info("Running 'init' commands in %s" % root_dir)
1406
1407         p = FDroidPopen(['bash', '-x', '-c', cmd], cwd=root_dir)
1408         if p.returncode != 0:
1409             raise BuildException("Error running init command for %s:%s" %
1410                                  (app.id, build.versionName), p.output)
1411
1412     # Apply patches if any
1413     if build.patch:
1414         logging.info("Applying patches")
1415         for patch in build.patch:
1416             patch = patch.strip()
1417             logging.info("Applying " + patch)
1418             patch_path = os.path.join('metadata', app.id, patch)
1419             p = FDroidPopen(['patch', '-p1', '-i', os.path.abspath(patch_path)], cwd=build_dir)
1420             if p.returncode != 0:
1421                 raise BuildException("Failed to apply patch %s" % patch_path)
1422
1423     # Get required source libraries
1424     srclibpaths = []
1425     if build.srclibs:
1426         logging.info("Collecting source libraries")
1427         for lib in build.srclibs:
1428             srclibpaths.append(getsrclib(lib, srclib_dir, build, preponly=onserver,
1429                                          refresh=refresh, build=build))
1430
1431     for name, number, libpath in srclibpaths:
1432         place_srclib(root_dir, int(number) if number else None, libpath)
1433
1434     basesrclib = vcs.getsrclib()
1435     # If one was used for the main source, add that too.
1436     if basesrclib:
1437         srclibpaths.append(basesrclib)
1438
1439     # Update the local.properties file
1440     localprops = [os.path.join(build_dir, 'local.properties')]
1441     if build.subdir:
1442         parts = build.subdir.split(os.sep)
1443         cur = build_dir
1444         for d in parts:
1445             cur = os.path.join(cur, d)
1446             localprops += [os.path.join(cur, 'local.properties')]
1447     for path in localprops:
1448         props = ""
1449         if os.path.isfile(path):
1450             logging.info("Updating local.properties file at %s" % path)
1451             with open(path, 'r', encoding='iso-8859-1') as f:
1452                 props += f.read()
1453             props += '\n'
1454         else:
1455             logging.info("Creating local.properties file at %s" % path)
1456         # Fix old-fashioned 'sdk-location' by copying
1457         # from sdk.dir, if necessary
1458         if build.oldsdkloc:
1459             sdkloc = re.match(r".*^sdk.dir=(\S+)$.*", props,
1460                               re.S | re.M).group(1)
1461             props += "sdk-location=%s\n" % sdkloc
1462         else:
1463             props += "sdk.dir=%s\n" % config['sdk_path']
1464             props += "sdk-location=%s\n" % config['sdk_path']
1465         ndk_path = build.ndk_path()
1466         # if for any reason the path isn't valid or the directory
1467         # doesn't exist, some versions of Gradle will error with a
1468         # cryptic message (even if the NDK is not even necessary).
1469         # https://gitlab.com/fdroid/fdroidserver/issues/171
1470         if ndk_path and os.path.exists(ndk_path):
1471             # Add ndk location
1472             props += "ndk.dir=%s\n" % ndk_path
1473             props += "ndk-location=%s\n" % ndk_path
1474         # Add java.encoding if necessary
1475         if build.encoding:
1476             props += "java.encoding=%s\n" % build.encoding
1477         with open(path, 'w', encoding='iso-8859-1') as f:
1478             f.write(props)
1479
1480     flavours = []
1481     if build.build_method() == 'gradle':
1482         flavours = build.gradle
1483
1484         if build.target:
1485             n = build.target.split('-')[1]
1486             regsub_file(r'compileSdkVersion[ =]+[0-9]+',
1487                         r'compileSdkVersion %s' % n,
1488                         os.path.join(root_dir, 'build.gradle'))
1489
1490     # Remove forced debuggable flags
1491     remove_debuggable_flags(root_dir)
1492
1493     # Insert version code and number into the manifest if necessary
1494     if build.forceversion:
1495         logging.info("Changing the version name")
1496         for path in manifest_paths(root_dir, flavours):
1497             if not os.path.isfile(path):
1498                 continue
1499             if has_extension(path, 'xml'):
1500                 regsub_file(r'android:versionName="[^"]*"',
1501                             r'android:versionName="%s"' % build.versionName,
1502                             path)
1503             elif has_extension(path, 'gradle'):
1504                 regsub_file(r"""(\s*)versionName[\s'"=]+.*""",
1505                             r"""\1versionName '%s'""" % build.versionName,
1506                             path)
1507
1508     if build.forcevercode:
1509         logging.info("Changing the version code")
1510         for path in manifest_paths(root_dir, flavours):
1511             if not os.path.isfile(path):
1512                 continue
1513             if has_extension(path, 'xml'):
1514                 regsub_file(r'android:versionCode="[^"]*"',
1515                             r'android:versionCode="%s"' % build.versionCode,
1516                             path)
1517             elif has_extension(path, 'gradle'):
1518                 regsub_file(r'versionCode[ =]+[0-9]+',
1519                             r'versionCode %s' % build.versionCode,
1520                             path)
1521
1522     # Delete unwanted files
1523     if build.rm:
1524         logging.info("Removing specified files")
1525         for part in getpaths(build_dir, build.rm):
1526             dest = os.path.join(build_dir, part)
1527             logging.info("Removing {0}".format(part))
1528             if os.path.lexists(dest):
1529                 if os.path.islink(dest):
1530                     FDroidPopen(['unlink', dest], output=False)
1531                 else:
1532                     FDroidPopen(['rm', '-rf', dest], output=False)
1533             else:
1534                 logging.info("...but it didn't exist")
1535
1536     remove_signing_keys(build_dir)
1537
1538     # Add required external libraries
1539     if build.extlibs:
1540         logging.info("Collecting prebuilt libraries")
1541         libsdir = os.path.join(root_dir, 'libs')
1542         if not os.path.exists(libsdir):
1543             os.mkdir(libsdir)
1544         for lib in build.extlibs:
1545             lib = lib.strip()
1546             logging.info("...installing extlib {0}".format(lib))
1547             libf = os.path.basename(lib)
1548             libsrc = os.path.join(extlib_dir, lib)
1549             if not os.path.exists(libsrc):
1550                 raise BuildException("Missing extlib file {0}".format(libsrc))
1551             shutil.copyfile(libsrc, os.path.join(libsdir, libf))
1552
1553     # Run a pre-build command if one is required
1554     if build.prebuild:
1555         logging.info("Running 'prebuild' commands in %s" % root_dir)
1556
1557         cmd = replace_config_vars(build.prebuild, build)
1558
1559         # Substitute source library paths into prebuild commands
1560         for name, number, libpath in srclibpaths:
1561             libpath = os.path.relpath(libpath, root_dir)
1562             cmd = cmd.replace('$$' + name + '$$', libpath)
1563
1564         p = FDroidPopen(['bash', '-x', '-c', cmd], cwd=root_dir)
1565         if p.returncode != 0:
1566             raise BuildException("Error running prebuild command for %s:%s" %
1567                                  (app.id, build.versionName), p.output)
1568
1569     # Generate (or update) the ant build file, build.xml...
1570     if build.build_method() == 'ant' and build.androidupdate != ['no']:
1571         parms = ['android', 'update', 'lib-project']
1572         lparms = ['android', 'update', 'project']
1573
1574         if build.target:
1575             parms += ['-t', build.target]
1576             lparms += ['-t', build.target]
1577         if build.androidupdate:
1578             update_dirs = build.androidupdate
1579         else:
1580             update_dirs = ant_subprojects(root_dir) + ['.']
1581
1582         for d in update_dirs:
1583             subdir = os.path.join(root_dir, d)
1584             if d == '.':
1585                 logging.debug("Updating main project")
1586                 cmd = parms + ['-p', d]
1587             else:
1588                 logging.debug("Updating subproject %s" % d)
1589                 cmd = lparms + ['-p', d]
1590             p = SdkToolsPopen(cmd, cwd=root_dir)
1591             # Check to see whether an error was returned without a proper exit
1592             # code (this is the case for the 'no target set or target invalid'
1593             # error)
1594             if p.returncode != 0 or p.output.startswith("Error: "):
1595                 raise BuildException("Failed to update project at %s" % d, p.output)
1596             # Clean update dirs via ant
1597             if d != '.':
1598                 logging.info("Cleaning subproject %s" % d)
1599                 p = FDroidPopen(['ant', 'clean'], cwd=subdir)
1600
1601     return (root_dir, srclibpaths)
1602
1603
1604 # Extend via globbing the paths from a field and return them as a map from
1605 # original path to resulting paths
1606 def getpaths_map(build_dir, globpaths):
1607     paths = dict()
1608     for p in globpaths:
1609         p = p.strip()
1610         full_path = os.path.join(build_dir, p)
1611         full_path = os.path.normpath(full_path)
1612         paths[p] = [r[len(build_dir) + 1:] for r in glob.glob(full_path)]
1613         if not paths[p]:
1614             raise FDroidException("glob path '%s' did not match any files/dirs" % p)
1615     return paths
1616
1617
1618 # Extend via globbing the paths from a field and return them as a set
1619 def getpaths(build_dir, globpaths):
1620     paths_map = getpaths_map(build_dir, globpaths)
1621     paths = set()
1622     for k, v in paths_map.items():
1623         for p in v:
1624             paths.add(p)
1625     return paths
1626
1627
1628 def natural_key(s):
1629     return [int(sp) if sp.isdigit() else sp for sp in re.split(r'(\d+)', s)]
1630
1631
1632 class KnownApks:
1633
1634     def __init__(self):
1635         self.path = os.path.join('stats', 'known_apks.txt')
1636         self.apks = {}
1637         if os.path.isfile(self.path):
1638             with open(self.path, 'r', encoding='utf8') as f:
1639                 for line in f:
1640                     t = line.rstrip().split(' ')
1641                     if len(t) == 2:
1642                         self.apks[t[0]] = (t[1], None)
1643                     else:
1644                         self.apks[t[0]] = (t[1], datetime.strptime(t[2], '%Y-%m-%d'))
1645         self.changed = False
1646
1647     def writeifchanged(self):
1648         if not self.changed:
1649             return
1650
1651         if not os.path.exists('stats'):
1652             os.mkdir('stats')
1653
1654         lst = []
1655         for apk, app in self.apks.items():
1656             appid, added = app
1657             line = apk + ' ' + appid
1658             if added:
1659                 line += ' ' + added.strftime('%Y-%m-%d')
1660             lst.append(line)
1661
1662         with open(self.path, 'w', encoding='utf8') as f:
1663             for line in sorted(lst, key=natural_key):
1664                 f.write(line + '\n')
1665
1666     def recordapk(self, apk, app, default_date=None):
1667         '''
1668         Record an apk (if it's new, otherwise does nothing)
1669         Returns the date it was added as a datetime instance
1670         '''
1671         if apk not in self.apks:
1672             if default_date is None:
1673                 default_date = datetime.utcnow()
1674             self.apks[apk] = (app, default_date)
1675             self.changed = True
1676         _, added = self.apks[apk]
1677         return added
1678
1679     # Look up information - given the 'apkname', returns (app id, date added/None).
1680     # Or returns None for an unknown apk.
1681     def getapp(self, apkname):
1682         if apkname in self.apks:
1683             return self.apks[apkname]
1684         return None
1685
1686     # Get the most recent 'num' apps added to the repo, as a list of package ids
1687     # with the most recent first.
1688     def getlatest(self, num):
1689         apps = {}
1690         for apk, app in self.apks.items():
1691             appid, added = app
1692             if added:
1693                 if appid in apps:
1694                     if apps[appid] > added:
1695                         apps[appid] = added
1696                 else:
1697                     apps[appid] = added
1698         sortedapps = sorted(apps.items(), key=operator.itemgetter(1))[-num:]
1699         lst = [app for app, _ in sortedapps]
1700         lst.reverse()
1701         return lst
1702
1703
1704 def get_file_extension(filename):
1705     """get the normalized file extension, can be blank string but never None"""
1706     if isinstance(filename, bytes):
1707         filename = filename.decode('utf-8')
1708     return os.path.splitext(filename)[1].lower()[1:]
1709
1710
1711 def isApkAndDebuggable(apkfile, config):
1712     """Returns True if the given file is an APK and is debuggable
1713
1714     :param apkfile: full path to the apk to check"""
1715
1716     if get_file_extension(apkfile) != 'apk':
1717         return False
1718
1719     p = SdkToolsPopen(['aapt', 'dump', 'xmltree', apkfile, 'AndroidManifest.xml'],
1720                       output=False)
1721     if p.returncode != 0:
1722         logging.critical("Failed to get apk manifest information")
1723         sys.exit(1)
1724     for line in p.output.splitlines():
1725         if 'android:debuggable' in line and not line.endswith('0x0'):
1726             return True
1727     return False
1728
1729
1730 class PopenResult:
1731     def __init__(self):
1732         self.returncode = None
1733         self.output = None
1734
1735
1736 def SdkToolsPopen(commands, cwd=None, output=True):
1737     cmd = commands[0]
1738     if cmd not in config:
1739         config[cmd] = find_sdk_tools_cmd(commands[0])
1740     abscmd = config[cmd]
1741     if abscmd is None:
1742         logging.critical("Could not find '%s' on your system" % cmd)
1743         sys.exit(1)
1744     if cmd == 'aapt':
1745         test_aapt_version(config['aapt'])
1746     return FDroidPopen([abscmd] + commands[1:],
1747                        cwd=cwd, output=output)
1748
1749
1750 def FDroidPopenBytes(commands, cwd=None, output=True, stderr_to_stdout=True):
1751     """
1752     Run a command and capture the possibly huge output as bytes.
1753
1754     :param commands: command and argument list like in subprocess.Popen
1755     :param cwd: optionally specifies a working directory
1756     :returns: A PopenResult.
1757     """
1758
1759     global env
1760     if env is None:
1761         set_FDroidPopen_env()
1762
1763     if cwd:
1764         cwd = os.path.normpath(cwd)
1765         logging.debug("Directory: %s" % cwd)
1766     logging.debug("> %s" % ' '.join(commands))
1767
1768     stderr_param = subprocess.STDOUT if stderr_to_stdout else subprocess.PIPE
1769     result = PopenResult()
1770     p = None
1771     try:
1772         p = subprocess.Popen(commands, cwd=cwd, shell=False, env=env,
1773                              stdout=subprocess.PIPE, stderr=stderr_param)
1774     except OSError as e:
1775         raise BuildException("OSError while trying to execute " +
1776                              ' '.join(commands) + ': ' + str(e))
1777
1778     if not stderr_to_stdout and options.verbose:
1779         stderr_queue = Queue()
1780         stderr_reader = AsynchronousFileReader(p.stderr, stderr_queue)
1781
1782         while not stderr_reader.eof():
1783             while not stderr_queue.empty():
1784                 line = stderr_queue.get()
1785                 sys.stderr.buffer.write(line)
1786                 sys.stderr.flush()
1787
1788             time.sleep(0.1)
1789
1790     stdout_queue = Queue()
1791     stdout_reader = AsynchronousFileReader(p.stdout, stdout_queue)
1792     buf = io.BytesIO()
1793
1794     # Check the queue for output (until there is no more to get)
1795     while not stdout_reader.eof():
1796         while not stdout_queue.empty():
1797             line = stdout_queue.get()
1798             if output and options.verbose:
1799                 # Output directly to console
1800                 sys.stderr.buffer.write(line)
1801                 sys.stderr.flush()
1802             buf.write(line)
1803
1804         time.sleep(0.1)
1805
1806     result.returncode = p.wait()
1807     result.output = buf.getvalue()
1808     buf.close()
1809     return result
1810
1811
1812 def FDroidPopen(commands, cwd=None, output=True, stderr_to_stdout=True):
1813     """
1814     Run a command and capture the possibly huge output as a str.
1815
1816     :param commands: command and argument list like in subprocess.Popen
1817     :param cwd: optionally specifies a working directory
1818     :returns: A PopenResult.
1819     """
1820     result = FDroidPopenBytes(commands, cwd, output, stderr_to_stdout)
1821     result.output = result.output.decode('utf-8', 'ignore')
1822     return result
1823
1824
1825 gradle_comment = re.compile(r'[ ]*//')
1826 gradle_signing_configs = re.compile(r'^[\t ]*signingConfigs[ \t]*{[ \t]*$')
1827 gradle_line_matches = [
1828     re.compile(r'^[\t ]*signingConfig [^ ]*$'),
1829     re.compile(r'.*android\.signingConfigs\.[^{]*$'),
1830     re.compile(r'.*\.readLine\(.*'),
1831 ]
1832
1833
1834 def remove_signing_keys(build_dir):
1835     for root, dirs, files in os.walk(build_dir):
1836         if 'build.gradle' in files:
1837             path = os.path.join(root, 'build.gradle')
1838
1839             with open(path, "r", encoding='utf8') as o:
1840                 lines = o.readlines()
1841
1842             changed = False
1843
1844             opened = 0
1845             i = 0
1846             with open(path, "w", encoding='utf8') as o:
1847                 while i < len(lines):
1848                     line = lines[i]
1849                     i += 1
1850                     while line.endswith('\\\n'):
1851                         line = line.rstrip('\\\n') + lines[i]
1852                         i += 1
1853
1854                     if gradle_comment.match(line):
1855                         o.write(line)
1856                         continue
1857
1858                     if opened > 0:
1859                         opened += line.count('{')
1860                         opened -= line.count('}')
1861                         continue
1862
1863                     if gradle_signing_configs.match(line):
1864                         changed = True
1865                         opened += 1
1866                         continue
1867
1868                     if any(s.match(line) for s in gradle_line_matches):
1869                         changed = True
1870                         continue
1871
1872                     if opened == 0:
1873                         o.write(line)
1874
1875             if changed:
1876                 logging.info("Cleaned build.gradle of keysigning configs at %s" % path)
1877
1878         for propfile in [
1879                 'project.properties',
1880                 'build.properties',
1881                 'default.properties',
1882                 'ant.properties', ]:
1883             if propfile in files:
1884                 path = os.path.join(root, propfile)
1885
1886                 with open(path, "r", encoding='iso-8859-1') as o:
1887                     lines = o.readlines()
1888
1889                 changed = False
1890
1891                 with open(path, "w", encoding='iso-8859-1') as o:
1892                     for line in lines:
1893                         if any(line.startswith(s) for s in ('key.store', 'key.alias')):
1894                             changed = True
1895                             continue
1896
1897                         o.write(line)
1898
1899                 if changed:
1900                     logging.info("Cleaned %s of keysigning configs at %s" % (propfile, path))
1901
1902
1903 def set_FDroidPopen_env(build=None):
1904     '''
1905     set up the environment variables for the build environment
1906
1907     There is only a weak standard, the variables used by gradle, so also set
1908     up the most commonly used environment variables for SDK and NDK.  Also, if
1909     there is no locale set, this will set the locale (e.g. LANG) to en_US.UTF-8.
1910     '''
1911     global env, orig_path
1912
1913     if env is None:
1914         env = os.environ
1915         orig_path = env['PATH']
1916         for n in ['ANDROID_HOME', 'ANDROID_SDK']:
1917             env[n] = config['sdk_path']
1918         for k, v in config['java_paths'].items():
1919             env['JAVA%s_HOME' % k] = v
1920
1921     missinglocale = True
1922     for k, v in env.items():
1923         if k == 'LANG' and v != 'C':
1924             missinglocale = False
1925         elif k == 'LC_ALL':
1926             missinglocale = False
1927     if missinglocale:
1928         env['LANG'] = 'en_US.UTF-8'
1929
1930     if build is not None:
1931         path = build.ndk_path()
1932         paths = orig_path.split(os.pathsep)
1933         if path not in paths:
1934             paths = [path] + paths
1935             env['PATH'] = os.pathsep.join(paths)
1936         for n in ['ANDROID_NDK', 'NDK', 'ANDROID_NDK_HOME']:
1937             env[n] = build.ndk_path()
1938
1939
1940 def replace_build_vars(cmd, build):
1941     cmd = cmd.replace('$$COMMIT$$', build.commit)
1942     cmd = cmd.replace('$$VERSION$$', build.versionName)
1943     cmd = cmd.replace('$$VERCODE$$', build.versionCode)
1944     return cmd
1945
1946
1947 def replace_config_vars(cmd, build):
1948     cmd = cmd.replace('$$SDK$$', config['sdk_path'])
1949     cmd = cmd.replace('$$NDK$$', build.ndk_path())
1950     cmd = cmd.replace('$$MVN3$$', config['mvn3'])
1951     cmd = cmd.replace('$$QT$$', config['qt_sdk_path'] or '')
1952     if build is not None:
1953         cmd = replace_build_vars(cmd, build)
1954     return cmd
1955
1956
1957 def place_srclib(root_dir, number, libpath):
1958     if not number:
1959         return
1960     relpath = os.path.relpath(libpath, root_dir)
1961     proppath = os.path.join(root_dir, 'project.properties')
1962
1963     lines = []
1964     if os.path.isfile(proppath):
1965         with open(proppath, "r", encoding='iso-8859-1') as o:
1966             lines = o.readlines()
1967
1968     with open(proppath, "w", encoding='iso-8859-1') as o:
1969         placed = False
1970         for line in lines:
1971             if line.startswith('android.library.reference.%d=' % number):
1972                 o.write('android.library.reference.%d=%s\n' % (number, relpath))
1973                 placed = True
1974             else:
1975                 o.write(line)
1976         if not placed:
1977             o.write('android.library.reference.%d=%s\n' % (number, relpath))
1978
1979
1980 apk_sigfile = re.compile(r'META-INF/[0-9A-Za-z]+\.(SF|RSA|DSA|EC)')
1981
1982
1983 def verify_apks(signed_apk, unsigned_apk, tmp_dir):
1984     """Verify that two apks are the same
1985
1986     One of the inputs is signed, the other is unsigned. The signature metadata
1987     is transferred from the signed to the unsigned apk, and then jarsigner is
1988     used to verify that the signature from the signed apk is also varlid for
1989     the unsigned one.  If the APK given as unsigned actually does have a
1990     signature, it will be stripped out and ignored.
1991
1992     There are two SHA1 git commit IDs that fdroidserver includes in the builds
1993     it makes: fdroidserverid and buildserverid.  Originally, these were inserted
1994     into AndroidManifest.xml, but that makes the build not reproducible. So
1995     instead they are included as separate files in the APK's META-INF/ folder.
1996     If those files exist in the signed APK, they will be part of the signature
1997     and need to also be included in the unsigned APK for it to validate.
1998
1999     :param signed_apk: Path to a signed apk file
2000     :param unsigned_apk: Path to an unsigned apk file expected to match it
2001     :param tmp_dir: Path to directory for temporary files
2002     :returns: None if the verification is successful, otherwise a string
2003               describing what went wrong.
2004     """
2005
2006     signed = ZipFile(signed_apk, 'r')
2007     meta_inf_files = ['META-INF/MANIFEST.MF']
2008     for f in signed.namelist():
2009         if apk_sigfile.match(f) \
2010            or f in ['META-INF/fdroidserverid', 'META-INF/buildserverid']:
2011             meta_inf_files.append(f)
2012     if len(meta_inf_files) < 3:
2013         return "Signature files missing from {0}".format(signed_apk)
2014
2015     tmp_apk = os.path.join(tmp_dir, 'sigcp_' + os.path.basename(unsigned_apk))
2016     unsigned = ZipFile(unsigned_apk, 'r')
2017     # only read the signature from the signed APK, everything else from unsigned
2018     with ZipFile(tmp_apk, 'w') as tmp:
2019         for filename in meta_inf_files:
2020             tmp.writestr(signed.getinfo(filename), signed.read(filename))
2021         for info in unsigned.infolist():
2022             if info.filename in meta_inf_files:
2023                 logging.warning('Ignoring ' + info.filename + ' from ' + unsigned_apk)
2024                 continue
2025             if info.filename in tmp.namelist():
2026                 return "duplicate filename found: " + info.filename
2027             tmp.writestr(info, unsigned.read(info.filename))
2028     unsigned.close()
2029     signed.close()
2030
2031     verified = verify_apk_signature(tmp_apk)
2032
2033     if not verified:
2034         logging.info("...NOT verified - {0}".format(tmp_apk))
2035         return compare_apks(signed_apk, tmp_apk, tmp_dir, os.path.dirname(unsigned_apk))
2036
2037     logging.info("...successfully verified")
2038     return None
2039
2040
2041 def verify_apk_signature(apk, jar=False):
2042     """verify the signature on an APK
2043
2044     Try to use apksigner whenever possible since jarsigner is very
2045     shitty: unsigned APKs pass as "verified"! So this has to turn on
2046     -strict then check for result 4.
2047
2048     You can set :param: jar to True if you want to use this method
2049     to verify jar signatures.
2050     """
2051     if set_command_in_config('apksigner'):
2052         args = [config['apksigner'], 'verify']
2053         if jar:
2054             args += ['--min-sdk-version=1']
2055         return subprocess.call(args + [apk]) == 0
2056     else:
2057         logging.warning("Using Java's jarsigner, not recommended for verifying APKs! Use apksigner")
2058         return subprocess.call([config['jarsigner'], '-strict', '-verify', apk]) == 4
2059
2060
2061 apk_badchars = re.compile('''[/ :;'"]''')
2062
2063
2064 def compare_apks(apk1, apk2, tmp_dir, log_dir=None):
2065     """Compare two apks
2066
2067     Returns None if the apk content is the same (apart from the signing key),
2068     otherwise a string describing what's different, or what went wrong when
2069     trying to do the comparison.
2070     """
2071
2072     if not log_dir:
2073         log_dir = tmp_dir
2074
2075     absapk1 = os.path.abspath(apk1)
2076     absapk2 = os.path.abspath(apk2)
2077
2078     if set_command_in_config('diffoscope'):
2079         logfilename = os.path.join(log_dir, os.path.basename(absapk1))
2080         htmlfile = logfilename + '.diffoscope.html'
2081         textfile = logfilename + '.diffoscope.txt'
2082         if subprocess.call([config['diffoscope'],
2083                             '--max-report-size', '12345678', '--max-diff-block-lines', '100',
2084                             '--html', htmlfile, '--text', textfile,
2085                             absapk1, absapk2]) != 0:
2086             return("Failed to unpack " + apk1)
2087
2088     apk1dir = os.path.join(tmp_dir, apk_badchars.sub('_', apk1[0:-4]))  # trim .apk
2089     apk2dir = os.path.join(tmp_dir, apk_badchars.sub('_', apk2[0:-4]))  # trim .apk
2090     for d in [apk1dir, apk2dir]:
2091         if os.path.exists(d):
2092             shutil.rmtree(d)
2093         os.mkdir(d)
2094         os.mkdir(os.path.join(d, 'jar-xf'))
2095
2096     if subprocess.call(['jar', 'xf',
2097                         os.path.abspath(apk1)],
2098                        cwd=os.path.join(apk1dir, 'jar-xf')) != 0:
2099         return("Failed to unpack " + apk1)
2100     if subprocess.call(['jar', 'xf',
2101                         os.path.abspath(apk2)],
2102                        cwd=os.path.join(apk2dir, 'jar-xf')) != 0:
2103         return("Failed to unpack " + apk2)
2104
2105     if set_command_in_config('apktool'):
2106         if subprocess.call([config['apktool'], 'd', os.path.abspath(apk1), '--output', 'apktool'],
2107                            cwd=apk1dir) != 0:
2108             return("Failed to unpack " + apk1)
2109         if subprocess.call([config['apktool'], 'd', os.path.abspath(apk2), '--output', 'apktool'],
2110                            cwd=apk2dir) != 0:
2111             return("Failed to unpack " + apk2)
2112
2113     p = FDroidPopen(['diff', '-r', apk1dir, apk2dir], output=False)
2114     lines = p.output.splitlines()
2115     if len(lines) != 1 or 'META-INF' not in lines[0]:
2116         meld = find_command('meld')
2117         if meld is not None:
2118             p = FDroidPopen(['meld', apk1dir, apk2dir], output=False)
2119         return("Unexpected diff output - " + p.output)
2120
2121     # since everything verifies, delete the comparison to keep cruft down
2122     shutil.rmtree(apk1dir)
2123     shutil.rmtree(apk2dir)
2124
2125     # If we get here, it seems like they're the same!
2126     return None
2127
2128
2129 def set_command_in_config(command):
2130     '''Try to find specified command in the path, if it hasn't been
2131     manually set in config.py.  If found, it is added to the config
2132     dict.  The return value says whether the command is available.
2133
2134     '''
2135     if command in config:
2136         return True
2137     else:
2138         tmp = find_command(command)
2139         if tmp is not None:
2140             config[command] = tmp
2141             return True
2142     return False
2143
2144
2145 def find_command(command):
2146     '''find the full path of a command, or None if it can't be found in the PATH'''
2147
2148     def is_exe(fpath):
2149         return os.path.isfile(fpath) and os.access(fpath, os.X_OK)
2150
2151     fpath, fname = os.path.split(command)
2152     if fpath:
2153         if is_exe(command):
2154             return command
2155     else:
2156         for path in os.environ["PATH"].split(os.pathsep):
2157             path = path.strip('"')
2158             exe_file = os.path.join(path, command)
2159             if is_exe(exe_file):
2160                 return exe_file
2161
2162     return None
2163
2164
2165 def genpassword():
2166     '''generate a random password for when generating keys'''
2167     h = hashlib.sha256()
2168     h.update(os.urandom(16))  # salt
2169     h.update(socket.getfqdn().encode('utf-8'))
2170     passwd = base64.b64encode(h.digest()).strip()
2171     return passwd.decode('utf-8')
2172
2173
2174 def genkeystore(localconfig):
2175     """
2176     Generate a new key with password provided in :param localconfig and add it to new keystore
2177     :return: hexed public key, public key fingerprint
2178     """
2179     logging.info('Generating a new key in "' + localconfig['keystore'] + '"...')
2180     keystoredir = os.path.dirname(localconfig['keystore'])
2181     if keystoredir is None or keystoredir == '':
2182         keystoredir = os.path.join(os.getcwd(), keystoredir)
2183     if not os.path.exists(keystoredir):
2184         os.makedirs(keystoredir, mode=0o700)
2185
2186     write_password_file("keystorepass", localconfig['keystorepass'])
2187     write_password_file("keypass", localconfig['keypass'])
2188     p = FDroidPopen([config['keytool'], '-genkey',
2189                      '-keystore', localconfig['keystore'],
2190                      '-alias', localconfig['repo_keyalias'],
2191                      '-keyalg', 'RSA', '-keysize', '4096',
2192                      '-sigalg', 'SHA256withRSA',
2193                      '-validity', '10000',
2194                      '-storepass:file', config['keystorepassfile'],
2195                      '-keypass:file', config['keypassfile'],
2196                      '-dname', localconfig['keydname']])
2197     # TODO keypass should be sent via stdin
2198     if p.returncode != 0:
2199         raise BuildException("Failed to generate key", p.output)
2200     os.chmod(localconfig['keystore'], 0o0600)
2201     if not options.quiet:
2202         # now show the lovely key that was just generated
2203         p = FDroidPopen([config['keytool'], '-list', '-v',
2204                          '-keystore', localconfig['keystore'],
2205                          '-alias', localconfig['repo_keyalias'],
2206                          '-storepass:file', config['keystorepassfile']])
2207         logging.info(p.output.strip() + '\n\n')
2208     # get the public key
2209     p = FDroidPopenBytes([config['keytool'], '-exportcert',
2210                           '-keystore', localconfig['keystore'],
2211                           '-alias', localconfig['repo_keyalias'],
2212                           '-storepass:file', config['keystorepassfile']]
2213                          + config['smartcardoptions'],
2214                          output=False, stderr_to_stdout=False)
2215     if p.returncode != 0 or len(p.output) < 20:
2216         raise BuildException("Failed to get public key", p.output)
2217     pubkey = p.output
2218     fingerprint = get_cert_fingerprint(pubkey)
2219     return hexlify(pubkey), fingerprint
2220
2221
2222 def get_cert_fingerprint(pubkey):
2223     """
2224     Generate a certificate fingerprint the same way keytool does it
2225     (but with slightly different formatting)
2226     """
2227     digest = hashlib.sha256(pubkey).digest()
2228     ret = [' '.join("%02X" % b for b in bytearray(digest))]
2229     return " ".join(ret)
2230
2231
2232 def get_certificate(certificate_file):
2233     """
2234     Extracts a certificate from the given file.
2235     :param certificate_file: file bytes (as string) representing the certificate
2236     :return: A binary representation of the certificate's public key, or None in case of error
2237     """
2238     content = decoder.decode(certificate_file, asn1Spec=rfc2315.ContentInfo())[0]
2239     if content.getComponentByName('contentType') != rfc2315.signedData:
2240         return None
2241     content = decoder.decode(content.getComponentByName('content'),
2242                              asn1Spec=rfc2315.SignedData())[0]
2243     try:
2244         certificates = content.getComponentByName('certificates')
2245         cert = certificates[0].getComponentByName('certificate')
2246     except PyAsn1Error:
2247         logging.error("Certificates not found.")
2248         return None
2249     return encoder.encode(cert)
2250
2251
2252 def write_to_config(thisconfig, key, value=None, config_file=None):
2253     '''write a key/value to the local config.py
2254
2255     NOTE: only supports writing string variables.
2256
2257     :param thisconfig: config dictionary
2258     :param key: variable name in config.py to be overwritten/added
2259     :param value: optional value to be written, instead of fetched
2260         from 'thisconfig' dictionary.
2261     '''
2262     if value is None:
2263         origkey = key + '_orig'
2264         value = thisconfig[origkey] if origkey in thisconfig else thisconfig[key]
2265     cfg = config_file if config_file else 'config.py'
2266
2267     # load config file
2268     with open(cfg, 'r', encoding="utf-8") as f:
2269         lines = f.readlines()
2270
2271     # make sure the file ends with a carraige return
2272     if len(lines) > 0:
2273         if not lines[-1].endswith('\n'):
2274             lines[-1] += '\n'
2275
2276     # regex for finding and replacing python string variable
2277     # definitions/initializations
2278     pattern = re.compile('^[\s#]*' + key + '\s*=\s*"[^"]*"')
2279     repl = key + ' = "' + value + '"'
2280     pattern2 = re.compile('^[\s#]*' + key + "\s*=\s*'[^']*'")
2281     repl2 = key + " = '" + value + "'"
2282
2283     # If we replaced this line once, we make sure won't be a
2284     # second instance of this line for this key in the document.
2285     didRepl = False
2286     # edit config file
2287     with open(cfg, 'w', encoding="utf-8") as f:
2288         for line in lines:
2289             if pattern.match(line) or pattern2.match(line):
2290                 if not didRepl:
2291                     line = pattern.sub(repl, line)
2292                     line = pattern2.sub(repl2, line)
2293                     f.write(line)
2294                     didRepl = True
2295             else:
2296                 f.write(line)
2297         if not didRepl:
2298             f.write('\n')
2299             f.write(repl)
2300             f.write('\n')
2301
2302
2303 def parse_xml(path):
2304     return XMLElementTree.parse(path).getroot()
2305
2306
2307 def string_is_integer(string):
2308     try:
2309         int(string)
2310         return True
2311     except ValueError:
2312         return False
2313
2314
2315 def get_per_app_repos():
2316     '''per-app repos are dirs named with the packageName of a single app'''
2317
2318     # Android packageNames are Java packages, they may contain uppercase or
2319     # lowercase letters ('A' through 'Z'), numbers, and underscores
2320     # ('_'). However, individual package name parts may only start with
2321     # letters. https://developer.android.com/guide/topics/manifest/manifest-element.html#package
2322     p = re.compile('^([a-zA-Z][a-zA-Z0-9_]*(\\.[a-zA-Z][a-zA-Z0-9_]*)*)?$')
2323
2324     repos = []
2325     for root, dirs, files in os.walk(os.getcwd()):
2326         for d in dirs:
2327             print('checking', root, 'for', d)
2328             if d in ('archive', 'metadata', 'repo', 'srclibs', 'tmp'):
2329                 # standard parts of an fdroid repo, so never packageNames
2330                 continue
2331             elif p.match(d) \
2332                     and os.path.exists(os.path.join(d, 'fdroid', 'repo', 'index.jar')):
2333                 repos.append(d)
2334         break
2335     return repos
2336
2337
2338 def is_repo_file(filename):
2339     '''Whether the file in a repo is a build product to be delivered to users'''
2340     if isinstance(filename, str):
2341         filename = filename.encode('utf-8', errors="surrogateescape")
2342     return os.path.isfile(filename) \
2343         and not filename.endswith(b'.asc') \
2344         and not filename.endswith(b'.sig') \
2345         and os.path.basename(filename) not in [
2346             b'index.jar',
2347             b'index_unsigned.jar',
2348             b'index.xml',
2349             b'index.html',
2350             b'index-v1.jar',
2351             b'index-v1.json',
2352             b'categories.txt',
2353         ]
2354
2355
2356 def make_binary_transparency_log(repodirs):
2357     '''Log the indexes in a standalone git repo to serve as a "binary
2358     transparency" log.
2359
2360     see: https://www.eff.org/deeplinks/2014/02/open-letter-to-tech-companies
2361
2362     '''
2363
2364     import git
2365     btrepo = 'binary_transparency'
2366     if os.path.exists(os.path.join(btrepo, '.git')):
2367         gitrepo = git.Repo(btrepo)
2368     else:
2369         if not os.path.exists(btrepo):
2370             os.mkdir(btrepo)
2371         gitrepo = git.Repo.init(btrepo)
2372
2373         gitconfig = gitrepo.config_writer()
2374         gitconfig.set_value('user', 'name', 'fdroid update')
2375         gitconfig.set_value('user', 'email', 'fdroid@' + platform.node())
2376
2377         url = config['repo_url'].rstrip('/')
2378         with open(os.path.join(btrepo, 'README.md'), 'w') as fp:
2379             fp.write("""
2380 # Binary Transparency Log for %s
2381
2382 """ % url[:url.rindex('/')])  # strip '/repo'
2383         gitrepo.index.add(['README.md', ])
2384         gitrepo.index.commit('add README')
2385
2386     for repodir in repodirs:
2387         cpdir = os.path.join(btrepo, repodir)
2388         if not os.path.exists(cpdir):
2389             os.mkdir(cpdir)
2390         for f in ('index.xml', 'index-v1.json'):
2391             dest = os.path.join(cpdir, f)
2392             shutil.copyfile(os.path.join(repodir, f), dest)
2393             gitrepo.index.add([os.path.join(repodir, f), ])
2394         for f in ('index.jar', 'index-v1.jar'):
2395             repof = os.path.join(repodir, f)
2396             dest = os.path.join(cpdir, f)
2397             jarin = ZipFile(repof, 'r')
2398             jarout = ZipFile(dest, 'w')
2399             for info in jarin.infolist():
2400                 if info.filename.startswith('META-INF/'):
2401                     jarout.writestr(info, jarin.read(info.filename))
2402             jarout.close()
2403             jarin.close()
2404             gitrepo.index.add([repof, ])
2405
2406         files = []
2407         for root, dirs, filenames in os.walk(repodir):
2408             for f in filenames:
2409                 files.append(os.path.relpath(os.path.join(root, f), repodir))
2410         output = collections.OrderedDict()
2411         for f in sorted(files):
2412             repofile = os.path.join(repodir, f)
2413             stat = os.stat(repofile)
2414             output[f] = (
2415                 stat.st_size,
2416                 stat.st_ctime_ns,
2417                 stat.st_mtime_ns,
2418                 stat.st_mode,
2419                 stat.st_uid,
2420                 stat.st_gid,
2421             )
2422         fslogfile = os.path.join(cpdir, 'filesystemlog.json')
2423         with open(fslogfile, 'w') as fp:
2424             json.dump(output, fp, indent=2)
2425         gitrepo.index.add([os.path.join(repodir, 'filesystemlog.json'), ])
2426
2427     gitrepo.index.commit('fdroid update')