940f49f5db
Once switched to using std::string, the mkdirs implementation was trying to create an empty string when an absolute file path on linux or macOS was used. Bug: 62336414 Test: manual Change-Id: I52f3050b410a923ca48f353b0983667c16d00ee8
336 lines
9.3 KiB
C++
336 lines
9.3 KiB
C++
/*
|
|
* Copyright (C) 2015 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#include "util/Files.h"
|
|
|
|
#include <dirent.h>
|
|
#include <sys/stat.h>
|
|
|
|
#include <algorithm>
|
|
#include <cerrno>
|
|
#include <cstdio>
|
|
#include <string>
|
|
|
|
#include "android-base/errors.h"
|
|
#include "android-base/file.h"
|
|
#include "android-base/logging.h"
|
|
#include "android-base/unique_fd.h"
|
|
#include "android-base/utf8.h"
|
|
|
|
#include "util/Util.h"
|
|
|
|
#ifdef _WIN32
|
|
// Windows includes.
|
|
#include <direct.h>
|
|
#endif
|
|
|
|
using ::android::FileMap;
|
|
using ::android::StringPiece;
|
|
using ::android::base::ReadFileToString;
|
|
using ::android::base::SystemErrorCodeToString;
|
|
using ::android::base::unique_fd;
|
|
|
|
namespace aapt {
|
|
namespace file {
|
|
|
|
FileType GetFileType(const std::string& path) {
|
|
// TODO(adamlesinski): I'd like to move this to ::android::base::utf8 but Windows does some macro
|
|
// trickery with 'stat' and things don't override very well.
|
|
#ifdef _WIN32
|
|
std::wstring path_utf16;
|
|
if (!::android::base::UTF8PathToWindowsLongPath(path.c_str(), &path_utf16)) {
|
|
return FileType::kNonexistant;
|
|
}
|
|
|
|
struct _stat64 sb;
|
|
int result = _wstat64(path_utf16.c_str(), &sb);
|
|
#else
|
|
struct stat sb;
|
|
int result = stat(path.c_str(), &sb);
|
|
#endif
|
|
|
|
if (result == -1) {
|
|
if (errno == ENOENT || errno == ENOTDIR) {
|
|
return FileType::kNonexistant;
|
|
}
|
|
return FileType::kUnknown;
|
|
}
|
|
|
|
if (S_ISREG(sb.st_mode)) {
|
|
return FileType::kRegular;
|
|
} else if (S_ISDIR(sb.st_mode)) {
|
|
return FileType::kDirectory;
|
|
} else if (S_ISCHR(sb.st_mode)) {
|
|
return FileType::kCharDev;
|
|
} else if (S_ISBLK(sb.st_mode)) {
|
|
return FileType::kBlockDev;
|
|
} else if (S_ISFIFO(sb.st_mode)) {
|
|
return FileType::kFifo;
|
|
#if defined(S_ISLNK)
|
|
} else if (S_ISLNK(sb.st_mode)) {
|
|
return FileType::kSymlink;
|
|
#endif
|
|
#if defined(S_ISSOCK)
|
|
} else if (S_ISSOCK(sb.st_mode)) {
|
|
return FileType::kSocket;
|
|
#endif
|
|
} else {
|
|
return FileType::kUnknown;
|
|
}
|
|
}
|
|
|
|
bool mkdirs(const std::string& path) {
|
|
constexpr const mode_t mode = S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP;
|
|
// Start after the first character so that we don't consume the root '/'.
|
|
// This is safe to do with unicode because '/' will never match with a continuation character.
|
|
size_t current_pos = 1u;
|
|
while ((current_pos = path.find(sDirSep, current_pos)) != std::string::npos) {
|
|
std::string parent_path = path.substr(0, current_pos);
|
|
int result = ::android::base::utf8::mkdir(parent_path.c_str(), mode);
|
|
if (result < 0 && errno != EEXIST) {
|
|
return false;
|
|
}
|
|
current_pos += 1;
|
|
}
|
|
return ::android::base::utf8::mkdir(path.c_str(), mode) == 0 || errno == EEXIST;
|
|
}
|
|
|
|
StringPiece GetStem(const StringPiece& path) {
|
|
const char* start = path.begin();
|
|
const char* end = path.end();
|
|
for (const char* current = end - 1; current != start - 1; --current) {
|
|
if (*current == sDirSep) {
|
|
return StringPiece(start, current - start);
|
|
}
|
|
}
|
|
return {};
|
|
}
|
|
|
|
StringPiece GetFilename(const StringPiece& path) {
|
|
const char* end = path.end();
|
|
const char* last_dir_sep = path.begin();
|
|
for (const char* c = path.begin(); c != end; ++c) {
|
|
if (*c == sDirSep) {
|
|
last_dir_sep = c + 1;
|
|
}
|
|
}
|
|
return StringPiece(last_dir_sep, end - last_dir_sep);
|
|
}
|
|
|
|
StringPiece GetExtension(const StringPiece& path) {
|
|
StringPiece filename = GetFilename(path);
|
|
const char* const end = filename.end();
|
|
const char* c = std::find(filename.begin(), end, '.');
|
|
if (c != end) {
|
|
return StringPiece(c, end - c);
|
|
}
|
|
return {};
|
|
}
|
|
|
|
void AppendPath(std::string* base, StringPiece part) {
|
|
CHECK(base != nullptr);
|
|
const bool base_has_trailing_sep = (!base->empty() && *(base->end() - 1) == sDirSep);
|
|
const bool part_has_leading_sep = (!part.empty() && *(part.begin()) == sDirSep);
|
|
if (base_has_trailing_sep && part_has_leading_sep) {
|
|
// Remove the part's leading sep
|
|
part = part.substr(1, part.size() - 1);
|
|
} else if (!base_has_trailing_sep && !part_has_leading_sep) {
|
|
// None of the pieces has a separator.
|
|
*base += sDirSep;
|
|
}
|
|
base->append(part.data(), part.size());
|
|
}
|
|
|
|
std::string PackageToPath(const StringPiece& package) {
|
|
std::string out_path;
|
|
for (StringPiece part : util::Tokenize(package, '.')) {
|
|
AppendPath(&out_path, part);
|
|
}
|
|
return out_path;
|
|
}
|
|
|
|
Maybe<FileMap> MmapPath(const std::string& path, std::string* out_error) {
|
|
int flags = O_RDONLY | O_CLOEXEC | O_BINARY;
|
|
unique_fd fd(TEMP_FAILURE_RETRY(::android::base::utf8::open(path.c_str(), flags)));
|
|
if (fd == -1) {
|
|
if (out_error) {
|
|
*out_error = SystemErrorCodeToString(errno);
|
|
}
|
|
return {};
|
|
}
|
|
|
|
struct stat filestats = {};
|
|
if (fstat(fd, &filestats) != 0) {
|
|
if (out_error) {
|
|
*out_error = SystemErrorCodeToString(errno);
|
|
}
|
|
return {};
|
|
}
|
|
|
|
FileMap filemap;
|
|
if (filestats.st_size == 0) {
|
|
// mmap doesn't like a length of 0. Instead we return an empty FileMap.
|
|
return std::move(filemap);
|
|
}
|
|
|
|
if (!filemap.create(path.c_str(), fd, 0, filestats.st_size, true)) {
|
|
if (out_error) {
|
|
*out_error = SystemErrorCodeToString(errno);
|
|
}
|
|
return {};
|
|
}
|
|
return std::move(filemap);
|
|
}
|
|
|
|
bool AppendArgsFromFile(const StringPiece& path, std::vector<std::string>* out_arglist,
|
|
std::string* out_error) {
|
|
std::string contents;
|
|
if (!ReadFileToString(path.to_string(), &contents, true /*follow_symlinks*/)) {
|
|
if (out_error) {
|
|
*out_error = "failed to read argument-list file";
|
|
}
|
|
return false;
|
|
}
|
|
|
|
for (StringPiece line : util::Tokenize(contents, ' ')) {
|
|
line = util::TrimWhitespace(line);
|
|
if (!line.empty()) {
|
|
out_arglist->push_back(line.to_string());
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool FileFilter::SetPattern(const StringPiece& pattern) {
|
|
pattern_tokens_ = util::SplitAndLowercase(pattern, ':');
|
|
return true;
|
|
}
|
|
|
|
bool FileFilter::operator()(const std::string& filename, FileType type) const {
|
|
if (filename == "." || filename == "..") {
|
|
return false;
|
|
}
|
|
|
|
const char kDir[] = "dir";
|
|
const char kFile[] = "file";
|
|
const size_t filename_len = filename.length();
|
|
bool chatty = true;
|
|
for (const std::string& token : pattern_tokens_) {
|
|
const char* token_str = token.c_str();
|
|
if (*token_str == '!') {
|
|
chatty = false;
|
|
token_str++;
|
|
}
|
|
|
|
if (strncasecmp(token_str, kDir, sizeof(kDir)) == 0) {
|
|
if (type != FileType::kDirectory) {
|
|
continue;
|
|
}
|
|
token_str += sizeof(kDir);
|
|
}
|
|
|
|
if (strncasecmp(token_str, kFile, sizeof(kFile)) == 0) {
|
|
if (type != FileType::kRegular) {
|
|
continue;
|
|
}
|
|
token_str += sizeof(kFile);
|
|
}
|
|
|
|
bool ignore = false;
|
|
size_t n = strlen(token_str);
|
|
if (*token_str == '*') {
|
|
// Math suffix.
|
|
token_str++;
|
|
n--;
|
|
if (n <= filename_len) {
|
|
ignore =
|
|
strncasecmp(token_str, filename.c_str() + filename_len - n, n) == 0;
|
|
}
|
|
} else if (n > 1 && token_str[n - 1] == '*') {
|
|
// Match prefix.
|
|
ignore = strncasecmp(token_str, filename.c_str(), n - 1) == 0;
|
|
} else {
|
|
ignore = strcasecmp(token_str, filename.c_str()) == 0;
|
|
}
|
|
|
|
if (ignore) {
|
|
if (chatty) {
|
|
diag_->Warn(DiagMessage()
|
|
<< "skipping "
|
|
<< (type == FileType::kDirectory ? "dir '" : "file '")
|
|
<< filename << "' due to ignore pattern '" << token << "'");
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
Maybe<std::vector<std::string>> FindFiles(const android::StringPiece& path, IDiagnostics* diag,
|
|
const FileFilter* filter) {
|
|
const std::string root_dir = path.to_string();
|
|
std::unique_ptr<DIR, decltype(closedir)*> d(opendir(root_dir.data()), closedir);
|
|
if (!d) {
|
|
diag->Error(DiagMessage() << SystemErrorCodeToString(errno));
|
|
return {};
|
|
}
|
|
|
|
std::vector<std::string> files;
|
|
std::vector<std::string> subdirs;
|
|
while (struct dirent* entry = readdir(d.get())) {
|
|
if (util::StartsWith(entry->d_name, ".")) {
|
|
continue;
|
|
}
|
|
|
|
std::string file_name = entry->d_name;
|
|
std::string full_path = root_dir;
|
|
AppendPath(&full_path, file_name);
|
|
const FileType file_type = GetFileType(full_path);
|
|
|
|
if (filter != nullptr) {
|
|
if (!(*filter)(file_name, file_type)) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if (file_type == file::FileType::kDirectory) {
|
|
subdirs.push_back(std::move(file_name));
|
|
} else {
|
|
files.push_back(std::move(file_name));
|
|
}
|
|
}
|
|
|
|
// Now process subdirs.
|
|
for (const std::string& subdir : subdirs) {
|
|
std::string full_subdir = root_dir;
|
|
AppendPath(&full_subdir, subdir);
|
|
Maybe<std::vector<std::string>> subfiles = FindFiles(full_subdir, diag, filter);
|
|
if (!subfiles) {
|
|
return {};
|
|
}
|
|
|
|
for (const std::string& subfile : subfiles.value()) {
|
|
std::string new_file = subdir;
|
|
AppendPath(&new_file, subfile);
|
|
files.push_back(new_file);
|
|
}
|
|
}
|
|
return files;
|
|
}
|
|
|
|
} // namespace file
|
|
} // namespace aapt
|