Inside Bitcoin

1#!/usr/bin/env python3
2#
3# Copyright (C) 2011  Patrick "p2k" Schneider <[email protected]>
4#
5# This program is free software: you can redistribute it and/or modify
6# it under the terms of the GNU General Public License as published by
7# the Free Software Foundation, either version 3 of the License, or
8# (at your option) any later version.
9#
10# This program is distributed in the hope that it will be useful,
11# but WITHOUT ANY WARRANTY; without even the implied warranty of
12# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13# GNU General Public License for more details.
14#
15# You should have received a copy of the GNU General Public License
16# along with this program.  If not, see <http://www.gnu.org/licenses/>.
17#
18
19import sys, re, os, platform, shutil, stat, subprocess, os.path
20from argparse import ArgumentParser
21from pathlib import Path
22from subprocess import PIPE, run
23from typing import Optional
24
25# This is ported from the original macdeployqt with modifications
26
27class FrameworkInfo(object):
28    def __init__(self):
29        self.frameworkDirectory = ""
30        self.frameworkName = ""
31        self.frameworkPath = ""
32        self.binaryDirectory = ""
33        self.binaryName = ""
34        self.binaryPath = ""
35        self.version = ""
36        self.installName = ""
37        self.deployedInstallName = ""
38        self.sourceFilePath = ""
39        self.destinationDirectory = ""
40        self.sourceResourcesDirectory = ""
41        self.sourceVersionContentsDirectory = ""
42        self.sourceContentsDirectory = ""
43        self.destinationResourcesDirectory = ""
44        self.destinationVersionContentsDirectory = ""
45
46    def __eq__(self, other):
47        if self.__class__ == other.__class__:
48            return self.__dict__ == other.__dict__
49        else:
50            return False
51
52    def __str__(self):
53        return f""" Framework name: {self.frameworkName}
54 Framework directory: {self.frameworkDirectory}
55 Framework path: {self.frameworkPath}
56 Binary name: {self.binaryName}
57 Binary directory: {self.binaryDirectory}
58 Binary path: {self.binaryPath}
59 Version: {self.version}
60 Install name: {self.installName}
61 Deployed install name: {self.deployedInstallName}
62 Source file Path: {self.sourceFilePath}
63 Deployed Directory (relative to bundle): {self.destinationDirectory}
64"""
65
66    def isDylib(self):
67        return self.frameworkName.endswith(".dylib")
68
69    def isQtFramework(self):
70        if self.isDylib():
71            return self.frameworkName.startswith("libQt")
72        else:
73            return self.frameworkName.startswith("Qt")
74
75    reOLine = re.compile(r'^(.+) \(compatibility version [0-9.]+, current version [0-9.]+\)$')
76    bundleFrameworkDirectory = "Contents/Frameworks"
77    bundleBinaryDirectory = "Contents/MacOS"
78
79    @classmethod
80    def fromLibraryLine(cls, line: str) -> Optional['FrameworkInfo']:
81        # Note: line must be trimmed
82        if line == "":
83            return None
84
85        # Don't deploy system libraries
86        if line.startswith("/System/Library/") or line.startswith("@executable_path") or line.startswith("/usr/lib/"):
87            return None
88
89        m = cls.reOLine.match(line)
90        if m is None:
91            raise RuntimeError(f"Line could not be parsed: {line}")
92
93        path = m.group(1)
94
95        info = cls()
96        info.sourceFilePath = path
97        info.installName = path
98
99        if path.endswith(".dylib"):
100            dirname, filename = os.path.split(path)
101            info.frameworkName = filename
102            info.frameworkDirectory = dirname
103            info.frameworkPath = path
104
105            info.binaryDirectory = dirname
106            info.binaryName = filename
107            info.binaryPath = path
108            info.version = "-"
109
110            info.installName = path
111            info.deployedInstallName = f"@executable_path/../Frameworks/{info.binaryName}"
112            info.sourceFilePath = path
113            info.destinationDirectory = cls.bundleFrameworkDirectory
114        else:
115            parts = path.split("/")
116            i = 0
117            # Search for the .framework directory
118            for part in parts:
119                if part.endswith(".framework"):
120                    break
121                i += 1
122            if i == len(parts):
123                raise RuntimeError(f"Could not find .framework or .dylib in line: {line}")
124
125            info.frameworkName = parts[i]
126            info.frameworkDirectory = "/".join(parts[:i])
127            info.frameworkPath = os.path.join(info.frameworkDirectory, info.frameworkName)
128
129            info.binaryName = parts[i+3]
130            info.binaryDirectory = "/".join(parts[i+1:i+3])
131            info.binaryPath = os.path.join(info.binaryDirectory, info.binaryName)
132            info.version = parts[i+2]
133
134            info.deployedInstallName = f"@executable_path/../Frameworks/{os.path.join(info.frameworkName, info.binaryPath)}"
135            info.destinationDirectory = os.path.join(cls.bundleFrameworkDirectory, info.frameworkName, info.binaryDirectory)
136
137            info.sourceResourcesDirectory = os.path.join(info.frameworkPath, "Resources")
138            info.sourceContentsDirectory = os.path.join(info.frameworkPath, "Contents")
139            info.sourceVersionContentsDirectory = os.path.join(info.frameworkPath, "Versions", info.version, "Contents")
140            info.destinationResourcesDirectory = os.path.join(cls.bundleFrameworkDirectory, info.frameworkName, "Resources")
141            info.destinationVersionContentsDirectory = os.path.join(cls.bundleFrameworkDirectory, info.frameworkName, "Versions", info.version, "Contents")
142
143        return info
144
145class ApplicationBundleInfo(object):
146    def __init__(self, path: str):
147        self.path = path
148        # for backwards compatibility reasons, this must remain as Bitcoin-Qt
149        self.binaryPath = os.path.join(path, "Contents", "MacOS", "Bitcoin-Qt")
150        if not os.path.exists(self.binaryPath):
151            raise RuntimeError(f"Could not find bundle binary for {path}")
152        self.resourcesPath = os.path.join(path, "Contents", "Resources")
153        self.pluginPath = os.path.join(path, "Contents", "PlugIns")
154
155class DeploymentInfo(object):
156    def __init__(self):
157        self.qtPath = None
158        self.pluginPath = None
159        self.deployedFrameworks = []
160
161    def detectQtPath(self, frameworkDirectory: str):
162        parentDir = os.path.dirname(frameworkDirectory)
163        if os.path.exists(os.path.join(parentDir, "share", "qt", "plugins")):
164            self.qtPath = parentDir
165        else:
166            self.qtPath = os.getenv("QTDIR", None)
167
168        if self.qtPath is not None:
169            pluginPath = os.path.join(self.qtPath, "share", "qt", "plugins")
170            if os.path.exists(pluginPath):
171                self.pluginPath = pluginPath
172
173    def usesFramework(self, name: str) -> bool:
174        for framework in self.deployedFrameworks:
175            if framework.endswith(".framework"):
176                if framework.startswith(f"{name}."):
177                    return True
178            elif framework.endswith(".dylib"):
179                if framework.startswith(f"lib{name}."):
180                    return True
181        return False
182
183def getFrameworks(binaryPath: str, verbose: int, rpath: str = '') -> list[FrameworkInfo]:
184    objdump = os.getenv("OBJDUMP", "objdump")
185    if verbose:
186        print(f"Inspecting with {objdump}: {binaryPath}")
187    output = run([objdump, "--macho", "--dylibs-used", binaryPath], stdout=PIPE, stderr=PIPE, text=True)
188    if output.returncode != 0:
189        sys.stderr.write(output.stderr)
190        sys.stderr.flush()
191        raise RuntimeError(f"{objdump} failed with return code {output.returncode}")
192
193    lines = output.stdout.split("\n")
194    lines.pop(0) # First line is the inspected binary
195    if ".framework" in binaryPath or binaryPath.endswith(".dylib"):
196        lines.pop(0) # Frameworks and dylibs list themselves as a dependency.
197
198    libraries = []
199    for line in lines:
200        line = line.replace("@loader_path", os.path.dirname(binaryPath))
201        if rpath:
202            line = line.replace("@rpath", rpath)
203        info = FrameworkInfo.fromLibraryLine(line.strip())
204        if info is not None:
205            if verbose:
206                print("Found framework:")
207                print(info)
208            libraries.append(info)
209
210    return libraries
211
212def runInstallNameTool(action: str, *args):
213    installnametoolbin=os.getenv("INSTALL_NAME_TOOL", "install_name_tool")
214    run([installnametoolbin, "-"+action] + list(args), check=True)
215
216def changeInstallName(oldName: str, newName: str, binaryPath: str, verbose: int):
217    if verbose:
218        print("Using install_name_tool:")
219        print(" in", binaryPath)
220        print(" change reference", oldName)
221        print(" to", newName)
222    runInstallNameTool("change", oldName, newName, binaryPath)
223
224def changeIdentification(id: str, binaryPath: str, verbose: int):
225    if verbose:
226        print("Using install_name_tool:")
227        print(" change identification in", binaryPath)
228        print(" to", id)
229    runInstallNameTool("id", id, binaryPath)
230
231def runStrip(binaryPath: str, verbose: int):
232    stripbin=os.getenv("STRIP", "strip")
233    if verbose:
234        print("Using strip:")
235        print(" stripped", binaryPath)
236    run([stripbin, "-x", binaryPath], check=True)
237
238def copyFramework(framework: FrameworkInfo, path: str, verbose: int) -> Optional[str]:
239    if framework.sourceFilePath.startswith("Qt"):
240        #standard place for Nokia Qt installer's frameworks
241        fromPath = f"/Library/Frameworks/{framework.sourceFilePath}"
242    else:
243        fromPath = framework.sourceFilePath
244    toDir = os.path.join(path, framework.destinationDirectory)
245    toPath = os.path.join(toDir, framework.binaryName)
246
247    if framework.isDylib():
248        if not os.path.exists(fromPath):
249            raise RuntimeError(f"No file at {fromPath}")
250