diff --git a/.gitignore b/.gitignore index 75f03da5..51f806c9 100644 --- a/.gitignore +++ b/.gitignore @@ -4,4 +4,7 @@ x86 obj local.properties gen -.DS_Store \ No newline at end of file +.DS_Store +.settings +libs +build diff --git a/Android.mk b/Android.mk index 93b3c740..0b9d2689 100644 --- a/Android.mk +++ b/Android.mk @@ -14,33 +14,58 @@ endif LOCAL_PATH := $(my_path) - include $(CLEAR_VARS) LOCAL_MODULE := su -LOCAL_MODULE_TAGS := eng debug +LOCAL_MODULE_TAGS := eng debug optional LOCAL_FORCE_STATIC_EXECUTABLE := true -LOCAL_STATIC_LIBRARIES := libc +LOCAL_STATIC_LIBRARIES := libc libcutils LOCAL_C_INCLUDES := external/sqlite/dist -LOCAL_SRC_FILES := Superuser/jni/su/su.c Superuser/jni/su/activity.c Superuser/jni/su/db.c Superuser/jni/su/utils.c ../../sqlite/dist/sqlite3.c +LOCAL_SRC_FILES := Superuser/jni/su/su.c Superuser/jni/su/daemon.c Superuser/jni/su/activity.c Superuser/jni/su/db.c Superuser/jni/su/utils.c Superuser/jni/su/pts.c ../../sqlite/dist/sqlite3.c LOCAL_CFLAGS := -DSQLITE_OMIT_LOAD_EXTENSION -DREQUESTOR=\"$(SUPERUSER_PACKAGE)\" + ifdef SUPERUSER_PACKAGE_PREFIX LOCAL_CFLAGS += -DREQUESTOR_PREFIX=\"$(SUPERUSER_PACKAGE_PREFIX)\" endif + +ifdef SUPERUSER_EMBEDDED + LOCAL_CFLAGS += -DSUPERUSER_EMBEDDED +endif + LOCAL_MODULE_PATH := $(TARGET_OUT_OPTIONAL_EXECUTABLES) include $(BUILD_EXECUTABLE) + SYMLINKS := $(addprefix $(TARGET_OUT)/bin/,su) -$(SYMLINKS): $(LOCAL_MODULE) -$(SYMLINKS): $(LOCAL_INSTALLED_MODULE) $(LOCAL_PATH)/Android.mk +$(SYMLINKS): @echo "Symlink: $@ -> /system/xbin/su" @mkdir -p $(dir $@) @rm -rf $@ - $(hide) ln -sf /system/xbin/su $@ + $(hide) ln -sf ../xbin/su $@ ALL_DEFAULT_INSTALLED_MODULES += $(SYMLINKS) # We need this so that the installed files could be picked up based on the # local module name ALL_MODULES.$(LOCAL_MODULE).INSTALLED := \ - $(ALL_MODULES.$(LOCAL_MODULE).INSTALLED) $(SYMLINKS) \ No newline at end of file + $(ALL_MODULES.$(LOCAL_MODULE).INSTALLED) $(SYMLINKS) + +ifdef SUPERUSER_EMBEDDED + +# make sure init.superuser.rc is imported from +# init.rc or similar + +SUPERUSER_RC := $(TARGET_ROOT_OUT)/init.superuser.rc +$(SUPERUSER_RC): $(LOCAL_PATH)/init.superuser.rc | $(ACP) + $(copy-file-to-new-target) + +SUPERUSER_MARKER := $(TARGET_OUT_ETC)/.has_su_daemon +$(SUPERUSER_MARKER): $(LOCAL_INSTALLED_MODULE) + @mkdir -p $(dir $@) + @rm -rf $@ + $(hide) touch $@ + +ALL_MODULES.$(LOCAL_MODULE).INSTALLED := \ + $(ALL_MODULES.$(LOCAL_MODULE).INSTALLED) $(SUPERUSER_RC) $(SUPERUSER_MARKER) + +endif diff --git a/README.md b/README.md index 7e2bebd7..6fb87f86 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,8 @@ You'll need the "Widgets" dependency. These repositories do not keep the actual projects in the top level directory. This is because they contain tests, libs, and samples. +Make sure the SDK Platform for API 19 is installed, through the Android SDK Manager. Install NDK Revision 9b from [here](http://developer.android.com/tools/sdk/ndk/index.html). + ## Eclipse In Eclipse, import Widgets/Widgets and Superuser/Superuser. It should Just Work (TM). @@ -36,21 +38,30 @@ In Eclipse, import Widgets/Widgets and Superuser/Superuser. It should Just Work * $ cd /path/to/src * $ cd Superuser/Superuser -In this directory, create a file called local.properties. This file is used by ant for custom properties. You need to specify the location of the ndk directory: +In this directory, create a file called local.properties. This file is used by ant for custom properties. You need to specify the location of the ndk directory and your keystore parameters: ``` ndk.dir=/Users/koush/src/android-ndk +key.store=/Users/koush/.keystore +key.alias=mykey ``` +If you do not have a release key yet, [create one using keytool](http://developer.android.com/tools/publishing/app-signing.html). + +Set up your SDK path (this is the directory containing platform-tools/, tools/, etc.): + +* $ export ANDROID_HOME=/Users/koush/src/sdk + Then you can build: * $ ant release Outputs: * bin/update.zip - Recovery installable zip -* bin/Superuser.apk - Superuser Android app +* bin/Superuser-release.apk - Superuser Android app * libs/armeabi/su - ARM su binary * libs/x86/su - x86 su binary +* libs/mips/su - MIPS su binary ## Building the su binary diff --git a/Superuser/.classpath b/Superuser/.classpath index 3f9691c5..d57ec025 100644 --- a/Superuser/.classpath +++ b/Superuser/.classpath @@ -1,8 +1,9 @@ - + + diff --git a/Superuser/AndroidManifest.xml b/Superuser/AndroidManifest.xml index cb102024..18dc2027 100644 --- a/Superuser/AndroidManifest.xml +++ b/Superuser/AndroidManifest.xml @@ -1,12 +1,8 @@ - - + android:versionCode="1030" + android:versionName="1.0.3.0" > - + + + + + + + + + + + + + + + + - \ No newline at end of file + diff --git a/Superuser/Superuser-Superuser.iml b/Superuser/Superuser-Superuser.iml new file mode 100644 index 00000000..2ed1ea53 --- /dev/null +++ b/Superuser/Superuser-Superuser.iml @@ -0,0 +1,86 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Superuser/Superuser.iml b/Superuser/Superuser.iml new file mode 100644 index 00000000..1a156d41 --- /dev/null +++ b/Superuser/Superuser.iml @@ -0,0 +1,20 @@ + + + + + + + + + + + + + + + + + + + + diff --git a/Superuser/assets/install-recovery.sh b/Superuser/assets/install-recovery.sh new file mode 100755 index 00000000..cf192b73 --- /dev/null +++ b/Superuser/assets/install-recovery.sh @@ -0,0 +1,2 @@ +#!/system/bin/sh +/system/xbin/su --daemon & diff --git a/Superuser/assets/mips b/Superuser/assets/mips new file mode 120000 index 00000000..9639e381 --- /dev/null +++ b/Superuser/assets/mips @@ -0,0 +1 @@ +../libs/mips \ No newline at end of file diff --git a/Superuser/assets/update-binary b/Superuser/assets/update-binary old mode 100644 new mode 100755 index 1c5cc31f..8bfe957f --- a/Superuser/assets/update-binary +++ b/Superuser/assets/update-binary @@ -6,10 +6,14 @@ echo -n -e 'ui_print Installing Superuser...\n' > /proc/self/fd/$2 echo -n -e 'ui_print\n' > /proc/self/fd/$2 -X86=$(uname -a | grep x86) -if [ ! -z "$X86" ] -then +# detect binary versions to install +ARCH=$(uname -m) + +# x86 needs to match: i486, i686, x86_64, ... +if echo "$ARCH" | grep -q 86; then PLATFORM=x86 +elif [ "$ARCH" = "mips" -o "$ARCH" = "mips64" ]; then + PLATFORM=mips else PLATFORM=armeabi fi @@ -23,6 +27,7 @@ then mkdir -p $PLATFORM cp /cache/su $PLATFORM/su cp /cache/Superuser.apk . + cp /cache/install-recovery.sh . fi @@ -30,6 +35,8 @@ echo -n -e 'ui_print Installing '$PLATFORM' binaries...\n' > /proc/self/fd/$2 echo -n -e 'ui_print\n' > /proc/self/fd/$2 mount /system +chattr -i /system/bin/su +chattr -i /system/xbin/su rm -f /system/bin/su rm -f /system/xbin/su rm -f /system/app/Superuser.* @@ -47,4 +54,29 @@ ln -s /system/xbin/su /system/bin/su cp Superuser.apk /system/app chmod 644 /system/app/Superuser.apk +# if the system is at least 4.3, and there is no su daemon built in, +# let's try to install it using install-recovery.sh +BUILD_VERSION_SDK="$(grep 'ro\.build\.version\.sdk' /system/build.prop)" +BUILD_VERSION_SDK="${BUILD_VERSION_SDK##*=}" + +if [ "$BUILD_VERSION_SDK" -ge 18 ] +then + # check for rom su daemon before clobbering install-recovery.sh + if [ ! -f "/system/etc/.has_su_daemon" ] + then + echo -n -e 'ui_print Installing Superuser daemon...\n' > /proc/self/fd/$2 + echo -n -e 'ui_print\n' > /proc/self/fd/$2 + chattr -i /system/etc/install-recovery.sh + chattr -i /system/bin/install-recovery.sh + cp install-recovery.sh /system/etc/install-recovery.sh + cp install-recovery.sh /system/bin/install-recovery.sh + chmod 755 /system/etc/install-recovery.sh + chmod 755 /system/bin/install-recovery.sh + # note that an post install su daemon was installed + # so recovery doesn't freak out and recommend you disable + # the install-recovery.sh execute bit. + touch /system/etc/.installed_su_daemon + fi +fi + umount /system \ No newline at end of file diff --git a/Superuser/build.gradle b/Superuser/build.gradle new file mode 100644 index 00000000..bb868821 --- /dev/null +++ b/Superuser/build.gradle @@ -0,0 +1,51 @@ +task wrapper(type: Wrapper) { + gradleVersion = '1.6' +} + +buildscript { + repositories { + mavenCentral() + } + dependencies { + classpath 'com.android.tools.build:gradle:0.12.+' + } +} +apply plugin: 'com.android.application' + +repositories { + mavenCentral() +} + +dependencies { + compile project(':Widgets:Widgets') +} + +android { + packagingOptions { + exclude 'META-INF/beans.xml' + } + + sourceSets { + main { + manifest.srcFile 'AndroidManifest.xml' + jniLibs.srcDirs = ['libs'] + assets.srcDirs = ['assets/'] + res.srcDirs = ['res/'] + java.srcDirs = ['src/'] + aidl.srcDirs = ['src/'] + } + } + + compileSdkVersion 21 + buildToolsVersion '20.0.0' + + defaultConfig { + minSdkVersion 14 + targetSdkVersion 21 + } +} + +// upload to maven task +//if (System.getenv().I_AM_KOUSH == 'true') { +// apply from: 'https://raw.github.com/koush/mvn-repo/master/maven.gradle' +//} diff --git a/Superuser/build.xml b/Superuser/build.xml index 5500c8a1..d85611be 100644 --- a/Superuser/build.xml +++ b/Superuser/build.xml @@ -86,6 +86,7 @@ + @@ -98,6 +99,7 @@ + diff --git a/Superuser/jni/Android.mk b/Superuser/jni/Android.mk index 6d27fdd4..04c7b8b1 100644 --- a/Superuser/jni/Android.mk +++ b/Superuser/jni/Android.mk @@ -3,16 +3,25 @@ LOCAL_PATH := $(call my-dir) include $(CLEAR_VARS) LOCAL_MODULE := su -LOCAL_LDFLAGS := -static +LOCAL_FORCE_STATIC_EXECUTABLE := true +LOCAL_STATIC_LIBRARIES := sqlite3 libcutils libc +LOCAL_C_INCLUDES := $(LOCAL_PATH)/sqlite3 +LOCAL_SRC_FILES := su/su.c su/activity.c su/db.c su/utils.c su/daemon.c su/pts.c +include $(BUILD_EXECUTABLE) + + +include $(CLEAR_VARS) + +LOCAL_MODULE := reboot +LOCAL_LDFLAGS := -llog LOCAL_STATIC_LIBRARIES := sqlite3 LOCAL_C_INCLUDES := $(LOCAL_PATH)/sqlite3 -LOCAL_SRC_FILES := su/su.c su/activity.c su/db.c su/utils.c +LOCAL_SRC_FILES := reboot/reboot.c include $(BUILD_EXECUTABLE) include $(CLEAR_VARS) -LOCAL_ARM_MODE := arm LOCAL_MODULE := sqlite3 LOCAL_SRC_FILES := sqlite3/sqlite3.c LOCAL_CFLAGS := -DSQLITE_OMIT_LOAD_EXTENSION diff --git a/Superuser/jni/Application.mk b/Superuser/jni/Application.mk index c1f99ebf..9651e05d 100644 --- a/Superuser/jni/Application.mk +++ b/Superuser/jni/Application.mk @@ -1,3 +1,3 @@ -APP_ABI := x86 armeabi -NDK_TOOLCHAIN_VERSION=4.7 -APP_PIE = false \ No newline at end of file +APP_ABI := x86 armeabi mips +# NDK_TOOLCHAIN_VERSION=4.8 +APP_PIE = true \ No newline at end of file diff --git a/Superuser/jni/reboot/reboot.c b/Superuser/jni/reboot/reboot.c new file mode 100644 index 00000000..904b786c --- /dev/null +++ b/Superuser/jni/reboot/reboot.c @@ -0,0 +1,145 @@ +/* +** Copyright 2013, Kevin Cernekee +** +** This was reverse engineered from an HTC "reboot" binary and is an attempt +** to remain bug-compatible with the original. +** +** 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 +#include +#include + +#include +#include +#include + +#define SETTINGS_DB "/data/data/com.android.providers.settings/databases/settings.db" +#define SCREEN_LOCK_STATUS "/data/misc/screen_lock_status" + +int pattern_lock; + +int sqlcallback(void *private, int n_columns, char **col_values, char **col_names) +{ + pattern_lock = 0; + + if (n_columns == 0 || !col_values[0]) + return 0; + + if (!strcmp(col_values[0], "1")) + pattern_lock = 1; + + __android_log_print(ANDROID_LOG_INFO, NULL, + "sqlcallback %s = %s, pattern_locks= %d\n", + col_names[0], col_values[0], pattern_lock); + return 0; +} + +int checkPatternLock(void) +{ + sqlite3 *pDb = NULL; + char *errmsg = NULL; + + if (sqlite3_open(SETTINGS_DB, &pDb) != 0) { + __android_log_print(ANDROID_LOG_ERROR, NULL, + "sqlite3_open error"); + /* BUG? probably shouldn't call sqlite3_close() if open failed */ + goto out; + } + + if (sqlite3_exec(pDb, + "select value from system where name= \"lock_pattern_autolock\"", + sqlcallback, "checkPatternLock", &errmsg) != 0) { + __android_log_print(ANDROID_LOG_ERROR, NULL, + "SQL error: %s\n", errmsg); + sqlite3_free(errmsg); + goto out; + } + +out: + sqlite3_close(pDb); + return 0; +} + +int main(int argc, char **argv) +{ + int no_sync = 0, power_off = 0; + int ret; + + opterr = 0; + while ((ret = getopt(argc, argv, "np")) != -1) { + switch (ret) { + case 'n': + no_sync = 1; + break; + case 'p': + power_off = 1; + break; + case '?': + fprintf(stderr, "usage: %s [-n] [-p] [rebootcommand]\n", + argv[0]); + exit(1); + break; + } + } + + if (argc > (optind + 1)) { + fprintf(stderr, "%s: too many arguments\n", argv[0]); + exit(1); + } + + /* BUG: this should use optind */ + if (argc > 1 && !strcmp(argv[1], "oem-78")) { + /* HTC RUU mode: "reboot oem-78" */ + + FILE *f; + char buf[5]; + + checkPatternLock(); + f = fopen(SCREEN_LOCK_STATUS, "r"); + if (!f) { + fputs("5\n", stderr); + exit(0); + } + fgets(buf, 5, f); + if (atoi(buf) == 1) { + if (pattern_lock != 0) { + fputs("1\n", stderr); + exit(0); + } + } + fputs("0\n", stderr); + } + + if (!no_sync) + sync(); + + if (power_off) { + ret = __reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, + LINUX_REBOOT_CMD_POWER_OFF, 0); + } else if (optind >= argc) { + ret = reboot(LINUX_REBOOT_CMD_RESTART); + } else { + ret = __reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, + LINUX_REBOOT_CMD_RESTART2, argv[optind]); + } + + if (ret < 0) { + perror("reboot"); + exit(1); + } else { + fputs("reboot returned\n", stderr); + exit(0); + } +} diff --git a/Superuser/jni/su/activity.c b/Superuser/jni/su/activity.c index 9bda4f98..a3ef9c7d 100644 --- a/Superuser/jni/su/activity.c +++ b/Superuser/jni/su/activity.c @@ -26,9 +26,15 @@ #include "su.h" +/* intent actions */ +#define ACTION_REQUEST "start", "-n", REQUESTOR "/" REQUESTOR_PREFIX ".RequestActivity" +#define ACTION_NOTIFY "start", "-n", REQUESTOR "/" REQUESTOR_PREFIX ".NotifyActivity" +#define ACTION_RESULT "broadcast", "-n", REQUESTOR "/" REQUESTOR_PREFIX ".SuReceiver" + +#define AM_PATH "/system/bin/app_process", "/system/bin", "com.android.commands.am.Am" + // TODO: leverage this with exec_log? -int silent_run(char* command) { - char *args[] = { "sh", "-c", command, NULL, }; +int silent_run(char* const args[]) { set_identity(0); pid_t pid; pid = fork(); @@ -45,7 +51,8 @@ int silent_run(char* command) { int null = open("/dev/null", O_WRONLY | O_CLOEXEC); dup2(null, 1); dup2(null, 2); - execv(_PATH_BSHELL, args); + setenv("CLASSPATH", "/system/framework/am.jar", 1); + execv(args[0], args); PLOGE("exec am"); _exit(EXIT_FAILURE); return -1; @@ -58,39 +65,97 @@ int get_owner_login_user_args(struct su_context *ctx, char* user, int user_len) if (0 != ctx->user.android_user_id) { needs_owner_login_prompt = 1; } - snprintf(user, user_len, "--user 0"); + snprintf(user, user_len, "0"); } else if (ctx->user.multiuser_mode == MULTIUSER_MODE_USER) { - snprintf(user, user_len, "--user %d", ctx->user.android_user_id); + snprintf(user, user_len, "%d", ctx->user.android_user_id); } else if (ctx->user.multiuser_mode == MULTIUSER_MODE_NONE) { user[0] = '\0'; } else { - snprintf(user, user_len, "--user 0"); + snprintf(user, user_len, "0"); } return needs_owner_login_prompt; } int send_result(struct su_context *ctx, policy_t policy) { + char binary_version[256]; + sprintf(binary_version, "%d", VERSION_CODE); + + char uid[256]; + sprintf(uid, "%d", ctx->from.uid); + + char desired_uid[256]; + sprintf(desired_uid, "%d", ctx->to.uid); + char user[64]; get_owner_login_user_args(ctx, user, sizeof(user)); - + if (0 != ctx->user.android_user_id) { - char user_result_command[ARG_MAX]; - snprintf(user_result_command, sizeof(user_result_command), "exec /system/bin/am " ACTION_RESULT " --ei binary_version %d --es from_name '%s' --es desired_name '%s' --ei uid %d --ei desired_uid %d --es command '%s' --es action %s --user %d", - VERSION_CODE, - ctx->from.name, ctx->to.name, - ctx->from.uid, ctx->to.uid, get_command(&ctx->to), policy == ALLOW ? "allow" : "deny", ctx->user.android_user_id); + char android_user_id[256]; + sprintf(android_user_id, "%d", ctx->user.android_user_id); + + char *user_result_command[] = { + AM_PATH, + ACTION_RESULT, + "--ei", + "binary_version", + binary_version, + "--es", + "from_name", + ctx->from.name, + "--es", + "desired_name", + ctx->to.name, + "--ei", + "uid", + uid, + "--ei", + "desired_uid", + desired_uid, + "--es", + "command", + get_command(&ctx->to), + "--es", + "action", + policy == ALLOW ? "allow" : "deny", + user[0] ? "--user" : NULL, + android_user_id, + NULL + }; silent_run(user_result_command); } - char result_command[ARG_MAX]; - snprintf(result_command, sizeof(result_command), "exec /system/bin/am " ACTION_RESULT " --ei binary_version %d --es from_name '%s' --es desired_name '%s' --ei uid %d --ei desired_uid %d --es command '%s' --es action %s %s", - VERSION_CODE, - ctx->from.name, ctx->to.name, - ctx->from.uid, ctx->to.uid, get_command(&ctx->to), policy == ALLOW ? "allow" : "deny", user); + char *result_command[] = { + AM_PATH, + ACTION_RESULT, + "--ei", + "binary_version", + binary_version, + "--es", + "from_name", + ctx->from.name, + "--es", + "desired_name", + ctx->to.name, + "--ei", + "uid", + uid, + "--ei", + "desired_uid", + desired_uid, + "--es", + "command", + get_command(&ctx->to), + "--es", + "action", + policy == ALLOW ? "allow" : "deny", + user[0] ? "--user" : NULL, + user, + NULL + }; return silent_run(result_command); } @@ -104,13 +169,23 @@ int send_request(struct su_context *ctx) { int ret; if (needs_owner_login_prompt) { - // in multiuser mode, the owner gets the su prompt - char notify_command[ARG_MAX]; + char uid[256]; + sprintf(uid, "%d", ctx->from.uid); - // start the activity that confirms the request - snprintf(notify_command, sizeof(notify_command), - "exec /system/bin/am " ACTION_NOTIFY " --ei caller_uid %d --user %d", - ctx->from.uid, ctx->user.android_user_id); + char android_user_id[256]; + sprintf(android_user_id, "%d", ctx->user.android_user_id); + + // in multiuser mode, the owner gets the su prompt + char *notify_command[] = { + AM_PATH, + ACTION_NOTIFY, + "--ei", + "caller_uid", + uid, + "--user", + android_user_id, + NULL + }; int ret = silent_run(notify_command); if (ret) { @@ -118,12 +193,16 @@ int send_request(struct su_context *ctx) { } } - char request_command[ARG_MAX]; - - // start the activity that confirms the request - snprintf(request_command, sizeof(request_command), - "exec /system/bin/am " ACTION_REQUEST " --es socket '%s' %s", - ctx->sock_path, user); + char *request_command[] = { + AM_PATH, + ACTION_REQUEST, + "--es", + "socket", + ctx->sock_path, + user[0] ? "--user" : NULL, + user, + NULL + }; return silent_run(request_command); } diff --git a/Superuser/jni/su/daemon.c b/Superuser/jni/su/daemon.c new file mode 100644 index 00000000..c75a5ea6 --- /dev/null +++ b/Superuser/jni/su/daemon.c @@ -0,0 +1,658 @@ +/* +** Copyright 2010, Adam Shanks (@ChainsDD) +** Copyright 2008, Zinx Verituse (@zinxv) +** +** 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. +*/ + +#define _GNU_SOURCE /* for unshare() */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef SUPERUSER_EMBEDDED +#include +#endif + +#include "su.h" +#include "utils.h" +#include "pts.h" + +int is_daemon = 0; +int daemon_from_uid = 0; +int daemon_from_pid = 0; + +// Constants for the atty bitfield +#define ATTY_IN 1 +#define ATTY_OUT 2 +#define ATTY_ERR 4 + +/* + * Receive a file descriptor from a Unix socket. + * Contributed by @mkasick + * + * Returns the file descriptor on success, or -1 if a file + * descriptor was not actually included in the message + * + * On error the function terminates by calling exit(-1) + */ +static int recv_fd(int sockfd) { + // Need to receive data from the message, otherwise don't care about it. + char iovbuf; + + struct iovec iov = { + .iov_base = &iovbuf, + .iov_len = 1, + }; + + char cmsgbuf[CMSG_SPACE(sizeof(int))]; + + struct msghdr msg = { + .msg_iov = &iov, + .msg_iovlen = 1, + .msg_control = cmsgbuf, + .msg_controllen = sizeof(cmsgbuf), + }; + + if (recvmsg(sockfd, &msg, MSG_WAITALL) != 1) { + goto error; + } + + // Was a control message actually sent? + switch (msg.msg_controllen) { + case 0: + // No, so the file descriptor was closed and won't be used. + return -1; + case sizeof(cmsgbuf): + // Yes, grab the file descriptor from it. + break; + default: + goto error; + } + + struct cmsghdr *cmsg = CMSG_FIRSTHDR(&msg); + + if (cmsg == NULL || + cmsg->cmsg_len != CMSG_LEN(sizeof(int)) || + cmsg->cmsg_level != SOL_SOCKET || + cmsg->cmsg_type != SCM_RIGHTS) { +error: + LOGE("unable to read fd"); + exit(-1); + } + + return *(int *)CMSG_DATA(cmsg); +} + +/* + * Send a file descriptor through a Unix socket. + * Contributed by @mkasick + * + * On error the function terminates by calling exit(-1) + * + * fd may be -1, in which case the dummy data is sent, + * but no control message with the FD is sent. + */ +static void send_fd(int sockfd, int fd) { + // Need to send some data in the message, this will do. + struct iovec iov = { + .iov_base = "", + .iov_len = 1, + }; + + struct msghdr msg = { + .msg_iov = &iov, + .msg_iovlen = 1, + }; + + char cmsgbuf[CMSG_SPACE(sizeof(int))]; + + if (fd != -1) { + // Is the file descriptor actually open? + if (fcntl(fd, F_GETFD) == -1) { + if (errno != EBADF) { + goto error; + } + // It's closed, don't send a control message or sendmsg will EBADF. + } else { + // It's open, send the file descriptor in a control message. + msg.msg_control = cmsgbuf; + msg.msg_controllen = sizeof(cmsgbuf); + + struct cmsghdr *cmsg = CMSG_FIRSTHDR(&msg); + + cmsg->cmsg_len = CMSG_LEN(sizeof(int)); + cmsg->cmsg_level = SOL_SOCKET; + cmsg->cmsg_type = SCM_RIGHTS; + + *(int *)CMSG_DATA(cmsg) = fd; + } + } + + if (sendmsg(sockfd, &msg, 0) != 1) { +error: + PLOGE("unable to send fd"); + exit(-1); + } +} + +static int read_int(int fd) { + int val; + int len = read(fd, &val, sizeof(int)); + if (len != sizeof(int)) { + LOGE("unable to read int: %d", len); + exit(-1); + } + return val; +} + +static void write_int(int fd, int val) { + int written = write(fd, &val, sizeof(int)); + if (written != sizeof(int)) { + PLOGE("unable to write int"); + exit(-1); + } +} + +static char* read_string(int fd) { + int len = read_int(fd); + if (len > PATH_MAX || len < 0) { + LOGE("invalid string length %d", len); + exit(-1); + } + char* val = malloc(sizeof(char) * (len + 1)); + if (val == NULL) { + LOGE("unable to malloc string"); + exit(-1); + } + val[len] = '\0'; + int amount = read(fd, val, len); + if (amount != len) { + LOGE("unable to read string"); + exit(-1); + } + return val; +} + +static void write_string(int fd, char* val) { + int len = strlen(val); + write_int(fd, len); + int written = write(fd, val, len); + if (written != len) { + PLOGE("unable to write string"); + exit(-1); + } +} + +#ifdef SUPERUSER_EMBEDDED +static void mount_emulated_storage(int user_id) { + const char *emulated_source = getenv("EMULATED_STORAGE_SOURCE"); + const char *emulated_target = getenv("EMULATED_STORAGE_TARGET"); + const char* legacy = getenv("EXTERNAL_STORAGE"); + + if (!emulated_source || !emulated_target) { + // No emulated storage is present + return; + } + + // Create a second private mount namespace for our process + if (unshare(CLONE_NEWNS) < 0) { + PLOGE("unshare"); + return; + } + + if (mount("rootfs", "/", NULL, MS_SLAVE | MS_REC, NULL) < 0) { + PLOGE("mount rootfs as slave"); + return; + } + + // /mnt/shell/emulated -> /storage/emulated + if (mount(emulated_source, emulated_target, NULL, MS_BIND, NULL) < 0) { + PLOGE("mount emulated storage"); + } + + char target_user[PATH_MAX]; + snprintf(target_user, PATH_MAX, "%s/%d", emulated_target, user_id); + + // /mnt/shell/emulated/ -> /storage/emulated/legacy + if (mount(target_user, legacy, NULL, MS_BIND | MS_REC, NULL) < 0) { + PLOGE("mount legacy path"); + } +} +#endif + +static int run_daemon_child(int infd, int outfd, int errfd, int argc, char** argv) { + if (-1 == dup2(outfd, STDOUT_FILENO)) { + PLOGE("dup2 child outfd"); + exit(-1); + } + + if (-1 == dup2(errfd, STDERR_FILENO)) { + PLOGE("dup2 child errfd"); + exit(-1); + } + + if (-1 == dup2(infd, STDIN_FILENO)) { + PLOGE("dup2 child infd"); + exit(-1); + } + + close(infd); + close(outfd); + close(errfd); + + return su_main(argc, argv, 0); +} + +static int daemon_accept(int fd) { + is_daemon = 1; + int pid = read_int(fd); + LOGD("remote pid: %d", pid); + char *pts_slave = read_string(fd); + LOGD("remote pts_slave: %s", pts_slave); + daemon_from_uid = read_int(fd); + LOGD("remote uid: %d", daemon_from_uid); + daemon_from_pid = read_int(fd); + LOGD("remote req pid: %d", daemon_from_pid); + + struct ucred credentials; + int ucred_length = sizeof(struct ucred); + /* fill in the user data structure */ + if(getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &credentials, &ucred_length)) { + LOGE("could obtain credentials from unix domain socket"); + exit(-1); + } + // if the credentials on the other side of the wire are NOT root, + // we can't trust anything being sent. + if (credentials.uid != 0) { + daemon_from_uid = credentials.uid; + pid = credentials.pid; + daemon_from_pid = credentials.pid; + } + + int mount_storage = read_int(fd); + // The the FDs for each of the streams + int infd = recv_fd(fd); + int outfd = recv_fd(fd); + int errfd = recv_fd(fd); + + int argc = read_int(fd); + if (argc < 0 || argc > 512) { + LOGE("unable to allocate args: %d", argc); + exit(-1); + } + LOGD("remote args: %d", argc); + char** argv = (char**)malloc(sizeof(char*) * (argc + 1)); + argv[argc] = NULL; + int i; + for (i = 0; i < argc; i++) { + argv[i] = read_string(fd); + } + + // ack + write_int(fd, 1); + + // Fork the child process. The fork has to happen before calling + // setsid() and opening the pseudo-terminal so that the parent + // is not affected + int child = fork(); + if (child < 0) { + // fork failed, send a return code and bail out + PLOGE("unable to fork"); + write(fd, &child, sizeof(int)); + close(fd); + return child; + } + + if (child != 0) { + // In parent, wait for the child to exit, and send the exit code + // across the wire. + int status, code; + + free(pts_slave); + + LOGD("waiting for child exit"); + if (waitpid(child, &status, 0) > 0) { + code = WEXITSTATUS(status); + } + else { + code = -1; + } + + // Pass the return code back to the client + LOGD("sending code"); + if (write(fd, &code, sizeof(int)) != sizeof(int)) { + PLOGE("unable to write exit code"); + } + + close(fd); + LOGD("child exited"); + return code; + } + + // We are in the child now + // Close the unix socket file descriptor + close (fd); + + // Become session leader + if (setsid() == (pid_t) -1) { + PLOGE("setsid"); + } + + int ptsfd; + if (pts_slave[0]) { + // Opening the TTY has to occur after the + // fork() and setsid() so that it becomes + // our controlling TTY and not the daemon's + ptsfd = open(pts_slave, O_RDWR); + if (ptsfd == -1) { + PLOGE("open(pts_slave) daemon"); + exit(-1); + } + + if (infd < 0) { + LOGD("daemon: stdin using PTY"); + infd = ptsfd; + } + if (outfd < 0) { + LOGD("daemon: stdout using PTY"); + outfd = ptsfd; + } + if (errfd < 0) { + LOGD("daemon: stderr using PTY"); + errfd = ptsfd; + } + } else { + // If a TTY was sent directly, make it the CTTY. + if (isatty(infd)) { + ioctl(infd, TIOCSCTTY, 1); + } + } + free(pts_slave); + +#ifdef SUPERUSER_EMBEDDED + if (mount_storage) { + mount_emulated_storage(multiuser_get_user_id(daemon_from_uid)); + } +#endif + + return run_daemon_child(infd, outfd, errfd, argc, argv); +} + +int run_daemon() { + if (getuid() != 0 || getgid() != 0) { + PLOGE("daemon requires root. uid/gid not root"); + return -1; + } + + int fd; + struct sockaddr_un sun; + + fd = socket(AF_LOCAL, SOCK_STREAM, 0); + if (fd < 0) { + PLOGE("socket"); + return -1; + } + if (fcntl(fd, F_SETFD, FD_CLOEXEC)) { + PLOGE("fcntl FD_CLOEXEC"); + goto err; + } + + memset(&sun, 0, sizeof(sun)); + sun.sun_family = AF_LOCAL; + sprintf(sun.sun_path, "%s/server", REQUESTOR_DAEMON_PATH); + + /* + * Delete the socket to protect from situations when + * something bad occured previously and the kernel reused pid from that process. + * Small probability, isn't it. + */ + unlink(sun.sun_path); + unlink(REQUESTOR_DAEMON_PATH); + + int previous_umask = umask(027); + mkdir(REQUESTOR_DAEMON_PATH, 0777); + + memset(sun.sun_path, 0, sizeof(sun.sun_path)); + memcpy(sun.sun_path, "\0" "SUPERUSER", strlen("SUPERUSER") + 1); + + if (bind(fd, (struct sockaddr*)&sun, sizeof(sun)) < 0) { + PLOGE("daemon bind"); + goto err; + } + + chmod(REQUESTOR_DAEMON_PATH, 0755); + chmod(sun.sun_path, 0777); + + umask(previous_umask); + + if (listen(fd, 10) < 0) { + PLOGE("daemon listen"); + goto err; + } + + int client; + while ((client = accept(fd, NULL, NULL)) > 0) { + if (fork_zero_fucks() == 0) { + close(fd); + return daemon_accept(client); + } + else { + close(client); + } + } + + LOGE("daemon exiting"); +err: + close(fd); + return -1; +} + +// List of signals which cause process termination +static int quit_signals[] = { SIGALRM, SIGHUP, SIGPIPE, SIGQUIT, SIGTERM, SIGINT, 0 }; + +static void sighandler(int sig) { + restore_stdin(); + + // Assume we'll only be called before death + // See note before sigaction() in set_stdin_raw() + // + // Now, close all standard I/O to cause the pumps + // to exit so we can continue and retrieve the exit + // code + close(STDIN_FILENO); + close(STDOUT_FILENO); + close(STDERR_FILENO); + + // Put back all the default handlers + struct sigaction act; + int i; + + memset(&act, '\0', sizeof(act)); + act.sa_handler = SIG_DFL; + for (i = 0; quit_signals[i]; i++) { + if (sigaction(quit_signals[i], &act, NULL) < 0) { + PLOGE("Error removing signal handler"); + continue; + } + } +} + +/** + * Setup signal handlers trap signals which should result in program termination + * so that we can restore the terminal to its normal state and retrieve the + * return code. + */ +static void setup_sighandlers(void) { + struct sigaction act; + int i; + + // Install the termination handlers + // Note: we're assuming that none of these signal handlers are already trapped. + // If they are, we'll need to modify this code to save the previous handler and + // call it after we restore stdin to its previous state. + memset(&act, '\0', sizeof(act)); + act.sa_handler = &sighandler; + for (i = 0; quit_signals[i]; i++) { + if (sigaction(quit_signals[i], &act, NULL) < 0) { + PLOGE("Error installing signal handler"); + continue; + } + } +} + +int connect_daemon(int argc, char *argv[], int ppid) { + int uid = getuid(); + int ptmx; + char pts_slave[PATH_MAX]; + + struct sockaddr_un sun; + + // Open a socket to the daemon + int socketfd = socket(AF_LOCAL, SOCK_STREAM, 0); + if (socketfd < 0) { + PLOGE("socket"); + exit(-1); + } + if (fcntl(socketfd, F_SETFD, FD_CLOEXEC)) { + PLOGE("fcntl FD_CLOEXEC"); + exit(-1); + } + + memset(&sun, 0, sizeof(sun)); + sun.sun_family = AF_LOCAL; + sprintf(sun.sun_path, "%s/server", REQUESTOR_DAEMON_PATH); + + memset(sun.sun_path, 0, sizeof(sun.sun_path)); + memcpy(sun.sun_path, "\0" "SUPERUSER", strlen("SUPERUSER") + 1); + + if (0 != connect(socketfd, (struct sockaddr*)&sun, sizeof(sun))) { + PLOGE("connect"); + exit(-1); + } + + LOGD("connecting client %d", getpid()); + + int mount_storage = getenv("MOUNT_EMULATED_STORAGE") != NULL; + + // Determine which one of our streams are attached to a TTY + int atty = 0; + + // Send TTYs directly (instead of proxying with a PTY) if + // the SUPERUSER_SEND_TTY environment variable is set. + if (getenv("SUPERUSER_SEND_TTY") == NULL) { + if (isatty(STDIN_FILENO)) atty |= ATTY_IN; + if (isatty(STDOUT_FILENO)) atty |= ATTY_OUT; + if (isatty(STDERR_FILENO)) atty |= ATTY_ERR; + } + + if (atty) { + // We need a PTY. Get one. + ptmx = pts_open(pts_slave, sizeof(pts_slave)); + if (ptmx < 0) { + PLOGE("pts_open"); + exit(-1); + } + } else { + pts_slave[0] = '\0'; + } + + // Send some info to the daemon, starting with our PID + write_int(socketfd, getpid()); + // Send the slave path to the daemon + // (This is "" if we're not using PTYs) + write_string(socketfd, pts_slave); + // User ID + write_int(socketfd, uid); + // Parent PID + write_int(socketfd, ppid); + write_int(socketfd, mount_storage); + + // Send stdin + if (atty & ATTY_IN) { + // Using PTY + send_fd(socketfd, -1); + } else { + send_fd(socketfd, STDIN_FILENO); + } + + // Send stdout + if (atty & ATTY_OUT) { + // Forward SIGWINCH + watch_sigwinch_async(STDOUT_FILENO, ptmx); + + // Using PTY + send_fd(socketfd, -1); + } else { + send_fd(socketfd, STDOUT_FILENO); + } + + // Send stderr + if (atty & ATTY_ERR) { + // Using PTY + send_fd(socketfd, -1); + } else { + send_fd(socketfd, STDERR_FILENO); + } + + // Number of command line arguments + write_int(socketfd, mount_storage ? argc - 1 : argc); + + // Command line arguments + int i; + for (i = 0; i < argc; i++) { + if (i == 1 && mount_storage) { + continue; + } + write_string(socketfd, argv[i]); + } + + // Wait for acknowledgement from daemon + read_int(socketfd); + + if (atty & ATTY_IN) { + setup_sighandlers(); + pump_stdin_async(ptmx); + } + if (atty & ATTY_OUT) { + pump_stdout_blocking(ptmx); + } + + // Get the exit code + int code = read_int(socketfd); + close(socketfd); + LOGD("client exited %d", code); + + return code; +} diff --git a/Superuser/jni/su/pts.c b/Superuser/jni/su/pts.c new file mode 100644 index 00000000..c810a347 --- /dev/null +++ b/Superuser/jni/su/pts.c @@ -0,0 +1,335 @@ +/* + * Copyright 2013, Tan Chee Eng (@tan-ce) + * + * 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. + */ + + /* + * pts.c + * + * Manages the pseudo-terminal driver on Linux/Android and provides some + * helper functions to handle raw input mode and terminal window resizing + */ + +#include +#include +#include +#include +#include +#include +#include + +#include "pts.h" + +/** + * Helper functions + */ +// Ensures all the data is written out +static int write_blocking(int fd, char *buf, size_t bufsz) { + ssize_t ret, written; + + written = 0; + do { + ret = write(fd, buf + written, bufsz - written); + if (ret == -1) return -1; + written += ret; + } while (written < bufsz); + + return 0; +} + +/** + * Pump data from input FD to output FD. If close_output is + * true, then close the output FD when we're done. + */ +static void pump_ex(int input, int output, int close_output) { + char buf[4096]; + int len; + while ((len = read(input, buf, 4096)) > 0) { + if (write_blocking(output, buf, len) == -1) break; + } + close(input); + if (close_output) close(output); +} + +/** + * Pump data from input FD to output FD. Will close the + * output FD when done. + */ +static void pump(int input, int output) { + pump_ex(input, output, 1); +} + +static void* pump_thread(void* data) { + int* files = (int*)data; + int input = files[0]; + int output = files[1]; + pump(input, output); + free(data); + return NULL; +} + +static void pump_async(int input, int output) { + pthread_t writer; + int* files = (int*)malloc(sizeof(int) * 2); + if (files == NULL) { + exit(-1); + } + files[0] = input; + files[1] = output; + pthread_create(&writer, NULL, pump_thread, files); +} + + +/** + * pts_open + * + * Opens a pts device and returns the name of the slave tty device. + * + * Arguments + * slave_name the name of the slave device + * slave_name_size the size of the buffer passed via slave_name + * + * Return Values + * on failure either -2 or -1 (errno set) is returned. + * on success, the file descriptor of the master device is returned. + */ +int pts_open(char *slave_name, size_t slave_name_size) { + int fdm; + char *sn_tmp; + + // Open master ptmx device + fdm = open("/dev/ptmx", O_RDWR); + if (fdm == -1) return -1; + + // Get the slave name + sn_tmp = ptsname(fdm); + if (!sn_tmp) { + close(fdm); + return -2; + } + + strncpy(slave_name, sn_tmp, slave_name_size); + slave_name[slave_name_size - 1] = '\0'; + + // Grant, then unlock + if (grantpt(fdm) == -1) { + close(fdm); + return -1; + } + if (unlockpt(fdm) == -1) { + close(fdm); + return -1; + } + + return fdm; +} + +// Stores the previous termios of stdin +static struct termios old_stdin; +static int stdin_is_raw = 0; + +/** + * set_stdin_raw + * + * Changes stdin to raw unbuffered mode, disables echo, + * auto carriage return, etc. + * + * Return Value + * on failure -1, and errno is set + * on success 0 + */ +int set_stdin_raw(void) { + struct termios new_termios; + + // Save the current stdin termios + if (tcgetattr(STDIN_FILENO, &old_stdin) < 0) { + return -1; + } + + // Start from the current settings + new_termios = old_stdin; + + // Make the terminal like an SSH or telnet client + new_termios.c_iflag |= IGNPAR; + new_termios.c_iflag &= ~(ISTRIP | INLCR | IGNCR | ICRNL | IXON | IXANY | IXOFF); + new_termios.c_lflag &= ~(ISIG | ICANON | ECHO | ECHOE | ECHOK | ECHONL); + new_termios.c_oflag &= ~OPOST; + new_termios.c_cc[VMIN] = 1; + new_termios.c_cc[VTIME] = 0; + + if (tcsetattr(STDIN_FILENO, TCSAFLUSH, &new_termios) < 0) { + return -1; + } + + stdin_is_raw = 1; + + return 0; +} + +/** + * restore_stdin + * + * Restore termios on stdin to the state it was before + * set_stdin_raw() was called. If set_stdin_raw() was + * never called, does nothing and doesn't return an error. + * + * This function is async-safe. + * + * Return Value + * on failure, -1 and errno is set + * on success, 0 + */ +int restore_stdin(void) { + if (!stdin_is_raw) return 0; + + if (tcsetattr(STDIN_FILENO, TCSAFLUSH, &old_stdin) < 0) { + return -1; + } + + stdin_is_raw = 0; + + return 0; +} + +// Flag indicating whether the sigwinch watcher should terminate. +volatile static int closing_time = 0; + +/** + * Thread process. Wait for a SIGWINCH to be received, then update + * the terminal size. + */ +static void *watch_sigwinch(void *data) { + sigset_t winch; + int sig; + int master = ((int *)data)[0]; + int slave = ((int *)data)[1]; + + sigemptyset(&winch); + sigaddset(&winch, SIGWINCH); + + do { + // Wait for a SIGWINCH + sigwait(&winch, &sig); + + if (closing_time) break; + + // Get the new terminal size + struct winsize w; + if (ioctl(master, TIOCGWINSZ, &w) == -1) { + continue; + } + + // Set the new terminal size + ioctl(slave, TIOCSWINSZ, &w); + + } while (1); + + free(data); + return NULL; +} + +/** + * watch_sigwinch_async + * + * After calling this function, if the application receives + * SIGWINCH, the terminal window size will be read from + * "input" and set on "output". + * + * NOTE: This function blocks SIGWINCH and spawns a thread. + * NOTE 2: This function must be called before any of the + * pump functions. + * + * Arguments + * master A file descriptor of the TTY window size to follow + * slave A file descriptor of the TTY window size which is + * to be set on SIGWINCH + * + * Return Value + * on failure, -1 and errno will be set. In this case, no + * thread has been spawned and SIGWINCH will not be + * blocked. + * on success, 0 + */ +int watch_sigwinch_async(int master, int slave) { + pthread_t watcher; + int *files = (int *) malloc(sizeof(int) * 2); + if (files == NULL) { + return -1; + } + + // Block SIGWINCH so sigwait can later receive it + sigset_t winch; + sigemptyset(&winch); + sigaddset(&winch, SIGWINCH); + if (sigprocmask(SIG_BLOCK, &winch, NULL) == -1) { + free(files); + return -1; + } + + // Initialize some variables, then start the thread + closing_time = 0; + files[0] = master; + files[1] = slave; + int ret = pthread_create(&watcher, NULL, &watch_sigwinch, files); + if (ret != 0) { + free(files); + errno = ret; + return -1; + } + + // Set the initial terminal size + raise(SIGWINCH); + return 0; +} + +/** + * watch_sigwinch_cleanup + * + * Cause the SIGWINCH watcher thread to terminate + */ +void watch_sigwinch_cleanup(void) { + closing_time = 1; + raise(SIGWINCH); +} + +/** + * pump_stdin_async + * + * Forward data from STDIN to the given FD + * in a seperate thread + */ +void pump_stdin_async(int outfd) { + // Put stdin into raw mode + set_stdin_raw(); + + // Pump data from stdin to the PTY + pump_async(STDIN_FILENO, outfd); +} + +/** + * pump_stdout_blocking + * + * Forward data from the FD to STDOUT. + * Returns when the remote end of the FD closes. + * + * Before returning, restores stdin settings. + */ +void pump_stdout_blocking(int infd) { + // Pump data from stdout to PTY + pump_ex(infd, STDOUT_FILENO, 0 /* Don't close output when done */); + + // Cleanup + restore_stdin(); + watch_sigwinch_cleanup(); +} diff --git a/Superuser/jni/su/pts.h b/Superuser/jni/su/pts.h new file mode 100644 index 00000000..c3236436 --- /dev/null +++ b/Superuser/jni/su/pts.h @@ -0,0 +1,116 @@ +/* + * Copyright 2013, Tan Chee Eng (@tan-ce) + * + * 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. + */ + + /* + * pts.h + * + * Manages the pseudo-terminal driver on Linux/Android and provides some + * helper functions to handle raw input mode and terminal window resizing + */ + +#ifndef _PTS_H_ +#define _PTS_H_ + +/** + * pts_open + * + * Opens a pts device and returns the name of the slave tty device. + * + * Arguments + * slave_name the name of the slave device + * slave_name_size the size of the buffer passed via slave_name + * + * Return Values + * on failure either -2 or -1 (errno set) is returned. + * on success, the file descriptor of the master device is returned. + */ +int pts_open(char *slave_name, size_t slave_name_size); + +/** + * set_stdin_raw + * + * Changes stdin to raw unbuffered mode, disables echo, + * auto carriage return, etc. + * + * Return Value + * on failure -1, and errno is set + * on success 0 + */ +int set_stdin_raw(void); + +/** + * restore_stdin + * + * Restore termios on stdin to the state it was before + * set_stdin_raw() was called. If set_stdin_raw() was + * never called, does nothing and doesn't return an error. + * + * This function is async-safe. + * + * Return Value + * on failure, -1 and errno is set + * on success, 0 + */ +int restore_stdin(void); + +/** + * watch_sigwinch_async + * + * After calling this function, if the application receives + * SIGWINCH, the terminal window size will be read from + * "input" and set on "output". + * + * NOTE: This function blocks SIGWINCH and spawns a thread. + * + * Arguments + * master A file descriptor of the TTY window size to follow + * slave A file descriptor of the TTY window size which is + * to be set on SIGWINCH + * + * Return Value + * on failure, -1 and errno will be set. In this case, no + * thread has been spawned and SIGWINCH will not be + * blocked. + * on success, 0 + */ +int watch_sigwinch_async(int master, int slave); + +/** + * watch_sigwinch_cleanup + * + * Cause the SIGWINCH watcher thread to terminate + */ +void watch_sigwinch_cleanup(void); + +/** + * pump_stdin_async + * + * Forward data from STDIN to the given FD + * in a seperate thread + */ +void pump_stdin_async(int outfd); + +/** + * pump_stdout_blocking + * + * Forward data from the FD to STDOUT. + * Returns when the remote end of the FD closes. + * + * Before returning, restores stdin settings. + */ +void pump_stdout_blocking(int infd); + +#endif diff --git a/Superuser/jni/su/su.c b/Superuser/jni/su/su.c index 5a57feff..e16baff2 100644 --- a/Superuser/jni/su/su.c +++ b/Superuser/jni/su/su.c @@ -36,26 +36,63 @@ #include "su.h" #include "utils.h" +extern int is_daemon; +extern int daemon_from_uid; +extern int daemon_from_pid; + unsigned get_shell_uid() { struct passwd* ppwd = getpwnam("shell"); if (NULL == ppwd) { return 2000; } - + + return ppwd->pw_uid; +} + +unsigned get_system_uid() { + struct passwd* ppwd = getpwnam("system"); + if (NULL == ppwd) { + return 1000; + } + + return ppwd->pw_uid; +} + +unsigned get_radio_uid() { + struct passwd* ppwd = getpwnam("radio"); + if (NULL == ppwd) { + return 1001; + } + return ppwd->pw_uid; } +int fork_zero_fucks() { + int pid = fork(); + if (pid) { + int status; + waitpid(pid, &status, 0); + return pid; + } + else { + if (pid = fork()) + exit(0); + return 0; + } +} + void exec_log(char *priority, char* logline) { int pid; if ((pid = fork()) == 0) { - int zero = open("/dev/zero", O_RDONLY | O_CLOEXEC); - dup2(zero, 0); int null = open("/dev/null", O_WRONLY | O_CLOEXEC); - dup2(null, 1); - dup2(null, 2); - execl("/system/bin/log", "/system/bin/log", "-p", priority, "-t", LOG_TAG, logline); + dup2(null, STDIN_FILENO); + dup2(null, STDOUT_FILENO); + dup2(null, STDERR_FILENO); + execl("/system/bin/log", "/system/bin/log", "-p", priority, "-t", LOG_TAG, logline, NULL); _exit(0); } + int status; + waitpid(pid, &status, 0); } void exec_loge(const char* fmt, ...) { @@ -99,6 +136,11 @@ static int from_init(struct su_initiator *from) { from->uid = getuid(); from->pid = getppid(); + if (is_daemon) { + from->uid = daemon_from_uid; + from->pid = daemon_from_pid; + } + /* Get the command line */ snprintf(path, sizeof(path), "/proc/%u/cmdline", from->pid); fd = open(path, O_RDONLY); @@ -214,7 +256,10 @@ static void populate_environment(const struct su_context *ctx) { pw = getpwuid(ctx->to.uid); if (pw) { setenv("HOME", pw->pw_dir, 1); - setenv("SHELL", ctx->to.shell, 1); + if (ctx->to.shell) + setenv("SHELL", ctx->to.shell, 1); + else + setenv("SHELL", DEFAULT_SHELL, 1); if (ctx->to.login || ctx->to.uid) { setenv("USER", pw->pw_name, 1); setenv("LOGNAME", pw->pw_name, 1); @@ -351,7 +396,7 @@ do { \ } \ } while (0) -#define write_string(fd, name, data) \ +#define write_string_data(fd, name, data) \ do { \ write_data(fd, name, strlen(name)); \ write_data(fd, data, strlen(data)); \ @@ -362,25 +407,26 @@ do { \ do { \ char buf[16]; \ snprintf(buf, sizeof(buf), "%d", data); \ - write_string(fd, name, buf); \ + write_string_data(fd, name, buf); \ } while (0) write_token(fd, "version", PROTO_VERSION); write_token(fd, "binary.version", VERSION_CODE); write_token(fd, "pid", ctx->from.pid); - write_string(fd, "from.name", ctx->from.name); - write_string(fd, "to.name", ctx->to.name); + write_string_data(fd, "from.name", ctx->from.name); + write_string_data(fd, "to.name", ctx->to.name); write_token(fd, "from.uid", ctx->from.uid); write_token(fd, "to.uid", ctx->to.uid); - write_string(fd, "from.bin", ctx->from.bin); - write_string(fd, "command", get_command(&ctx->to)); + write_string_data(fd, "from.bin", ctx->from.bin); + // TODO: Fix issue where not using -c does not result a in a command + write_string_data(fd, "command", get_command(&ctx->to)); write_token(fd, "eof", PROTO_VERSION); return 0; } static int socket_receive_result(int fd, char *result, ssize_t result_len) { ssize_t len; - + LOGD("waiting for user"); len = read(fd, result, result_len-1); if (len < 0) { @@ -398,6 +444,7 @@ static void usage(int status) { fprintf(stream, "Usage: su [options] [--] [-] [LOGIN] [--] [args...]\n\n" "Options:\n" + " --daemon start the su daemon agent\n" " -c, --command COMMAND pass COMMAND to the invoked shell\n" " -h, --help display this help message and exit\n" " -, -l, --login pretend the shell to be a login shell\n" @@ -414,10 +461,19 @@ static void usage(int status) { static __attribute__ ((noreturn)) void deny(struct su_context *ctx) { char *cmd = get_command(&ctx->to); - // No send to UI denied requests for shell and root users (they are in the log) - // if( ctx->from.uid != AID_SHELL && ctx->from.uid != AID_ROOT ) { + int send_to_app = 1; + + // no need to log if called by root + if (ctx->from.uid == AID_ROOT) + send_to_app = 0; + + // dumpstate (which logs to logcat/shell) will spam the crap out of the system with su calls + if (strcmp("/system/bin/dumpstate", ctx->from.bin) == 0) + send_to_app = 0; + + if (send_to_app) send_result(ctx, DENY); - // } + LOGW("request rejected (%u->%u %s)", ctx->from.uid, ctx->to.uid, cmd); fprintf(stderr, "%s\n", strerror(EACCES)); exit(EXIT_FAILURE); @@ -428,13 +484,40 @@ static __attribute__ ((noreturn)) void allow(struct su_context *ctx) { int argc, err; umask(ctx->umask); - // No send to UI accepted requests for shell and root users (they are in the log) - // if( ctx->from.uid != AID_SHELL && ctx->from.uid != AID_ROOT ) { + int send_to_app = 1; + + // no need to log if called by root + if (ctx->from.uid == AID_ROOT) + send_to_app = 0; + + // dumpstate (which logs to logcat/shell) will spam the crap out of the system with su calls + if (strcmp("/system/bin/dumpstate", ctx->from.bin) == 0) + send_to_app = 0; + + if (send_to_app) send_result(ctx, ALLOW); - // } - arg0 = strrchr (ctx->to.shell, '/'); - arg0 = (arg0) ? arg0 + 1 : ctx->to.shell; + char *binary; + argc = ctx->to.optind; + if (ctx->to.command) { + binary = ctx->to.shell; + ctx->to.argv[--argc] = ctx->to.command; + ctx->to.argv[--argc] = "-c"; + } + else if (ctx->to.shell) { + binary = ctx->to.shell; + } + else { + if (ctx->to.argv[argc]) { + binary = ctx->to.argv[argc++]; + } + else { + binary = DEFAULT_SHELL; + } + } + + arg0 = strrchr (binary, '/'); + arg0 = (arg0) ? arg0 + 1 : binary; if (ctx->to.login) { int s = strlen(arg0) + 2; char *p = malloc(s); @@ -451,25 +534,20 @@ static __attribute__ ((noreturn)) void allow(struct su_context *ctx) { set_identity(ctx->to.uid); #define PARG(arg) \ - (ctx->to.optind + (arg) < ctx->to.argc) ? " " : "", \ - (ctx->to.optind + (arg) < ctx->to.argc) ? ctx->to.argv[ctx->to.optind + (arg)] : "" + (argc + (arg) < ctx->to.argc) ? " " : "", \ + (argc + (arg) < ctx->to.argc) ? ctx->to.argv[argc + (arg)] : "" - LOGD("%u %s executing %u %s using shell %s : %s%s%s%s%s%s%s%s%s%s%s%s%s%s", + LOGD("%u %s executing %u %s using binary %s : %s%s%s%s%s%s%s%s%s%s%s%s%s%s", ctx->from.uid, ctx->from.bin, - ctx->to.uid, get_command(&ctx->to), ctx->to.shell, + ctx->to.uid, get_command(&ctx->to), binary, arg0, PARG(0), PARG(1), PARG(2), PARG(3), PARG(4), PARG(5), (ctx->to.optind + 6 < ctx->to.argc) ? " ..." : ""); - argc = ctx->to.optind; - if (ctx->to.command) { - ctx->to.argv[--argc] = ctx->to.command; - ctx->to.argv[--argc] = "-c"; - } ctx->to.argv[--argc] = arg0; - execv(ctx->to.shell, ctx->to.argv + argc); + execvp(binary, ctx->to.argv + argc); err = errno; PLOGE("exec"); - fprintf(stderr, "Cannot execute %s: %s\n", ctx->to.shell, strerror(err)); + fprintf(stderr, "Cannot execute %s: %s\n", binary, strerror(err)); exit(EXIT_FAILURE); } @@ -481,6 +559,9 @@ static __attribute__ ((noreturn)) void allow(struct su_context *ctx) { * Find the properties ourselves. */ int access_disabled(const struct su_initiator *from) { +#ifndef SUPERUSER_EMBEDDED + return 0; +#else char *data; char build_type[PROPERTY_VALUE_MAX]; char debuggable[PROPERTY_VALUE_MAX], enabled[PROPERTY_VALUE_MAX]; @@ -527,12 +608,56 @@ int access_disabled(const struct su_initiator *from) { "enable it under settings -> developer options"); return 1; } - + } return 0; +#endif +} + +static int get_api_version() { + char sdk_ver[PROPERTY_VALUE_MAX]; + char *data = read_file("/system/build.prop"); + get_property(data, sdk_ver, "ro.build.version.sdk", "0"); + int ver = atoi(sdk_ver); + free(data); + return ver; +} + +static void fork_for_samsung(void) +{ + // Samsung CONFIG_SEC_RESTRICT_SETUID wants the parent process to have + // EUID 0, or else our setresuid() calls will be denied. So make sure + // all such syscalls are executed by a child process. + int rv; + + switch (fork()) { + case 0: + return; + case -1: + PLOGE("fork"); + exit(1); + default: + if (wait(&rv) < 0) { + exit(1); + } else { + exit(WEXITSTATUS(rv)); + } + } } int main(int argc, char *argv[]) { + return su_main(argc, argv, 1); +} + +int su_main(int argc, char *argv[], int need_client) { + // start up in daemon mode if prompted + if (argc == 2 && strcmp(argv[1], "--daemon") == 0) { + return run_daemon(); + } + + int ppid = getppid(); + fork_for_samsung(); + // Sanitize all secure environment variables (from linker_environ.c in AOSP linker). /* The same list than GLibc at this point */ static const char* const unsec_vars[] = { @@ -591,7 +716,7 @@ int main(int argc, char *argv[]) { .uid = AID_ROOT, .login = 0, .keepenv = 0, - .shell = DEFAULT_SHELL, + .shell = NULL, .command = NULL, .argv = argv, .argc = argc, @@ -622,6 +747,7 @@ int main(int argc, char *argv[]) { while ((c = getopt_long(argc, argv, "+c:hlmps:Vvu", long_opts, NULL)) != -1) { switch(c) { case 'c': + ctx.to.shell = DEFAULT_SHELL; ctx.to.command = optarg; break; case 'h': @@ -665,6 +791,20 @@ int main(int argc, char *argv[]) { usage(2); } } + + if (need_client) { + // attempt to use the daemon client if not root, + // or this is api 18 and adb shell (/data is not readable even as root) + // or just always use it on API 19+ (ART) + if ((geteuid() != AID_ROOT && getuid() != AID_ROOT) || + (get_api_version() >= 18 && getuid() == AID_SHELL) || + get_api_version() >= 19) { + // attempt to connect to daemon... + LOGD("starting daemon client %d %d", getuid(), geteuid()); + return connect_daemon(argc, argv, ppid); + } + } + if (optind < argc && !strcmp(argv[optind], "-")) { ctx.to.login = 1; optind++; @@ -700,21 +840,21 @@ int main(int argc, char *argv[]) { if (from_init(&ctx.from) < 0) { deny(&ctx); } - + read_options(&ctx); user_init(&ctx); - - // TODO: customizable behavior for shell? It can currently be toggled via settings. - if (ctx.from.uid == AID_ROOT || ctx.from.uid == AID_SHELL) { - LOGD("Allowing root/shell."); + + // the latter two are necessary for stock ROMs like note 2 which do dumb things with su, or crash otherwise + if (ctx.from.uid == AID_ROOT) { + LOGD("Allowing root/system/radio."); allow(&ctx); } // verify superuser is installed if (stat(ctx.user.base_path, &st) < 0) { - // send to market - if (0 == strcmp(JAVA_PACKAGE_NAME, REQUESTOR)) - silent_run("am start -d http://www.clockworkmod.com/superuser/install.html -a android.intent.action.VIEW"); + // send to market (disabled, because people are and think this is hijacking their su) + // if (0 == strcmp(JAVA_PACKAGE_NAME, REQUESTOR)) + // silent_run("am start -d http://www.clockworkmod.com/superuser/install.html -a android.intent.action.VIEW"); PLOGE("stat %s", ctx.user.base_path); deny(&ctx); } @@ -725,7 +865,7 @@ int main(int argc, char *argv[]) { (int)st.st_uid, (int)st.st_gid); deny(&ctx); } - + // always allow if this is the superuser uid // superuser needs to be able to reenable itself when disabled... if (ctx.from.uid == st.st_uid) { @@ -738,6 +878,12 @@ int main(int argc, char *argv[]) { deny(&ctx); } + // autogrant shell at this point + if (ctx.from.uid == AID_SHELL) { + LOGD("Allowing shell."); + allow(&ctx); + } + // deny if this is a non owner request and owner mode only if (ctx.user.multiuser_mode == MULTIUSER_MODE_OWNER_ONLY && ctx.user.android_user_id != 0) { deny(&ctx); @@ -776,7 +922,7 @@ int main(int argc, char *argv[]) { LOGD("db denied"); deny(&ctx); /* never returns too */ } - + socket_serv_fd = socket_create_temp(ctx.sock_path, sizeof(ctx.sock_path)); LOGD(ctx.sock_path); if (socket_serv_fd < 0) { diff --git a/Superuser/jni/su/su.h b/Superuser/jni/su/su.h index eba9468a..070d7fa5 100644 --- a/Superuser/jni/su/su.h +++ b/Superuser/jni/su/su.h @@ -31,6 +31,14 @@ #define AID_ROOT 0 #endif +#ifndef AID_SYSTEM +#define AID_SYSTEM (get_system_uid()) +#endif + +#ifndef AID_RADIO +#define AID_RADIO (get_radio_uid()) +#endif + // CyanogenMod-specific behavior #define CM_ROOT_ACCESS_DISABLED 0 #define CM_ROOT_ACCESS_APPS_ONLY 1 @@ -55,6 +63,7 @@ #define REQUESTOR_FILES_PATH REQUESTOR_DATA_PATH REQUESTOR "/files" #define REQUESTOR_USER_PATH "/data/user/" #define REQUESTOR_CACHE_PATH "/dev/" REQUESTOR +#define REQUESTOR_DAEMON_PATH REQUESTOR_CACHE_PATH ".daemon" // there's no guarantee that the db or files are actually created named as such by // SQLiteOpenHelper, etc. Though that is the behavior as of current. @@ -62,17 +71,14 @@ #define REQUESTOR_DATABASE_PATH REQUESTOR "/databases/su.sqlite" #define REQUESTOR_MULTIUSER_MODE REQUESTOR_FILES_PATH "/multiuser_mode" -/* intent actions */ -#define ACTION_REQUEST "start -n " REQUESTOR "/" REQUESTOR_PREFIX ".RequestActivity" -#define ACTION_NOTIFY "start -n " REQUESTOR "/" REQUESTOR_PREFIX ".NotifyActivity" -#define ACTION_RESULT "broadcast -n " REQUESTOR "/" REQUESTOR_PREFIX ".SuReceiver" - #define DEFAULT_SHELL "/system/bin/sh" #define xstr(a) str(a) #define str(a) #a -#define VERSION_CODE 7 +#ifndef VERSION_CODE +#define VERSION_CODE 16 +#endif #define VERSION xstr(VERSION_CODE) " " REQUESTOR #define PROTO_VERSION 1 @@ -149,17 +155,31 @@ extern policy_t database_check(struct su_context *ctx); extern void set_identity(unsigned int uid); extern int send_request(struct su_context *ctx); extern int send_result(struct su_context *ctx, policy_t policy); -extern int silent_run(char* command); static inline char *get_command(const struct su_request *to) { - return (to->command) ? to->command : to->shell; + if (to->command) + return to->command; + if (to->shell) + return to->shell; + char* ret = to->argv[to->optind]; + if (ret) + return ret; + return DEFAULT_SHELL; } void exec_loge(const char* fmt, ...); void exec_logw(const char* fmt, ...); void exec_logd(const char* fmt, ...); +int run_daemon(); +int connect_daemon(int argc, char *argv[], int ppid); +int su_main(int argc, char *argv[], int need_client); +// for when you give zero fucks about the state of the child process. +// this version of fork understands you don't care about the child. +// deadbeat dad fork. +int fork_zero_fucks(); + // fallback to using /system/bin/log. // can't use liblog.so because this is a static binary. #ifndef LOGE diff --git a/Superuser/libs/android-support-v4.jar b/Superuser/libs/android-support-v4.jar deleted file mode 100644 index 6080877d..00000000 Binary files a/Superuser/libs/android-support-v4.jar and /dev/null differ diff --git a/Superuser/project.properties b/Superuser/project.properties index dd3bbf71..eb92e9e8 100644 --- a/Superuser/project.properties +++ b/Superuser/project.properties @@ -11,6 +11,6 @@ #proguard.config=${sdk.dir}/tools/proguard/proguard-android.txt:proguard-project.txt # Project target. -target=android-17 +target=android-21 android.library.reference.1=../../Widgets/Widgets ndk.executable=ndk-build diff --git a/Superuser/res/layout/empty.xml b/Superuser/res/layout/empty.xml new file mode 100644 index 00000000..8eb5e3fc --- /dev/null +++ b/Superuser/res/layout/empty.xml @@ -0,0 +1,10 @@ + + + + \ No newline at end of file diff --git a/Superuser/res/layout/log_item.xml b/Superuser/res/layout/log_item.xml index e2fc9c9f..73022f9d 100644 --- a/Superuser/res/layout/log_item.xml +++ b/Superuser/res/layout/log_item.xml @@ -3,8 +3,8 @@ android:layout_width="fill_parent" android:layout_height="wrap_content" android:orientation="horizontal" - android:paddingLeft="?attr/listPreferredItemPaddingLeft" - android:paddingRight="?attr/listPreferredItemPaddingRight" + android:paddingLeft="?attr/listPreferredItemPaddingLeft_" + android:paddingRight="?attr/listPreferredItemPaddingRight_" android:paddingBottom="@dimen/log_item_padding" android:paddingTop="@dimen/log_item_padding" > diff --git a/Superuser/res/layout/request.xml b/Superuser/res/layout/request.xml index bf2a20a4..95b1c41d 100644 --- a/Superuser/res/layout/request.xml +++ b/Superuser/res/layout/request.xml @@ -119,6 +119,7 @@ android:layout_height="wrap_content" android:layout_weight="1" android:enabled="false" + android:filterTouchesWhenObscured="true" android:text="@string/allow" /> diff --git a/Superuser/res/menu-v11/app.xml b/Superuser/res/menu-v11/app.xml index 4ab0f376..213a39e2 100644 --- a/Superuser/res/menu-v11/app.xml +++ b/Superuser/res/menu-v11/app.xml @@ -4,4 +4,10 @@ android:title="@string/about" android:icon="@drawable/ic_action_about" /> + + diff --git a/Superuser/res/menu-v11/main.xml b/Superuser/res/menu-v11/main.xml index a74ea5e5..b1d93cd0 100644 --- a/Superuser/res/menu-v11/main.xml +++ b/Superuser/res/menu-v11/main.xml @@ -5,10 +5,5 @@ android:icon="@drawable/ic_action_logs" android:showAsAction="ifRoom" /> - - + diff --git a/Superuser/res/menu/app.xml b/Superuser/res/menu/app.xml index 11287ccb..97ba76e8 100644 --- a/Superuser/res/menu/app.xml +++ b/Superuser/res/menu/app.xml @@ -4,5 +4,9 @@ android:id="@+id/about" android:icon="@drawable/ic_menu_about" android:title="@string/about"/> + \ No newline at end of file diff --git a/Superuser/res/menu/main.xml b/Superuser/res/menu/main.xml index 7eb86c2b..fc9fcd5e 100644 --- a/Superuser/res/menu/main.xml +++ b/Superuser/res/menu/main.xml @@ -4,9 +4,5 @@ android:id="@+id/logs" android:icon="@drawable/ic_menu_logs" android:title="@string/logs"/> - \ No newline at end of file diff --git a/Superuser/res/values-af/strings.xml b/Superuser/res/values-af/strings.xml new file mode 100644 index 00000000..04b34732 --- /dev/null +++ b/Superuser/res/values-af/strings.xml @@ -0,0 +1,108 @@ + + + + + Superuser + Laat toe + Verwerp + Inkomende Superuser versoek\u2026 + Onbekende UID: %s + %s vra tans Superuser toegang aan. + Waarskuwing: As jy dit nie verstaan ​​nie, dan kan jy die versoek weier. + Superuser versoek + Pakket: + Program: + Aangevraagde UID: + Bevel: + Net die keer + Onthou die keuse vir %s minute + Onthou keuse vir ewig + Interaktief + Verslaë + Instellings + Skrap + Geen verslag + Daar is tans nie \'n Superuser program wat \'root\' toegang het nie. + Verslaggewing + Aktiveer of deaktiveer verslaggewing vir alle Superuser versoeke + PIN beskerming + Vereis insleutel van \'n PIN om \'n Superuser versoeke goed te keur + Versoek se tyd het verstreek + Superuser versoeke sal verstryk en verwerp word na %s sekondes + Kennisgewings + Geen + \'n %s sal getoon word wanneer \'n program Superuser regte toegeken of geweier word + Voer PIN in + Gee \'n nuwe PIN + Verkeerde PIN + Bevestig PIN + PIN het nie ooreengestem nie + Superuser PIN beskerming is aangeskakel + %s sekondes + Superuser toegestaan ​​aan %s + Superuser geweier aan %s + Opspring kennisgewing + Kennisgewing + Geen kennisgewings sal vertoon word nie + Ontwikkelaar Waarskuwing:\nandroid.permission.ACCESS_SUPERUSER\nis nie in program \'manifest\' verklaar nie. + Volle regte aan alle toestel funksies en stoorspasie + Superuser verleen volle (Administrasie) toegang tot alle toestel funksies en stoorspasie, insluitend veilige en sensitiewe hardeware elemente van jou toestel. Hierdie toestemming kan potensieel gevaarlik wees. + Verklaarde toestemming + Laat slegs versoeke toe van programme wat die android.permission.ACCESS_SUPERUSER verklaar het. + Outomatiese reaksie + Vra + Laat nuwe versoeke outomaties toe + Weier outomaties nuwe versoeke + Toon die bevestigings skerm vir nuwe versoeke + Sekuriteit + Multigebruikerstelsel beleid + Slegs die eienaar van die toestel kan Superuser versoeke aanvra + Die eienaar van die toestel sal gevra word wanneer \'n ander gebruiker Superuser versoeke aanvra + Alle gebruikers kan Superuser versoeke aanvra + Slegs die eienaar + Beheer deur die eienaar + Alle gebruikers + Die multigebruikerstelsel beleid kan slegs bestuur word deur die eienaar van die toestel. + Skakel na die eienaar se rekening om hierdie versoek goedtekeur of te weier. + Alle opdragte + Meer oor Superuser + Programme + Installeer tans + Besig met die instalasie van Superuser\u2026 + Installeer Superuser + Die Superuser binêre lêer (su) moet opgedateer word.\n\nKies \'n installasie metode.\n\'Recovery\' mode installasie word tensterkste aanbeveel vir HTC toestelle. + \'Recovery\' installasie + Installeer + Inspekteur Superuser\u2026 + Daar was \'n fout tydens die instalasie van Superuser. Stuur \'n verslag na die ontwikelaar. + Superuser was suksesvol geïnstalleer. + Die su lêer is oud. + Superuser toegang + Af + Slegs Programme + Slegs ADB + Programme en ADB + Wat is nuut + Gradeer + Tema + Lig + Donker + Superuser PIN beveiliging is afgeskakel + Kanselleer Superuser toestemming + Besonderhede + Superuser toestemming kan nie herroep word vir hierdie program.\nHerlaai asseblief die Superuser program en probeer weer. + diff --git a/Superuser/res/values-ar/strings.xml b/Superuser/res/values-ar/strings.xml new file mode 100644 index 00000000..5c87aee9 --- /dev/null +++ b/Superuser/res/values-ar/strings.xml @@ -0,0 +1,108 @@ + + + + + مستخدم خارق + يسمح + رفض + وارد طلب المستخدم الخارق \u2026 + UID غير معروف: %s + %s مطلوب الوصول الى المستخدم الخارق. + تحذير: إذا كنت لا تفهم هذا، يجب رفض الطلب. + طلب المستخدم الخارق + حزمة: + التطبيق: + طلب UID: + الأمر: + هذه المرة فقط + تذكر الاختيار لي %s دقائة + تذكر الخيار إلى الأبد + التفاعلية + سجلات + إعدادات + حذف + لا توجد سجلات + لا يوجد حاليا سياسات تطبيق ميتخدم خارق . + التسجيل + تمكين كل طلب تسجيل الدخول المستخدم الخارق + حماية الرقم السري + وتتطلب إدخال الرقم السري للموافقة على طلبات المستخدم الخارق + مهلة الطلب + المستخدم الخارق يتطلب وقت الإيقاف لي الرفض بعد %s ثانية + التنبيهات + لا شيء + %s سيضهر عندما يطلب او يرفض التطبيق صلاحيات المستخدم الخارق + أدخل الرقم الشخصي + أدخل الرقم الشخصي الجديد + الرقم الشخصي غير صحيح + تأكيد الرقم الشخصي + لا يتطابق مع الرقم الشخصي + تمكين الحماية الرقم الشخصي لي المستخدم الخارق + %s ثانية + منح المستخدم الخارق لي %s + رفض المستخدم الخارق لي %s + Toast (مربع في الإسفل) + الإعلام + لن بظهر أي إعلام + تحذير المطور \n android.permission.ACCESS_SUPERUSE \n لن يظهر في البيان. + أذونات كاملة إلى جميع ميزات الجهاز والتخزين + مستخدم خارق يمنح حق الوصول الكامل إلى كافة ميزات الجهاز والتخزين، بما في ذلك عناصر الأجهزة الآمنة والحساسة للجهاز الخاص بك. هذا الإذن يحتمل أن تكون خطرة. + إذن مصرح به + السماح فقط لطلبات من تطبيقات التي مصرح به android.permission.ACCESS_SUPERUSER + الرد التلقائي + موجه + السماح للطلبات الجديدة تلقائياً + رفض طلبات جديدة تلقائياً + إظهار مربع حوار تأكيد للطلبات الجديدة + الأمن + سياسة متعددة المستخدمين + يمكن فقط لمالك الجهاز لطلب المسنخدم الخارق + ستتم مطالبتك مالك الجهاز عندما يطلب مستخدم آخر مستخدم خارق + يمكن لكافة المستخدمين طلب مستخدم خارق + مالك فقط + مالك المداراء + كافة المستخدمين + فقط يمكن أن تدار سياسة تعدد المستخدين من مالك الجهاز. + يرجى التبديل إلى حساب المالك لقبول أو رفض هذا الطلب. + كافة الأوامر + حول + تطبيقات + جاري التثبيت + تركيب مستخدم خارق\u2026 + تثبيت مستخدم خارق + يجب أن يكون المستخدم الخارق binary (su) محدث \n\n الرجاء اختر من المستحسن.\n وضعRecovery أسلوب التثبيت. تثبيت لأجهزة HTC. + تثبيت Recovery + تثبيت + التحقق من المستخدم الخارق\u2026 + حدث خطأ أثناء تثبيت المستخدم الخارق. الرجاء إرسال سجل الخطأ للمطور. + التثبيت للمستخدم الخارق كانت ناجحة. + su binary منتهية التاريخ. + وصول مستخدم خارق + معطلة + تطبيقات فقط + ADB فقط + تطبيقات و ADB + ما هو الجديد + تقييم البرنامج + قالب + فاتح + داكن + تمكين حماية الرقم الشخصي لي المستخدم الخارق + إبطال أذونات مستخدم الخارق + التفاصيل + لا يمكن إبطال أذونات المستخدم الخارق من هذا التطبيق \n الرجاء إعادة تشغيل تطبيق المستخدم الخارق وحاول مرة أخرى. + diff --git a/Superuser/res/values-ca/strings.xml b/Superuser/res/values-ca/strings.xml new file mode 100644 index 00000000..73412aa9 --- /dev/null +++ b/Superuser/res/values-ca/strings.xml @@ -0,0 +1,108 @@ + + + + + Superusuari + Permet + Denega + Petició de Superusuari entrant\u2026 + UID desconeguda: %s + %s està demanant accés de Superusuari. + Alerta: Si no entens això, hauries de denegar la petició. + Petició de superusuari + Paquet: + App: + UID demanada: + Ordre: + Només aquesta vegada + Recorda l\'elecció durant %s minuts + Recorda l\'elecció per sempre + Interactiu + Registres + Ajustaments + Esborra + Sense Registres + Actualment no hi ha polítiques d\'app de Superusuari. + Registre + Activa o desactiva el registre de totes les peticions de Superusuari + Protecció amb PIN + Requereix la introducció d\'un PIN per aprovar les peticions de Superusuari + Dóna un temps d\'espera + Les peticions de Superusuari tindran un temps d\'espera i seran denegades després de %s segons + Notificacions + Cap + Es mostrarà una %s quan a una aplicació se li otorguin o deneguin permisos de Superusuari + Introdueix PIN + Introdueix nou PIN + PIN incorrecte + Confirma el PIN + El PIN no coincideix + Protecció del Superusuari amb PIN activada + %s segons + Superusuari otorgat a %s + Superusuari denegat a %s + Notificació emergent + Notificació + No es mostraran notificacions + Alerta pel Desenvolupador:\nandroid.permission.ACCESS_SUPERUSER\nno declarada al manifest. + permisos totals a totes les característiques i emmagatzematge del dispositiu + Superusuari otorga accés total a totes les característiques del dispositiu i emmagatzematge, incloent els elements segurs i sensibles del maquinari del teu dispositiu. Aquest permís és potencialment perillós. + Permís Declarat + Permet només les peticions d\'apps que declarin android.permission.ACCESS_SUPERUSER + Resposta Automàtica + Pregunta + Permet automaticament totes les noves peticions + Denega automaticatiment les noves peticions + Mostra un diàleg de confirmació per a les noves peticions + Seguretat + Polítiques de Multiusuari + Només el propietari del dispositiu pot demanar el Superusuari + El propietari del dispositiu serà preguntat quan un altre usuari demani el Superusuari + Tots els usuaris poden demanar el Superusuari + Només el propietari + Gestionat pel propietari + Tots els usuaris + La política de Multiusuari només la pot gestionar el propietari del dispositiu. + Si us plau canvia al compte del propietari per aprovar o denegar aquesta petició. + Totes les ordres + Quant a + Apps + Instal·lant + Instal·lant Superuari\u2026 + Instal·la Superusuari + El binari Superuari (su) ha de ser actualitzat.\n\nSi us plau tria un mètode d\'instal·lació.\nLa instal·lació en mode Recuperació està recomanat pels dispositius HTC. + Instal·lació en mode Recuperació + Instal·la + Verificant Superusuari\u2026 + Hi ha hagut un error instal·lant el Superusuari. Si us plau envia un registre de l\'error al desenvolupador. + Superusuari instal·lat amb èxit. + El binari su està obsolet. + Accés al Superusuari + Desactivat + Només Apps + Només ADB + Apps i ADB + Que hi ha de nou + Valora + Tema + Clar + Fosc + Protecció del Superusuari amb PIN desactivada + Revoca el permís del superusuari + Detalls + El permís del superusuari no pot ser revocat des d\'aquesta app. \nSi us plau reinicia l\'app del superusuari i intenta-ho de nou. + diff --git a/Superuser/res/values-cs/strings.xml b/Superuser/res/values-cs/strings.xml new file mode 100644 index 00000000..27ad864f --- /dev/null +++ b/Superuser/res/values-cs/strings.xml @@ -0,0 +1,108 @@ + + + + + Superuser + Povolit + Zakázat + Příchozí požadavek na Superuser\u2026 + Neznámé UID: %s + %s požaduje Superuser přístup. + Varování: Pokud si nejste jisti, kdo a proč tuto akci vyvolal nebo pokud tomuto požadavku nerozumíte, je opravdu doporučeno tento požadavek nepovolit. + Superuser požadavek + Balíček: + Aplikace: + Požad. UID: + Příkaz: + Pouze nyní + Zapamatovat volbu po %s minut + Zapamatovat volbu napořád + Interaktivní + Záznamy + Nastavení + Smazat + Žádné záznamy + Žádná Superuser pravidla pro aplikace. + Zaznamenávání + Zapnout nebo vypnout veškeré zaznamenávání požadavků Superuser + Ochrana PINem + Pro povolení Superuser požadavků je potřeba zadat PIN + Vypršení požadavku + Superuser požadavky budou automaticky zakázány po %s sekundách + Upozornění + žádné + Při udělení povolení nebo zákazu oprávnění Superuser bude zobrazeno %s + Zadat PIN + Zadat nový PIN + Neplatný PIN + Potvrdit PIN + PIN nesouhlasí + Superuser ochrana PINem zapnuta + %s sekund + Superuser povolen pro %s + Superuser zakázán pro %s + Oznámení + Upozornění + Nebude zobrazeno žádné upozornění + Varování pro vývojáře:\nandroid.permission.ACCESS_SUPERUSER\nnení specifikováno v manifestu. + plná oprávnění pro všechny vlastnosti zařízení a úložiště + Superuser umožní plný přístup ke všem vlastnostem zařízení a úložišti, včetně bezpečnostně citlivých částí zařízení. Toto oprávnění může být velmi nebezpečné. + Deklarované oprávnění + Povolit pouze požadavky aplikací, které deklarují android.permission.ACCESS_SUPERUSER + Automatická odpověď + Vyzvat + Automaticky povolit nové požadakvy + Automaticky zakázat nové požadavky + Zobrazit potvrzovací dialog pro nové požadavky + Zabezpečení + Pravidla více uživatelů + Pouze majitel zařízení může požádat o Superuser + Majitel zařízení bude požádán o schválení, pokud jiný uživatel požádá o Superuser + Všichni uživatelé mohou požádat o Superuser + Pouze majitel + Kontrolováno majitelem + Všichni uživatelé + Pravidla více uživatelů může spravovat pouze majitel zařízení. + Pro povolení nebo zakázání tohoto požadavku je nutné přepnout na účet majitele zařízení. + Všechny příkazy + O aplikaci + Aplikace + Instaluje se + Instaluje se Superuser\u2026 + Instalovat Superuser + Superuser příkaz \"su\" musí být aktualizován.\n\nJe nutné zvolit metodu instalace.\nInstalace z Recovery je doporučena pro zařízení HTC. + Instalovat z Recovery + Instalovat + Kontrola Superuser\u2026 + Během instalace Superuser došlo k chybě. Zašlete prosím záznam s chybou vývojáři. + Instalace Superuser byla úspěšná. + Příkaz \"su\" je neaktuální. + Superuser přístup + Vypnuto + Pouze aplikace + Pouze ADB + Aplikace a ADB + Co je nového + Ohodnotit + Téma + Světlé + Tmavé + Superuser ochrana PINem vypnuta + Odmítnout oprávnění Superuser + Podrobnosti + Oprávnění Superuser nelze této aplikaci odmítnout.\nProsím restartujte aplikaci Superuser a zkuste znovu. + diff --git a/Superuser/res/values-da/strings.xml b/Superuser/res/values-da/strings.xml index cf54fc61..a8ac475e 100644 --- a/Superuser/res/values-da/strings.xml +++ b/Superuser/res/values-da/strings.xml @@ -1,90 +1,108 @@ - + + + + Superuser + Tillad + Afvis + Indkommende Superuser-anmodning\u2026 + Ukendt UID: %s + %s anmoder om Superuser-rettigheder. + Advarsel: Hvis du ikke forstår dette, bør du afvise anmodningen. + Superuser-anmodning + Pakke: + App: + Anmodet UID: + Kommando: + Kun denne gang + Husk valg i %s minutter + Husk valg altid + Interaktiv + Logs + Indstillinger + Slet + Ingen logs + Der er i øjeblikket ingen Superuser app-politikker. + Logning + Aktiver eller deaktiver al logning af Superuser-anmodninger + PIN-beskyttelse + Kræver indtastning af en PIN for at godkende Superuser-anmodninger + Anmodelses-timeout + Superuser-anmodninger vil udløbe og blive afvist efter %s sekunder + Notifikationer + Ingen + En %s vil blive vist når en app får givet eller afvist Superuser-rettigheder + Indtast PIN + Indtast ny PIN + Forkert PIN + Bekræft PIN + PIN var ikke ens + Superuser PIN-beskyttelse aktiveret + %s sekunder + Superuser givet til %s + Superuser afvist til %s + Toast + Notifikation + Ingen notifikation vil blive vist + Udvikler-advarsel:\nandroid.permission.ACCESS_SUPERUSER\ner ikke deklareret i manifestet. + fuld adgang til alle enheds-funktioner og lager + Superuser giver fuld adgang til alle enheds-funktioner og lager, inklusiv de sikre og følsomme hardware-elementer af din enhed. Denne tilladelse kan være farlig. + Deklareret tilladelse + Tillad kun anmodninger fra apps der deklarerer android.permission.ACCESS_SUPERUSER + Automatisk svar + Prompt + Tillad automatisk nye anmodninger + Afvis automatisk nye anmodninger + Vis bekræftelses-dialog for nye anmodninger + Sikkerhed + Multibruger-politik + Kun enheds-ejeren kan anmode Superuser + Enhedsejeren vil blive spurgt når en anden bruger anmoder Superuser + Alle brugere kan anmode Superuser + Kun ejer + Ejer-styret + Alle brugere + Multibruger-politikken kan kun styres af enhends-ejeren. + Skift venligst til ejer-kontoen for at bekræfte eller afvise denne anmodning. + Alle kommandoer + Om + Apps + Installerer + Installerer Superuser\u2026 + Installer Superuser + Superuser-binaryet (su) skal opdateres.\n\nVælg venligst en installationsmetode.\nInstallation gennem recovery anbefales til HTC-enheder. + Recovery-installering + Installer + Checker Superuser\u2026 + Der skete en fejl i installationen af Superuser. Send venligst en log af fejlen til udvikleren. + Installationen af Superuser var sucessfuld. + Superuser-binaryet er for gammelt. + Superuser-adgang + Slået fra + Kun apps + Kun ADB + Apps og ADB + Hvad er nyt + Bedøm + Tema + Lyst + Mørkt + Superuser PIN-beskyttelse slået fra + Ophæv Superuser-tilladelsen + Detaljer + Superuser-tilladelsen kan ikke ophæves for denne app.\nGenstart Superuser-app\'en og prøv igen. diff --git a/Superuser/res/values-de/strings.xml b/Superuser/res/values-de/strings.xml index 5b085b36..65a19405 100644 --- a/Superuser/res/values-de/strings.xml +++ b/Superuser/res/values-de/strings.xml @@ -1,67 +1,108 @@ - + + + + Superuser + Gewähren + Verweigern + Eingehende Superuser-Anfrage\u2026 + Unbekannte UID: %s + %s fordert Superuser-Zugriff. + Warnung: Wenn Sie das nicht verstehen, sollten Sie die Anfrage ablehnen. + Superuser-Anfrage + Paket: + App: + Angeforderte UID: + Befehl: + Nur diesmal + Auswahl für %s Minuten merken + Auswahl dauerhaft merken + Interaktiv + Protokolle + Einstellungen + Löschen + Keine Protokolle + Es sind noch keine App-Einstellungen vorhanden. + Protokollierung + Alle Superuser-Anfragen protokollieren + PIN-Schutz + Die Eingabe einer PIN erfordern, um Superuser-Anfragen zu genehmigen + Zeitlimit + Superuser-Anfragen verweigern, wenn sie nach %s Sekunden nicht beantwortet wurden + Benachrichtigungen + Keine + Eine %s anzeigen, wenn einer App Superuser-Rechte gewährt oder verweigert werden + PIN eingeben + Neue PIN eingeben + Falsche PIN + PIN bestätigen + Die eingegebenen PINs stimmen nicht überein + PIN-Schutz aktiviert + %s Sekunden + Superuser für %s gewährt + Superuser für %s verweigert + Kurzzeit-Benachrichtigung + Statusleisten-Benachrichtigung + Keine Benachrichtigungen anzeigen + Entwickler-Warnung:\nandroid.permission.ACCESS_SUPERUSER\n wurde im Manifest nicht deklariert. + Voller Zugriff auf alle Gerätefunktionen und Speicher + Superuser gewährt vollen Zugriff auf alle Gerätefunktionen und Speicher, einschließlich der sicheren und sensiblen Hardware-Elemente Ihres Geräts. Diese Berechtigung ist potenziell gefährlich. + Deklaration erfordern + Anfragen von Apps, die die Superuser-Berechtigung nicht im Manifest deklarieren, ignorieren + Automatische Beantwortung + Nachfragen + Neue Anfragen automatisch gewähren + Neue Anfragen automatisch verweigern + Bei neuen Anfragen Bestätigungsdialog anzeigen + Sicherheit + Mehrbenutzer-Verhalten + Nur der Eigentümer kann Superuser anfordern + Superuser-Anfragen durch den Eigentümer beantworten lassen + Alle Benutzer können Superuser anfordern + Nur Eigentümer + Vom Eigentümer verwaltet + Alle Benutzer + Nur der Eigentümer kann die Mehrbenutzer-Verhalten ändern. + Bitte zum Eigentümer-Konto wechseln, um die Anfrage zu erlauben oder zu verweigern. + Alle Befehle + Über + Apps + Installation + Superuser wird installiert\u2026 + Superuser installieren + Die Superuser-Binärdatei (su) muss aktualisiert werden.\n\nBitte eine Installationsmethode auswählen.\nBei HTC-Geräten wird die Installation via \"Recovery\" empfohlen. + Recovery + Installieren + Superuser wird überprüft\u2026 + Bei der Installation von Superuser ist ein Fehler aufgetreten. Bitte ein Fehlerprotokoll an den Entwickler senden. + Superuser wurde erfolgreich installiert. + Die su-Binärdatei ist veraltet. + Superuser-Zugriff + Deaktiviert + Nur Apps + Nur ADB + Apps und ADB + Was ist neu? + Bewerten + Design + Hell + Dunkel + Superuser-PIN-Schutz deaktiviert + Superuser-Zugriff entziehen + Details + Dieser App kann der Superuser-Zugriff nicht entzogen werden.\nStarten Sie die Superuser-App neu und versuchen Sie es erneut. diff --git a/Superuser/res/values-el/strings.xml b/Superuser/res/values-el/strings.xml new file mode 100644 index 00000000..90e73f77 --- /dev/null +++ b/Superuser/res/values-el/strings.xml @@ -0,0 +1,108 @@ + + + + + Superuser + Να επιτρέπεται + Άρνηση + Αίτηση superuser\u2026 + Άγνωστο UID: %s + %s ζητά πρόσβαση Superuser. + Προσοχή: Αν δεν κατανοείτε αυτό το μήνυμα, είναι καλύτερα να αρνηθείτε την αίτηση. + Αίτηση Superuser + Πακέτο: + Εφαρμογή: + Ζητούμενο UID: + Εντολή: + Μόνο αυτή τη φορά + Απομνημόνευση επιλογής για %s λεπτά + Απομνημόνευση επιλογής για πάντα + Διαδραστικά + Αρχείο καταγραφής + Ρυθμίσεις + Διαγραφή + Δεν υπάρχει αρχείο καταγραφής + Δεν υπάρχουν πολιτικές εφαρμογών Superuser + Καταγραφή + Ενεργοποίηση της καταγραφής όλων των αιτήσεων Superuser + Προστασία PIN + Απαίτηση εισαγωγής PIN για την έγκριση των αιτήσεων Superuser + Χρον. όριο αίτησης + Οι αιτήσεις Superuser θα λήγουν και θα αρνούνται μετά από %s δευτερόλεπτα + Ειδοποιήσεις + Καμία + Μια %s θα εμφανίζεται όταν επιτρέπονται ή αρνούνται σε μια εφαρμογή τα δικαιώματα Superuser + Εισαγωγή PIN + Εισάγετε νέο PIN + Λανθασμένο PIN + Επιβεβαίωση PIN + Τα PIN δεν ταιριάζουν + Ενεργοποιήθηκε η προστασία PIN του Superuser + %s δευτερόλεπτα + %s έλαβε δικαιώματα Superuser + %s αρνήθηκε δικαιώματα Superuser + Μήνυμα + Ειδοποίηση + Δεν θα εμφανίζεται ειδοποίηση + Προειδοποίηση για προγραμματιστές:\nandroid.permission.ACCESS_SUPERUSER\nδεν έχει δηλωθεί στο manifest. + πλήρη δικαιώματα σε όλες τις λειτουργίες της συσκευής και χώρου αποθήκευσης + Το Superuser παρέχει πλήρη πρόσβαση σε όλες τις λειτουργίες της συσκευής και χώρου αποθήκευσης, συμπεριλαμβανομένων των ευαίσθητων στοιχείων του υλικού της συσκευής σας. Αυτή η άδεια ενδεχομένως είναι επικίνδυνη. + Έγκριση δικαιωμάτων + Να επιτρέπονται αιτήσεις μόνο από εφαρμογές που έχουν δηλώσει το android.permission.ACCESS_SUPERUSER + Αυτόματη απάντηση + Προτροπή + Να επιτρέπονται αυτόματα οι νέες αιτήσεις + Να αρνούνται αυτόματα οι νέες αιτήσεις + Εμφάνιση μηνύματος επιβεβαίωσης για νέες αιτήσεις + Ασφάλεια + Πολιτική πολλαπλών χρηστών + Μόνο ο κάτοχος της συσκευής μπορεί να κάνει αίτηση Superuser + Θα ερωτάται ο κάτοχος της συσκευής όταν κάποιος άλλος χρήστης κάνει αίτηση Superuser + Όλοι οι χρήστες μπορούν να κάνουν αίτηση Superuser + Μόνο ο κάτοχος + Έλεγχος από τον κάτοχο + Όλοι οι χρήστες + Η πολιτική πολλαπλών χρηστών μπορεί να αλλάξει μόνο από τον κάτοχο της συσκευής. + Παρακαλώ συνδεθείτε με τον λογαριασμό του κατόχου για να δεχθείτε ή να απορρίψετε αυτή την αίτηση. + Όλες οι εντολές + Σχετικά + Εφαρμογές + Εγκατάσταση + Γίνεται εγκατάσταση του Superuser\u2026 + Εγκατάσταση του Superuser + Το Superuser binary (su) χρειάζεται ενημέρωση.\n\nΠαρακαλώ επιλέξτε μέθοδο εγκατάστασης.\nΗ εγκατάστασης σε λειτουργία recovery προτείνεται για συσκευές HTC. + Εγκατάσταση από λειτουργία recovery + Εγκατάσταση + Γίνεται έλεγχος του Superuser\u2026 + Υπήρξε ένα σφάλμα κατά την εγκατάσταση του Superuser. Παρακαλώ στείλτε ένα αρχείο καταγραφής του σφάλματος στον προγραμματιστή. + Η εγκατάσταση του Superuser ήταν επιτυχής. + Το su binary δεν είναι ενημερωμένο. + Πρόσβαση Superuser + Απενεργοποιημένη + Μόνο εφαρμογές + Μόνο ADB + Εφαρμογές και ADB + Τι νέο υπάρχει + Βαθμολογία + Θέμα + Φωτεινό + Σκοτεινό + Η προστασία PIN του Superuser απενεργοποιήθηκε + Ανάκληση δικαιωμάτων Superuser + Λεπτομέρειες + Η ανάκληση των δικαιωμάτων Superuser στάθηκε αδύνατη γι\' αυτή την εφαρμογή.\nΕπανεκκινήστε την εφαρμογή Superuser και δοκιμάστε ξανά. + diff --git a/Superuser/res/values-es-rXA/strings.xml b/Superuser/res/values-es-rXA/strings.xml new file mode 100644 index 00000000..80a46eb2 --- /dev/null +++ b/Superuser/res/values-es-rXA/strings.xml @@ -0,0 +1,108 @@ + + + + + Superusuariu + Permitir + Refugar + Solicitú de Superusuariu\u2026 + UID desconocíu: %s + %s ta solicitando accesu alministrativu. + Avisu: Si nun aniciasti esta aición, o si nun entiendes esta petición, ye meyor que nun la permitas. + Petición Superusuariu + Paquete: + Aplicación: + UID solicitáu: + Comandu: + Namái esta vegada + Recordar mientres %s minutos + Recordar indefinidamente + Interactivu + Rexistros + Axustes + Desaniciar + Ensin rexistros + Anguaño, nun hai polítiques d\'app de Superusuariu. + Logging + Habilitar o deshabilitar el rexistru de toles solicitúes + Proteición por PIN + Necesítase introducir un PIN p\'aprobar la solicitú + Tiempu d\'espera + Les solicitúes tienen un tiempu d\'espera y van refugase dempués de %s segundos + Notificaciones + Nengún + Va amosase una %s cuando a una aplicación se-y otorguen o refugen permisos de Superusuariu + Inxertar PIN + Inxertar PIN nuevu + PIN incorreutu + Confirmar PIN + Los númberos PIN nun concasen + Proteición del Superusuariu por PIN activada + %s segundos + Superusuariu otorgáu a %s + Superusuariu refugáu a %s + Notificación emerxente + Notificación + Nun va amosase nenguna notificación + Avisu al desendolcador:\nandroid.permission.ACCESS_SUPERUSER\nnon declaráu en manifest. + acceso completu a toles funciones y almacenamientu del preséu + Superusuariu permite l\'accesu a toles funciones y almacenamientu del preséu, incluyendo los elementos de hardware seguros y sensibles del preséu. Esti permisu ye enforma peligrosu. + Permisu declaráu + Namái permitir solicitúes d\'aplicaciones que declaren android.permission.ACCESS_SUPERUSER + Rempuesta automática + Entruga + Permitir solicitúes nueves automáticamente + Refugar solicitúes nueves automáticamente + Amosar un dialogu de confirmación pa les solicitúes nueves + Seguridá + Política multiusuariu + Namái el propietariu del preséu pue acceder a Superusuariu + Va entrugase-y al propietariu del preséu cuando otru usuariu pida ser Superusuariu + Tolos usuarios pueden pidir ser Superusuariu + Namái\'l propietariu + Alministráu pol propietariu + Tolos usuarios + La política multiusuariu namái pue alministrala\'l propietariu del preséu. + Fai\'l favor de camudar la cuenta del propietariu pa permitir o torgar esti pidimientu. + Tolos comandos + Tocante a + Aplicaciones + Instalando + Instalando Superusuariu\u2026 + Instalar Superusuariu + El binariu de Superusuariu (su) tien d\'anovase.\n\nPor favor, escueyi un métodu d\'instalación.\nRecomiéndase\'l mou recuperación pa los preseos HTC. + Instalación en mou Recuperación + Instalar + Verificación de Superusuariu\u2026 + Hebo un fallu mentanto s\'instalaba\'l Superusuariu. Mánda-y por favor un rexistru de fallu al desendolcador. + Superusuariu instaláu con exitu. + El binariu su ta caducáu. + Accesu al Superusuariu + Desactiváu + Namái aplicaciones + Namái ADB + Aplicaciones y ADB + Novedaes + Puntúa + Tema + Claru + Escuru + La proteición del Superusuariu ta desactivada + Revocar el permisu de Superusuariu + Detalles + El permisu de superusuariu nun pue revocase dende esta app.\nPor favor reanicia l\'app del Superusuariu y prueba otra vuelta. + diff --git a/Superuser/res/values-es/strings.xml b/Superuser/res/values-es/strings.xml index ccfef9c8..49ee7a11 100644 --- a/Superuser/res/values-es/strings.xml +++ b/Superuser/res/values-es/strings.xml @@ -1,90 +1,108 @@ - + + + + Superusuario + Permitir + Denegar + Solicitud de Superusuario\u2026 + UID desconocido: %s + %s está solicitando acceso administrativo. + Atención: Si no has iniciado esta acción, o si no entiendes esta petición, es mejor que no la permitas. + Petición Superusuario + Paquete: + Aplicación: + UID solicitado: + Comando: + Solo esta vez + Recordar durante %s minutos + Recordar indefinidamente + Interactivo + Registro + Ajustes + Eliminar + No hay información de registro + No hay aplicaciones en lista. + Registro + Habilitar o deshabilitar el registro de todas las peticiones + Protección por PIN + Se requiere introducir un PIN para aprobar la petición + Tiempo de espera + Las peticiones tienen un tiempo de espera y se denegarán después de %s segundos + Notificaciones + Ninguna + Notificación que se mostrará cuando se conceda acceso administrativo a una aplicación: %s + Introducir PIN + Introducir nuevo PIN + PIN incorrecto + Confirmar PIN + Los números PIN no coinciden + Protección por PIN activada + %s segundos + Acceso administrativo permitido a %s + Acceso administrativo denegado a %s + Notificación emergente + Barra de estado + No se mostrará ninguna notificación + Advertencia al desarrollador:\nandroid.permission.ACCESS_SUPERUSER\nno declarado en manifest. + Acceso completo a todas las funciones y almacenamiento del dispositivo + Superusuario permite el acceso a todas las funciones y almacenamiento del dispositivo, incluyendo los elementos de hardware seguros y sensibles del dispositivo. Este permiso es potencialmente peligroso. + Permiso declarado + Solo permitir peticiones de aplicaciones que declaren android.permission.ACCESS_SUPERUSER + Respuesta automática + Preguntar + Permitir nuevas peticiones automáticamente + Denegar nuevas peticiones automáticamente + Mostrar un dialogo de confirmación para las nuevas peticiones + Seguridad + Política multiusuario + Solo el propietario del dispositivo puede acceder a Superusuario + Se preguntará al propietario del dispositivo cuando otro usuario solicite acceso a Superusuario + Todos los usuarios pueden acceder a Superusuario + Solo el propietario + Administrado por el propietario + Todos los usuarios + La política multiusuario solo puede ser administrada por el propietario del dispositivo. + Por favor, cambia a la cuenta del propietario para permitir o denegar esta petición. + Todos los comandos + Acerca de + Aplicaciones + Instalando + Instalando Superusuario\u2026 + Instalar Superusuario + El binario de Superusuario (su) se debe actualizar.\n\nPor favor, escoge un método de instalación.\nSe recomienda el modo recuperación para los dispositivos HTC. + Instalar en modo recuperación + Instalar + Probando Superusuario\u2026 + Ha ocurrido un error mientras se instalaba Superusuario. Por favor, envía un registro del error al desarrollador + La instalación de Superusuario se ha realizado con éxito. + El binario \u00ABsu\u00BB está desactualizado. + Acceso administrativo + Deshabilitado + Solo aplicaciones + Solo ADB + Aplicaciones y ADB + Novedades + Valorar + Temas + Claro + Oscuro + Protección por PIN desactivada + Revocar acceso administrativo + Detalles + El acceso administrativo no puede ser revocado para esta aplicación.\nPor favor, reinicia la aplicación Superusuario e inténtalo de nuevo. diff --git a/Superuser/res/values-fi/strings.xml b/Superuser/res/values-fi/strings.xml index 04ffc22d..0ab3f79c 100644 --- a/Superuser/res/values-fi/strings.xml +++ b/Superuser/res/values-fi/strings.xml @@ -1,66 +1,108 @@ + + - Superuser - Salli - Estä - Superuser pyyntö... - Tuntematon UID: %s - %s pyytää Superuser oikeuksia. - Varoitus: Josset tiedä, mikä tämä on, estä pyyntö. - Superuser Pyyntö - Paketti: - Sovellus: - Pyydetty UID: - Komento: - Vain tämän kerran - Muista valinta %s minuuttia - Muista valinta pysyvästi - Interaktiivinen - Lokit - Asetukset - Poista - Ei Lokeja - Ei voimassa olevia Superuser sovellussääntöjä. - Kirjaus - Kytke Superuser pyyntöjen kirjaus päälle tai pois päältä - PIN Suojaus - Vaadi PIN Superuser pyyntöjen hyväksymiseen - Pyynnön aikakatkaisu - Superuser pyynnöt katkaistaan ja estetään %s sekunnin päästä - Ilmoitukset - Ei mitään - Näytetään %s, kun sovellukselle myönnetään tai siltä evätään Superuser käyttöoikeudet - Anna PIN - Anna uusi PIN - Väärä PIN - Vahvista PIN - PIN ei täsmää - Superuser PIN suojaus päällä - %s sekuntia - Superuser myönnetty %s:lle - Superuser estetty %s:lle - Toast-ilmoitus - Notifikaatio - Ilmoitusta ei näytetä - Kehittäjä varoitus:\nandroid.permission.ACCESS_SUPERUSER\nei ole määritetty manifestissa. - täydet käyttöoikeudet kaikkiin laitteen ominaisuuksiin ja muistiin - Superuser sallii täydet käyttöoikeudet kaikkiin laitteen ominaisuuksiin ja muistiin, mukaan lukien suojatut ja arkaluonteiset laitteiston osat. Tämä käyttöoikeus on mahdollisesti vaarallinen. - Määritetty Käyttöoikeus - Salli pyynnöt ainoastaan sovelluksilta, joissa on määritelty android.permission.ACCESS_SUPERUSER - Automaattinen Vastaus - Kysy - Salli uudet pyynnöt automaatisesti - Estä uudet pyynnöt automaattisesti - Näytä vahvistusikkuna uusille pyynnöille - Turvallisuus - Usean Käyttäjän Toimintatapa - Salli Superuser pyynnöt ainoastaan laitteen omistajalle - Laitteen omistajalta kysytään, kun toiset käyttäjät pyytävät Superuser oikeuksia - Kaikki käyttäjät voivat pyytää Superuser oikeuksia - Vain Omistaja - Omistajan Hallitsema - Kaikki Käyttäjät - Usean Käyttäjän Toimintatapaa voi muuttaa vain laitteen omistaja. - Vaihda omistajan käyttäjätilille hyväksyäksesi tai estääksesi tämän pyynnön. - Kaikki Komennot + Superuser + Salli + Estä + Pääkäyttäjän oikeudet tarvitaan\u2026 + Tuntematon UID: %s + %s tarvitsee pääkäyttäjän oikeuksia. + Varoitus: Jos et tiedä mitä olet tekemässä, sinun pitäisi estää pyyntö. + Pääkäyttäjän oikeudet + Paketti: + Sovellus: + Pyydetty UID: + Komento: + Vain kerran + Muista valinta %s minuutin ajan + Muista pysyvästi + Vuorovaikutteinen + Loki + Asetukset + Poista + Ei lokeja + Ei voimassa olevia pääkäyttäjän sovellussääntöjä. + Lokiin kirjaus + Ota sovellusten lokiin kirjaaminen käyttöön tai pois käytöstä + PIN-suojaus + Pyydä PIN-koodi hyväksyäksesi pääkäyttäjän oikeudet + Pyynnön aikakatkaisu + Pyyntö aikakatkaistaan ja pääkäyttäjän oikeudet estetään %s sekunnin kuluttua + Ilmoitukset + Ei mitään + %s näytetään, kun sovellukselle myönnetään/estetään pääkäyttäjän oikeudet + Syötä PIN + Syötä uusi PIN + Väärä PIN + Vahvista PIN + PIN-koodit eivät täsmänneet + PIN-suojaus otettu käyttöön + %s sekuntia + Pääkäyttäjän oikeudet myönnetty sovellukselle %s + Pääkäyttäjän oikeudet estetty sovellukselta %s + Toast-ilmoitus + Ilmoitus + Ilmoitusta ei näytetä + Kehittäjävaroitus:\nandroid.permission.ACCESS_SUPERUSER\npuuttuu manifestista. + täydet oikeudet kaikkiin laitteen ominaisuuksiin ja muistiin + Superuser antaa täydet oikeudet kaikkiin laitteen ominaisuuksiin ja muistiin, mukaanlukien suojatut ja arkaluonteiset laitteiston osat. Tämä käyttöoikeus saattaa olla vaarallinen. + Määritetyt käyttöoikeudet + Salli pääkäyttäjän oikeudet vain, jos sovelluksessa on määritelty käyttöoikeus android.permission.ACCESS_SUPERUSER + Automaattinen vastaus + Kehote + Hyväksy uudet pyynnöt automaattisesti + Hylkää uudet pyynnöt automaattisesti + Näytä vahvistusikkuna uusille pyynnöille + Turvallisuus + Usean käyttäjän toiminta + Vain laitteen omistajalla on pääkäyttäjän oikeudet + Laitteen omistajalta kysytään, kun toinen käyttäjä pyytää pääkäyttäjän oikeuksia + Kaikilla käyttäjillä on pääkäyttäjän oikeudet + Vain omistaja + Omistajan hallinnassa + Kaikki käyttäjät + Vain laitteen omistaja voi muuttaa usean käyttäjän toiminnan asetuksia. + Vaihda omistajan tilille hyväksyäksesi tai hylätäksesi tämän pyynnön. + Kaikki komennot + Tietoja + Sovellukset + Asennetaan + Asennetaan Superuseria\u2026 + Asenna Superuser + Superuser-binääri (su) on päivitettävä.\n\nValitse asennustapa.\nRecovery-tilassa asentaminen on suositeltavaa HTC:n laitteilla. + Recovery-asennus + Asenna + Tarkistetaan\u2026 + Superuserin asennus ei onnistunut. Lähetä lokitiedosto virheestä kehittäjälle. + Superuser asennettu onnistuneesti. + su-binääri on vanhentunut. + Pääkäyttäjän oikeudet + Pois käytöstä + Vain sovellukset + Vain ADB + Sovellukset ja ADB + Uutta + Arvostele + Teema + Vaalea + Tumma + PIN-suojaus poistettu käytöstä + Kumoa pääkäyttäjän oikeudet + Tietoja + Pääkäyttäjän oikeuksia ei voi kumota tältä sovellukselta.\nUudelleenkäynnistä Superuser ja yritä uudelleen. diff --git a/Superuser/res/values-fr/strings.xml b/Superuser/res/values-fr/strings.xml index 25effd47..6a8b973f 100644 --- a/Superuser/res/values-fr/strings.xml +++ b/Superuser/res/values-fr/strings.xml @@ -1,90 +1,108 @@ - + + + + Super-utilisateur + Autoriser + Refuser + Demande des droits Super-utilisateur\u2026 + UID Inconnu : %s + %s demande les droits Super-utilisateur. + Attention : Si vous ne comprenez pas ceci, vous devriez refuser la demande. + Demande Super-utilisateur + Paquet : + Application : + UID demandé : + Commande : + Cette fois seulement + Se souvenir pendant %s minutes + Toujours se souvenir + Interactif + Historiques + Paramètres + Supprimer + Pas d\'historique + Actuellement aucune application n\'a de règle Super-utilisateur + Historique + Activer ou désactiver l\'historique des demandes Super-utilisateur + Protection par code + Demander un code pour valider les demandes Super-utilisateur + Délai de réponse + Les demandes Super-utilisateur expireront et seront refusées après %s secondes + Notifications + Aucune + Une %s sera affichée lorsque les droits Super-utilisateur seront accordés ou refusés à une application + Entrer le code + Entrer le nouveau code + Code incorrect + Confirmer le code + Le code entré n\'est pas valide + La protection de Super-utilisateur par code est activée + %s secondes + Droits Super-utilisateur accordés à %s + Droits Super-utilisateur refusés à %s + Notification pop-up + Notification + Aucune notification ne sera affichée + Mise en garde Développeur :\nandroid.permission.ACCESS_SUPERUSER\nnon déclaré dans le manifest. + autorisations totales pour toutes les fonctionnalités et tous les emplacements de stockage du périphérique + Super-utilisateur permet un accès total à toutes les fonctionnalités et tous les emplacements de stockage de l\'appareil, incluant ses éléments matériels sécurisés et sensibles. Cette permission est potentiellement dangereuse. + Autorisations déclarées + Autoriser uniquement les demandes des applications qui déclarent utiliser la permission android.permission.ACCESS_SUPERUSER + Réponse automatique + Demander + Autoriser automatiquement les nouvelles demandes + Refuser automatiquement les nouvelles demandes + Afficher une confirmation pour les nouvelles demandes + Sécurité + Politique multi-utilisateurs + Seul le propriétaire de l\'appareil peut demander les droits Super-utilisateur + Le propriétaire de l\'appareil sera consulté lorsqu\'un autre utilisateur demandera les droits Super-utilisateur + Tous les utilisateurs peuvent demander les droits Super-utilisateur + Uniquement le propriétaire + Géré par le propriétaire + Tous les utilisateurs + La politique multi-utilisateurs ne peut-être gérée que par le propriétaire de l\'appareil + Merci de basculer sur le compte du propriétaire de cet appareil afin d\'autoriser ou refuser cette demande. + Toutes les commandes + À propos + Application + Installation + Installation de Super-utilisateur\u2026 + Installer Super-utilisateur + Le binaire Super-utilisateur (su) doit être mis à jour.\n\nVeuillez choisir une méthode d\'installation.\nL\'installation par Recovery est recommandée pour les appareils HTC. + Installation par Recovery + Installer + Vérification de Super-utilisateur\u2026 + Une erreur est survenue pendant l\'installation de Super-utilisateur. Merci d\'envoyer le rapport d\'erreur au développeur. + Super-utilisateur installé avec succès. + Le binaire su n\'est pas à jour. + Accès Super-utilisateur + Désactivé + Application seulement + ADB seulement + Application et ADB + Nouveautés + Noter + Thème + Lumineux + Sombre + La protection par code est désactivée + Révoquer les permissions Super-utilisateur + Détails + Les droits Super-utilisateur ne peuvent pas être supprimés depuis cette application.\nRedémarrez l\'application Super-utilisateur et essayez de nouveau. diff --git a/Superuser/res/values-gl/strings.xml b/Superuser/res/values-gl/strings.xml new file mode 100644 index 00000000..b40ddecd --- /dev/null +++ b/Superuser/res/values-gl/strings.xml @@ -0,0 +1,108 @@ + + + + + Superusuario + Permitir + Denegar + Solicitude de superusuario\u2026 + UID descoñecido: %s + %s está solicitando acceso de superusuario. + Atención: Se non entendes isto, deberías denegar a petición. + Petición de superusuario + Paquete: + Aplicación: + UID solicitado: + Comando: + Só esta vez + Lembrar a elección durante %s minutos + Lembrar elección para sempre + Interactivo + Rexistros + Axustes + Eliminar + Sen rexistros + Non hai aplicacións con regras de superusuario. + Rexistro + Activar o rexistro de todas as peticións de superusuario + Protección con PIN + Esixir a inserción dun PIN para aprobar a petición de superusuario + Tempo de espera + As peticións de superusuario terán un tempo de expiración e se denegarán despois de %s segundos + Notificacións + Ningunha + Amosarase unha %s cando se lle permitan ou se lle denegen permisos de superusuario a unha aplicación + Inserir PIN + Inserir novo PIN + PIN incorrecto + Confirmar PIN + Os PIN non coinciden + Protección con PIN activada + %s segundos + Concedéronse permisos de superusuario a %s + Denegáronse permisos de superusuario a %s + Notificación emerxente + Notificación + Non se amosarán notificacións + Aviso do desenvolvedor:\nandroid.permission.ACCESS_SUPERUSER\nnon declarado no manifesto. + Acceso total a todas as funcións e almacenamento do dispositivo + O superusuario concede acceso total a todos os recursos e almacenamento do dispositivo, incluídos os elementos de hardware sensíbeis e seguros do dispositivo. Este permiso é potencialmente perigoso. + Permiso declarado + Só permitir peticións de aplicacións que declaren android.permission.ACCESS_SUPERUSER + Resposta automática + Preguntar + Permitir automáticamente peticións novas + Denegar automáticamente peticións novas + Mostrar un diálogo de confirmación para as novas peticións + Seguridade + Política multiusuario + Só o propietario do dispositivo pode conceder permisos de superusuario + Notificaráselle ao propietario do dispositivo cando outro usuario solicite permisos de superusuario + Todos os usuarios poden solicitar permisos de superusuario + Só o propietario + Controlado polo propietario + Tódolos usuarios + A política multiusuario só pode ser controlada polo propietario do dispositivo. + Por favor, cambia a conta do propietario para permitir ou denegar esta petición. + Tódolos comandos + Sobre + Aplicacións + Instalando + A instalar superusuario\u2026 + Instalar superusuario + O binario de superusuario (su) debe actualizarse.\n\nPor favor, escolle un método de instalación.\nRecoméndase a instalación en modo recuperación para os dispositivos HTC. + Instalación en modo recuperación + Instalar + Verificando superusuario\u2026 + Houbo un erro durante a instalación de superusuario. Por favor, envía un rexistro do erro ao desenvolvedor. + Instalouse superusuario con éxito. + O binario su está desactualizado. + Acceso de superusuario + Desactivado + Só aplicacións + Só ADB + Aplicacións e ADB + Novidades + Valorar + Tema + Claro + Escuro + Protección con PIN desactivada + Retirar permiso de superusuario + Detalles + Non se pode retirar o permiso de superusuario desta aplicación.\nPor favor, reinicie a aplicación de superusuario e inténteo de novo. + diff --git a/Superuser/res/values-hi/strings.xml b/Superuser/res/values-hi/strings.xml deleted file mode 100644 index d90b4316..00000000 --- a/Superuser/res/values-hi/strings.xml +++ /dev/null @@ -1,90 +0,0 @@ - - - - Superuser - अनुमति दीजिये - इनकार कीजिये - आवक Superuser अनुरोध... - अनजान UID: %s - %s Superuser उपयोग का अनुरोध कर रहा है| - चेतावनी: यदि आपको यह समझ में नहीं आ रहा, तो आपको अनुरोध इनकार करना चाहिए। - Superuser अनुरोध - पैकेज: - App: - अनुरोधित UID: - Command: - सिर्फ इस बार - %s मिनट के लिए चुनाव को याद रखे - चुनाव को हमेशा याद रखे - इंटरैक्टिव - लौगों - सेटिंग - मिटा दीजिये - कोई लौग नहीं है - वर्त्तमान नें कोई Superuser app नीतियों नहीं है| - Logging - सभी Superuser logging अनुरोध के सक्षम या अक्षम करे - PIN द्वारा सुरक्षा - Require entry of a PIN to approve Superuser requests - Request Timeout - Superuser requests will time out and be denied after %s seconds - Notifications - None - A %s will be shown when an app is granted or denied Superuser permissions - Enter PIN - Enter New PIN - Incorrect PIN - Confirm PIN - PIN did not match - Superuser PIN protection enabled - %s seconds - Superuser granted to %s - Superuser denied to %s - Toast - Notification - No notification will be shown - Developer Warning:\nandroid.permission.ACCESS_SUPERUSER\nnot declared in manifest. - full permissions to all device features and storage - Superuser grants full access to all device features and storage, including the secure and sensitive hardware elements of your device. This permission is potentially dangerous. - Declared Permission - Only allow requests from apps that declare android.permission.ACCESS_SUPERUSER - Automatic Response - Prompt - Automatically allow new requests - Automatically deny new requests - Show confirmation dialog for new requests - Security - Multiuser Policy - Only the device owner can request Superuser - The device owner will be prompted when another user requests Superuser - सब users can request Superuser - Owner Only - Owner Managed - सब उपयोगकर्ताओं - The Multiuser Policy can only be managed by the device owner. - Please switch to the owner account to approve or deny this request. - सब Commands - About - Apps - इंस्टॉल हो रहा है - Superuser इंस्टॉल हो रहा है... - Install Superuser - The Superuser binary (su) must be updated.\n\nPlease choose an installation method.\nRecovery mode installation is recommended for HTC devices. - Recovery Install - Install - Checking Superuser... - There was an error installing Superuser. Please send a log of the error to the developer. - Superuser इंस्टॉल सफल रहा| - su binary पुराना है| - Superuser Access - Disabled - सिर्फ Apps - सिर्फ ADB - Apps और ADB - क्या नया है - मूल्यांकन करे - थीम - सफ़ेद - काला - Superuser PIN protection disabled - diff --git a/Superuser/res/values-hr/strings.xml b/Superuser/res/values-hr/strings.xml new file mode 100644 index 00000000..762b59ec --- /dev/null +++ b/Superuser/res/values-hr/strings.xml @@ -0,0 +1,86 @@ + + + + + Superuser + Dopusti + Odbij + Dolazni Superuser Zahtjev\u2026 + Nepoznati UID: %s + %s zahtjeva Superuser pristup. + Upozorenje: Ako ne znate što je ovo, trebali biste odbiti ovaj zahtjev. + Superuser Zahtjev + Paket: + Aplikacija: + Zahtijevani UID: + Naredba: + Samo ovaj put + Zapamti odabir sljedećih %s minuta + Zapamti odabir zauvijek + Interaktivno + Izvještaji + Postavke + Obriši + Nema Izvještaja + Izvještavanje + Dopusti sve zahtjeve Superuser izvještavanja + Zaštita PIN-om + Zahtjevaj unos PIN-a za potvrdu Superuser zahtjeva + Istek Zahtjeva + Superuser zahtjevi će isteći i biti će odbijeni nakon %s sekundi + Obavijesti + Ništa + %s će biti prikazane kada je aplikacija odobrila ili odbila Superuser dozvolu + Unesite PIN + Unesite Nov PIN + Pogrešan PIN + Potvrdite PIN + PIN se ne podudara + Superuser zaštita PIN-om omogućena + %s sekundi + Superuser odobren aplikaciji %s + Tost + Obavijest + Obavijesti neće biti prikazane + potpuna dozvola svim značajkama uređaja i pohranjivanju + Superuser odobrava potpuni pristup svim značajkama uređaja i pohranjivanju, uključujući sigurnosne i osjetljive hardverske elemente vašeg uređaja. Ova je dozvola potencijalno opasna. + Odobrite samo zahtjeve aplikacija koje imaju android.permission.ACCESS_SUPERUSER + Automatski Odgovor + Automatski dopusti nove zahtjeve + Automatski odbij nove zahtjeve + Prikaži prozor za potvrdu za nove zahtjeve + Sigurnost + Samo vlasnik uređaja može zahtijevati Superuser + Vlasnik uređaja biti će obaviješten kada drugi korisnik zahtjeva Superuser + Svi korisnici mogu zahtijevati Superuser + Samo Vlasnik + Upravljano Vlasnikom + Svi Korisnici + Sve Naredbe + O + Aplikacije + Instaliranje + Instaliranje Superuser-a\u2026 + Instaliraj Superuser + Instalacija Načina Oporavka + Instaliraj + Provjeravanje Superuser-a\u2026 + Su binary datoteka je zastarjela. + Superuser Pristup + Samo aplikacije + Samo ADB + diff --git a/Superuser/res/values-hu/strings.xml b/Superuser/res/values-hu/strings.xml new file mode 100644 index 00000000..f6d6ef13 --- /dev/null +++ b/Superuser/res/values-hu/strings.xml @@ -0,0 +1,108 @@ + + + + + Rendszergazda + Engedélyez + Megtagad + Rendszergazdai jog kérése\u2026 + Ismeretlen UID: %s + %s rendszergazdai jogokat kér. + Figyelem: Amennyiben nincs tisztában a funkcióval, jobban jár, ha letiltja! + Rendszergazdai jog kérése + Csomag: + Alkalmazás: + Kért UID: + Parancs: + Csak most + Emlékezzen a válaszra %s percig + Válasz megjegyzése örökre + Interaktív + Napló + Beállítások + Törlés + Nincs napló bejegyzés + Jelenleg még nincs beállítva rendszergazdai jogosultság egyetlen alkalmazáshoz sem. + Naplózás + Engedélyezze a jogosultságkérelmek naplózását + PIN-kód használata + PIN-kód szükséges a rendszergazdai jog engedélyezéséhez + Időtúllépés + A rendszergazdai jog kérések %s másodperc után el lesznek utasítva + Figyelmeztetések + Nincs + %s megjelenítése rendszergazdai jog kérésekor + Adja meg a PIN-kódot + Adja meg az új PIN-kódot + Helytelen PIN-kód + Erősítse meg a PIN-kódot + A megadott PIN-kódok nem egyeznek + PIN-kód védelem bekapcsolva + %s másodperc + %s rendszergazdai jogot kapott + %s rendszergazdai jog kérése megtagadva + Felugró ablak + Figyelmeztetés + Nem jelennek meg az értesítések + Fejlesztői figyelmeztetés:\nandroid.permission.ACCESS_SUPERUSER\nnincs deklarálva a manifest fájlban. + teljes hozzáférés az összes eszközfunkcióhoz és tárolóhoz + Teljes rendszergazdai hozzáférést ad az összes eszközfunkcióhoz és tárolóhoz, beleértve a készülék egyébként védett és érzékeny hardverelemeit. Ez az engedély potenciálisan veszélyes. + Nyilvántartott engedély + Csak azon alkalmazások számára engedélyezi a rendszergazdai jog kérését, melyek deklarálják az android.permission.ACCESS_SUPERUSER engedélyt + Automatikus válasz + Rákérdezés + Új kérések automatikus engedélyezése + Új kérések automatikus elutasítása + Megerősítő párbeszédablak megjelenítése új kéréskor + Biztonság + Többfelhasználós szabály + Csak a tulajdonos kérhet rendszergazdai jogosultságot + A tulajdonos értesítése, ha egy másik felhasználó rendszergazdai jogosultságot kér + Minden felhasználó kérhet rendszergazdai jogosultságot + Csak tulajdonos + Tulajdonos által meghatározott + Összes felhasználó + A többfelhasználós szabályt csak az eszköz tulajdonosa módosíthatja. + Kérjük, váltson át a tulajdonosi fiókba a kérés jóváhagyásához, vagy megtagadásához. + Minden parancs + Névjegy + Alkalmazások + Telepítés + Superuser telepítése\u2026 + Superuser telepítés + A Superuser binárist (su) frissíteni kell.\n\nKérjük, válassza ki a telepítés módját.\nHTC készülékeknél Recovery módú telepítés ajánlott. + Recovery telepítés + Telepítés + Superuser ellenőrzése\u2026 + Hiba történt a Superuser telepítésekor. Kérjük, küldje el a hibanaplót a fejlesztőknek. + A Superuser telepítése sikeres volt. + A su bináris elavult. + Rendszergazdai jog + Letiltva + Csak alkalmazások + Csak ADB + Alkalmazások és ADB + Újdonságok + Szavazás + Téma + Világos + Sötét + PIN-kód használat letiltva + Rendszeradminisztrátori engedély visszavonása + Részletek + Az adminisztrátori jog nem vonható vissza ettől az alkalmazástól. \nIndítsa újra a Superuser alkalmazást és próbálja újra. + diff --git a/Superuser/res/values-it/strings.xml b/Superuser/res/values-it/strings.xml index eabfb6d6..ed38f9c8 100644 --- a/Superuser/res/values-it/strings.xml +++ b/Superuser/res/values-it/strings.xml @@ -1,90 +1,108 @@ - + + + + Superuser + Consenti + Nega + Richiesta di Superuser in arrivo\u2026 + UID sconosciuto: %s + %s richiede l\'accesso a Superuser. + Attenzione: se non comprendi cosa significhi dovresti negare l\'accesso. + Richiesta Superuser + Pacchetto: + Applicazione: + UID Richiesto: + Comando: + Solo per questa volta + Ricorda questa scelta per %s minuti + Ricorda questa scelta per sempre + Interattivo + Log + Impostazioni + Cancella + Nessun log + Nessuna App gestita da Superuser. + Registrazione log + Attiva o disattiva tutte le richieste di log da parte di Superuser + Protezione con PIN + Sarà richiesto l\'inserimento del PIN per approvare la richiesta di Superuser + Scadenza richieste + Le richieste di Superuser scadranno e sarannno rifiutate dopo %s secondi + Notifica + Nessuna + Un %s verrà mostrato quando ad un\'app sono stati garantiti o rifiutati i permessi di Superuser + Inserisci il PIN + Inserisci un nuovo PIN + PIN errato + Conferma PIN + Il PIN inserito non corrisponde + Protezione di Superuser con PIN attivata + %s secondi + A %s è stato garantito l\'accesso a Superuser + A %s è stato negato l\'accesso a Superuser + Avviso + Notifiche + Non verrà mostrata nessuna notifica + Attenzione sviluppatore:\nandroid.permission.ACCESS_SUPERUSER\nnon è stato dichiarato nel manifesto. + massimi privilegi per accedere a tutti gli strumenti e memoria del dispositivo + Superuser garantisce completo accesso a tutti gli stumenti e memoria interna del dispositivo, compresi gli elementi hardware in sicurezza del tuo dispositivo. Questo permesso è potenzialmente dannoso. + Dichiarazione dei Permessi + Consenti solo richieste da App che dichiarano android.permission.ACCESS_SUPERUSER + Risposta Automatica + Prompt + Consenti automaticamente le nuove richieste + Nega automaticamente le nuove richieste + Mostra finestra di dialogo per le nuove richieste + Sicurezza + Gestione multiutente + Solo l\'utente proprietario può amministrare le richieste di Superuser + L\'utente proprietario sarà avvisato quando un\'altro utente richiederà Superuser + Tutti gli utenti possono utilizzare Superuser + Solo utente proprietario + Gestite dal proprietario + Tutti gli utenti + La gestione multiutente può essere amministrata solo dall\'utente proprietario. + E\' necessario utilizzare l\'utente proprietario per approvare o negare questa richiesta. + Tutti i comandi + Informazioni + Applicazioni + Installazione + Sto installando Superuser\u2026 + Installa Superuser + Il file binario di Superuser (su) deve essere aggiornato.\n\nPer favore scegli un metodo per installarlo.\nL\'installazione tramite Recovery è raccomandata per i dispositivi HTC. + Installa da Recovery + Installa + Sto controllando Superuser\u2026 + Si è verificato un errore durante l\'installazione di Superuser. Per favore invia un log dell\'errore allo sviluppatore. + L\'installazione di Superuser è avvenuta con successo. + Il file binario su è obsoleto. + Accesso a Superuser + Disattivato + Solo Applicazioni + Solo ADB + Applicazioni ed ADB + Novità + Valuta + Tema + Chiaro + Scuro + Protezione di Superuser con PIN disattivata + Revoca permesso Superuser + Dettagli + Il permesso Superuser non può essere revocato da questa applicazione. Si prega di riavviare l\'applicazione Superuser e riprovare. diff --git a/Superuser/res/values-iw/strings.xml b/Superuser/res/values-iw/strings.xml index 669f424c..759cee5a 100644 --- a/Superuser/res/values-iw/strings.xml +++ b/Superuser/res/values-iw/strings.xml @@ -1,84 +1,108 @@ - - - - Superuser - אפשר - דחה - בקשת Superuser נכנסת... - לא ידוע UID: %s - %s מבקש הרשאת Superuser. - אזהרה: אם אתה לא מבין את זה, אתה צריך לדחות את הבקשה. - Superuser בקשת - חבילה: - יישום: - נדרש UID: - פקודה: - בפעם הזאת בלבד - זכור בחירה למשך %s דקות - זכור תמיד - אינטראקטיבי - רישומים - הגדרות - מחק - אין רישומים - כרגע אין מדיניות יישום Superuser. - רישום - הפעלה או ביטול של כל רישום בקשות Superuser - PIN הגנת - דרוש הכנסת PIN כדי לאשר בקשות Superuser - השהיית בקשה - בקשות Superuser תהיינה בפסק זמן וישללו לאחר %s שניות - התראות - ללא - %s יוצג כאשר אפליקציה אושרה או נדחתה מלקבל הרשאות של Superuser - הכנס PIN - הכנס PIN חדש - לא נכון PIN - אשר PIN - PIN לא מתאים - הגנת PIN מופעלת - %s שניות - Superuser אושר למשך %s - Superuser נדחה למשך %s - דיווח - התראות - התראות לא יוצגו - אזהרת מפתחים: \nandroid.permission.ACCESS_SUPERUSER\n הצהיר במניפסט. - הרשאות מלאות לכל תכונות המכשיר והאחסון - Superuser מעניק גישה מלאה לכל תכונות המכשיר והאחסון, כולל רכיבי חומרה מאובטחים ורגישים של המכשיר. הרשאה זו עלולה להיות מסוכנת. - רשות מוצהרת - התר רק בקשות מאפליקציות שמצהירות android.permission.ACCESS_SUPERUSER - תגובה אוטומטית - התרע - אשר אוטומטית בקשות חדשות - דחה אוטומטית בקשות חדשות - הצג חלונית אישור לבקשות חדשות - אבטחה - מדיניות ריבוי משתמשים - רק בעל המכשיר יכול לבקש Superuser - בעלי המכשיר ייודעו כאשר משתמש אחר מבקש Superuser - כל המשתמשים יכולים לבקש הרשאות Superuser - בעלים בלבד - מנוהל בעלים - כל המשתמשים - מדיניות ריבוי משתמשים יכולה להיות מנוהלת רק על ידי בעל המכשיר. - אנא עבור לחשבון של הבעלים כדי לאשר או לדחות בקשה זו. - כל הפקודות - אודות - יישומים - מתקין - מתקין את Superuser... - התקן את Superuser - קבצי Superuser binary (su) זקוקים לעדכון.\n\n בחר שיטת התקנה.\nשיטת הRecovery מומלצת במיוחד למכשירי HTC. - Recovery התקנה דרך - התקן - בודק Superuser... - אירעה שגיאה בעת התקנת Superuser. בבקשה שלח דוח למפתח התוכנה. - התקנת Superuser הצליחה. - מבוטל - יישומים בלבד - ADB בלבד - יישומים ו-ADB - מה חדש? - דרג - \ No newline at end of file + + + + + משתמש על + אפשר + דחה + בקשת Superuser נכנסת... + לא ידוע UID: %s + %s מבקש הרשאת Superuser. + אזהרה: אם אתה לא מבין את זה, אתה צריך לדחות את הבקשה. + Superuser בקשת + חבילה: + יישום: + נדרש UID: + פקודה: + בפעם הזאת בלבד + זכור בחירה למשך %s דקות + זכור תמיד + אינטראקטיבי + רישומים + הגדרות + מחק + אין רישומים + כרגע אין מדיניות יישום Superuser. + רישום + הפעלה או ביטול של כל רישום בקשות Superuser + PIN הגנת + דרוש הכנסת PIN כדי לאשר בקשות Superuser + השהיית בקשה + בקשות Superuser תהיינה בפסק זמן וישללו לאחר %s שניות + התראות + ללא + %s יוצג כאשר אפליקציה אושרה או נדחתה מלקבל הרשאות של Superuser + הכנס PIN + הכנס PIN חדש + לא נכון PIN + אשר PIN + PIN לא מתאים + הגנת PIN מופעלת + %s שניות + Superuser אושר למשך %s + Superuser נדחה למשך %s + דיווח + התראות + התראות לא יוצגו + אזהרת מפתחים: \nandroid.permission.ACCESS_SUPERUSER\n הצהיר במניפסט. + הרשאות מלאות לכל תכונות המכשיר והאחסון + Superuser מעניק גישה מלאה לכל תכונות המכשיר והאחסון, כולל רכיבי חומרה מאובטחים ורגישים של המכשיר. הרשאה זו עלולה להיות מסוכנת. + רשות מוצהרת + התר רק בקשות מאפליקציות שמצהירות android.permission.ACCESS_SUPERUSER + תגובה אוטומטית + התרע + אשר אוטומטית בקשות חדשות + דחה אוטומטית בקשות חדשות + הצג חלונית אישור לבקשות חדשות + אבטחה + מדיניות ריבוי משתמשים + רק בעל המכשיר יכול לבקש Superuser + בעלי המכשיר ייודעו כאשר משתמש אחר מבקש Superuser + כל המשתמשים יכולים לבקש הרשאות Superuser + בעלים בלבד + מנוהל בעלים + כל המשתמשים + מדיניות ריבוי משתמשים יכולה להיות מנוהלת רק על ידי בעל המכשיר. + אנא עבור לחשבון של הבעלים כדי לאשר או לדחות בקשה זו. + כל הפקודות + אודות + יישומים + מתקין + מתקין את Superuser... + התקן את Superuser + קבצי Superuser binary (su) זקוקים לעדכון.\n\n בחר שיטת התקנה.\nשיטת הRecovery מומלצת במיוחד למכשירי HTC. + Recovery התקנה דרך + התקן + בודק Superuser... + אירעה שגיאה בעת התקנת Superuser. בבקשה שלח דוח למפתח התוכנה. + התקנת Superuser הצליחה. + גרסת ה-su פגת תוקף. + הרשאת Superuser + מבוטל + יישומים בלבד + ADB בלבד + יישומים ו-ADB + מה חדש? + דרג + ערכת עיצוב + בהיר + כהה + הגנת PIN ל-Superuser מושבתת + ביטול הרשאת משתמש על + פרטים + הרשאות משתמש על לא יכולות להתבטל מיישום זה.\nאנה טען מחדש את יישום משתמש העל ונסה שוב. + diff --git a/Superuser/res/values-ja/strings.xml b/Superuser/res/values-ja/strings.xml index c176e1af..fe33b610 100644 --- a/Superuser/res/values-ja/strings.xml +++ b/Superuser/res/values-ja/strings.xml @@ -1,87 +1,108 @@ - + + + + スーパーユーザー + 許可 + 拒否 + スーパーユーザーリクエストがありました\u2026 + 不明なUID: %s + %sがスーパーユーザーアクセスをリクエストしています。 + 警告: 心当たりのないリクエストは拒否した方がよいでしょう。 + スーパーユーザーリクエスト + パッケージ: + アプリ: + リクエストUID: + コマンド: + 1回のみ + %s分間のみ + 選択を記憶する + インタラクティブ + ログ + 設定 + 削除 + ログはありません + スーパーユーザーアプリのポリシーはありません。 + ログを記録 + すべてのスーパーユーザーリクエストのログを有効にする + PINによる保護 + スーパーユーザーリクエストの承認にPINの入力を要求する + リクエストのタイムアウト + スーパーユーザーリクエストは%s秒でタイムアウトして拒否されます + 通知 + なし + アプリにスーパーユーザー権限が許可または拒否された際に%sを表示する + PINを入力 + 新しいPINを入力 + PINが正しくありません + PINの確認 + PINが一致しません + スーパーユーザーのPINによる保護が有効 + %s秒 + スーパーユーザーは%sを許可しました + スーパーユーザーは%sを拒否しました + トースト + 通知 + 通知を表示しない + 開発者警告:\nandroid.permission.ACCESS_SUPERUSER\nがマニフェストで宣言されていません。 + すべてのデバイスの機能とストレージへの完全なアクセス許可 + スーパーユーザーはセキュリティーで保護されている繊細なハードウェア要素を含めた端末のすべての機能とストレージへの完全なアクセスを許可します。この権限は潜在的に危険です。 + 宣言された権限 + android.permission.ACCESS_SUPERUSERを宣言しているアプリからのリクエストのみを許可する + 自動応答 + プロンプト + 新しいリクエストを自動的に許可する + 新しいリクエストを自動的に拒否する + 新しいリクエストをダイアログで確認する + セキュリティ + マルチユーザーポリシー + 端末の所有者のみスーパーユーザーをリクエストできます + 他のユーザーがスーパーユーザーをリクエストした際に端末の所有者にプロンプトで確認する + すべてのユーザーがスーパーユーザーをリクエストできます + 所有者のみ + 所有者が管理しています + すべてのユーザー + マルチユーザーポリシーは端末の所有者のみが管理できます。 + このリクエストを許可または拒否するには、所有者アカウントに切り替えてください。 + すべてのコマンド + 情報 + アプリ + インストールしています + スーパーユーザーをインストールしています\u2026 + スーパーユーザーをインストール + スーパーユーザーバイナリ（su）を更新する必要があります。\n\nインストール方法を選んでください。\nHTC端末ではリカバリーインストールが推奨されます。 + リカバリーインストール + インストール + スーパーユーザーを確認しています\u2026 + スーパーユーザーのインストール中にエラーが発生しました。エラーログを開発者に送信してください。 + スーパーユーザーのインストールに成功しました。 + suバイナリが古いようです。 + スーパーユーザーアクセス + 無効 + アプリのみ + ADBのみ + アプリとADB + 更新情報 + 評価する + テーマ + ライト + ダーク + スーパーユーザーのPINによる保護は無効 + スーパーユーザー権限を取り消す + 詳細情報 + このアプリからスーパーユーザー権限を取り消すことができませんでした。\nスーパーユーザーアプリを再起動して、もう一度やり直してください。 diff --git a/Superuser/res/values-ko/strings.xml b/Superuser/res/values-ko/strings.xml deleted file mode 100644 index 60fe6558..00000000 --- a/Superuser/res/values-ko/strings.xml +++ /dev/null @@ -1,84 +0,0 @@ - - - - 슈퍼유저 - 허가 - 취소 - 슈퍼유저 권한 요청 중... - 알수없는 UID: %s - %s (이)가 슈퍼유저 권한을 요청했습니다. - 주의: 루팅에 대해 모를시에는 허가를 누르지마세요. - 슈퍼유저 요청 - 패키지: - 앱: - 요청 UID: - 명령: - 이번에만 - 이 선택을 %s 분 동안 유지 합니다. - 이 선택을 계속 유지 합니다. - 상호작용 - 로그 - 설정 - 삭제 - 로그 없음 - 현재 슈퍼유저 앱의 정책이 없습니다. - 로그 - 슈퍼유저 요청 로그를 사용하거나 사용하지 않도록 설정. - PIN 보호 - PIN의 항목을 슈퍼유저가 요청을 승인하도록 요구. - 요청 시간 초과 - Superuser requests will time out and be denied after %s seconds - 알림 - 없음 - A %s will be shown when an app is granted or denied Superuser permissions - PIN 입력 - 새로운 PIN 입력 - 잘못된 PIN - PIN 확인 - PIN이 일치하지 않습니다. - 슈퍼유저 PIN 보호 활성화 - %s 초 - %s이(가) 슈퍼유저 권한을 부여받았습니다. - %s의 슈퍼유저 권한이 거부되었습니다. - 팝업 - 알림 - 알림이 표시되지 않습니다. - 개발자 경고:\nandroid.permission.ACCESS_SUPERUSER\nnot declared in manifest. - 장치 기능 및 저장소에 대한 모든 권한 - 슈퍼유저는 장치의 하드웨어 구성 요소를 포함하여 모든 장치 기능과 스토리지에 대한 전체 액세스 권한을 부여합니다. 이 권한은 위험합니다. - 선언 허가 - Only allow requests from apps that declare android.permission.ACCESS_SUPERUSER - 자동 응답 - Prompt - 자동으로 새 요청을 허용 - 자동으로 새 요청을 거부 - 새 요청에 대한 확인 대화 상자를 표시 - 보안 - 멀티유저 정책 - Only the device owner can request Superuser - The device owner will be prompted when another user requests Superuser - 모든 사용자가 슈퍼유저를 요청할수 있습니다. - 소유자만 - 소유자가 관리 - 모든 유저 - 다중 정책은 장치 소유자가 관리 할 수 ​​있습니다. - Please switch to the owner account to approve or deny this request. - 모든 명령 - 대하여 - 애플리케이션 - 설치 - 슈퍼유저 설치중... - 슈퍼유저 설치 - 슈퍼유저 바이너리(su)를 업데이트 해야합니다.\n\n설치 방법을 선택하세요.\n리커버리 설치는 HTC 장치를 사용하는 것이 좋습니다. - 리커버리 설치 - 설치 - 슈퍼유저 확인중... - 슈퍼유저를 설치하는 중에 오류가 발생했습니다.개발자에게 오류로그를 보내 주시기 바랍니다. - 슈퍼유저가 성공적으로 설치되었습니다. - su 바이너리의 유효 기간이 지났습니다. - 슈퍼유저 액세스 - 비활성화 - 애플리케이션만 - ADB 만 - 애플리케이션과 ADB - diff --git a/Superuser/res/values-lt/strings.xml b/Superuser/res/values-lt/strings.xml new file mode 100644 index 00000000..731a5d12 --- /dev/null +++ b/Superuser/res/values-lt/strings.xml @@ -0,0 +1,108 @@ + + + + + Superuser + Leisti + Atmesti + „Superuser“ užklausa\u2026 + Nežinomas UID: %s + %s prašo „Superuser“ prieigos + Įspėjimas: Jei nesuprantate, atmeskite užklausą + „Superuser“ užklausa + Paketas: + Programa: + Prašoma UID: + Komanda: + Tik šį kartą + Prisiminti pasirinkimą %s minučių + Prisiminti pasirinkimą + Interaktyvus + Įrašai + Nustatymai + Ištrinti + Įrašų nėra + Šiuo metu „Superuser“ užklausų įrašų nėra + Įrašų vedimas + Įjungti arba išjungti visus „Superuser“ įrašų vedimus + PIN kodo apsauga + Reikalauti pateikti PIN kodą tam, kad patvirtinti „Superuser“ užklausas + Užklausos delsimas + „Superuser“ užklausos pasibaigs ir bus atmestos po %s sekundžių + Pranešimai + Nerodomi + %s rodomas kai programai bus suteiktos arba atmestos „Superuser“ teisės + Įveskite PIN kodą + Įveskite naują PIN kodą + Neteisingas PIN kodas + Patvirtinkite PIN kodą + PIN kodas nesutampa + „Superuser“ PIN kodo apsauga įjungta + %s sekundžių + „Superuser“ suteiktas %s + „Superuser“ atmestas %s + Informacinis langelis + Pranešimas + Pranešimas nebus rodomas + Kūrėjo Įspėjimas:\nandroid.permission.ACCESS_SUPERUSER\nnedeklaruotas manifeste. + visos teisės į visas įrenginio funkcijas, saugyklą + „Superuser“ suteikiamos visos prieigos į visas įrenginio funkcijas, saugyklą. Šis leidimas gali būti pavojingas. + Deklaruojamas leidimas + Leisti užklausas tik iš programų kurios deklaruoja android.permission.ACCESS_SUPERUSER + Automatinis atsakymas + Klausti + Automatiškai leisti naujas užklausas + Automatiškai atmesti naujas užklausas + Rodyti langą naujoms užklausoms + Sauga + Kelių vartotojų politika + Tik prietaiso savininkas gali prašyti „Superuser“ + Prietaiso savininkas bus įspėtas kai kitas vartotojas prašys „Superuser“ + Visi vartotojai gali prašyti „Superuser“ + Tik savininkas + Savininkas tvarko + Visi vartotojai + Tik savininkas gali tvarkyti kelių vartotojų valdymo veiksmus. + Prašome perjungti į savininko paskyrą norėdami patvirtinti arba atmesti šį prašymą. + Visos komandos + Apie + Programos + Diegimas + Diegiamas „Superuser“\u2026 + Įdiegti „Superuser“ + „Superuser“ dvejetainis (su) turi būti atnaujintas.\n\nPrašome pasirinkti diegimo metodą.\n + Įdiegti per atkūrimo režimą + Įdiegti + Tikrinamas „Superuser“\u2026 + Įvyko klaida diegiant „Superuser“. Prašome atsiųsti klaidos žurnalą kūrėjui + „Superuser“ įdiegtas sėkmingai + „su“ dvejetainis pasenęs. + „Superuser“ prieiga + Išjungta + Tik programoms + Tik USB derin. + Programoms ir USB derin. + Kas naujo + Įvertinti + Tema + Šviesi + Tamsi + „Superuser“ PIN kodo apsauga išjungta. + Panaikinti „Superuser“ leidimą + Išsamiau + „Superuser“ leidimas negali būti panaikintas nuo šio prašymo. \nPrašome iš naujo paleisti „Superuser“ programą ir bandyti dar kartą. + diff --git a/Superuser/res/values-nl/strings.xml b/Superuser/res/values-nl/strings.xml new file mode 100644 index 00000000..07d4dc90 --- /dev/null +++ b/Superuser/res/values-nl/strings.xml @@ -0,0 +1,108 @@ + + + + + Superuser + Toestaan + Weigeren + Inkomend Superuser-verzoek\u2026 + Onbekend UID: %s + %s vraagt Superuser-toegang. + Let op: indien u dit niet begrijpt, is het raadzaam te weigeren. + Superuser-verzoek + Pakket: + App: + Verzocht UID: + Opdracht: + Alleen deze keer + Voor %s minuten + Permanent + Interactief + Logboek + Instellingen + Verwijderen + Logboek is leeg + Er zijn momenteel geen apps met Superuser-beleid. + Logboek + Superuser-verzoeken opslaan in logboek + Pincodebescherming + Pincode vereisen voor het toestaan van Superuser-verzoeken + Time-out verzoek + Superuser-verzoeken automatisch weigeren na %s seconden zonder antwoord + Meldingen + Geen + %s tonen als een app Superuser-toegang krijgt of geweigerd wordt + Pincode invoeren + Nieuwe pincode + Pincode onjuist + Pincode bevestigen + Pincodes komen niet overeen + Pincodebescherming voor Superuser ingeschakeld + %s seconden + \'%s\' heeft Superuser-toegang verkregen + \'%s\' is Superuser-toegang geweigerd + Toast-melding + Statusbalkmelding + Geen melding + Waarschuwing voor de ontwikkelaar:\nandroid.permission.ACCESS_SUP ERUSER\nniet opgegeven in het manifest + volledige toegang tot apparaatopslag en -mogelijkheden + Superuser verleent volledige toegang tot alle (opslag)mogelijkheden van uw apparaat, inclusief beveiligde en kwetsbare hardware-elementen. Deze machtiging is mogelijk gevaarlijk. + Machtiging vereisen + Alleen verzoeken toestaan van apps met de machtiging \'android.permission.ACCESS_SUPERUSER\' + Reactie op verzoeken + Vragen + Nieuwe verzoeken automatisch toestaan + Nieuwe verzoeken automatisch weigeren + Bevestiging vragen voor nieuwe verzoeken + Beveiliging + Meerdere gebruikers + Alleen de eigenaar kan Superuser-toegang vragen + De eigenaar wordt gevraagd te reageren op Superuser-verzoeken van andere gebruikers + Alle gebruikers kunnen Superuser-toegang vragen + Alleen de eigenaar + Beheerd door de eigenaar + Alle gebruikers + Het beleid voor meerdere gebruikers kan alleen worden beheerd door de eigenaar. + Schakel om naar het eigenaarsaccount om dit verzoek te behandelen. + Alle opdrachten + Over + Apps + Bezig met installeren + Superuser installeren\u2026 + Superuser installeren + Het \'su\'-bestand moet worden bijgewerkt.\n\nKies een installatiemethode.\n\'Via recovery\' is aanbevolen voor HTC-apparaten. + Via recovery + Normaal + Superuser controleren\u2026 + Kan Superuser niet installeren. Stuur een foutrapport naar de ontwikkelaar. + Superuser succesvol geïnstalleerd. + Het \'su\'-bestand is verouderd. + Superuser-toegang + Uitgeschakeld + Alleen apps + Alleen ADB + Apps en ADB + Changelog + Beoordelen + Thema + Licht + Donker + Pincodebescherming uitgeschakeld + Superuser-machtiging intrekken + Details + Superuser-machtiging van deze app kan niet worden ingetrokken.\nHerstart Superuser en probeer nogmaals. + diff --git a/Superuser/res/values-pl/strings.xml b/Superuser/res/values-pl/strings.xml new file mode 100644 index 00000000..5bf46f95 --- /dev/null +++ b/Superuser/res/values-pl/strings.xml @@ -0,0 +1,108 @@ + + + + + Superuser + Przyznaj + Odmów + Żądanie uprawnień Superuser\u2026 + Nieznane UID: %s + %s prosi o prawa dostępu Superuser. + Uwaga: Jeżeli nie rozumiesz tego komunikatu, powinieneś odmówić. + Żądanie Superuser + Pakiet: + Aplikacja: + UID: + Komenda: + Tylko tym razem + Zapamiętaj przez %s minut + Zapamiętaj na zawsze + Interaktywna + Raportowanie + Ustawienia + Usuń + Brak raportów + Aktualnie nie ma żadnych ustawień polityki Superuser. + Logowanie + Włącza i wyłącza raporty wszystkich żądań Superuser. + Zabezpieczenie PIN-em + Przed przyznaniem uprawnień Superuser wymagaj PIN-u + Czas na decyzję + Żądanie Superuser zostanie odrzucone po upływie %s sekund + Powiadomienia + Brak + %s poinformuje o przyznaniu lub nie uprawnień Superuser + Wprowadź PIN + Wprowadź nowy PIN + Niepoprawny PIN + Potwierdź PIN + PIN się nie zgadza + Zabezpieczenie PIN-em jest aktywne + %s sekund + Przyznano uprawnienia dla %s + Odmówiono uprawnień dla %s + Dymek + Powiadomienie + Żadne powiadomienia nie będą wyświetlane + Uwaga:\nandroid.permission.ACCESS_SUPERUSER\nnie zostały zadeklarowane w manifeście. + pełne uprawnienia dla wszystkich funkcji i magazynu urządzenia + Superuser zapewnia pełne uprawnienia dla wszystkich funkcji i magazynu urządzenia, w tym zabezpieczonych i wrażliwych elementów sprzętowych urządzenia. Uprawnienia te mogą być potencjalnie niebezpieczne. + Zadeklarowane uprawnienia + Pozwalaj na żądanie uprawnień tylko od aplikacji deklarujących android.permission.ACCESS_SUPERUSER + Automatyczna odpowiedź + Pytaj za każdym razem + Automatycznie przyznawaj uprawnienia + Automatycznie odmawiaj przyznania uprawnień + Pokaż okno dialogowe przy każdym żądaniu + Zabezpieczenia + Ustawienia dla wielu użytkowników + Tylko właściciel urządzenia może prosić o uprawnienia Superuser + Właściciel urządzenia zostanie powiadomiony, gdy użytkownik poprosi o uprawnienia Superuser + Wszyscy użytkownicy mogą prosić o uprawnienia Superuser + Tylko właściciel + Właściciel zarządza + Wszyscy użytkownicy + Ustawienia dla wielu użytkowników może edytować tylko właściciel urządzenia. + Proszę przełączyć się na konto właściciela by przyznać lub odrzucić uprawnienia. + Wszystkie komendy + O aplikacji + Aplikacje + Instalacja + Instalacja Superuser\u2026 + Instaluj Superuser + Pliki binarne Superuser (su) muszą zostać zaktualizowane.\n\nProszę wybrać metodę instalacji.\nInstalacja przez Recovery jest rekomendowana dla urządzeń marki HTC. + Instalacja przez Recovery + Instalacja + Sprawdzanie Superuser\u2026 + Podczas instalacji Superuser wystąpił błąd. Proszę wysłać raport błędu do developera. + Instalacja Superuser zakończona sukcesem. + Pliki binarne su są nieaktualne. + Dostęp Superuser + Wyłączony + Tylko aplikacje + Tylko ADB + Aplikacje i ADB + Co nowego? + Oceń + Motyw + Jasny + Ciemny + Zabezpieczenie PIN-em wyłączone. + Odwołanie uprawnień Superuser + Szczegóły + Uprawnienia administratora nie mogą być odwołane z tej aplikacji.\nProszę zrestartować aplikację Superuser i spróbować ponownie. + diff --git a/Superuser/res/values-pt-rBR/strings.xml b/Superuser/res/values-pt-rBR/strings.xml new file mode 100644 index 00000000..af015c5a --- /dev/null +++ b/Superuser/res/values-pt-rBR/strings.xml @@ -0,0 +1,108 @@ + + + + + Superusuário + Permitir + Negar + Pedido de entrada de Superusuário\u2026 + UID Desconhecido: %s + %s está solicitando acesso de Superusuário. + Aviso: Se você não iniciou esta ação, você deve negar o pedido. + Pedido de Superusuário + Pacote: + Aplicativo: + UID Solicitado: + Command: + Apenas desta vez. + Lembre-se desta escolha por %s minutos. + Lembre-se dessa escolha para sempre. + Interativo + Registros + Configurações + Deletar + Sem logs + Não há atualmente aplicativos Superusuário na lista. + Registro + Ativar registro de todas requisições de Superusuário + Proteção com PIN + Exigir a entrada de um PIN para aprovar pedidos de Superusuário + Tempo esgotado! + Pedidos de Superusuário irão expirar e serão negados após %s segundos + Notificações + Nenhum + Uma %s será mostrado quando um aplicativo é concedido ou negado permissões de Superusuário + Digite o PIN + Digite um novo PIN + PIN incorreto! + Confirme o PIN: + PIN não corresponde. + Proteção com PIN habilitada. + %s segundos + Permissões de Superusuário concedidas para %s + Permissões de Superusuário negadas para %s + Toast (Aviso na tela) + Notificação + Nenhuma notificação será mostrada. + Aviso de Desenvolvedor:\nandroid.permission.ACCESS_SUPERUSER\nnão declarado no manifest. + Permissões completas para todos os recursos do dispositivo e armazenamento + O Superusuário concede acesso total a todos os recursos do dispositivo e de armazenamento, incluindo os elementos de hardware seguros e sensíveis do seu dispositivo. Estas permissões são potencialmente perigosas. + Permissão Declarada + Só permitir pedidos de aplicativos que declaram android.permission.ACCESS_SUPERUSER no manifest. + Resposta Automática + Perguntar + Permitir automaticamente novos pedidos + Negar automaticamente novos pedidos + Mostrar caixa de diálogo de confirmação para novos pedidos + Segurança + Política de Multi-usuário + Apenas o proprietário do dispositivo pode conceder permissões de Superusuário + O proprietário do dispositivo será notificado quando outro usuário solicita permissões de Superusuário + Todos os usuários podem solicitar permissões de Superusuário + Somente o proprietário + Controlar Proprietário + Todos os usuários + A política de multi-usuário só pode ser controlada pelo proprietário do dispositivo. + Por favor, mude para a conta do proprietário para aprovar ou negar este pedido. + Todos os comandos + Sobre + Aplicativos + Instalando + Instalando Superusuário\u2026 + Instalar Superusuário + O binário do Superusuário (su) deve ser atualizado.\n\nPor favor escolha um método de instalação.\nInstalação em modo de recuperação é recomendada para dispositivos HTC. + Instalação pela Recuperação + Instalar + Verificando Superusuário\u2026 + Ocorreu um erro ao instalar o Superusuário. Por favor, envie um registro de erro para o desenvolvedor. + A instalação do Superusuário foi bem sucedida. + O binário (su) está desatualizado. + Acesso ao Superusuário + Desabilitado + Somente aplicativos + Somente ADB + Aplicativos e ADB + Novidades + Avaliar + Tema + Light + Dark + A proteção por PIN está desativada + Cancelar permissão de Superusuário + Detalhes + Permissão de Superusuário não pode ser cancelada para este aplicativo.\nPor favor, reinicie o aplicativo Superusuário e tente novamente. + diff --git a/Superuser/res/values-pt-rPT/strings.xml b/Superuser/res/values-pt-rPT/strings.xml new file mode 100644 index 00000000..81b25d6e --- /dev/null +++ b/Superuser/res/values-pt-rPT/strings.xml @@ -0,0 +1,108 @@ + + + + + Superuser + Permitir + Negar + Pedido de entrada de Superuser\u2026 + Desconhecido UID: %s + %s está a pedir acesso de Superuser. + Aviso: Se não iniciou esta ação, deve negar o pedido. + Pedido do Superuser + Pacote: + Aplicação: + UID Solicitado: + Comando: + Apenas desta vez + Lembrar esta escolha por %s minutos. + Lembrar esta escolha para sempre. + Interativo + Registos + Configurações + Remover + Sem Registos + Atualmente não há aplicações com regras Superuser. + Registo + Ativar ou desativar o registo de todos os pedidos + Proteção com PIN + Exigir a inserção de um PIN para aprovar pedidos de Superuser + Expiração do Pedido + Pedidos de Superuser expirarão e serão negados após %s segundos. + Notificações + Nenhum + Uma %s será mostrada quando forem permitidas ou negadas permissões de Superuser a uma aplicação. + Introduza o PIN + Introduza o novo PIN + PIN incorreto + Confirme o PIN + O PIN não corresponde + Proteção com PIN activada + %s segundos + Permissões de Superuser concedidas a %s + Permissões de Superuser negadas a %s + Toast (Aviso no ecrã) + Notificação + Nenhuma notificação será mostrada + Aviso do programador:\nandroid.permission.ACCESS_SUPERUSER\nnão declarado no manifesto. + Permissões completas para todos os recursos do dispositivo e armazenamento + O Superuser concede acesso total a todos os recursos do dispositivo e de armazenamento, incluindo os elementos de hardware seguros e sensíveis do seu dispositivo. Estas permissões são potencialmente perigosas. + Permissão Declarada + Só permitir pedidos de aplicações que declaram android.permission.ACCESS_SUPERUSER no manifesto. + Resposta Automática + Perguntar + Aceitar automaticamente novos pedidos + Negar automaticamente novos pedidos + Mostrar dialogo de confirmação para novos pedidos + Segurança + Politíca Multi-utilizador + Apenas o proprietário do dispositivo pode conceder permissões de Superuser. + O proprietário do dispositivo será notificado quando outro utilizador solicita permissões de Superuser. + Todos os utilizadores podem solicitar permissões de Superuser. + Apenas o proprietário + Controlado pelo proprietário + Todos os utilizadores + A política de multi-utilizador só pode ser controlada pelo proprietário do dispositivo. + Por favor, mude para a conta do proprietário para aprovar ou negar este pedido. + Todos os comandos + Sobre + Aplicações + A instalar + A instalar Superuser\u2026 + Instalar Superuser + O binário do Superuser (su) deve ser actualizado.\n\nPor favor escolha um método de instalação.\nA instalação em modo de recuperação é recomendada para dispositivos HTC. + Instalação pelo modo de Recuperação + Instalar + A verificar Superuser\u2026 + Houve um erro ao instalar o Superuser. Por favor, envie um registo do erro para o programador. + A instalação do Superuser foi bem sucedida. + O binário do Superuser (su) está desatualizado. + Acesso ao Superuser + Desativado + Só aplicações + Só ADB + Aplicações e ADB + O que há de novo + Avaliar + TEMA + Claro + Escuro + A proteção por PIN não está ativa + Revogar permissão de Superuser + Detalhes + As permissões de Superuser não podem ser revogadas para esta aplicação.\nPor favor reinicie a aplicação Superuser e tente novamente. + diff --git a/Superuser/res/values-pt/strings.xml b/Superuser/res/values-pt/strings.xml index 267cf057..35fae2a8 100644 --- a/Superuser/res/values-pt/strings.xml +++ b/Superuser/res/values-pt/strings.xml @@ -1,86 +1,92 @@ - - Superuser + Superusuário Permitir Negar - Pedido de entrada de superusuário... - Unknown UID: %s - %s está solicitando acesso de Superuser - Aviso :Se você não iniciou esta ação, você deve negar o pedido. - Pedido de superusuário - Package: - App: - Requested UID: + Pedido de entrada de Superusuário\u2026 + UID Desconhecido: %s + Aviso: Se você não iniciou esta ação, você deve negar o pedido. + Pedido de Superusuário + Pacote: + Aplicativo: + UID Solicitado: Command: - Desta vez,apenas - Lembre-se desta escolha por %s minutes - Lembre-se dessa escolha para sempre + Apenas desta vez. + Lembre-se desta escolha por %s minutos. + Lembre-se dessa escolha para sempre. Interativo - Logs + Registros Configurações Deletar Sem logs - Atualmente não existem políticas app Superuser. + Não há aplicativos na lista. Registro - Ativar ou desativar todo o registro de pedido Superusuário - PIN Proteão - Exigir a entrada de um PIN para aprovar pedidos de superusuário - Tempo esgotado - Pedidos de superusuário irá expirar e ser negado após %s segundos + Ativar ou desativar o registro de todos os pedidos. + Proteção com PIN + Exigir a entrada de um PIN para aprovar pedidos de Superusuário. + Tempo esgotado! + Pedidos de Superusuário irão expirar e serão negados após %s segundos. Notificações Nenhum - Um %s será mostrado quando um aplicativo é concedido ou negado permissões de superusuário - Entre com o PIN - Entre com um novo PIN - PIN incorreto - Confirme o PIN - PIN não corresponde - Superuser proteção PIN habilitado + Uma %s será mostrado quando um aplicativo é concedido ou negado permissões de Superusuário + Digite o PIN + Digite um novo PIN + PIN incorreto! + Confirme o PIN: + PIN não corresponde. + Proteção com PIN habilitada. %s segundos - Superuser garantido para %s - Superuser negado para %s - Toast + Permissões de Superusuário concedidas para %s + Permissões de Superusuário negadas para %s + Toast (Aviso na tela) Notificação - Nenhuma notificação será mostrada - Developer Warning:\nandroid.permission.ACCESS_SUPERUSER\nnot declared in manifest. + Nenhuma notificação será mostrada. + Aviso de Desenvolvedor:\nandroid.permission.ACCESS_SUPERUSER\nnão declarado no manifest. Permissões completas para todos os recursos do dispositivo e armazenamento - Superuser concede acesso total a todos os recursos do dispositivo e de armazenamento, incluindo os elementos de hardware seguras e sensíveis do seu dispositivo. Esta permissão é potencialmente perigoso. - Declared Permission - Só permitir que os pedidos de aplicativos que declaram android.permission.ACCESS_SUPERUSER + O Superusuário concede acesso total a todos os recursos do dispositivo e de armazenamento, incluindo os elementos de hardware seguros e sensíveis do seu dispositivo. Estas permissões são potencialmente perigosas. + Permissão Declarada + Só permitir pedidos de aplicativos que declaram android.permission.ACCESS_SUPERUSER no manifest. Resposta Automática - Prompt + Perguntar Permitir automaticamente novos pedidos Negar automaticamente novos pedidos Mostrar caixa de diálogo de confirmação para novos pedidos - Security - Multiuser Policy - Apenas o proprietário do dispositivo pode requerer Superuser - O proprietário do dispositivo será solicitado quando outro usuário solicita superusuário - Todos os usuários podem solicitar Superusuário + Segurança + Política de Multi-usuário + Apenas o proprietário do dispositivo pode conceder permissões de Superusuário. + O proprietário do dispositivo será notificado quando outro usuário solicita permissões de Superusuário. + Todos os usuários podem solicitar permissões de Superusuário. Somente o proprietário Controlar Proprietário Todos os usuários - A Política multiusuário só pode ser gerido pelo proprietário do dispositivo. + A política de multi-usuário só pode ser controlada pelo proprietário do dispositivo. Por favor, mude para a conta do proprietário para aprovar ou negar este pedido. Todos os comandos Sobre - Apps + Aplicativos Instalando - Instalando Superuser... - Instalar Superuser - O binário de Superusuário (su) deve ser atualizado.\n\nPor favor escolha um método de instalação.\nInstalação em modo de recuperação é recomendado para dispositivos HTC. - Instalaçao pela Recuperação + Instalando Superusuário\u2026 + Instalar Superusuário + O binário do Superusuário (su) deve ser atualizado.\n\nPor favor escolha um método de instalação.\nInstalação em modo de recuperação é recomendada para dispositivos HTC. + Instalação pela Recuperação Instalar - Verificando Superusuário... - Houve um erro ao instalar Superusuário. Por favor, envie um log do erro para o desenvolvedor. - IInstalação de Superuser foi bem sucedida. - O binário su está desatualizado. - Superuser Accesso - Desabilitado - Apps somente - ADB somente - Apps and ADB - What\'s New - Rate - + Verificando Superusuário\u2026 + Houve um erro ao instalar o Superusuário. Por favor, envie um log do erro para o desenvolvedor. + A instalação do Superusuário foi bem sucedida. + O binário do Superusuário (su) está desatualizado. + Acesso ao Superusuário + Desabilitado + Somente aplicativos + Somente ADB + Aplicativos e ADB + Novidades + Avaliar + Tema + Light + Dark + A proteção por PIN está desativada + Revogar permissão Superusuário + Detalhes + Permissão Superusuário não pode ser revogada deste aplicativo.\nFavor reiniciar o aplicativo Superusuário e tente novamente. + %s está requisitando acesso Superusuário. + \ No newline at end of file diff --git a/Superuser/res/values-ro/strings.xml b/Superuser/res/values-ro/strings.xml index 9ec16767..285ef5e8 100644 --- a/Superuser/res/values-ro/strings.xml +++ b/Superuser/res/values-ro/strings.xml @@ -1,84 +1,108 @@ - + + + + Superuser + Permiteţi + Refuzaţi + Cerere superuser de intrare\u2026 + UID necunoscut: %s + %s cere acces Superuser. + Avertizare: Dacă nu înţelegeţi aceasta, ar trebui să refuzaţi cererea. + Cerere Superuser + Pachet: + Aplicaţie: + UID Solicitat: + Comandă: + Numai de data aceasta + Memoraţi alegerea pentru %s minute + Memoraţi alegerea pentru totdeauna + Interactiv + Jurnaluri + Setări + Şterge + Nici un jurnal + În prezent nu există politici pentru aplicaţia Superuser. + Se scrie în jurnal + Activați înscrierea în jurnal a tuturor cererilor Superuser + Protecţie cu PIN + Necesită introducerea unui PIN pentru aprobarea cererilor Superuser + Expirare Cerere + Cererile Superuser vor expira şi vor fi refuzate după %s secunde + Notificări + Nimic + O %s se va afişa când unei aplicaţii i se acordă sau i se refuză permisiuni de Superuser + Introduceţi PIN + Introduceţi noul PIN + PIN incorect + Confirmaţi PIN + PIN nu se potriveşte + Protecţie Superuser PIN activată + %s secunde + Superuser acordat pentru %s + Superuser refuzat pentru %s + Alertă + Notificare + Nici o notificare nu va fi afişată + Avertizare Dezvoltator:\nandroid.permission.ACCESS_SUPERUSER\nnu este declarat în manifest. + permisiuni depline pentru toate caracteristicile dispozitivului şi stocare + Superuser acordă acces deplin pentru toate caracteristicile dispozitivului şi stocare, inclusiv elementele sigure și sensibile hardware ale dispozitivului dvs. Această permisiune este potențial periculoasă. + Permisiune declarată + Permiteţi doar cererile de la aplicațiile care declară android.permission.ACCESS_SUPERUSER + Răspuns automat + Sugestie + Permiteţi cereri noi în mod automat + Refuzați cereri noi în mod automat + Afişaţi dialog de confirmare pentru cererile noi + Securitate + Politica Multi-utilizator + Doar proprietarul dispozitivului poate cere Superuser + Proprietarul dispozitivului va fi întrebat când un alt utilizator cere Superuser + Toţi utilizatorii pot cere Superuser + Doar proprietarul + Gestionat de proprietar + Toţi utilizatorii + Politica multi-utilizator poate fi gestionată doar de proprietarul dispozitivului. + Vă rugăm să comutaţi la contul proprietarului pentru a acorda sau refuza această cerere. + Toate comenzile + Despre + Aplicaţii + Instalez + Instalez Superuser\u2026 + Instalaţi Superuser + Fişierulu binar (su) Superuser trebuie actualizat.\n\nVă rugăm selectaţi o metodă de instalare.\nInstalarea prin Mod Recuperare este recomandată pentru dispozitivele HTC. + Instalare prin Recuperare + Instalaţi + Verificare Superuser\u2026 + A fost o eroare la instalarea Superuser. Trimiteţi un jurnal al erorii către dezvoltator. + Superuser sa instalat cu succes. + Fişierul binar su este expirat. + Acces Superuser + Dezactivat + Numai pentru aplicaţii + Numai pentru ADB + Pentru aplicaţii şi ADB + Ce este nou + Evaluare + Temă + Luminos + Întunecat + Protecție PIN pentru Superuser dezactivată + Revocă permisiune Superuser + Detalii + Permisiunea Superuser nu poate fi revocată din această aplicație.\nRepornește aplicația Superuser și încearcă din nou. diff --git a/Superuser/res/values-ru/strings.xml b/Superuser/res/values-ru/strings.xml index 0baad1ed..401c5d1f 100644 --- a/Superuser/res/values-ru/strings.xml +++ b/Superuser/res/values-ru/strings.xml @@ -1,90 +1,108 @@ - + + + + Суперпользователь + Разрешить + Отказать + Запрос прав Суперпользователя\u2026 + Неизвестный UID: %s + Приложение «%s» запрашивает права Суперпользователя + Внимание: если вы не запрашивали это действие или не понимаете, что это за запрос — отклоните его. + Запрос прав Суперпользователя + Пакет: + Приложение: + Требуемый UID: + Команда: + Только в этот раз + Запомнить на %s минут + Больше не спрашивать + Интерактивно + Журнал + Настройки + Очистить журнал + Журнал пуст + Нет приложений для управления + Журналирование + Включить ведение журнала + Защита PIN-кодом + Запрашивать ввод PIN-кода для подтверждения доступа + Таймаут запроса + Запрос прав Суперпользователя будет автоматически отклонён после %s секунд + Уведомления + Выключены + Будет показано %s о предоставлении прав Суперпользователя + Введите PIN-код + Введите новый PIN-код + Неправильный PIN-код + Подтвердите PIN-код + PIN-коды не совпадают, попробуйте ещё раз + Включено использование PIN-кода + %s секунд + Приложению «%s» предоставлены права суперпользователя + Приложению «%s» отказано в получении прав суперпользователя + всплывающее оповещение + уведомление в строке состояния + Уведомления отключены + Внимание:\nразрешение android.permission.ACCESS_SUPERUSER\nне объявлено в манифесте приложения. + Полный доступ к функциям устройства и памяти + Права Суперпользователя предоставляют полный доступ к функциям и памяти устройства, в том числе к аппаратной составляющей. Предоставление этих прав является потенциально опасным. + Заявленное разрешение + Разрешение будут получать только приложения с заявленным в манифесте android.permission.ACCESS_SUPERUSER + Автоматический режим + Спрашивать каждый раз + Новые запросы будут разрешены + Новые запросы будут отклонены + Запрашивать разрешение каждый раз + Безопасность + Многопользовательские настройки + Только владелец может запрашивать права Суперпользователя + Владелец будет оповещён, если другой пользователь потребует прав Суперпользователя + Все пользователи могут запрашивать права Суперпользователя + Только владелец + Одобренные владельцем + Все пользователи + Многопользовательские настройки управляются только владельцем + Пожалуйста, перейдите в аккаунт владельца для управления запросом + Все команды + О приложении + Другие приложения + Установка + Установка Суперпользователя\u2026 + Установить Суперпользователя + Бинарный файл Суперпользователя (su) нуждается в обновлении.\n\nПожалуйста, выберите метод установки.\nСпособ установки через Recovery рекомендуется для устройств HTC + Через Recovery + Установить + Проверка Суперпользователя\u2026 + Произошла ошибка при установке Суперпользователя. Пожалуйста, отправте лог ошибки разработчику + Установка Суперпользователя прошла успешно. + Файл su устарел + Доступ Суперпользователя + Выключен + Только приложения + Только ADB + Приложения и ADB + Что нового + Оценить + Тема + Светлая + Тёмная + Защита PIN-кодом отключена + Отозвать права Суперпользователя + Подробно + Не удаётся отозвать права Суперпользователя.\nПерезапустите это приложение и повторите попытку. diff --git a/Superuser/res/values-sk/strings.xml b/Superuser/res/values-sk/strings.xml old mode 100755 new mode 100644 index e63ad604..ca38747e --- a/Superuser/res/values-sk/strings.xml +++ b/Superuser/res/values-sk/strings.xml @@ -1,90 +1,108 @@ - + + + + Superuser + Povoliť + Odmietnuť + Prichádzajúca žiadosť o Superusera\u2026 + Neznáme UID: %s + %s žiada prístup k Superuserovi. + Varovanie: Ak tomuto nechápete, mali by ste žiadosť odmietnuť. + Žiadosť o Superusera + Balík: + Aplikácia: + Požadované UID: + Príkaz: + Len teraz + Zapamätať si voľbu na %s min. + Zapamätať si voľbu navždy + Interaktívne + Záznamy + Nastavenia + Vymazať + Žiadne záznamy + Žiadne pravidlá Superusera pre aplikácie. + Tvorba záznamov + Povoliť alebo zakázať tvorbu záznamov všetkých žiadostí o Superusera + PIN ochrana + Požadovať zadanie PIN kódu pre schválenie žiadostí o Superusera + Časový limit pre žiadosť + Žiadosť o Superusera vyprší a bude odmietnutá po %s sekundách + Oznámenia + Žiadne + Pri povolení alebo odmietnutí povolenia Superusera bude zobrazené: %s + Zadajte PIN + Zadajte nový PIN + Nesprávny PIN + Potvrďte PIN + PIN kódy sa nezhodujú + PIN ochrana Superusera bola povolená + %s sekúnd + Superuser bol povolený pre %s + Superuser bol odmietnutý pre %s + Toast + Oznámenie + Žiadne oznámenie nebude zobrazené + Varovanie pre vývojara:\nandroid.permission.ACCESS_SUPERUSER\n povolenie nie je deklarované v manifeste. + plné povolenia pre všetky funkcie zariadenia a úložisko + Superuser povolí plný prístup pre všetky funkcie zariadenia a úložisko, vrátane bezpečnostných a citlivých hardvérových prvkov zariadenia. Toto povolenie je potenciálne nebezpečné. + Deklarované povolenie + Povoliť len žiadosti od aplikácií, ktoré majú deklarované povolenie android.permission.ACCESS_SUPERUSER + Automatická odozva + Výzva + Automaticky povoliť nové žiadosti + Automaticky odmietnuť nové žiadosti + Zobraziť potvrdzovacie okno pre novú žiadosť + Zabezpečenie + Pravidlá viacerých používateľov + Len vlastník zariadenia môže požiadať Superusera + Vlastník zariadenia bude vyzvaný, keď iný používateľ požiada Superusera + Všetci používatelia môžu požiadať Superusera + Len vlastník + Spravované vlastníkom + Všetci používatelia + Pravidlá viacerých používateľov možu byť spravované len vlastníkom zariadenia. + Prepnite, prosím, na účet vlastníka zariadenia pre schválenie alebo odmietnutie tejto žiadosti. + Všetky príkazy + O aplikácii + Aplikácie + Inštalovanie + Inštalovanie Superusera\u2026 + Inštalovať Superusera + Binárny súbor Superusera (su) musí byť aktualizovaný.\n\nProsím, vyberte spôsob inštalácie.\nInštalácia cez recovery je odporúčaná pre HTC zariadenia. + Inštalovať cez recovery + Inštalovať + Kontrolovanie Superusera\u2026 + Došlo k chybe pri inštalácii Superusera. Prosím pošlite záznam s chybou vývojárovi. + Inštalácia Superusera bola úspešná. + Binárny súbor Superusera (su) je zastaraný. + Superuser prístup + Zakázaný + Len aplikácie + Len ADB + Aplikácie a ADB + Čo je nové + Ohodnotiť + Téma + Svetlá + Tmavá + PIN ochrana Superusera bola zakázaná + Odvolať povolenie Superusera + Podrobnosti + Povolenie Superusera nemôže byť odvolané z tejto aplikácie.\nProsím, reštartujte aplikáciu Superuser a skúste to znova. diff --git a/Superuser/res/values-sr/strings.xml b/Superuser/res/values-sr/strings.xml new file mode 100644 index 00000000..ca9f6431 --- /dev/null +++ b/Superuser/res/values-sr/strings.xml @@ -0,0 +1,108 @@ + + + + + Суперкорисник + Дозволи + Одбиј + Долазни Суперкорисник захтев\u2026 + Непознати UID: %s + %s захтева приступ Суперкорисника + Упозорење: Ако не разумеш ово, требало би забранити захтев. + Суперкорисник захтев + Пакет: + Апл: + Захтевани UID: + Команда: + Само овај пут + Запамти избор за %s минута + Запамти избор заувек + Интерактивно + Приступи + Подешавања + Избриши + Нема приступа + Тренутно нема Суперкорисник апл политике. + Евидентирање + Омогући евидентирање за све Суперкорисник захтеве + PIN Заштита + Захтевај унос PINа за одобравање Суперкорисник захтева + Време истека захтева + Супекорисник захтеви ће бити искључени и бити одбијени након %s секунди + Обавештења + Ниједно + %s ће бити приказан када је апликација одобрена или одбијена од Суперкорисника + Унесите PIN + Унесите нови PIN + Нетачан PIN + Потврдите PIN + PIN се не поклапа + Суперкорисник PIN заштита омогућена + %s секунде + Суперкорисник одобрен за %s + Суперкорисник одбијен за %s + Облак + Обавештење + Ниједно обавештење неће бити приказано + Упозорење аутора:\nandroid.permission.ACCESS_SUPERUSER\n није објављено у манифесту. + Пуне дозволе свим карактеристикама и уређајима за складиштење + Суперкорисник даје пун приступ свим функцијама и складиштењу, укључујући и безбедне и осетљиве хардверске елементе Вашег уређаја. Ова дозвола је потенцијално опасна. + Дозвола је декларисана + Дозволи само захтеве од апликација које прогласе android.permission.ACCESS_SUPERUSER + Аутоматски одговор + Благовремено + Аутоматски дозволи нове захтеве + Аутоматски одбаци нове захтеве + Прикажи прозор за потврду за нове захтеве + Сигурност + Политика више корисника + Само власник уређаја може захтевати Суперкорисник привилегије + Власник уређаја ће бити информисан када други корисник захтева Суперкорисник привилегије + Сви корисници могу захтевати Суперкорисник привилегије + Само власник + Управљање од стране власника + Сви корисници + Управљање политиком више корисника може вршити само власник уређаја. + Молимо пријавите се као власник уређаја да би сте одобрили или одбили овај захтев. + Све команде + О програму + Апликације + Инсталирање у току + Инсталирање Суперкорисника\u2026 + Инсталирај Суперкорисника + Бинарни код Суперкорисника мора бити ажуриран.\n\nОдаберите начин инсталације.\nЗа HTC уређаје, препоручљива је инсталација путем режима опотавка. + Инсталација у режиму опоравка + Инсталирај + Проверавање Суперкорисника\u2026 + Грешка приликом инсталације Суперкорисника. Молимо Вас пошаљите информације о грешци програмеру. + Инсталација Суперкорисника је успешна. + Бинарни код Суперкорисника је застарео. + Приступ Суперкорисника + Онемогућено + Само апликације + Само АDB + Апликације и ADB + Шта је ново + Стопа + Тема + Светла + Тамна + PIN заштита Суперкорисника онемогућена + Опозови привилегију Суперкорисника + Детаљи + Привилегије Суперкорисника не могу бити опозване путем ове апликације.\nМолимо поново покрените Суперкорисник апликацију и покушајте поново. + diff --git a/Superuser/res/values-sv/strings.xml b/Superuser/res/values-sv/strings.xml index 48dd93a7..f31e2efd 100644 --- a/Superuser/res/values-sv/strings.xml +++ b/Superuser/res/values-sv/strings.xml @@ -1,90 +1,102 @@ - - + + + + + Superuser + Tillåt + Neka + Inkommande Superuserbegäran\u2026 + %s begär Superuseråtkomst. + Varning: Om du inte förstår detta bör du neka begäran. + Superuserbegäran + Paket: + App: + Begärt UID: + Kommando: + Endast denna gång + Kom ihåg val i %s minuter + Kom ihåg val för alltid + Interaktivt + Loggar + Inställningar + Ta bort + Inga loggar + Det finns för närvarande inga Superuser app policys. + Loggning + Aktivera eller inaktivera all loggning av Superuserbegäran + PIN-skydd + Kräv inmatning av en PIN för att tillåta Superuserbegäran + Tidsgräns för begäran + Superuserbegäran nekas automatiskt efter %s sekunder + Notifieringar + Inga + En %s visas när en app beviljas eller nekas Superuserrättigheter + Ange PIN + Ange ny PIN + Felaktig PIN + Bekräfta PIN + PIN stämde inte överrens + Superuser PIN-skydd aktiverat + %s sekunder + Superuser beviljad till %s + Superuser nekad för %s + Notifiering + Ingen notifiering kommer att visas + Utvecklarvarning:\nandroid.permission.ACCESS_SUPERUSER\ninte deklarerad i manifestet. + fullständig behörighet till alla enhetens funktioner och lagring + Superuser ger full tillgång till alla enhetens funktioner och lagring inklusive skyddad och känslig hårdvara i din enhet. Detta medgivande kan vara farligt. + Deklarerad behörighet + Tillåt bara begäran från appar som deklarerar behörigheten android.permission.ACCESS_SUPERUSER + Automatiskt svar + Fråga + Tillåt automatiskt nya begäran + Neka automatiskt nya begäran + Visa en bekräftelsedialog för nya begäran + Säkerhet + Fleranvändarpolicy + Endast enhetsägaren kan begära Superuseråtkomst + Alla användare kan begära Superuseråtkomst + Endast ägaren + Ägarhanterad + Alla användare + Fleranvändarpolicyn kan endast hanteras av enhetsägaren. + Byt till ägarkontot för att bevilja eller neka denna begäran. + Alla kommandon + Om + Appar + Installerar + Installerar Superuser\u2026 + Installera Superuser + Superuserbinären (su) måste uppdateras.\n\nVälj en installationsmetod.\nRecoveryinstallation rekommenderas för enheter från HTC. + Recoveryinstallation + Installation + Kontrollerar Superuser\u2026 + Ett fel uppstod när Superuser installerades. Skicka en logg till utvecklaren för att möjliggöra felsökning. + Superuser installerades korrekt. + Superuseråtkomst + Inaktiverad + Endast Appar + Endast ADB + Appar och ADB + Nyheter + Tema + Ljust + Mörkt + Superuser PIN-skydd inaktiverat + Återkalla behörighet för superuser + Detaljer diff --git a/Superuser/res/values-tr/strings.xml b/Superuser/res/values-tr/strings.xml new file mode 100644 index 00000000..2f043bb8 --- /dev/null +++ b/Superuser/res/values-tr/strings.xml @@ -0,0 +1,108 @@ + + + + + Yetkili kullanıcı + İzin ver + İzin verme + Gelen yetkili kullanıcı isteği\u2026 + Bilinmeyen UID: %s + %s yetkili kullanıcı erişimi istiyor. + Uyarı: Eğer bundan bir şey anlamadıysanız isteğe izin vermeyin. + Yetkili Kullanıcı İsteği + Paket: + Uygulama: + İstenen UID: + Komut: + Sadece bu kez + Seçimi %s dakikalığına hatırla + Seçimi sonsuza kadar hatırla + Etkişimli + Kütükler + Ayarlar + Sil + Kütük yok + Şu anda bir yetkili kullanıcı uygulama politikası yok. + Kütükleme + Yetkili kullanıcı isteklerini kütüğe yazmayı etkinleştirin/devre dışı bırakın + PIN Koruması + Yetkili kullanıcı isteklerini onaylarken bir PIN girilmesini gerekli kılın + İstek Zaman Aşımı + Yetkili kullanıcı istekleri %s saniye sonra zaman aşımına uğrayıp reddedilecek + Bildirimler + Yok + Bir uygulamanın yetklili kullanıcı isteği kabul ya da reddedildiğinde %s görüntülenecek + PIN\'i girin + Yeni PIN girin + Geçirsiz PIN + PIN\'i doğrulayın + PIN uyuşmadı + Yetkili kullanıcı PIN koruması etkinleştirildi + %s saniye + Yetkili kullanıcı hakları %s için sağlandı + %s için yetkili kullanıcı hakkı isteği reddedildi + Toast + Bildirim + Hiçbir bildirim görüntülenmeyecek + Geliştirici Uyarısı:\nandroid.permission.ACCESS_SUPERUSER\nmanifest içinde ayarlanmamış. + tüm cihaz ve depolamaya sınırsız erişim + Superuser cihazınızın güvenli ve hasas donanım bileşenleri dahil olmak üzere cihaz özelliklerine ve depolama alanlarına sınırsız bir yetkili kullanıcı erişimi sağlayacak. Bu erişimin tehlikeli olma potansiyeli var. + Belirtilmiş İzin + Sadece android.permission.ACCESS_SUPERUSER iznini belirtmiş uygulamalardan gelen taleplere izin ver + Otomatik Yanıtlama + Sor + Yeni istekleri otomatik onlayla + Yeni istekleri otomatik reddet + Yeni istekler için onay kutucuğu göster + Güvenlik + Çoklu Kullanıcı Politikası + Sadece cihazın sahibi yetkili kullanıcı isteği gönderebilir + Cihazın sahibi, başka bir kullanıcı yetkili kullanıcı isteğinde bulunduğunda haberdar edilir + Her kullanıcı yetkili kullanıcı isteği gönderebilir + Sadece cihaz sahibi + Sahibin yönetiminde + Tüm Kullanıcılar + Çoklu Kullanıcı Politikası sadece cihaz sahibi tarafından yönetilebilir. + İsteği kabul ya da reddetmek için cihaz sahibinin hesabına geçiş yapın. + Tüm Komutlar + Hakkında + Uygulamalar + Kuruluyor + Superuser kuruluyor\u2026 + Superuser\'i Kur + Yetkili kullanıcı ikili kodu (su) güncellenmeli.\n\nLütfen bir kurulum yöntemi seçin.\nHTC cihazlar için recovery (kurtarma) modu kurulumu tavsiye edilir. + Recovery (Kurtarma Modu) Kurulumu + Kur + Superuser kontrol ediliyor\u2026 + Superuser kurulurken hata. Lütfen hata raporunu geliştiriciye iletin + Superuser kurulumu başarılı. + su ikili dosyası eski. + Yetkili kullanıcı erişimi + Devre dışı + Sadece uygulamalar + Sadece ADB + Uygulamalar ve ADB + Neler Yeni? + Otla + Tema + Aydınlık + Karanlık + Superuser PIN koruması devre dışı + Yetkili kullanıcı iznini iptal et + Ayrıntılar + Yetkili kullanıcı izni bu uygulamadan geri alınamadı.\nLütfen Superuser uygulamasını yeniden başlatın ve tekrar deneyin. + diff --git a/Superuser/res/values-v14/dimens.xml b/Superuser/res/values-v14/dimens.xml deleted file mode 100644 index e5f8fdc2..00000000 --- a/Superuser/res/values-v14/dimens.xml +++ /dev/null @@ -1,2 +0,0 @@ - - \ No newline at end of file diff --git a/Superuser/res/values-vi/strings.xml b/Superuser/res/values-vi/strings.xml deleted file mode 100644 index 9b4b7551..00000000 --- a/Superuser/res/values-vi/strings.xml +++ /dev/null @@ -1,90 +0,0 @@ - - - - Superuser - Cho phép - Từ chối - Yêu cầu quyền superuser... - Không rõ UID: %s - %s đang yêu cầu quyền truy cập Superuser. - Cảnh báo: Nếu bạn không hiểu điều này, bạn nên từ chối yêu cầu. - Yêu cầu Superuser - Gói: - Ứng dụng: - UID yêu cầu: - Lệnh: - Chỉ lần này - Ghi nhớ lựa chọn trong %s phút - Ghi nhớ lựa chọn vĩnh viễn - Tương tác - Nhật trình - Thiết lập - Xóa - Không có nhật trình - Hiện không có quy định cho ứng dụng Superuser. - Ghi nhật trình - Mở hoặc tắt tất cả nhật trình yêu cầu Superuser - Bảo vệ bằng mã khóa - Yêu cầu nhập mã khóa khi muốn chấp thuận yêu cầu Superuser - Thời hạn yêu cầu - Yêu cầu Superuser sẽ bị từ chối sau %s giây - Thông báo - Không - Hiện một %s khi ứng dụng được chấp thuận hoặc từ chối quyền Superuser - Nhập mã khóa - Nhập mã khóa mới - Mã khóa sai - Xác nhận mã khóa - Mã khóa không khớp - Đã kích hoạt bảo vệ Superuser bằng mã khóa - %s giây - Đã cấp phép Superuser cho %s - Đã từ chối cấp Superuser cho %s - Tin nhắn bật nhanh - Thông báo - Không hiện thông báo - Cảnh báo của lập trình viên:\nandroid.permission.ACCESS_SUPERUSER\nkhông được định nghĩa trong manifest. - toàn quyền cho tất cả các tính năng và phần lưu trữ của thiết bị - Superuser trao toàn quyền truy cập đến tất cả các tính năng và phần lưu trữ của thiết bị, bao gồm cả bộ phận phần cứng nhạy cảm và bảo mật của thiết bị. Quyền này có khả năng gây nguy hiểm. - Khai rõ quyền - Chỉ cho phép các yêu cầu từ những ứng dụng khai báo rõ android.permission.ACCESS_SUPERUSER - Hồi đáp tự động - Hỏi tôi - Tự động cấp phép các yêu cầu mới - Tự động từ chối các yêu cầu mới - Hiện hộp thoại xác nhận cho mỗi yêu cầu mới - An toàn - Quy định nhiều người dùng - Chỉ có chủ sở hữu thiết bị mới có thể yêu cầu Superuser - Chủ sở hữu thiết bị sẽ được hỏi khi người dùng khác yêu cầu Superuser - Tất cả người dùng đều có thể yêu cầu Superuser - Chỉ chủ sở hữu - Chủ sở hữu quyết định - Tất cả người dùng - Chỉ có chủ sở hữu mới có thể thiết lập quy định nhiều người dùng. - Vui lòng chuyển sang tài khoản chủ sở hữu để chấp thuận hoặc từ chối yêu cầu này. - Tất cả các lệnh - Giới thiệu - Ứng dụng - Đang cài đặt - Đang cài đặt Superuser... - Cài đặt Superuser - Cần cập nhật lệnh Superuser (su).\n\nVui lòng chọn phương cách cập nhật.\nKhuyên dùng chế độ Hồi phục cho thiết bị HTC. - Cài đặt Hồi phục - Cài đặt - Đang kiểm tra Superuser... - Có lỗi trong khi cài Superuser. Vui lòng gửi nhật trình lỗi cho lập trình viên. - Cài đặt Superuser thành công. - Chương trình su đã cũ. - Quyền truy cập Superuser - Tắt - Chỉ cho ứng dụng - Chỉ cho ADB - Cả ứng dụng và ADB - Có gì mới - Xếp hạng - Tông màu - Sáng - Tối - Bảo vệ Superuser bằng mã khóa đã tắt - diff --git a/Superuser/res/values-zh-rCN/strings.xml b/Superuser/res/values-zh-rCN/strings.xml index a07c0150..e091af11 100644 --- a/Superuser/res/values-zh-rCN/strings.xml +++ b/Superuser/res/values-zh-rCN/strings.xml @@ -1,94 +1,109 @@ - - - 超级用户 - 允许 - 拒绝 - 收到超级用户请求… - 未知 UID：%s - %s 正在请求超级用户访问权限。 - 警告：如果你对此不了解，你应该选拒绝。 - 超级用户请求 - 软件包： - 应用程序： - 请求的 UID： - 命令： - 仅此次 - 记住选择 %s 分钟 - 永久记住选择 - 交互式 - 日志 - 设置 - 删除 - 无日志 - 当前没有超级用户应用程序策略 - 日志 - 启用/禁用超级用户请求日志 - 密码保护 - 授权超级用户请求时要求输入密码 - 请求超时 - %s 秒后超级用户请求将超时并被拒绝 - 通知 - 无 - 当应用程序被允许或拒绝时将显示一个%s - 输入密码 - 输入新密码 - 密码不正确 - 确认密码 - 密码不一致 - 超级用户密码保护已启用 - %s 秒 - 已授予 %s 超级用户权限 - 已拒绝 %s 获取超级用户权限 - 提示 - 通知 - 不显示通知 - "开发人员警告： -android.permission.ACCESS_SUPERUSER -在 manifest 中未定义。" - 对所有设备功能和存储的完整权限 - 超级用户授予访问你的设备的所有功能和存储设备的完整权限，包括加密和敏感硬件设备。此许可有潜在的风险。 - 权限申明 - 仅允许来自申明了 android.permission.ACCESS_SUPERUSER 权限的应用程序的请求 - 自动响应 - 提示 - 自动允许新请求 - 自动拒绝新请求 - 对新请求显示确认对话框 - 安全 - 多用户策略 - 仅机主可以请求超级用户权限 - 其他用户请求超级用户权限时，机主将被提示 - 所有用户都可以请求超级用户权限 - 仅机主 - 机主控制 - 所有用户 - 多用户策略仅可以由机主管理 - 请切换到机主帐户允许或拒绝此请求。 - 所有命令 - 关于 - 应用程序 - 正在安装 - 正在安装超级用户… - 安装超级用户 - "超级用户二进制可执行文件 (su) 需要更新。 - -请选择安装方式。 -对 HTC 设备建议选择 recovery 模式安装。" - recovery 模式安装 - 常规安装 - 正在检查超级用户… - 安装超级用户时出错。请将错误日志发送给开发人员。 - 超级用户安装成功。 - su 二进制可执行文件已过期。 - 超级用户访问权限 - 禁用 - 仅应用程序 - 仅 ADB - 应用程序和 ADB - 更新说明 - 评价 - 界面主题 - 亮色调 - 暗色调 - 超级用户密码保护已禁用 - + + + + + 超级用户 + 允许 + 拒绝 + 收到超级用户请求\u2026 + 未知 UID：%s + “%s”正在请求超级用户访问权限。 + 警告：如果你对此不了解，你应该选拒绝。 + 超级用户请求 + 软件包： + 应用程序： + 请求的 UID： + 命令： + 仅此次 + 记住选择 %s 分钟 + 永久记住选择 + 交互式 + 日志 + 设置 + 删除 + 无日志 + 当前没有超级用户应用程序策略。 + 日志 + 启用/禁用超级用户请求日志 + 密码保护 + 授权超级用户请求时要求输入密码 + 请求超时 + %s 秒后超级用户请求将超时并被拒绝 + 通知 + 无 + 当应用程序被允许或拒绝时将显示一个%s + 输入密码 + 输入新的密码 + 密码不正确 + 确认密码 + 密码不一致 + 超级用户密码保护已启用 + %s 秒 + 已授予“%s”超级用户权限 + 已拒绝“%s”获取超级用户权限 + 提示 + 通知 + 不显示通知 + \"开发人员警告：\nandroid.permission.ACCESS_SUPERUSER +在 manifest 中未定义。 + 对所有设备功能和存储的完整权限 + 超级用户授予访问你的设备的所有功能和存储设备的完整权限，包括加密和敏感硬件设备。此权限有潜在的风险。 + 权限申明 + 仅允许来自申明了 android.permission.ACCESS_SUPERUSER 权限的应用程序的请求 + 自动响应 + 提示 + 自动允许新请求 + 自动拒绝新请求 + 对新请求显示确认对话框 + 安全 + 多用户策略 + 仅机主可以请求超级用户权限 + 其他用户请求超级用户权限时，机主将被提示 + 所有用户都可以请求超级用户权限 + 仅机主 + 机主控制 + 所有用户 + 多用户策略仅可以由机主管理 + 请切换到机主帐户允许或拒绝此请求。 + 所有命令 + 关于 + 应用程序 + 正在安装 + 正在安装超级用户\u2026 + 安装超级用户 + 超级用户二进制可执行文件 (su) 需要更新。\n\n请选择安装方式。\n对 HTC 设备建议选择恢复模式安装。 + 恢复模式安装 + 常规安装 + 正在检查超级用户\u2026 + 安装超级用户时出错。请将错误日志发送给开发人员。 + 超级用户安装成功。 + su 二进制可执行文件已过旧。 + 超级用户访问权限 + 禁用 + 仅限于应用程序 + 仅限于 ADB + 应用程序和 ADB + 更新说明 + 评价 + 界面主题 + 亮色调 + 暗色调 + 超级用户密码保护已禁用 + 撤消超级用户权限 + 详细信息 + 无法撤销此应用的超级用户权限。\n请重启超级用户并再试一次。 + diff --git a/Superuser/res/values-zh-rHK/strings.xml b/Superuser/res/values-zh-rHK/strings.xml index 20feeb9d..790a9a35 100644 --- a/Superuser/res/values-zh-rHK/strings.xml +++ b/Superuser/res/values-zh-rHK/strings.xml @@ -1,90 +1,28 @@ - + + + + 允許 + 記住選擇 %s 分鐘 + 永遠記住選擇 + 刪除 + 通知 + %s 秒 + 通知 + 主題 + 深色 diff --git a/Superuser/res/values-zh-rSG/strings.xml b/Superuser/res/values-zh-rSG/strings.xml index a07c0150..b2c7a8e5 100644 --- a/Superuser/res/values-zh-rSG/strings.xml +++ b/Superuser/res/values-zh-rSG/strings.xml @@ -1,94 +1,94 @@ - - - 超级用户 - 允许 - 拒绝 - 收到超级用户请求… - 未知 UID：%s - %s 正在请求超级用户访问权限。 - 警告：如果你对此不了解，你应该选拒绝。 - 超级用户请求 - 软件包： - 应用程序： - 请求的 UID： - 命令： - 仅此次 - 记住选择 %s 分钟 - 永久记住选择 - 交互式 - 日志 - 设置 - 删除 - 无日志 - 当前没有超级用户应用程序策略 - 日志 - 启用/禁用超级用户请求日志 - 密码保护 - 授权超级用户请求时要求输入密码 - 请求超时 - %s 秒后超级用户请求将超时并被拒绝 - 通知 - 无 - 当应用程序被允许或拒绝时将显示一个%s - 输入密码 - 输入新密码 - 密码不正确 - 确认密码 - 密码不一致 - 超级用户密码保护已启用 - %s 秒 - 已授予 %s 超级用户权限 - 已拒绝 %s 获取超级用户权限 - 提示 - 通知 - 不显示通知 - "开发人员警告： -android.permission.ACCESS_SUPERUSER -在 manifest 中未定义。" - 对所有设备功能和存储的完整权限 - 超级用户授予访问你的设备的所有功能和存储设备的完整权限，包括加密和敏感硬件设备。此许可有潜在的风险。 - 权限申明 - 仅允许来自申明了 android.permission.ACCESS_SUPERUSER 权限的应用程序的请求 - 自动响应 - 提示 - 自动允许新请求 - 自动拒绝新请求 - 对新请求显示确认对话框 - 安全 - 多用户策略 - 仅机主可以请求超级用户权限 - 其他用户请求超级用户权限时，机主将被提示 - 所有用户都可以请求超级用户权限 - 仅机主 - 机主控制 - 所有用户 - 多用户策略仅可以由机主管理 - 请切换到机主帐户允许或拒绝此请求。 - 所有命令 - 关于 - 应用程序 - 正在安装 - 正在安装超级用户… - 安装超级用户 - "超级用户二进制可执行文件 (su) 需要更新。 - -请选择安装方式。 -对 HTC 设备建议选择 recovery 模式安装。" - recovery 模式安装 - 常规安装 - 正在检查超级用户… - 安装超级用户时出错。请将错误日志发送给开发人员。 - 超级用户安装成功。 - su 二进制可执行文件已过期。 - 超级用户访问权限 - 禁用 - 仅应用程序 - 仅 ADB - 应用程序和 ADB - 更新说明 - 评价 - 界面主题 - 亮色调 - 暗色调 - 超级用户密码保护已禁用 - + + + 超级用户 + 允许 + 拒绝 + 收到超级用户请求… + 未知 UID：%s + %s 正在请求超级用户访问权限。 + 警告：如果你对此不了解，你应该选拒绝。 + 超级用户请求 + 软件包： + 应用程序： + 请求的 UID： + 命令： + 仅此次 + 记住选择 %s 分钟 + 永久记住选择 + 交互式 + 日志 + 设置 + 删除 + 无日志 + 当前没有超级用户应用程序策略 + 日志 + 启用/禁用超级用户请求日志 + 密码保护 + 授权超级用户请求时要求输入密码 + 请求超时 + %s 秒后超级用户请求将超时并被拒绝 + 通知 + 无 + 当应用程序被允许或拒绝时将显示一个%s + 输入密码 + 输入新密码 + 密码不正确 + 确认密码 + 密码不一致 + 超级用户密码保护已启用 + %s 秒 + 已授予 %s 超级用户权限 + 已拒绝 %s 获取超级用户权限 + 提示 + 通知 + 不显示通知 + "开发人员警告： +android.permission.ACCESS_SUPERUSER +在 manifest 中未定义。" + 对所有设备功能和存储的完整权限 + 超级用户授予访问你的设备的所有功能和存储设备的完整权限，包括加密和敏感硬件设备。此许可有潜在的风险。 + 权限申明 + 仅允许来自申明了 android.permission.ACCESS_SUPERUSER 权限的应用程序的请求 + 自动响应 + 提示 + 自动允许新请求 + 自动拒绝新请求 + 对新请求显示确认对话框 + 安全 + 多用户策略 + 仅机主可以请求超级用户权限 + 其他用户请求超级用户权限时，机主将被提示 + 所有用户都可以请求超级用户权限 + 仅机主 + 机主控制 + 所有用户 + 多用户策略仅可以由机主管理 + 请切换到机主帐户允许或拒绝此请求。 + 所有命令 + 关于 + 应用程序 + 正在安装 + 正在安装超级用户… + 安装超级用户 + "超级用户二进制可执行文件 (su) 需要更新。 + +请选择安装方式。 +对 HTC 设备建议选择 recovery 模式安装。" + recovery 模式安装 + 常规安装 + 正在检查超级用户… + 安装超级用户时出错。请将错误日志发送给开发人员。 + 超级用户安装成功。 + su 二进制可执行文件已过期。 + 超级用户访问权限 + 禁用 + 仅应用程序 + 仅 ADB + 应用程序和 ADB + 更新说明 + 评价 + 界面主题 + 亮色调 + 暗色调 + 超级用户密码保护已禁用 + diff --git a/Superuser/res/values-zh-rTW/strings.xml b/Superuser/res/values-zh-rTW/strings.xml index 20feeb9d..dd3b754c 100644 --- a/Superuser/res/values-zh-rTW/strings.xml +++ b/Superuser/res/values-zh-rTW/strings.xml @@ -1,90 +1,108 @@ - + + + + 超級使用者 + 允許 + 拒絕 + 收到超級使用者要求\u2026 + 未知的 UID：%s + 「%s」正在要求超級使用者存取權。 + 警告：如果您不知道這是什麼，您應該拒絕此要求。 + 超級使用者要求 + 套件： + 應用程式： + 要求的 UID： + 命令： + 只有這次 + 記住選擇 %s 分鐘 + 永遠記住選擇 + 互動式 + 紀錄 + 設定 + 刪除 + 沒有紀錄 + 目前沒有任何超級使用者應用程式的規則。 + 紀錄 + 啟用所有超級使用者要求的紀錄。 + PIN 保護 + 要求輸入 PIN 以同意超級使用者要求 + 要求逾時 + 超級使用者要求會在 %s 秒後逾時並被拒絕 + 通知 + 無 + 應用程式被授予或拒絕超級使用者權限時會顯示%s + 輸入 PIN + 輸入新的 PIN + PIN 錯誤 + 確認 PIN + PIN 不符 + 超級使用者 PIN 保護已啟用 + %s 秒 + 超級使用者授予了「%s」 + 超級使用者拒絕了「%s」 + 彈出訊息 (Toast) + 通知 + 不顯示通知 + 開發人員警告：\n還沒有在 manifest 宣告\nandroid.permission.ACCESS_SUPERUSER。 + 對所有裝置功能和儲存空間的完全權限 + 超級使用者授予對所有裝置功能和儲存空間的完全存取權，包括您裝置安全與機密的硬體元件。這個權限有潛在的風險。 + 宣告權限 + 只允許已宣告 android.permission.ACCESS_SUPERUSER 的應用程式的要求 + 自動回應 + 詢問 + 自動允許新要求 + 自動拒絕新要求 + 對新要求顯示確認對話框 + 安全性 + 多使用者規則 + 只有裝置擁有者可以要求超級使用者權限 + 當其他使用者要求超級使用者權限時，裝置擁有者將會被詢問 + 所有使用者都能夠要求超級使用者權限 + 僅限擁有者 + 擁有者管理 + 所有使用者 + 多使用者規則只能由裝置擁有者管理。 + 請切換到擁有者帳戶以同意或拒絕這個要求。 + 所有命令 + 關於 + 應用程式 + 正在安裝 + 正在安裝超級使用者\u2026 + 安裝超級使用者 + 超級使用者二進位檔 (su) 必須更新。\n\n請選擇安裝方法。\nHTC 裝置建議 recovery 模式安裝。 + Recovery 安裝 + 安裝 + 正在檢查超級使用者\u2026 + 安裝超級使用者時發生錯誤。請傳送錯誤紀錄給開發人員。 + 超級使用者安裝成功。 + su 二進位檔已過時。 + 超級使用者存取權 + 停用 + 僅限應用程式 + 僅限 ADB + 應用程式和 ADB + 更新說明 + 評分 + 主題 + 淺色 + 深色 + 超級使用者 PIN 保護已停用 + 撤銷超級使用者權限 + 詳細資訊 + 無法撤銷這個應用程式的超級使用者權限。\n請重新啟動超級使用者應用程式並再試一次。 diff --git a/Superuser/res/values-zh/strings.xml b/Superuser/res/values-zh/strings.xml index 20feeb9d..58929b04 100644 --- a/Superuser/res/values-zh/strings.xml +++ b/Superuser/res/values-zh/strings.xml @@ -77,7 +77,7 @@ 超級使用者安裝成功。 二進制檔案（su）已經過期。 訪問權限 - 禁用 + 禁用 僅應用程式 僅 ADB 應用程式和 ADB diff --git a/Superuser/res/values/strings.xml b/Superuser/res/values/strings.xml index 63096ed9..573372ac 100644 --- a/Superuser/res/values/strings.xml +++ b/Superuser/res/values/strings.xml @@ -1,10 +1,24 @@ - + + Superuser Allow Deny - Incoming Superuser Request... + Incoming Superuser Request\u2026 Unknown UID: %s %s is requesting Superuser access. Warning: If you do not understand this, you should deny the request. @@ -23,7 +37,7 @@ No Logs There are currently no Superuser app policies. Logging - Enable or disable all Superuser request logging + Enable all Superuser request logging PIN Protection Require entry of a PIN to approve Superuser requests Request Timeout @@ -67,17 +81,17 @@ About Apps Installing - Installing Superuser... + Installing Superuser\u2026 Install Superuser The Superuser binary (su) must be updated.\n\nPlease choose an installation method.\nRecovery mode installation is recommended for HTC devices. Recovery Install Install - Checking Superuser... + Checking Superuser\u2026 There was an error installing Superuser. Please send a log of the error to the developer. Installation of Superuser was successful. The su binary is out of date. Superuser Access - Disabled + Disabled Apps only ADB only Apps and ADB @@ -87,4 +101,7 @@ Light Dark Superuser PIN protection disabled + Revoke Superuser permission + Details + Superuser permission cannot be revoked from this app.\nPlease restart the Superuser app and try again. diff --git a/Superuser/res/values/styles.xml b/Superuser/res/values/styles.xml index 39ca7f2f..728da58b 100644 --- a/Superuser/res/values/styles.xml +++ b/Superuser/res/values/styles.xml @@ -35,6 +35,10 @@