Magisk/native/jni/utils/file.cpp

406 lines
9.7 KiB
C++
Raw Normal View History

2019-06-23 12:53:41 +02:00
#include <sys/sendfile.h>
#include <linux/fs.h>
2017-10-11 20:57:18 +02:00
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
2017-11-15 14:00:52 +01:00
#include <errno.h>
#include <string.h>
2017-11-27 08:37:28 +01:00
#include <libgen.h>
2017-10-14 15:10:22 +02:00
2019-02-10 09:57:51 +01:00
#include <utils.h>
#include <selinux.h>
2017-10-11 20:57:18 +02:00
2019-01-20 05:59:37 +01:00
using namespace std;
2019-03-14 11:34:22 +01:00
ssize_t fd_path(int fd, char *path, size_t size) {
2017-10-14 15:10:22 +02:00
snprintf(path, size, "/proc/self/fd/%d", fd);
2019-03-14 11:34:22 +01:00
return xreadlink(path, path, size);
}
2019-03-14 11:34:22 +01:00
int fd_pathat(int dirfd, const char *name, char *path, size_t size) {
ssize_t len = fd_path(dirfd, path, size);
if (len < 0)
return -1;
path[len] = '/';
strlcpy(&path[len + 1], name, size - len - 1);
2018-09-27 06:09:59 +02:00
return 0;
2017-10-14 15:10:22 +02:00
}
int mkdirs(const char *pathname, mode_t mode) {
2017-10-11 20:57:18 +02:00
char *path = strdup(pathname), *p;
errno = 0;
for (p = path + 1; *p; ++p) {
if (*p == '/') {
*p = '\0';
if (mkdir(path, mode) == -1) {
if (errno != EEXIST)
return -1;
}
*p = '/';
}
}
if (mkdir(path, mode) == -1) {
if (errno != EEXIST)
return -1;
}
free(path);
return 0;
}
2019-03-31 12:32:33 +02:00
static bool is_excl(initializer_list<const char *> excl, const char *name) {
for (auto item : excl)
if (strcmp(item, name) == 0)
return true;
return false;
}
static void post_order_walk(int dirfd, initializer_list<const char *> excl,
int (*fn)(int, struct dirent *)) {
2017-10-11 20:57:18 +02:00
struct dirent *entry;
int newfd;
2017-12-15 19:02:17 +01:00
DIR *dir = fdopendir(dirfd);
2018-11-03 08:06:01 +01:00
if (dir == nullptr) return;
2017-10-11 20:57:18 +02:00
2017-10-13 18:08:12 +02:00
while ((entry = xreaddir(dir))) {
2017-10-11 20:57:18 +02:00
if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0)
continue;
2019-03-31 12:32:33 +02:00
if (is_excl(excl, entry->d_name))
2017-10-11 20:57:18 +02:00
continue;
if (entry->d_type == DT_DIR) {
2017-10-13 18:08:12 +02:00
newfd = xopenat(dirfd, entry->d_name, O_RDONLY | O_CLOEXEC);
2019-03-31 12:32:33 +02:00
post_order_walk(newfd, excl, fn);
2017-10-11 20:57:18 +02:00
close(newfd);
}
2019-02-14 06:52:59 +01:00
fn(dirfd, entry);
}
}
2019-03-31 12:32:33 +02:00
static int remove_at(int dirfd, struct dirent *entry) {
return unlinkat(dirfd, entry->d_name, entry->d_type == DT_DIR ? AT_REMOVEDIR : 0);
}
void rm_rf(const char *path) {
2019-02-12 08:44:46 +01:00
struct stat st;
if (lstat(path, &st) < 0)
return;
if (S_ISDIR(st.st_mode)) {
2019-03-14 11:34:22 +01:00
int fd = open(path, O_RDONLY | O_CLOEXEC);
2017-12-15 19:02:17 +01:00
frm_rf(fd);
close(fd);
}
remove(path);
}
2019-03-31 12:32:33 +02:00
void frm_rf(int dirfd, initializer_list<const char *> excl) {
post_order_walk(dirfd, excl, remove_at);
}
2017-10-11 20:57:18 +02:00
/* This will only on the same file system */
void mv_f(const char *source, const char *destination) {
struct stat st;
xlstat(source, &st);
int src, dest;
struct file_attr a;
if (S_ISDIR(st.st_mode)) {
xmkdirs(destination, st.st_mode & 0777);
2017-10-11 20:57:18 +02:00
src = xopen(source, O_RDONLY | O_CLOEXEC);
dest = xopen(destination, O_RDONLY | O_CLOEXEC);
fclone_attr(src, dest);
mv_dir(src, dest);
close(src);
close(dest);
} else{
getattr(source, &a);
2017-10-13 18:08:12 +02:00
xrename(source, destination);
2017-10-11 20:57:18 +02:00
setattr(destination, &a);
}
rmdir(source);
}
/* This will only on the same file system */
void mv_dir(int src, int dest) {
struct dirent *entry;
DIR *dir;
int newsrc, newdest;
struct file_attr a;
2017-10-13 18:08:12 +02:00
dir = xfdopendir(src);
while ((entry = xreaddir(dir))) {
2017-10-11 20:57:18 +02:00
if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0)
continue;
getattrat(src, entry->d_name, &a);
switch (entry->d_type) {
case DT_DIR:
2017-10-13 18:08:12 +02:00
xmkdirat(dest, entry->d_name, a.st.st_mode & 0777);
newsrc = xopenat(src, entry->d_name, O_RDONLY | O_CLOEXEC);
newdest = xopenat(dest, entry->d_name, O_RDONLY | O_CLOEXEC);
2017-10-11 20:57:18 +02:00
fsetattr(newdest, &a);
mv_dir(newsrc, newdest);
close(newsrc);
close(newdest);
unlinkat(src, entry->d_name, AT_REMOVEDIR);
break;
case DT_LNK:
case DT_REG:
renameat(src, entry->d_name, dest, entry->d_name);
setattrat(dest, entry->d_name, &a);
break;
}
}
}
void cp_afc(const char *source, const char *destination) {
int src, dest;
struct file_attr a;
getattr(source, &a);
if (S_ISDIR(a.st.st_mode)) {
xmkdirs(destination, a.st.st_mode & 0777);
2017-10-11 20:57:18 +02:00
src = xopen(source, O_RDONLY | O_CLOEXEC);
dest = xopen(destination, O_RDONLY | O_CLOEXEC);
clone_dir(src, dest);
close(src);
close(dest);
} else{
unlink(destination);
if (S_ISREG(a.st.st_mode)) {
src = xopen(source, O_RDONLY);
dest = xopen(destination, O_WRONLY | O_CREAT | O_TRUNC);
2018-11-03 08:06:01 +01:00
xsendfile(dest, src, nullptr, a.st.st_size);
2017-10-11 20:57:18 +02:00
close(src);
close(dest);
} else if (S_ISLNK(a.st.st_mode)) {
char buf[PATH_MAX];
xreadlink(source, buf, sizeof(buf));
xsymlink(buf, destination);
}
}
2018-06-16 19:25:27 +02:00
setattr(destination, &a);
2017-10-11 20:57:18 +02:00
}
2019-03-31 12:32:33 +02:00
void clone_dir(int src, int dest, bool overwrite) {
2017-10-11 20:57:18 +02:00
struct dirent *entry;
DIR *dir;
int srcfd, destfd, newsrc, newdest;
char buf[PATH_MAX];
struct file_attr a;
2017-10-13 18:08:12 +02:00
dir = xfdopendir(src);
while ((entry = xreaddir(dir))) {
2017-10-11 20:57:18 +02:00
if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0)
continue;
2019-03-31 12:32:33 +02:00
if (struct stat st; !overwrite &&
fstatat(dest, entry->d_name, &st, AT_SYMLINK_NOFOLLOW) == 0)
2017-10-11 20:57:18 +02:00
continue;
getattrat(src, entry->d_name, &a);
switch (entry->d_type) {
case DT_DIR:
2017-10-13 18:08:12 +02:00
xmkdirat(dest, entry->d_name, a.st.st_mode & 0777);
2017-10-11 20:57:18 +02:00
setattrat(dest, entry->d_name, &a);
2017-10-13 18:08:12 +02:00
newsrc = xopenat(src, entry->d_name, O_RDONLY | O_CLOEXEC);
newdest = xopenat(dest, entry->d_name, O_RDONLY | O_CLOEXEC);
2019-03-31 12:32:33 +02:00
clone_dir(newsrc, newdest, overwrite);
2017-10-11 20:57:18 +02:00
close(newsrc);
close(newdest);
break;
case DT_REG:
2017-10-13 18:08:12 +02:00
destfd = xopenat(dest, entry->d_name, O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC);
srcfd = xopenat(src, entry->d_name, O_RDONLY | O_CLOEXEC);
2019-03-14 11:34:22 +01:00
xsendfile(destfd, srcfd, nullptr, a.st.st_size);
2017-10-11 20:57:18 +02:00
fsetattr(destfd, &a);
close(destfd);
close(srcfd);
break;
case DT_LNK:
2017-10-13 18:08:12 +02:00
xreadlinkat(src, entry->d_name, buf, sizeof(buf));
xsymlinkat(buf, dest, entry->d_name);
2017-10-11 20:57:18 +02:00
setattrat(dest, entry->d_name, &a);
break;
}
}
}
2018-02-01 20:22:38 +01:00
void link_dir(int src, int dest) {
struct dirent *entry;
DIR *dir;
int newsrc, newdest;
struct file_attr a;
dir = xfdopendir(src);
while ((entry = xreaddir(dir))) {
if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0)
continue;
if (entry->d_type == DT_DIR) {
getattrat(src, entry->d_name, &a);
xmkdirat(dest, entry->d_name, a.st.st_mode & 0777);
setattrat(dest, entry->d_name, &a);
newsrc = xopenat(src, entry->d_name, O_RDONLY | O_CLOEXEC);
newdest = xopenat(dest, entry->d_name, O_RDONLY | O_CLOEXEC);
link_dir(newsrc, newdest);
close(newsrc);
close(newdest);
} else {
xlinkat(src, entry->d_name, dest, entry->d_name, 0);
2018-02-01 20:22:38 +01:00
}
}
}
2017-10-11 20:57:18 +02:00
int getattr(const char *path, struct file_attr *a) {
2017-10-14 15:10:22 +02:00
if (xlstat(path, &a->st) == -1)
2017-10-11 20:57:18 +02:00
return -1;
2018-09-27 06:09:59 +02:00
char *con;
2017-10-14 15:10:22 +02:00
if (lgetfilecon(path, &con) == -1)
return -1;
strcpy(a->con, con);
freecon(con);
return 0;
2017-10-11 20:57:18 +02:00
}
2019-03-14 11:34:22 +01:00
int getattrat(int dirfd, const char *name, struct file_attr *a) {
char path[4096];
fd_pathat(dirfd, name, path, sizeof(path));
return getattr(path, a);
2017-10-11 20:57:18 +02:00
}
int fgetattr(int fd, struct file_attr *a) {
2019-03-14 11:34:22 +01:00
if (xfstat(fd, &a->st) < 0)
return -1;
char *con;
if (fgetfilecon(fd, &con) < 0)
return -1;
strcpy(a->con, con);
freecon(con);
return 0;
2017-10-11 20:57:18 +02:00
}
int setattr(const char *path, struct file_attr *a) {
2017-10-14 15:10:22 +02:00
if (chmod(path, a->st.st_mode & 0777) < 0)
2017-10-11 20:57:18 +02:00
return -1;
2017-10-14 15:10:22 +02:00
if (chown(path, a->st.st_uid, a->st.st_gid) < 0)
return -1;
2019-03-14 11:34:22 +01:00
if (a->con[0] && lsetfilecon(path, a->con) < 0)
2017-10-14 15:10:22 +02:00
return -1;
return 0;
2017-10-11 20:57:18 +02:00
}
2019-03-14 11:34:22 +01:00
int setattrat(int dirfd, const char *name, struct file_attr *a) {
char path[4096];
fd_pathat(dirfd, name, path, sizeof(path));
return setattr(path, a);
2017-10-11 20:57:18 +02:00
}
int fsetattr(int fd, struct file_attr *a) {
2019-03-14 11:34:22 +01:00
if (fchmod(fd, a->st.st_mode & 0777) < 0)
return -1;
if (fchown(fd, a->st.st_uid, a->st.st_gid) < 0)
return -1;
if (a->con[0] && fsetfilecon(fd, a->con) < 0)
return -1;
return 0;
2017-10-11 20:57:18 +02:00
}
void clone_attr(const char *source, const char *target) {
struct file_attr a;
getattr(source, &a);
setattr(target, &a);
}
2019-01-20 05:59:37 +01:00
void fclone_attr(int sourcefd, int targetfd) {
2017-10-11 20:57:18 +02:00
struct file_attr a;
fgetattr(sourcefd, &a);
fsetattr(targetfd, &a);
}
2017-10-11 21:39:39 +02:00
2019-02-25 05:09:34 +01:00
void *__mmap(const char *filename, size_t *size, bool rw) {
2017-11-19 20:40:37 +01:00
struct stat st;
2019-02-25 05:09:34 +01:00
void *buf;
2018-04-14 21:18:18 +02:00
int fd = xopen(filename, (rw ? O_RDWR : O_RDONLY) | O_CLOEXEC);
2017-12-06 05:51:16 +01:00
fstat(fd, &st);
2017-11-19 20:40:37 +01:00
if (S_ISBLK(st.st_mode))
ioctl(fd, BLKGETSIZE64, size);
else
*size = st.st_size;
2019-02-25 05:09:34 +01:00
buf = *size > 0 ? xmmap(nullptr, *size, PROT_READ | (rw ? PROT_WRITE : 0), MAP_SHARED, fd, 0) : nullptr;
2017-11-09 18:51:41 +01:00
close(fd);
2019-02-25 05:09:34 +01:00
return buf;
2017-11-09 18:51:41 +01:00
}
void fd_full_read(int fd, void **buf, size_t *size) {
*size = lseek(fd, 0, SEEK_END);
lseek(fd, 0, SEEK_SET);
*buf = xmalloc(*size + 1);
xxread(fd, *buf, *size);
((char *) *buf)[*size] = '\0';
}
2017-12-06 18:30:48 +01:00
void full_read(const char *filename, void **buf, size_t *size) {
2018-04-14 21:18:18 +02:00
int fd = xopen(filename, O_RDONLY | O_CLOEXEC);
2017-12-06 18:30:48 +01:00
if (fd < 0) {
2018-11-03 08:06:01 +01:00
*buf = nullptr;
2017-12-06 18:30:48 +01:00
*size = 0;
return;
}
fd_full_read(fd, buf, size);
close(fd);
}
2017-11-09 18:51:41 +01:00
void write_zero(int fd, size_t size) {
char buf[4096] = {0};
size_t len;
while (size > 0) {
len = sizeof(buf) > size ? size : sizeof(buf);
write(fd, buf, len);
size -= len;
}
2017-11-09 18:51:41 +01:00
}
2018-11-03 08:06:01 +01:00
2019-12-13 06:37:06 +01:00
void file_readline(bool trim, const char *file, const std::function<bool(std::string_view)> &fn) {
2019-03-06 02:27:09 +01:00
FILE *fp = xfopen(file, "re");
2018-11-03 08:06:01 +01:00
if (fp == nullptr)
return;
size_t len = 1024;
char *buf = (char *) malloc(len);
char *start;
ssize_t read;
while ((read = getline(&buf, &len, fp)) >= 0) {
start = buf;
if (trim) {
2019-03-09 10:27:04 +01:00
while (read && (buf[read - 1] == '\n' || buf[read - 1] == ' '))
--read;
buf[read] = '\0';
while (*start == ' ')
++start;
}
2019-03-06 02:27:09 +01:00
if (!fn(start))
break;
2018-11-03 08:06:01 +01:00
}
fclose(fp);
free(buf);
2018-11-03 08:06:01 +01:00
}
2019-03-06 02:27:09 +01:00
void parse_prop_file(const char *file, const function<bool (string_view, string_view)> &fn) {
2019-12-13 06:37:06 +01:00
file_readline(true, file, [&](string_view line_view) -> bool {
2019-03-06 02:27:09 +01:00
char *line = (char *) line_view.data();
if (line[0] == '#')
return true;
char *eql = strchr(line, '=');
if (eql == nullptr || eql == line)
return true;
*eql = '\0';
return fn(line, eql + 1);
2019-12-13 06:37:06 +01:00
});
2019-03-06 02:27:09 +01:00
}
2019-06-23 12:53:41 +02:00
void parse_mnt(const char *file, const function<bool (mntent*)> &fn) {
2019-06-23 23:54:48 +02:00
unique_ptr<FILE, decltype(&endmntent)> fp(setmntent(file, "re"), &endmntent);
2019-06-23 12:53:41 +02:00
if (fp) {
2019-06-23 23:54:48 +02:00
mntent mentry{};
char buf[4096];
while (getmntent_r(fp.get(), &mentry, buf, sizeof(buf))) {
if (!fn(&mentry))
2019-06-23 12:53:41 +02:00
break;
}
}
}