update ffmpeg.git files for newer versions
[goodguy/cinelerra.git] / cinelerra-5.1 / tools / makeappimagetool / elf_file.cpp
1 // system includes
2 #include <fstream>
3 #include <memory>
4 #include <utility>
5 #include <fcntl.h>
6
7 // library includes
8 #include <boost/regex.hpp>
9 #include <sys/mman.h>
10
11 // local includes
12 #include "includes/elf_file.h"
13 #include "includes/log.h"
14 #include "includes/util.h"
15 #include "includes/subprocess.h"
16
17 using namespace linuxdeploy::core::log;
18
19 namespace bf = boost::filesystem;
20
21 namespace linuxdeploy {
22     namespace core {
23         namespace elf_file {
24             class ElfFile::PrivateData {
25                 public:
26                     const bf::path path;
27                     uint8_t elfClass = ELFCLASSNONE;
28                     uint8_t elfABI = 0;
29                     bool isDebugSymbolsFile = false;
30                     bool isDynamicallyLinked = false;
31
32                 public:
33                     explicit PrivateData(bf::path path) : path(std::move(path)) {}
34
35                 public:
36                     static std::string getPatchelfPath() {
37                         // by default, try to use a patchelf next to the makeappimage binary
38                         // if that isn't available, fall back to searching for patchelf in the PATH
39                         std::string patchelfPath;
40
41                         const auto envPatchelf = getenv("PATCHELF");
42
43                         // allows users to use a custom patchelf instead of the bundled one
44                         if (envPatchelf != nullptr) {
45                             ldLog() << LD_DEBUG << "Using patchelf specified in $PATCHELF:" << envPatchelf << std::endl;
46                             patchelfPath = envPatchelf;
47                         } else {
48                             auto binDirPath = bf::path(util::getOwnExecutablePath());
49                             auto localPatchelfPath = binDirPath.parent_path() / "patchelf";
50
51                             if (bf::exists(localPatchelfPath)) {
52                                 patchelfPath = localPatchelfPath.string();
53                             } else {
54                                 for (const bf::path directory : util::split(getenv("PATH"), ':')) {
55                                     if (!bf::is_directory(directory))
56                                         continue;
57
58                                     auto path = directory / "patchelf";
59
60                                     if (bf::is_regular_file(path)) {
61                                         patchelfPath = path.string();
62                                         break;
63                                     }
64                                 }
65                             }
66                         }
67
68                         if (!bf::is_regular_file(patchelfPath)) {
69                             ldLog() << LD_ERROR << "Could not find patchelf: no such file:" << patchelfPath << std::endl;
70                             throw std::runtime_error("Could not find patchelf");
71                         }
72
73                         ldLog() << LD_DEBUG << "Using patchelf:" << patchelfPath << std::endl;
74                         return patchelfPath;
75                     }
76
77                 private:
78                     template<typename Ehdr_T, typename Shdr_T, typename Phdr_T>
79                     void parseElfHeader(std::shared_ptr<uint8_t> data) {
80                         // TODO: the following code will _only_ work if the native byte order equals the program's
81                         // this should not be a big problem as we don't offer ARM builds yet, and require the user to
82                         // use a matching binary for the target binaries
83
84                         auto* ehdr = reinterpret_cast<Ehdr_T*>(data.get());
85
86                         elfABI = ehdr->e_ident[EI_OSABI];
87
88                         std::vector<Shdr_T> sections;
89
90                         // parse section header table
91                         // first, we collect all entries in a vector so we can conveniently iterate over it
92                         for (uint64_t i = 0; i < ehdr->e_shnum; ++i) {
93                             auto* nextShdr = reinterpret_cast<Shdr_T*>(data.get() + ehdr->e_shoff + i * sizeof(Shdr_T));
94                             sections.emplace_back(*nextShdr);
95                         }
96
97                         auto getString = [data, &sections, ehdr](uint64_t offset) {
98                             assert(ehdr->e_shstrndx != SHN_UNDEF);
99                             const auto& stringTableSection = sections[ehdr->e_shstrndx];
100                             return std::string{reinterpret_cast<char*>(data.get() + stringTableSection.sh_offset + offset)};
101                         };
102
103                         // now that we can look up texts, we can create a map to easily access the sections by name
104                         std::unordered_map<std::string, Shdr_T> sectionsMap;
105                         std::for_each(sections.begin(), sections.end(), [&sectionsMap, &getString](const Shdr_T& shdr) {
106                             const auto headerName = getString(shdr.sh_name);
107                             sectionsMap.insert(std::make_pair(headerName, shdr));
108                         });
109
110                         // this function is based on observations of the behavior of:
111                         // - strip --only-keep-debug
112                         // - objcopy --only-keep-debug
113                         isDebugSymbolsFile = (sectionsMap[".text"].sh_type == SHT_NOBITS);
114
115                         // https://stackoverflow.com/a/7298931
116                         for (uint64_t i = 0; i < ehdr->e_phnum && !isDynamicallyLinked; ++i) {
117                             auto* nextPhdr = reinterpret_cast<Phdr_T*>(data.get() + ehdr->e_phoff + i * sizeof(Phdr_T));
118                             switch (nextPhdr->p_type) {
119                                 case PT_DYNAMIC:
120                                 case PT_INTERP:
121                                     isDynamicallyLinked = true;
122                                     break;
123                             }
124                         }
125                     }
126
127                 public:
128                     void readDataUsingElfAPI() {
129                         int fd = open(path.c_str(), O_RDONLY);
130                         auto map_size = static_cast<size_t>(lseek(fd, 0, SEEK_END));
131
132                         std::shared_ptr<uint8_t> data(
133                             static_cast<uint8_t*>(mmap(nullptr, map_size, PROT_READ, MAP_SHARED, fd, 0)),
134                             [map_size](uint8_t* p) {
135                                 if (munmap(static_cast<void*>(p), map_size) != 0) {
136                                     int error = errno;
137                                     throw ElfFileParseError(std::string("Failed to call munmap(): ") + strerror(error));
138                                 }
139                                 p = nullptr;
140                             }
141                         );
142                         close(fd);
143
144                         // check which ELF "class" (32-bit or 64-bit) to use
145                         // the "class" is available at a specific constant offset in the section e_ident, which
146                         // happens to be the first section, so just reading one byte at EI_CLASS yields the data we're
147                         // looking for
148                         elfClass = data.get()[EI_CLASS];
149
150                         switch (elfClass) {
151                             case ELFCLASS32:
152                                 parseElfHeader<Elf32_Ehdr, Elf32_Shdr, Elf32_Phdr>(data);
153                                 break;
154                             case ELFCLASS64:
155                                 parseElfHeader<Elf64_Ehdr, Elf64_Shdr, Elf64_Phdr>(data);
156                                 break;
157                             default:
158                                 throw ElfFileParseError("Unknown ELF class: " + std::to_string(elfClass));
159                         }
160                     }
161             };
162
163             ElfFile::ElfFile(const boost::filesystem::path& path) {
164                 // check if file exists
165                 if (!bf::exists(path))
166                     throw ElfFileParseError("No such file or directory: " + path.string());
167
168                 // check magic bytes
169                 std::ifstream ifs(path.string());
170                 if (!ifs)
171                     throw ElfFileParseError("Could not open file: " + path.string());
172
173                 std::vector<char> magicBytes(4);
174                 ifs.read(magicBytes.data(), 4);
175
176                 if (strncmp(magicBytes.data(), "\177ELF", 4) != 0)
177                     throw ElfFileParseError("Invalid magic bytes in file header");
178
179                 d = new PrivateData(path);
180                 d->readDataUsingElfAPI();
181             }
182
183             ElfFile::~ElfFile() {
184                 delete d;
185             }
186
187             std::vector<bf::path> ElfFile::traceDynamicDependencies() {
188                 // this method's purpose is to abstract this process
189                 // the caller doesn't care _how_ it's done, after all
190
191                 // for now, we use the same ldd based method linuxdeployqt uses
192
193                 std::vector<bf::path> paths;
194
195                 subprocess::subprocess_env_map_t env;
196                 env["LC_ALL"] = "C";
197
198                 // workaround for https://sourceware.org/bugzilla/show_bug.cgi?id=25263
199                 // when you pass an absolute path to ldd, it can find libraries referenced in the rpath properly
200                 // this bug was first found when trying to find a library next to the binary which contained $ORIGIN
201                 // note that this is just a bug in ldd, the linker has always worked as intended
202                 const auto resolvedPath = bf::canonical(d->path);
203
204                 subprocess::subprocess lddProc({"ldd", resolvedPath.string()}, env);
205
206                 const auto result = lddProc.run();
207
208                 if (result.exit_code() != 0) {
209                     if (result.stdout_string().find("not a dynamic executable") != std::string::npos || result.stderr_string().find("not a dynamic executable") != std::string::npos) {
210                         ldLog() << LD_WARNING << this->d->path << "is not linked dynamically" << std::endl;
211                         return {};
212                     }
213
214                     throw std::runtime_error{"Failed to run ldd: exited with code " + std::to_string(result.exit_code())};
215                 }
216
217                 const boost::regex expr(R"(\s*(.+)\s+\=>\s+(.+)\s+\((.+)\)\s*)");
218                 boost::smatch what;
219
220                 for (const auto& line : util::splitLines(result.stdout_string())) {
221                     if (boost::regex_search(line, what, expr)) {
222                         auto libraryPath = what[2].str();
223                         util::trim(libraryPath);
224                         paths.push_back(bf::absolute(libraryPath));
225                     } else {
226                         if (util::stringContains(line, "=> not found")) {
227                             auto missingLib = line;
228                             static const std::string pattern = "=> not found";
229                             missingLib.erase(missingLib.find(pattern), pattern.size());
230                             util::trim(missingLib);
231                             util::trim(missingLib, '\t');
232                             throw DependencyNotFoundError("Could not find dependency: " + missingLib);
233                         } else {
234                             ldLog() << LD_DEBUG << "Invalid ldd output: " << line << std::endl;
235                         }
236                     }
237                 }
238
239                 return paths;
240             }
241
242             std::string ElfFile::getRPath() {
243                 // don't try to fetch patchelf path in a catchall to make sure the process exists when the tool cannot be found
244                 const auto patchelfPath = PrivateData::getPatchelfPath();
245
246                 try {
247                     subprocess::subprocess patchelfProc({patchelfPath, "--print-rpath", d->path.string()});
248
249                     const auto result = patchelfProc.run();
250
251                     if (result.exit_code() != 0) {
252                         // if file is not an ELF executable, there is no need for a detailed error message
253                         if (result.exit_code() == 1 && result.stderr_string().find("not an ELF executable") != std::string::npos) {
254                             return "";
255                         } else {
256                             ldLog() << LD_ERROR << "Call to patchelf failed:" << std::endl << result.stderr_string();
257                             return "";
258                         }
259                     }
260
261                     auto stdoutContents = result.stdout_string();
262
263                     util::trim(stdoutContents, '\n');
264                     util::trim(stdoutContents);
265
266                     return stdoutContents;
267                 } catch (const std::exception&) {
268                     return "";
269                 }
270             }
271
272             bool ElfFile::setRPath(const std::string& value) {
273                 // don't try to fetch patchelf path in a catchall to make sure the process exists when the tool cannot be found
274                 const auto patchelfPath = PrivateData::getPatchelfPath();
275
276                 try {
277                     subprocess::subprocess patchelfProc({patchelfPath.c_str(), "--set-rpath", value.c_str(), d->path.c_str()});
278
279                     const auto result = patchelfProc.run();
280
281                     if (result.exit_code() != 0) {
282                         ldLog() << LD_ERROR << "Call to patchelf failed:" << std::endl << result.stderr_string() << std::endl;
283                         return false;
284                     }
285                 } catch (const std::exception&) {
286                     return false;
287                 }
288
289                 return true;
290             }
291
292             uint8_t ElfFile::getSystemElfABI() {
293                 // the only way to get the system's ELF ABI is to read the own executable using the ELF header,
294                 // and get the ELFOSABI flag
295                 auto self = std::shared_ptr<char>(realpath("/proc/self/exe", nullptr), [](char* p) { free(p); });
296
297                 if (self == nullptr)
298                     throw ElfFileParseError("Could not read /proc/self/exe");
299
300                 std::ifstream ifs(self.get());
301
302                 if (!ifs)
303                     throw ElfFileParseError("Could not open file: " + std::string(self.get()));
304
305                 // the "class" is available at a specific constant offset in the section e_ident, which
306                 // happens to be the first section, so just reading one byte at EI_CLASS yields the data we're
307                 // looking for
308                 ifs.seekg(EI_OSABI);
309
310                 char buf;
311                 ifs.read(&buf, 1);
312
313                 return static_cast<uint8_t>(buf);
314             }
315
316             uint8_t ElfFile::getSystemElfClass() {
317                 #if __SIZEOF_POINTER__ == 4
318                 return ELFCLASS32;
319                 #elif __SIZEOF_POINTER__ == 8
320                 return ELFCLASS64;
321                 #else
322                 #error "Invalid address size"
323                 #endif
324             }
325
326             uint8_t ElfFile::getSystemElfEndianness() {
327                 #if __BYTE_ORDER == __LITTLE_ENDIAN
328                 return ELFDATA2LSB;
329                 #elif __BYTE_ORDER == __BIG_ENDIAN
330                 return ELFDATA2MSB;
331                 #else
332                 #error "Unknown machine endianness"
333                 #endif
334             }
335
336             uint8_t ElfFile::getElfClass()  {
337                 return d->elfClass;
338             }
339
340             uint8_t ElfFile::getElfABI() {
341                 return d->elfABI;
342             }
343
344             bool ElfFile::isDebugSymbolsFile() {
345                 return d->isDebugSymbolsFile;
346             }
347
348             bool ElfFile::isDynamicallyLinked() {
349                 return d->isDynamicallyLinked;
350             }
351         }
352     }
353 }