TheArchive/Magisk
1
0
Fork 0
mirror of https://github.com/topjohnwu/Magisk.git synced 2024-12-25 10:07:38 +00:00
Code Issues Packages Projects Releases Wiki Activity

Reduce C++ wizardry

Browse Source
This commit is contained in:
topjohnwu 2022-03-01 02:13:18 -08:00 committed by John Wu
parent 7999b66c3c
commit be7586137c
11 changed files with 100 additions and 146 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
native/jni/core/bootstages.cpp
View File

@ -14,7 +14,6 @@
#include <selinux.hpp>
#include "core.hpp"
#include "zygisk/deny/deny.hpp"
using namespace std;
@ -264,6 +263,7 @@ static bool check_key_combo() {
***********************/
static pthread_mutex_t stage_lock = PTHREAD_MUTEX_INITIALIZER;
extern int disable_deny();
void post_fs_data(int client) {
// ack

95
native/jni/core/daemon.cpp
View File

@ -133,34 +133,33 @@ static void poll_ctrl_handler(pollfd *pfd) {
}
}
static void handle_request_async(int client, DaemonRequest code, const sock_cred &cred) {
// using enum DAEMON_REQUEST;
static void handle_request_async(int client, int code, const sock_cred &cred) {
switch (code) {
case DaemonRequest::DENYLIST:
case MainRequest::DENYLIST:
denylist_handler(client, &cred);
break;
case DaemonRequest::SUPERUSER:
case MainRequest::SUPERUSER:
su_daemon_handler(client, &cred);
break;
case DaemonRequest::POST_FS_DATA:
case MainRequest::POST_FS_DATA:
post_fs_data(client);
break;
case DaemonRequest::LATE_START:
case MainRequest::LATE_START:
late_start(client);
break;
case DaemonRequest::BOOT_COMPLETE:
case MainRequest::BOOT_COMPLETE:
boot_complete(client);
break;
case DaemonRequest::SQLITE_CMD:
case MainRequest::SQLITE_CMD:
exec_sql(client);
break;
case DaemonRequest::REMOVE_MODULES:
case MainRequest::REMOVE_MODULES:
remove_modules();
write_int(client, 0);
close(client);
reboot();
break;
case DaemonRequest::ZYGISK_REQUEST:
case MainRequest::ZYGISK:
zygisk_handler(client, &cred);
break;
default:
@ -168,22 +167,21 @@ static void handle_request_async(int client, DaemonRequest code, const sock_cred
}
}
static void handle_request_sync(int client, DaemonRequest code) {
// using enum DAEMON_REQUEST;
static void handle_request_sync(int client, int code) {
switch (code) {
case DaemonRequest::CHECK_VERSION:
case MainRequest::CHECK_VERSION:
write_string(client, MAGISK_VERSION ":MAGISK");
break;
case DaemonRequest::CHECK_VERSION_CODE:
case MainRequest::CHECK_VERSION_CODE:
write_int(client, MAGISK_VER_CODE);
break;
case DaemonRequest::GET_PATH:
case MainRequest::GET_PATH:
write_string(client, MAGISKTMP.data());
break;
case DaemonRequest::START_DAEMON:
case MainRequest::START_DAEMON:
setup_logfile(true);
break;
case DaemonRequest::STOP_DAEMON:
case MainRequest::STOP_DAEMON:
denylist_handler(-1, nullptr);
write_int(client, 0);
// Terminate the daemon!
@ -201,13 +199,7 @@ static bool is_client(pid_t pid) {
return !(stat(path, &st) || st.st_dev != self_st.st_dev || st.st_ino != self_st.st_ino);
}
inline static void write_response(int client, DaemonResponse res) {
write_int(client, static_cast<std::underlying_type_t<DaemonResponse>>(res));
}
static void handle_request(pollfd *pfd) {
// using enum DAEMON_REQUEST;
// using enum DAEMON_RESPONSE;
int client = xaccept4(pfd->fd, nullptr, nullptr, SOCK_CLOEXEC);
// Verify client credentials
@ -215,7 +207,6 @@ static void handle_request(pollfd *pfd) {
bool is_root;
bool is_zygote;
int code;
DaemonRequest req;
if (!get_client_cred(client, &cred))
goto done;
@ -226,30 +217,27 @@ static void handle_request(pollfd *pfd) {
goto done;
code = read_int(client);
static_assert(is_scoped_enum_v<DaemonRequest>);
if (code < 0 || code >= DaemonRequest::END || code == DaemonRequest::_SYNC_BARRIER_)
if (code < 0 || code >= MainRequest::END || code == MainRequest::_SYNC_BARRIER_)
goto done;
req = static_cast<DaemonRequest>(code);
// Check client permissions
switch (req) {
case DaemonRequest::POST_FS_DATA:
case DaemonRequest::LATE_START:
case DaemonRequest::BOOT_COMPLETE:
case DaemonRequest::SQLITE_CMD:
case DaemonRequest::GET_PATH:
case DaemonRequest::DENYLIST:
case DaemonRequest::STOP_DAEMON:
switch (code) {
case MainRequest::POST_FS_DATA:
case MainRequest::LATE_START:
case MainRequest::BOOT_COMPLETE:
case MainRequest::SQLITE_CMD:
case MainRequest::GET_PATH:
case MainRequest::DENYLIST:
case MainRequest::STOP_DAEMON:
if (!is_root) {
write_response(client, DaemonResponse::ROOT_REQUIRED);
write_int(client, MainResponse::ROOT_REQUIRED);
goto done;
}
break;
case DaemonRequest::REMOVE_MODULES:
case MainRequest::REMOVE_MODULES:
if (!is_root && cred.uid != UID_SHELL) {
write_response(client, DaemonResponse::ROOT_REQUIRED);
write_int(client, MainResponse::ROOT_REQUIRED);
goto done;
}
break;
@ -257,15 +245,15 @@ static void handle_request(pollfd *pfd) {
break;
}
write_response(client, DaemonResponse::OK);
write_int(client, MainResponse::OK);
if (req < DaemonRequest::_SYNC_BARRIER_) {
handle_request_sync(client, req);
if (code < MainRequest::_SYNC_BARRIER_) {
handle_request_sync(client, code);
goto done;
}
// Handle complex requests in another thread
exec_task([=] { handle_request_async(client, req, cred); });
exec_task([=] { handle_request_async(client, code, cred); });
return;
done:
@ -402,8 +390,7 @@ static void daemon_entry() {
poll_loop();
}
int connect_daemon(DaemonRequest req, bool create) {
// using enum DAEMON_RESPONSE;
int connect_daemon(int req, bool create) {
sockaddr_un sun{};
socklen_t len = setup_sockaddr(&sun, MAIN_SOCKET);
int fd = xsocket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0);
@ -422,23 +409,23 @@ int connect_daemon(DaemonRequest req, bool create) {
while (connect(fd, (struct sockaddr *) &sun, len))
usleep(10000);
}
write_int(fd, static_cast<int>(req));
int ret = read_int(fd);
auto res = (ret < DaemonResponse::ERROR || ret >= DaemonResponse::END) ? DaemonResponse::ERROR
: static_cast<DaemonResponse>(ret);
write_int(fd, req);
int res = read_int(fd);
if (res < MainResponse::ERROR || res >= MainResponse::END)
res = MainResponse::ERROR;
switch (res) {
case DaemonResponse::OK:
case MainResponse::OK:
break;
case DaemonResponse::ERROR:
case MainResponse::ERROR:
LOGE("Daemon error\n");
exit(-1);
case DaemonResponse::ROOT_REQUIRED:
case MainResponse::ROOT_REQUIRED:
LOGE("Root is required for this operation\n");
exit(-1);
case DaemonResponse::INVALID_REQUEST:
case MainResponse::INVALID_REQUEST:
LOGE("Invalid request\n");
exit(-1);
case DaemonResponse::END:
default:
__builtin_unreachable();
}
return fd;

21
native/jni/core/magisk.cpp
View File

@ -50,19 +50,18 @@ Available applets:
}
int magisk_main(int argc, char *argv[]) {
// using enum DAEMON_REQUEST;
if (argc < 2)
usage();
if (argv[1] == "-c"sv) {
printf(MAGISK_VERSION ":MAGISK (" str(MAGISK_VER_CODE) ")\n");
return 0;
} else if (argv[1] == "-v"sv) {
int fd = connect_daemon(DaemonRequest::CHECK_VERSION);
int fd = connect_daemon(MainRequest::CHECK_VERSION);
string v = read_string(fd);
printf("%s\n", v.data());
return 0;
} else if (argv[1] == "-V"sv) {
int fd = connect_daemon(DaemonRequest::CHECK_VERSION_CODE);
int fd = connect_daemon(MainRequest::CHECK_VERSION_CODE);
printf("%d\n", read_int(fd));
return 0;
} else if (argv[1] == "--list"sv) {
@ -82,25 +81,25 @@ int magisk_main(int argc, char *argv[]) {
cp_afc(argv[2], argv[3]);
return 0;
} else if (argv[1] == "--daemon"sv) {
int fd = connect_daemon(DaemonRequest::START_DAEMON, true);
int fd = connect_daemon(MainRequest::START_DAEMON, true);
close(fd);
return 0;
} else if (argv[1] == "--stop"sv) {
int fd = connect_daemon(DaemonRequest::STOP_DAEMON);
int fd = connect_daemon(MainRequest::STOP_DAEMON);
return read_int(fd);
} else if (argv[1] == "--post-fs-data"sv) {
int fd = connect_daemon(DaemonRequest::POST_FS_DATA, true);
int fd = connect_daemon(MainRequest::POST_FS_DATA, true);
return read_int(fd);
} else if (argv[1] == "--service"sv) {
int fd = connect_daemon(DaemonRequest::LATE_START, true);
int fd = connect_daemon(MainRequest::LATE_START, true);
return read_int(fd);
} else if (argv[1] == "--boot-complete"sv) {
int fd = connect_daemon(DaemonRequest::BOOT_COMPLETE, true);
int fd = connect_daemon(MainRequest::BOOT_COMPLETE, true);
return read_int(fd);
} else if (argv[1] == "--denylist"sv) {
return denylist_cli(argc - 1, argv + 1);
} else if (argc >= 3 && argv[1] == "--sqlite"sv) {
int fd = connect_daemon(DaemonRequest::SQLITE_CMD);
int fd = connect_daemon(MainRequest::SQLITE_CMD);
write_string(fd, argv[2]);
string res;
for (;;) {
@ -110,10 +109,10 @@ int magisk_main(int argc, char *argv[]) {
printf("%s\n", res.data());
}
} else if (argv[1] == "--remove-modules"sv) {
int fd = connect_daemon(DaemonRequest::REMOVE_MODULES);
int fd = connect_daemon(MainRequest::REMOVE_MODULES);
return read_int(fd);
} else if (argv[1] == "--path"sv) {
int fd = connect_daemon(DaemonRequest::GET_PATH);
int fd = connect_daemon(MainRequest::GET_PATH);
string path = read_string(fd);
printf("%s\n", path.data());
return 0;

12
native/jni/include/daemon.hpp
View File

@ -10,7 +10,8 @@
#include <socket.hpp>
// Daemon command codes
enum class DaemonRequest: int {
namespace MainRequest {
enum : int {
START_DAEMON,
CHECK_VERSION,
CHECK_VERSION_CODE,
@ -26,18 +27,21 @@ enum class DaemonRequest: int {
DENYLIST,
SQLITE_CMD,
REMOVE_MODULES,
ZYGISK_REQUEST,
ZYGISK,
END,
};
}
// Return codes for daemon
enum class DaemonResponse: int {
namespace MainResponse {
enum : int {
ERROR = -1,
OK = 0,
ROOT_REQUIRED,
INVALID_REQUEST,
END
};
}
struct module_info {
std::string name;
@ -52,7 +56,7 @@ extern int app_process_32;
extern int app_process_64;
extern std::vector<module_info> *module_list;
int connect_daemon(DaemonRequest req, bool create = false);
int connect_daemon(int req, bool create = false);
// Poll control
using poll_callback = void(*)(pollfd*);

2
native/jni/su/su.cpp
View File

@ -159,7 +159,7 @@ int su_client_main(int argc, char *argv[]) {
int ptmx, fd;
// Connect to client
fd = connect_daemon(DaemonRequest::SUPERUSER);
fd = connect_daemon(MainRequest::SUPERUSER);
// Send su_request
xwrite(fd, &su_req, sizeof(su_req_base));

31
native/jni/utils/misc.hpp
View File

@ -5,8 +5,6 @@
#include <functional>
#include <string_view>
#include <bitset>
#include <compare>
#include "xwrap.hpp"
#define UID_ROOT 0
#define UID_SHELL 2000
@ -199,32 +197,3 @@ void exec_command_async(Args &&...args) {
};
exec_command(exec);
}
template <class _Tp, bool = std::is_enum_v<_Tp> >
struct __is_scoped_enum_helper : std::false_type {};
template <class _Tp>
struct __is_scoped_enum_helper<_Tp, true>
: public std::bool_constant<!std::is_convertible_v<_Tp, std::underlying_type_t<_Tp> > > {};
template <class _Tp>
struct is_scoped_enum
: public __is_scoped_enum_helper<_Tp> {};
template <class _Tp>
inline constexpr bool is_scoped_enum_v = is_scoped_enum<_Tp>::value;
template<typename Enum> requires( is_scoped_enum_v<Enum> )
constexpr inline auto operator <=> (std::underlying_type_t<Enum> a, Enum b) {
return a <=> static_cast<std::underlying_type_t<Enum>>(b);
}
template<typename Enum> requires( is_scoped_enum_v<Enum> )
constexpr inline auto operator != (std::underlying_type_t<Enum> a, Enum b) {
return a != static_cast<std::underlying_type_t<Enum>>(b);
}
template<typename Enum> requires( is_scoped_enum_v<Enum> )
constexpr inline auto operator == (std::underlying_type_t<Enum> a, Enum b) {
return a == static_cast<std::underlying_type_t<Enum>>(b);
}

29
native/jni/zygisk/deny/cli.cpp
View File

@ -32,12 +32,10 @@ void denylist_handler(int client, const sock_cred *cred) {
return;
}
DenyResponse res = DenyResponse::ERROR;
int req = read_int(client);
int res = DenyResponse::ERROR;
int code = read_int(client);
auto req = static_cast<DenyRequest>(code);
if (code < 0 || code >= DenyRequest::END) {
if (req < 0 || req >= DenyRequest::END) {
goto done;
}
@ -58,14 +56,14 @@ void denylist_handler(int client, const sock_cred *cred) {
ls_list(client);
return;
case DenyRequest::STATUS:
res = (zygisk_enabled && denylist_enforced) ? DenyResponse::ENFORCED
: DenyResponse::NOT_ENFORCED;
res = (zygisk_enabled && denylist_enforced)
? DenyResponse::ENFORCED : DenyResponse::NOT_ENFORCED;
break;
case DenyRequest::END:
default:
__builtin_unreachable();
}
done:
write_int(client, static_cast<int>(res));
write_int(client, res);
close(client);
}
@ -73,7 +71,7 @@ int denylist_cli(int argc, char **argv) {
if (argc < 2)
usage();
DenyRequest req;
int req;
if (argv[1] == "enable"sv)
req = DenyRequest::ENFORCE;
else if (argv[1] == "disable"sv)
@ -97,16 +95,17 @@ int denylist_cli(int argc, char **argv) {
}
// Send request
int fd = deny_request(req);
int fd = connect_daemon(MainRequest::DENYLIST);
write_int(fd, req);
if (req == DenyRequest::ADD || req == DenyRequest::REMOVE) {
write_string(fd, argv[2]);
write_string(fd, argv[3] ? argv[3] : "");
}
// Get response
int code = read_int(fd);
auto res = (code < 0 || code >= DenyResponse::END) ? DenyResponse::ERROR
: static_cast<DenyResponse>(code);
int res = read_int(fd);
if (res < 0 || res >= DenyResponse::END)
res = DenyResponse::ERROR;
switch (res) {
case DenyResponse::NOT_ENFORCED:
fprintf(stderr, "Denylist is not enforced\n");
@ -131,7 +130,7 @@ int denylist_cli(int argc, char **argv) {
return -1;
case DenyResponse::OK:
break;
case DenyResponse::END:
default:
__builtin_unreachable();
}

23
native/jni/zygisk/deny/deny.hpp
View File

@ -10,7 +10,8 @@
#define ISOLATED_MAGIC "isolated"
enum class DenyRequest : int {
namespace DenyRequest {
enum : int {
ENFORCE,
DISABLE,
ADD,
@ -20,8 +21,10 @@ enum class DenyRequest : int {
END
};
}
enum class DenyResponse: int {
namespace DenyResponse {
enum : int {
OK,
ENFORCED,
NOT_ENFORCED,
@ -33,13 +36,13 @@ enum class DenyResponse: int {
END
};
}
// CLI entries
DenyResponse enable_deny();
DenyResponse disable_deny();
DenyResponse add_list(int client);
DenyResponse rm_list(int client);
int enable_deny();
int disable_deny();
int add_list(int client);
int rm_list(int client);
void ls_list(int client);
// Utility functions
@ -49,9 +52,3 @@ void revert_unmount();
extern std::atomic<bool> denylist_enforced;
extern std::atomic<int> cached_manager_app_id;
inline int deny_request(DenyRequest req) {
int fd = connect_daemon(DaemonRequest::DENYLIST);
write_int(fd, static_cast<std::underlying_type_t<DenyRequest>>(req));
return fd;
}

12
native/jni/zygisk/deny/utils.cpp
View File

@ -226,7 +226,7 @@ error:
return false;
}
static DenyResponse add_list(const char *pkg, const char *proc) {
static int add_list(const char *pkg, const char *proc) {
if (proc[0] == '\0')
proc = pkg;
@ -252,13 +252,13 @@ static DenyResponse add_list(const char *pkg, const char *proc) {
return DenyResponse::OK;
}
DenyResponse add_list(int client) {
int add_list(int client) {
string pkg = read_string(client);
string proc = read_string(client);
return add_list(pkg.data(), proc.data());
}
static DenyResponse rm_list(const char *pkg, const char *proc) {
static int rm_list(const char *pkg, const char *proc) {
{
mutex_guard lock(data_lock);
if (!ensure_data())
@ -298,7 +298,7 @@ static DenyResponse rm_list(const char *pkg, const char *proc) {
return DenyResponse::OK;
}
DenyResponse rm_list(int client) {
int rm_list(int client) {
string pkg = read_string(client);
string proc = read_string(client);
return rm_list(pkg.data(), proc.data());
@ -342,7 +342,7 @@ static void update_deny_config() {
db_err(err);
}
DenyResponse enable_deny() {
int enable_deny() {
if (denylist_enforced) {
return DenyResponse::OK;
} else {
@ -377,7 +377,7 @@ DenyResponse enable_deny() {
return DenyResponse::OK;
}
DenyResponse disable_deny() {
int disable_deny() {
if (denylist_enforced) {
denylist_enforced = false;
LOGI("* Disable DenyList\n");

8
native/jni/zygisk/entry.cpp
View File

@ -399,18 +399,16 @@ static void get_moddir(int client) {
}
void zygisk_handler(int client, const sock_cred *cred) {
// using enum ZYGISK_REQUEST;
int code = read_int(client);
char buf[256];
if (code < ZygiskRequest::SETUP || code >= ZygiskRequest::END) {
write_int(client, -1);
return;
}
auto req = static_cast<ZygiskRequest>(code);
if (req != ZygiskRequest::PASSTHROUGH && cred->context != "u:r:zygote:s0") {
if (code != ZygiskRequest::PASSTHROUGH && cred->context != "u:r:zygote:s0") {
return;
}
switch (req) {
switch (code) {
case ZygiskRequest::SETUP:
setup_files(client, cred);
break;
@ -430,7 +428,7 @@ void zygisk_handler(int client, const sock_cred *cred) {
case ZygiskRequest::GET_MODDIR:
get_moddir(client);
break;
case ZygiskRequest::END:
default:
__builtin_unreachable();
}
close(client);

11
native/jni/zygisk/zygisk.hpp
View File

@ -10,7 +10,8 @@
#define MAGISKFD_ENV "MAGISKFD"
#define MAGISKTMP_ENV "MAGISKTMP"
enum class ZygiskRequest : int {
namespace ZygiskRequest {
enum : int {
SETUP,
GET_INFO,
GET_LOG_PIPE,
@ -19,6 +20,7 @@ enum class ZygiskRequest : int {
PASSTHROUGH,
END
};
}
#if defined(__LP64__)
#define ZLOGD(...) LOGD("zygisk64: " __VA_ARGS__)
@ -51,9 +53,8 @@ void hook_functions();
int remote_get_info(int uid, const char *process, uint32_t *flags, std::vector<int> &fds);
int remote_request_unmount();
inline int zygisk_request(ZygiskRequest req) {
int fd = connect_daemon(DaemonRequest::ZYGISK_REQUEST, false);
write_int(fd, static_cast<int>(req));
inline int zygisk_request(int req) {
int fd = connect_daemon(MainRequest::ZYGISK);
write_int(fd, req);
return fd;
}