static int restore(const char *pathname, const struct stat *sb) {
char *oldcontext, *newcontext;
if(lgetfilecon(pathname, &oldcontext) < 0) {
fprintf(stderr, "Could not get context of %s: %s\n", pathname, strerror(errno));
return -1;
}
if(selabel_lookup(sehandle, &newcontext, pathname, sb->st_mode) < 0) {
fprintf(stderr, "Could not lookup context for %s: %s\n", pathname, strerror(errno));
return -1;
}
if(strcmp(newcontext, "<<none>>") && strcmp(oldcontext, newcontext)) {
if(verbose) printf("Relabeling %s from %s to %s.\n", pathname, oldcontext, newcontext);
if(!nochange) {
if(lsetfilecon(pathname, newcontext) < 0) {
fprintf(stderr, "Could not label %s with %s: %s\n",
pathname, newcontext, strerror(errno));
return -1;
}
}
}
freecon(oldcontext);
freecon(newcontext);
return 0;
}
VALUE Selinux_lgetfilecon(VALUE self, VALUE path)
{
char *_path = StringValuePtr(path);
security_context_t _con = NULL;
int _result = lgetfilecon(_path, &_con);
VALUE result = rb_ary_new3(2, INT2FIX(_result), _result == -1 ? Qnil : rb_str_new2(_con));
freecon(_con);
return result;
}
int matchpathcon_main(int argc, char **argv)
{
int error = 0;
unsigned opts;
char *fcontext, *prefix, *path;
opt_complementary = "-1" /* at least one param reqd */
":?:f--p:p--f"; /* mutually exclusive */
opts = getopt32(argc, argv, "nNf:p:V", &fcontext, &prefix);
argv += optind;
if (opts & OPT_NOT_TRANS) {
set_matchpathcon_flags(MATCHPATHCON_NOTRANS);
}
if (opts & OPT_FCONTEXT) {
if (matchpathcon_init(fcontext))
bb_perror_msg_and_die("error while processing %s", fcontext);
}
if (opts & OPT_PREFIX) {
if (matchpathcon_init_prefix(NULL, prefix))
bb_perror_msg_and_die("error while processing %s", prefix);
}
while ((path = *argv++) != NULL) {
security_context_t con;
int rc;
if (!(opts & OPT_VERIFY)) {
error += print_matchpathcon(path, opts & OPT_NOT_PRINT);
continue;
}
if (selinux_file_context_verify(path, 0)) {
printf("%s verified\n", path);
continue;
}
if (opts & OPT_NOT_TRANS)
rc = lgetfilecon_raw(path, &con);
else
rc = lgetfilecon(path, &con);
if (rc >= 0) {
printf("%s has context %s, should be ", path, con);
error += print_matchpathcon(path, 1);
freecon(con);
continue;
}
printf("actual context unknown: %s, should be ", strerror(errno));
error += print_matchpathcon(path, 1);
}
matchpathcon_fini();
return error;
}
const char * rpmsxLgetfilecon(rpmsx sx, const char *fn)
{
const char * scon = NULL;
if (sx == NULL) sx = rpmsxI();
if (_rpmsx_debug)
fprintf(stderr, "--> %s(%p,%s) sxfn %s\n", __FUNCTION__, sx, fn, sx->fn);
#if defined(WITH_SELINUX)
if (sx->fn && fn) {
security_context_t _con = NULL;
int rc = lgetfilecon(fn, &_con);
if (rc > 0 && _con != NULL)
scon = (const char *) _con;
else
freecon(_con);
}
#endif
if (_rpmsx_debug)
fprintf(stderr, "<-- %s(%p,%s) scon %s\n", __FUNCTION__, sx, fn, scon);
return scon;
}
static int change_file_context(const char *file, unsigned long opts)
{
security_context_t file_context = NULL;
security_context_t context_string;
context_t context;
int errors = 0;
int status = 0;
if (opts & OPT_CHCON_NODEREFERENCE) {
status = lgetfilecon(file, &file_context);
} else {
status = getfilecon(file, &file_context);
}
if (status < 0 && errno != ENODATA) {
if ((opts & OPT_CHCON_QUIET) == 0)
fprintf(stderr, "could not obtain security context: %s\n", file);
return 1;
}
if (file_context == NULL && specified_context == NULL) {
fprintf(stderr, "can't apply partial context to unlabeled file %s", file);
return 1;
}
if (specified_context == NULL) {
context = compute_context_from_mask(file_context, opts);
if (!context) {
fprintf(stderr, "couldn't compute security context from %s",
file_context);
return 1;
}
} else {
context = context_new(specified_context);
if (!context) {
fprintf(stderr, "invalid context: %s", specified_context);
return 1;
}
}
context_string = context_str(context);
if (file_context == NULL || strcmp(context_string, file_context)!=0) {
int fail = 0;
if (opts & OPT_CHCON_NODEREFERENCE) {
fail = lsetfilecon (file, context_string);
} else {
fail = setfilecon (file, context_string);
}
if ((opts & OPT_CHCON_VERBOSE)
|| ((opts & OPT_CHCON_CHANHES) && !fail)) {
printf(!fail
? "context of %s changed to %s\n"
: "failed to change context of %s to %s\n",
file, context_string);
}
if (fail) {
errors = 1;
if ((opts & OPT_CHCON_QUIET) == 0)
fprintf(stderr, "failed to change context of %s to %s\n",
file, context_string);
}
} else if (opts & OPT_CHCON_VERBOSE) {
printf("context of %s retained as %s\n", file, context_string);
}
context_free(context);
freecon(file_context);
if (opts & OPT_CHCON_RECURSIVE) {
struct stat file_stats;
if (lstat(file, &file_stats) == 0
&& S_ISDIR(file_stats.st_mode))
errors |= change_dir_context(file, opts);
}
return errors;
}
/**
* Generate all files from a Directory path
* Similar functionality with ls -R
* @param path Directory path
* @param file_list List of files
* @param dir_list List of directories
*
* @return 0 on success, negative number in case of an error
*/
static int generate_file_list(const char *path, file_info ** file_list,
file_info ** dir_list)
{
DIR *dir;
struct dirent *dirent;
struct stat st;
security_context_t con;
int len;
char *file_path;
file_info *node;
int ret = -1;
len = strlen(path);
if (len > MAX_PATH_LENGTH) {
LOGE("Invalid argument %s\n", path);
return -1;
}
dir = opendir(path);
if (!dir) {
LOGE("open dir %s failed", path);
return -1;
}
while ((dirent = readdir(dir))) {
int file_len = strlen(dirent->d_name);
/* This should not happen */
if (file_len > MAX_FILE_LENGTH) {
LOGE("file system error\n");
closedir(dir);
return -1;
}
/* Ignore /. and /.. */
if (file_len == 1 || file_len == 2) {
if (dirent->d_name[0] == '.') {
if (dirent->d_name[1] == '\0')
continue;
if ((dirent->d_name[1] == '.')
&& (dirent->d_name[2] == '\0'))
continue;
}
}
file_path =
(char *)malloc(MAX_PATH_LENGTH + MAX_FILE_LENGTH + 1);
if (!file_path) {
LOGE("insufficient memory\n");
exit(EXIT_FAILURE);
}
memset(file_path, 0, MAX_PATH_LENGTH + MAX_FILE_LENGTH + 1);
strcpy(file_path, path);
*(file_path + len) = '/';
strcpy(file_path + len + 1, dirent->d_name);
ret = lstat(file_path, &st);
if (ret < 0) {
LOGE("lstat failed on %s\n", file_path);
closedir(dir);
return ret;
}
ret = lgetfilecon(file_path, &con);
if (ret < 0) {
LOGE("lgetfilecon failed on %s\n", file_path);
closedir(dir);
return ret;
}
node = create_node(file_path, &st, con);
if (dirent->d_type == DT_DIR) {
node->next = *dir_list;
*dir_list = node;
ret =
generate_file_list(file_path, file_list, dir_list);
if (ret < 0) {
free(file_path);
return ret;
}
} else {
node->next = *file_list;
*file_list = node;
}
free(file_path);
}
closedir(dir);
return 0;
}
int
rpl_lgetfilecon (char const *file, security_context_t *con)
{
int ret = lgetfilecon (file, con);
return map_to_failure (ret, con);
}
int main(int argc, char **argv) {
// Recovery needs to install world-readable files, so clear umask
// set by init
umask(0);
Log_Offset = 0;
// Set up temporary log file (/tmp/recovery.log)
freopen(TMP_LOG_FILE, "a", stdout);
setbuf(stdout, NULL);
freopen(TMP_LOG_FILE, "a", stderr);
setbuf(stderr, NULL);
signal(SIGPIPE, SIG_IGN);
// Handle ADB sideload
if (argc == 3 && strcmp(argv[1], "--adbd") == 0) {
property_set("ctl.stop", "adbd");
adb_main(argv[2]);
return 0;
}
#ifdef RECOVERY_SDCARD_ON_DATA
datamedia = true;
#endif
char crash_prop_val[PROPERTY_VALUE_MAX];
int crash_counter;
property_get("twrp.crash_counter", crash_prop_val, "-1");
crash_counter = atoi(crash_prop_val) + 1;
snprintf(crash_prop_val, sizeof(crash_prop_val), "%d", crash_counter);
property_set("twrp.crash_counter", crash_prop_val);
property_set("ro.twrp.boot", "1");
property_set("ro.twrp.version", TW_VERSION_STR);
time_t StartupTime = time(NULL);
printf("Starting TWRP %s on %s (pid %d)\n", TW_VERSION_STR, ctime(&StartupTime), getpid());
// Load default values to set DataManager constants and handle ifdefs
DataManager::SetDefaultValues();
printf("Starting the UI...");
gui_init();
printf("=> Linking mtab\n");
symlink("/proc/mounts", "/etc/mtab");
if (TWFunc::Path_Exists("/etc/twrp.fstab")) {
if (TWFunc::Path_Exists("/etc/recovery.fstab")) {
printf("Renaming regular /etc/recovery.fstab -> /etc/recovery.fstab.bak\n");
rename("/etc/recovery.fstab", "/etc/recovery.fstab.bak");
}
printf("Moving /etc/twrp.fstab -> /etc/recovery.fstab\n");
rename("/etc/twrp.fstab", "/etc/recovery.fstab");
}
printf("=> Processing recovery.fstab\n");
if (!PartitionManager.Process_Fstab("/etc/recovery.fstab", 1)) {
LOGERR("Failing out of recovery due to problem with recovery.fstab.\n");
return -1;
}
PartitionManager.Output_Partition_Logging();
// Load up all the resources
gui_loadResources();
#ifdef HAVE_SELINUX
if (TWFunc::Path_Exists("/prebuilt_file_contexts")) {
if (TWFunc::Path_Exists("/file_contexts")) {
printf("Renaming regular /file_contexts -> /file_contexts.bak\n");
rename("/file_contexts", "/file_contexts.bak");
}
printf("Moving /prebuilt_file_contexts -> /file_contexts\n");
rename("/prebuilt_file_contexts", "/file_contexts");
}
struct selinux_opt selinux_options[] = {
{ SELABEL_OPT_PATH, "/file_contexts" }
};
selinux_handle = selabel_open(SELABEL_CTX_FILE, selinux_options, 1);
if (!selinux_handle)
printf("No file contexts for SELinux\n");
else
printf("SELinux contexts loaded from /file_contexts\n");
{ // Check to ensure SELinux can be supported by the kernel
char *contexts = NULL;
if (PartitionManager.Mount_By_Path("/cache", true) && TWFunc::Path_Exists("/cache/recovery")) {
lgetfilecon("/cache/recovery", &contexts);
if (!contexts) {
lsetfilecon("/cache/recovery", "test");
lgetfilecon("/cache/recovery", &contexts);
}
} else {
LOGINFO("Could not check /cache/recovery SELinux contexts, using /sbin/teamwin instead which may be inaccurate.\n");
lgetfilecon("/sbin/teamwin", &contexts);
}
if (!contexts) {
gui_print_color("warning", "Kernel does not have support for reading SELinux contexts.\n");
} else {
free(contexts);
gui_print("Full SELinux support is present.\n");
}
}
#else
gui_print_color("warning", "No SELinux support (no libselinux).\n");
#endif
PartitionManager.Mount_By_Path("/cache", true);
string Zip_File, Reboot_Value;
bool Cache_Wipe = false, Factory_Reset = false, Perform_Backup = false, Shutdown = false;
{
TWPartition* misc = PartitionManager.Find_Partition_By_Path("/misc");
if (misc != NULL) {
if (misc->Current_File_System == "emmc") {
set_device_type('e');
set_device_name(misc->Actual_Block_Device.c_str());
} else if (misc->Current_File_System == "mtd") {
set_device_type('m');
set_device_name(misc->MTD_Name.c_str());
} else {
LOGERR("Unknown file system for /misc\n");
}
}
get_args(&argc, &argv);
int index, index2, len;
char* argptr;
char* ptr;
printf("Startup Commands: ");
for (index = 1; index < argc; index++) {
argptr = argv[index];
printf(" '%s'", argv[index]);
len = strlen(argv[index]);
if (*argptr == '-') {argptr++; len--;}
if (*argptr == '-') {argptr++; len--;}
if (*argptr == 'u') {
ptr = argptr;
index2 = 0;
while (*ptr != '=' && *ptr != '\n')
ptr++;
// skip the = before grabbing Zip_File
while (*ptr == '=')
ptr++;
if (*ptr) {
Zip_File = ptr;
} else
LOGERR("argument error specifying zip file\n");
} else if (*argptr == 'w') {
if (len == 9)
Factory_Reset = true;
else if (len == 10)
Cache_Wipe = true;
} else if (*argptr == 'n') {
Perform_Backup = true;
} else if (*argptr == 'p') {
Shutdown = true;
} else if (*argptr == 's') {
ptr = argptr;
index2 = 0;
while (*ptr != '=' && *ptr != '\n')
ptr++;
if (*ptr) {
Reboot_Value = *ptr;
}
}
}
printf("\n");
}
if(crash_counter == 0) {
property_list(Print_Prop, NULL);
printf("\n");
} else {
printf("twrp.crash_counter=%d\n", crash_counter);
}
// Check for and run startup script if script exists
TWFunc::check_and_run_script("/sbin/runatboot.sh", "boot");
TWFunc::check_and_run_script("/sbin/postrecoveryboot.sh", "boot");
#ifdef TW_INCLUDE_INJECTTWRP
// Back up TWRP Ramdisk if needed:
TWPartition* Boot = PartitionManager.Find_Partition_By_Path("/boot");
LOGINFO("Backing up TWRP ramdisk...\n");
if (Boot == NULL || Boot->Current_File_System != "emmc")
TWFunc::Exec_Cmd("injecttwrp --backup /tmp/backup_recovery_ramdisk.img");
else {
string injectcmd = "injecttwrp --backup /tmp/backup_recovery_ramdisk.img bd=" + Boot->Actual_Block_Device;
TWFunc::Exec_Cmd(injectcmd);
}
LOGINFO("Backup of TWRP ramdisk done.\n");
#endif
bool Keep_Going = true;
if (Perform_Backup) {
DataManager::SetValue(TW_BACKUP_NAME, "(Auto Generate)");
if (!OpenRecoveryScript::Insert_ORS_Command("backup BSDCAE\n"))
Keep_Going = false;
}
if (Keep_Going && !Zip_File.empty()) {
string ORSCommand = "install " + Zip_File;
if (!OpenRecoveryScript::Insert_ORS_Command(ORSCommand))
Keep_Going = false;
}
if (Keep_Going) {
if (Factory_Reset) {
if (!OpenRecoveryScript::Insert_ORS_Command("wipe data\n"))
Keep_Going = false;
} else if (Cache_Wipe) {
if (!OpenRecoveryScript::Insert_ORS_Command("wipe cache\n"))
Keep_Going = false;
}
}
TWFunc::Update_Log_File();
// Offer to decrypt if the device is encrypted
if (DataManager::GetIntValue(TW_IS_ENCRYPTED) != 0) {
LOGINFO("Is encrypted, do decrypt page first\n");
if (gui_startPage("decrypt", 1, 1) != 0) {
LOGERR("Failed to start decrypt GUI page.\n");
} else {
// Check for and load custom theme if present
gui_loadCustomResources();
}
} else if (datamedia) {
if (tw_get_default_metadata(DataManager::GetSettingsStoragePath().c_str()) != 0) {
LOGINFO("Failed to get default contexts and file mode for storage files.\n");
} else {
LOGINFO("Got default contexts and file mode for storage files.\n");
}
}
// Read the settings file
#ifdef TW_HAS_MTP
// We unmount partitions sometimes during early boot which may override
// the default of MTP being enabled by auto toggling MTP off. This
// will force it back to enabled then get overridden by the settings
// file, assuming that an entry for tw_mtp_enabled is set.
DataManager::SetValue("tw_mtp_enabled", 1);
#endif
DataManager::ReadSettingsFile();
// Fixup the RTC clock on devices which require it
if(crash_counter == 0)
TWFunc::Fixup_Time_On_Boot();
// Run any outstanding OpenRecoveryScript
if (DataManager::GetIntValue(TW_IS_ENCRYPTED) == 0 && (TWFunc::Path_Exists(SCRIPT_FILE_TMP) || TWFunc::Path_Exists(SCRIPT_FILE_CACHE))) {
OpenRecoveryScript::Run_OpenRecoveryScript();
}
#ifdef TW_HAS_MTP
// Enable MTP?
char mtp_crash_check[PROPERTY_VALUE_MAX];
property_get("mtp.crash_check", mtp_crash_check, "0");
if (strcmp(mtp_crash_check, "0") == 0) {
property_set("mtp.crash_check", "1");
if (DataManager::GetIntValue("tw_mtp_enabled") == 1 && ((DataManager::GetIntValue(TW_IS_ENCRYPTED) != 0 && DataManager::GetIntValue(TW_IS_DECRYPTED) != 0) || DataManager::GetIntValue(TW_IS_ENCRYPTED) == 0)) {
LOGINFO("Enabling MTP during startup\n");
if (!PartitionManager.Enable_MTP())
PartitionManager.Disable_MTP();
else
gui_print("MTP Enabled\n");
} else {
PartitionManager.Disable_MTP();
}
property_set("mtp.crash_check", "0");
} else {
gui_print_color("warning", "MTP Crashed, not starting MTP on boot.\n");
DataManager::SetValue("tw_mtp_enabled", 0);
PartitionManager.Disable_MTP();
}
#else
PartitionManager.Disable_MTP();
#endif
// Launch the main GUI
gui_start();
// Disable flashing of stock recovery
TWFunc::Disable_Stock_Recovery_Replace();
// Check for su to see if the device is rooted or not
if (PartitionManager.Mount_By_Path("/system", false)) {
if (TWFunc::Path_Exists("/supersu/su") && !TWFunc::Path_Exists("/system/bin/su") && !TWFunc::Path_Exists("/system/xbin/su") && !TWFunc::Path_Exists("/system/bin/.ext/.su")) {
// Device doesn't have su installed
DataManager::SetValue("tw_busy", 1);
if (gui_startPage("installsu", 1, 1) != 0) {
LOGERR("Failed to start SuperSU install page.\n");
}
}
sync();
PartitionManager.UnMount_By_Path("/system", false);
}
// Reboot
TWFunc::Update_Intent_File(Reboot_Value);
TWFunc::Update_Log_File();
gui_print("Rebooting...\n");
string Reboot_Arg;
DataManager::GetValue("tw_reboot_arg", Reboot_Arg);
if (Reboot_Arg == "recovery")
TWFunc::tw_reboot(rb_recovery);
else if (Reboot_Arg == "poweroff")
TWFunc::tw_reboot(rb_poweroff);
else if (Reboot_Arg == "bootloader")
TWFunc::tw_reboot(rb_bootloader);
else if (Reboot_Arg == "download")
TWFunc::tw_reboot(rb_download);
else
TWFunc::tw_reboot(rb_system);
return 0;
}
int main(int argc, char **argv)
{
/* these vars are reused several times */
int rc, opt, i, c;
char *context, *root_path;
/* files that need context checks */
char *fc[MAX_CHECK];
char *cterm = ttyname(0);
int nfc = 0;
struct stat m;
/* processes that need context checks */
char *pc[MAX_CHECK];
int npc = 0;
/* booleans */
char **bools;
int nbool;
int verbose = 0;
int show_bools = 0;
/* policy */
const char *pol_name, *root_dir;
char *pol_path;
while (1) {
opt = getopt(argc, argv, "vb");
if (opt == -1)
break;
switch (opt) {
case 'v':
verbose = 1;
break;
case 'b':
show_bools = 1;
break;
default:
/* invalid option */
printf("\nUsage: %s [OPTION]\n\n", basename(argv[0]));
printf(" -v Verbose check of process and file contexts.\n");
printf(" -b Display current state of booleans.\n");
printf("\nWithout options, show SELinux status.\n");
return -1;
}
}
printf_tab("SELinux status:");
rc = is_selinux_enabled();
switch (rc) {
case 1:
printf("enabled\n");
break;
case 0:
printf("disabled\n");
return 0;
break;
default:
printf("unknown (%s)\n", strerror(errno));
return 0;
break;
}
printf_tab("SELinuxfs mount:");
if (selinux_mnt != NULL) {
printf("%s\n", selinux_mnt);
} else {
printf("not mounted\n\n");
printf("Please mount selinuxfs for proper results.\n");
return -1;
}
printf_tab("SELinux root directory:");
root_dir = selinux_path();
if (root_dir == NULL) {
printf("error (%s)\n", strerror(errno));
return -1;
}
/* The path has a trailing '/' so duplicate to edit */
root_path = strdup(root_dir);
if (!root_path) {
printf("malloc error (%s)\n", strerror(errno));
return -1;
}
/* actually blank the '/' */
root_path[strlen(root_path) - 1] = '\0';
printf("%s\n", root_path);
free(root_path);
/* Dump all the path information */
printf_tab("Loaded policy name:");
pol_path = strdup(selinux_policy_root());
if (pol_path) {
pol_name = basename(pol_path);
puts(pol_name);
free(pol_path);
} else {
printf("error (%s)\n", strerror(errno));
}
printf_tab("Current mode:");
rc = security_getenforce();
switch (rc) {
case 1:
printf("enforcing\n");
break;
case 0:
printf("permissive\n");
break;
default:
printf("unknown (%s)\n", strerror(errno));
break;
}
printf_tab("Mode from config file:");
if (selinux_getenforcemode(&rc) == 0) {
switch (rc) {
case 1:
printf("enforcing\n");
break;
case 0:
printf("permissive\n");
break;
case -1:
printf("disabled\n");
break;
}
} else {
printf("error (%s)\n", strerror(errno));
}
printf_tab("Policy MLS status:");
rc = is_selinux_mls_enabled();
switch (rc) {
case 0:
printf("disabled\n");
break;
case 1:
printf("enabled\n");
break;
default:
printf("error (%s)\n", strerror(errno));
break;
}
printf_tab("Policy deny_unknown status:");
rc = security_deny_unknown();
switch (rc) {
case 0:
printf("allowed\n");
break;
case 1:
printf("denied\n");
break;
default:
printf("error (%s)\n", strerror(errno));
break;
}
rc = security_policyvers();
printf_tab("Max kernel policy version:");
if (rc < 0)
printf("unknown (%s)\n", strerror(errno));
else
printf("%d\n", rc);
if (show_bools) {
/* show booleans */
if (security_get_boolean_names(&bools, &nbool) >= 0) {
printf("\nPolicy booleans:\n");
for (i = 0; i < nbool; i++) {
if (strlen(bools[i]) + 1 > COL)
COL = strlen(bools[i]) + 1;
}
for (i = 0; i < nbool; i++) {
printf_tab(bools[i]);
rc = security_get_boolean_active(bools[i]);
switch (rc) {
case 1:
printf("on");
break;
case 0:
printf("off");
break;
default:
printf("unknown (%s)", strerror(errno));
break;
}
c = security_get_boolean_pending(bools[i]);
if (c != rc)
switch (c) {
case 1:
printf(" (activate pending)");
break;
case 0:
printf(" (inactivate pending)");
break;
default:
printf(" (pending error: %s)",
strerror(errno));
break;
}
printf("\n");
/* free up the booleans */
free(bools[i]);
}
free(bools);
}
}
/* only show contexts if -v is given */
if (!verbose)
return 0;
load_checks(pc, &npc, fc, &nfc);
printf("\nProcess contexts:\n");
printf_tab("Current context:");
if (getcon(&context) >= 0) {
printf("%s\n", context);
freecon(context);
} else
printf("unknown (%s)\n", strerror(errno));
printf_tab("Init context:");
if (getpidcon(1, &context) >= 0) {
printf("%s\n", context);
freecon(context);
} else
printf("unknown (%s)\n", strerror(errno));
for (i = 0; i < npc; i++) {
rc = pidof(pc[i]);
if (rc > 0) {
if (getpidcon(rc, &context) < 0)
continue;
printf_tab(pc[i]);
printf("%s\n", context);
freecon(context);
}
}
printf("\nFile contexts:\n");
/* controlling term */
printf_tab("Controlling terminal:");
if (lgetfilecon(cterm, &context) >= 0) {
printf("%s\n", context);
freecon(context);
} else {
printf("unknown (%s)\n", strerror(errno));
}
for (i = 0; i < nfc; i++) {
if (lgetfilecon(fc[i], &context) >= 0) {
printf_tab(fc[i]);
/* check if this is a symlink */
if (lstat(fc[i], &m)) {
printf
("%s (could not check link status (%s)!)\n",
context, strerror(errno));
freecon(context);
continue;
}
if (S_ISLNK(m.st_mode)) {
/* print link target context */
printf("%s -> ", context);
freecon(context);
if (getfilecon(fc[i], &context) >= 0) {
printf("%s\n", context);
freecon(context);
} else {
printf("unknown (%s)\n",
strerror(errno));
}
} else {
printf("%s\n", context);
freecon(context);
}
}
}
return 0;
}
/*
This function takes a PATH of an existing file system object, and a LOCAL
boolean that indicates whether the function should set the object's label
to the default for the local process, or one using system wide settings.
If LOCAL == true, it will ask the SELinux Kernel what the default label
for all objects created should be and then sets the label on the object.
Otherwise it calls matchpathcon on the object to ask the system what the
default label should be, extracts the type field and then modifies the file
system object. Note only the type field is updated, thus preserving MLS
levels and user identity etc. of the PATH.
Returns -1 on failure. errno will be set appropriately.
*/
static int
restorecon_private (char const *path, bool local)
{
int rc = -1;
struct stat sb;
char *scon = NULL;
char *tcon = NULL;
context_t scontext = 0, tcontext = 0;
const char *contype;
char *constr;
int fd;
if (local)
{
if (getfscreatecon (&tcon) < 0)
return rc;
if (!tcon)
{
errno = ENODATA;
return rc;
}
rc = lsetfilecon (path, tcon);
freecon (tcon);
return rc;
}
fd = open (path, O_RDONLY | O_NOFOLLOW);
if (fd == -1 && (errno != ELOOP))
goto quit;
if (fd != -1)
{
if (fstat (fd, &sb) < 0)
goto quit;
}
else
{
if (lstat (path, &sb) < 0)
goto quit;
}
if (matchpathcon (path, sb.st_mode, &scon) < 0)
{
/* "No such file or directory" is a confusing error,
when processing files, when in fact it was the
associated default context that was not found.
Therefore map the error to something more appropriate
to the context in which we're using matchpathcon(). */
if (errno == ENOENT)
errno = ENODATA;
goto quit;
}
if (!(scontext = context_new (scon)))
goto quit;
if (fd != -1)
{
if (fgetfilecon (fd, &tcon) < 0)
goto quit;
}
else
{
if (lgetfilecon (path, &tcon) < 0)
goto quit;
}
if (!(tcontext = context_new (tcon)))
goto quit;
if (!(contype = context_type_get (scontext)))
goto quit;
if (context_type_set (tcontext, contype))
goto quit;
if (!(constr = context_str (tcontext)))
goto quit;
if (fd != -1)
rc = fsetfilecon (fd, constr);
else
rc = lsetfilecon (path, constr);
quit:
if (fd != -1)
close (fd);
context_free (scontext);
context_free (tcontext);
freecon (scon);
freecon (tcon);
return rc;
}
int matchpathcon_main(int argc, char **argv)
{
int i;
int header = 1;
int verify = 0;
int notrans = 0;
int error = 0;
unsigned long opts;
char *fcontext, *prefix;
if (argc < 2)
bb_show_usage();
opts = bb_getopt_ulflags(argc, argv, "nNf:p:V", &fcontext, &prefix);
if (opts & BB_GETOPT_ERROR)
bb_show_usage();
if (opts & MATCHPATHCON_OPT_NOT_PRINT)
header = 0;
if (opts & MATCHPATHCON_OPT_NOT_TRANS) {
notrans = 1;
set_matchpathcon_flags(MATCHPATHCON_NOTRANS);
}
if ((opts & MATCHPATHCON_OPT_FCONTEXT) && (opts & MATCHPATHCON_OPT_PREFIX))
bb_error_msg_and_die("-f and -p are exclusive");
if (opts & MATCHPATHCON_OPT_FCONTEXT) {
if (matchpathcon_init(fcontext))
bb_error_msg_and_die("Error while processing %s: %s",
fcontext, errno ? strerror(errno) : "invalid");
}
if (opts & MATCHPATHCON_OPT_PREFIX) {
if (matchpathcon_init_prefix(NULL, prefix))
bb_error_msg_and_die("Error while processing %s: %s",
prefix, errno ? strerror(errno) : "invalid");
}
if (opts & MATCHPATHCON_OPT_VERIFY)
verify = 1;
for (i = optind; i < argc; i++) {
if (verify) {
if (selinux_file_context_verify(argv[i], 0)) {
printf("%s verified.\n", argv[i]);
} else {
security_context_t con;
int rc;
if (notrans)
rc = lgetfilecon_raw(argv[i], &con);
else
rc = lgetfilecon(argv[i], &con);
if (rc >= 0) {
printf("%s has context %s, should be ",
argv[i], con);
error += printmatchpathcon(argv[i], 0);
freecon(con);
} else {
printf
("actual context unknown: %s, should be ",
strerror(errno));
error += printmatchpathcon(argv[i], 0);
}
}
} else {
error += printmatchpathcon(argv[i], header);
}
}
matchpathcon_fini();
return error;
}
static void display_verbose(void)
{
security_context_t con, _con;
char *fc[50], *pc[50], *cterm;
pid_t *pidList;
int i;
read_config(pc, ARRAY_SIZE(pc), fc, ARRAY_SIZE(fc));
/* process contexts */
puts("\nProcess contexts:");
/* current context */
if (getcon(&con) == 0) {
printf(COL_FMT "%s\n", "Current context:", con);
if (ENABLE_FEATURE_CLEAN_UP)
freecon(con);
}
/* /sbin/init context */
if (getpidcon(1, &con) == 0) {
printf(COL_FMT "%s\n", "Init context:", con);
if (ENABLE_FEATURE_CLEAN_UP)
freecon(con);
}
/* [process] context */
for (i = 0; pc[i] != NULL; i++) {
pidList = find_pid_by_name(bb_basename(pc[i]));
if (pidList[0] > 0 && getpidcon(pidList[0], &con) == 0) {
printf(COL_FMT "%s\n", pc[i], con);
if (ENABLE_FEATURE_CLEAN_UP)
freecon(con);
}
if (ENABLE_FEATURE_CLEAN_UP)
free(pidList);
}
/* files contexts */
puts("\nFile contexts:");
cterm = ttyname(0);
puts(cterm);
if (cterm && lgetfilecon(cterm, &con) >= 0) {
printf(COL_FMT "%s\n", "Controlling term:", con);
if (ENABLE_FEATURE_CLEAN_UP)
freecon(con);
}
for (i=0; fc[i] != NULL; i++) {
struct stat stbuf;
if (lgetfilecon(fc[i], &con) < 0)
continue;
if (lstat(fc[i], &stbuf) == 0) {
if (S_ISLNK(stbuf.st_mode)) {
if (getfilecon(fc[i], &_con) >= 0) {
printf(COL_FMT "%s -> %s\n", fc[i], _con, con);
if (ENABLE_FEATURE_CLEAN_UP)
freecon(_con);
}
} else {
printf(COL_FMT "%s\n", fc[i], con);
}
}
if (ENABLE_FEATURE_CLEAN_UP)
freecon(con);
}
}
static int change_filedir_context(const char *fname, struct stat *stbuf, void *userData, int depth)
{
context_t context = NULL;
security_context_t file_context = NULL;
security_context_t context_string;
int rc = FALSE;
int status = 0;
if (option_mask32 & OPT_NODEREFERENCE) {
status = lgetfilecon(fname, &file_context);
} else {
status = getfilecon(fname, &file_context);
}
if (status < 0 && errno != ENODATA) {
if ((option_mask32 & OPT_QUIET) == 0)
bb_error_msg("cannot obtain security context: %s", fname);
goto skip;
}
if (file_context == NULL && specified_context == NULL) {
bb_error_msg("cannot apply partial context to unlabeled file %s", fname);
goto skip;
}
if (specified_context == NULL) {
context = set_security_context_component(file_context,
user, role, type, range);
if (!context) {
bb_error_msg("cannot compute security context from %s", file_context);
goto skip;
}
} else {
context = context_new(specified_context);
if (!context) {
bb_error_msg("invalid context: %s", specified_context);
goto skip;
}
}
context_string = context_str(context);
if (!context_string) {
bb_error_msg("cannot obtain security context in text expression");
goto skip;
}
if (file_context == NULL || strcmp(context_string, file_context) != 0) {
int fail;
if (option_mask32 & OPT_NODEREFERENCE) {
fail = lsetfilecon(fname, context_string);
} else {
fail = setfilecon(fname, context_string);
}
if ((option_mask32 & OPT_VERBOSE) || ((option_mask32 & OPT_CHANHES) && !fail)) {
printf(!fail
? "context of %s changed to %s\n"
: "failed to change context of %s to %s\n",
fname, context_string);
}
if (!fail) {
rc = TRUE;
} else if ((option_mask32 & OPT_QUIET) == 0) {
bb_error_msg("failed to change context of %s to %s",
fname, context_string);
}
} else if (option_mask32 & OPT_VERBOSE) {
printf("context of %s retained as %s\n", fname, context_string);
rc = TRUE;
}
skip:
context_free(context);
freecon(file_context);
return rc;
}
static void unix_do_one(int nr, const char *line)
{
static int has = 0;
char path[PATH_MAX], ss_flags[32];
char *ss_proto, *ss_state, *ss_type;
int num, state, type, inode;
void *d;
unsigned long refcnt, proto, unix_flags;
USE_SELINUX(security_context_t unixcon = NULL);
if (nr == 0) {
if (strstr(line, "Inode"))
has |= HAS_INODE;
return;
}
path[0] = '\0';
num = sscanf(line, "%p: %lX %lX %lX %X %X %d %s",
&d, &refcnt, &proto, &unix_flags, &type, &state, &inode, path);
if (num < 6) {
bb_error_msg("warning, got bogus unix line.");
return;
}
if (!(has & HAS_INODE))
snprintf(path,sizeof(path),"%d",inode);
if ((flags&(NETSTAT_LISTENING|NETSTAT_CONNECTED))!=(NETSTAT_LISTENING|NETSTAT_CONNECTED)) {
if ((state == SS_UNCONNECTED) && (unix_flags & SO_ACCEPTCON)) {
if (!(flags&NETSTAT_LISTENING))
return;
} else {
if (!(flags&NETSTAT_CONNECTED))
return;
}
}
switch (proto) {
case 0:
ss_proto = "unix";
break;
default:
ss_proto = "??";
}
switch (type) {
case SOCK_STREAM:
ss_type = "STREAM";
break;
case SOCK_DGRAM:
ss_type = "DGRAM";
break;
case SOCK_RAW:
ss_type = "RAW";
break;
case SOCK_RDM:
ss_type = "RDM";
break;
case SOCK_SEQPACKET:
ss_type = "SEQPACKET";
break;
default:
ss_type = "UNKNOWN";
}
switch (state) {
case SS_FREE:
ss_state = "FREE";
break;
case SS_UNCONNECTED:
/*
* Unconnected sockets may be listening
* for something.
*/
if (unix_flags & SO_ACCEPTCON) {
ss_state = "LISTENING";
} else {
ss_state = "";
}
break;
case SS_CONNECTING:
ss_state = "CONNECTING";
break;
case SS_CONNECTED:
ss_state = "CONNECTED";
break;
case SS_DISCONNECTING:
ss_state = "DISCONNECTING";
break;
default:
ss_state = "UNKNOWN";
}
strcpy(ss_flags, "[ ");
if (unix_flags & SO_ACCEPTCON)
strcat(ss_flags, "ACC ");
if (unix_flags & SO_WAITDATA)
strcat(ss_flags, "W ");
if (unix_flags & SO_NOSPACE)
strcat(ss_flags, "N ");
strcat(ss_flags, "]");
#ifdef CONFIG_SELINUX
if ((flags & NETSTAT_SELINUX) && is_selinux_enabled()) {
if (lgetfilecon(path, &unixcon) < 0)
unixcon = NULL;
}
#endif
printf("%-5s %-6ld %-11s %-10s %-13s ",
ss_proto, refcnt, ss_flags, ss_type, ss_state);
if (has & HAS_INODE)
printf("%-6d ",inode);
else
printf("- ");
#ifdef CONFIG_SELINUX
if (flags & NETSTAT_SELINUX) {
printf("%-32s ", unixcon ? unixcon : "-");
if (unixcon)
freecon(unixcon);
}
#endif
puts(path);
}
/* appends a file to the tar archive */
int
tar_append_file(TAR *t, char *realname, char *savename)
{
struct stat s;
int i;
libtar_hashptr_t hp;
tar_dev_t *td = NULL;
tar_ino_t *ti = NULL;
char path[MAXPATHLEN];
#ifdef DEBUG
printf("==> tar_append_file(TAR=0x%lx (\"%s\"), realname=\"%s\", "
"savename=\"%s\")\n", t, t->pathname, realname,
(savename ? savename : "[NULL]"));
#endif
if (lstat(realname, &s) != 0)
{
#ifdef DEBUG
perror("lstat()");
#endif
return -1;
}
/* set header block */
#ifdef DEBUG
puts(" tar_append_file(): setting header block...");
#endif
memset(&(t->th_buf), 0, sizeof(struct tar_header));
th_set_from_stat(t, &s);
/* set the header path */
#ifdef DEBUG
puts(" tar_append_file(): setting header path...");
#endif
th_set_path(t, (savename ? savename : realname));
#ifdef HAVE_SELINUX
/* get selinux context */
if(t->options & TAR_STORE_SELINUX) {
if(t->th_buf.selinux_context != NULL) {
free(t->th_buf.selinux_context);
t->th_buf.selinux_context = NULL;
}
security_context_t selinux_context = NULL;
if (lgetfilecon(realname, &selinux_context) >= 0) {
t->th_buf.selinux_context = strdup(selinux_context);
printf("setting selinux context: %s\n", selinux_context);
freecon(selinux_context);
}
else
perror("Failed to get selinux context");
}
#endif
/* check if it's a hardlink */
#ifdef DEBUG
puts(" tar_append_file(): checking inode cache for hardlink...");
#endif
libtar_hashptr_reset(&hp);
if (libtar_hash_getkey(t->h, &hp, &(s.st_dev),
(libtar_matchfunc_t)dev_match) != 0)
td = (tar_dev_t *)libtar_hashptr_data(&hp);
else
{
#ifdef DEBUG
printf("+++ adding hash for device (0x%lx, 0x%lx)...\n",
major(s.st_dev), minor(s.st_dev));
#endif
td = (tar_dev_t *)calloc(1, sizeof(tar_dev_t));
td->td_dev = s.st_dev;
td->td_h = libtar_hash_new(256, (libtar_hashfunc_t)ino_hash);
if (td->td_h == NULL)
return -1;
if (libtar_hash_add(t->h, td) == -1)
return -1;
}
libtar_hashptr_reset(&hp);
if (libtar_hash_getkey(td->td_h, &hp, &(s.st_ino),
(libtar_matchfunc_t)ino_match) != 0)
{
ti = (tar_ino_t *)libtar_hashptr_data(&hp);
#ifdef DEBUG
printf(" tar_append_file(): encoding hard link \"%s\" "
"to \"%s\"...\n", realname, ti->ti_name);
#endif
t->th_buf.typeflag = LNKTYPE;
th_set_link(t, ti->ti_name);
}
else
{
#ifdef DEBUG
printf("+++ adding entry: device (0x%lx,0x%lx), inode %ld "
"(\"%s\")...\n", major(s.st_dev), minor(s.st_dev),
s.st_ino, realname);
#endif
ti = (tar_ino_t *)calloc(1, sizeof(tar_ino_t));
if (ti == NULL)
return -1;
ti->ti_ino = s.st_ino;
snprintf(ti->ti_name, sizeof(ti->ti_name), "%s",
savename ? savename : realname);
libtar_hash_add(td->td_h, ti);
}
/* check if it's a symlink */
if (TH_ISSYM(t))
{
i = readlink(realname, path, sizeof(path));
if (i == -1)
return -1;
if (i >= MAXPATHLEN)
i = MAXPATHLEN - 1;
path[i] = '\0';
#ifdef DEBUG
printf(" tar_append_file(): encoding symlink \"%s\" -> "
"\"%s\"...\n", realname, path);
#endif
th_set_link(t, path);
}
/* print file info */
if (t->options & TAR_VERBOSE)
th_print_long_ls(t);
#ifdef DEBUG
puts(" tar_append_file(): writing header");
#endif
/* write header */
if (th_write(t) != 0)
{
#ifdef DEBUG
printf("t->fd = %d\n", t->fd);
#endif
return -1;
}
#ifdef DEBUG
puts(" tar_append_file(): back from th_write()");
#endif
/* if it's a regular file, write the contents as well */
if (TH_ISREG(t) && tar_append_regfile(t, realname) != 0)
return -1;
return 0;
}
/* Return:
* -1 error, copy not made
* 0 copy is made or user answered "no" in interactive mode
* (failures to preserve mode/owner/times are not reported in exit code)
*/
int FAST_FUNC copy_file(const char *source, const char *dest, int flags)
{
/* This is a recursive function, try to minimize stack usage */
/* NB: each struct stat is ~100 bytes */
struct stat source_stat;
struct stat dest_stat;
smallint retval = 0;
smallint dest_exists = 0;
smallint ovr;
/* Inverse of cp -d ("cp without -d") */
#define FLAGS_DEREF (flags & (FILEUTILS_DEREFERENCE + FILEUTILS_DEREFERENCE_L0))
if ((FLAGS_DEREF ? stat : lstat)(source, &source_stat) < 0) {
/* This may be a dangling symlink.
* Making [sym]links to dangling symlinks works, so... */
if (flags & (FILEUTILS_MAKE_SOFTLINK|FILEUTILS_MAKE_HARDLINK))
goto make_links;
bb_perror_msg("can't stat '%s'", source);
return -1;
}
if (lstat(dest, &dest_stat) < 0) {
if (errno != ENOENT) {
bb_perror_msg("can't stat '%s'", dest);
return -1;
}
} else {
if (source_stat.st_dev == dest_stat.st_dev
&& source_stat.st_ino == dest_stat.st_ino
) {
bb_error_msg("'%s' and '%s' are the same file", source, dest);
return -1;
}
dest_exists = 1;
}
#if ENABLE_SELINUX
if ((flags & FILEUTILS_PRESERVE_SECURITY_CONTEXT) && is_selinux_enabled() > 0) {
security_context_t con;
if (lgetfilecon(source, &con) >= 0) {
if (setfscreatecon(con) < 0) {
bb_perror_msg("can't set setfscreatecon %s", con);
freecon(con);
return -1;
}
} else if (errno == ENOTSUP || errno == ENODATA) {
setfscreatecon_or_die(NULL);
} else {
bb_perror_msg("can't lgetfilecon %s", source);
return -1;
}
}
#endif
if (S_ISDIR(source_stat.st_mode)) {
DIR *dp;
const char *tp;
struct dirent *d;
mode_t saved_umask = 0;
if (!(flags & FILEUTILS_RECUR)) {
bb_error_msg("omitting directory '%s'", source);
return -1;
}
/* Did we ever create source ourself before? */
tp = is_in_ino_dev_hashtable(&source_stat);
if (tp) {
/* We did! it's a recursion! man the lifeboats... */
bb_error_msg("recursion detected, omitting directory '%s'",
source);
return -1;
}
if (dest_exists) {
if (!S_ISDIR(dest_stat.st_mode)) {
bb_error_msg("target '%s' is not a directory", dest);
return -1;
}
/* race here: user can substitute a symlink between
* this check and actual creation of files inside dest */
} else {
/* Create DEST */
mode_t mode;
saved_umask = umask(0);
mode = source_stat.st_mode;
if (!(flags & FILEUTILS_PRESERVE_STATUS))
mode = source_stat.st_mode & ~saved_umask;
/* Allow owner to access new dir (at least for now) */
mode |= S_IRWXU;
if (mkdir(dest, mode) < 0) {
umask(saved_umask);
bb_perror_msg("can't create directory '%s'", dest);
return -1;
}
umask(saved_umask);
/* need stat info for add_to_ino_dev_hashtable */
if (lstat(dest, &dest_stat) < 0) {
bb_perror_msg("can't stat '%s'", dest);
return -1;
}
}
/* remember (dev,inode) of each created dir.
* NULL: name is not remembered */
add_to_ino_dev_hashtable(&dest_stat, NULL);
/* Recursively copy files in SOURCE */
dp = opendir(source);
if (dp == NULL) {
retval = -1;
goto preserve_mode_ugid_time;
}
while ((d = readdir(dp)) != NULL) {
char *new_source, *new_dest;
new_source = concat_subpath_file(source, d->d_name);
if (new_source == NULL)
continue;
new_dest = concat_path_file(dest, d->d_name);
if (copy_file(new_source, new_dest, flags & ~FILEUTILS_DEREFERENCE_L0) < 0)
retval = -1;
free(new_source);
free(new_dest);
}
closedir(dp);
if (!dest_exists
&& chmod(dest, source_stat.st_mode & ~saved_umask) < 0
) {
bb_perror_msg("can't preserve %s of '%s'", "permissions", dest);
/* retval = -1; - WRONG! copy *WAS* made */
}
goto preserve_mode_ugid_time;
}
if (flags & (FILEUTILS_MAKE_SOFTLINK|FILEUTILS_MAKE_HARDLINK)) {
int (*lf)(const char *oldpath, const char *newpath);
make_links:
/* Hmm... maybe
* if (DEREF && MAKE_SOFTLINK) source = realpath(source) ?
* (but realpath returns NULL on dangling symlinks...) */
lf = (flags & FILEUTILS_MAKE_SOFTLINK) ? symlink : link;
if (lf(source, dest) < 0) {
ovr = ask_and_unlink(dest, flags);
if (ovr <= 0)
return ovr;
if (lf(source, dest) < 0) {
bb_perror_msg("can't create link '%s'", dest);
return -1;
}
}
/* _Not_ jumping to preserve_mode_ugid_time:
* (sym)links don't have those */
return 0;
}
if (/* "cp thing1 thing2" without -R: just open and read() from thing1 */
!(flags & FILEUTILS_RECUR)
/* "cp [-opts] regular_file thing2" */
|| S_ISREG(source_stat.st_mode)
/* DEREF uses stat, which never returns S_ISLNK() == true.
* So the below is never true: */
/* || (FLAGS_DEREF && S_ISLNK(source_stat.st_mode)) */
) {
int src_fd;
int dst_fd;
mode_t new_mode;
if (!FLAGS_DEREF && S_ISLNK(source_stat.st_mode)) {
/* "cp -d symlink dst": create a link */
goto dont_cat;
}
if (ENABLE_FEATURE_PRESERVE_HARDLINKS && !FLAGS_DEREF) {
const char *link_target;
link_target = is_in_ino_dev_hashtable(&source_stat);
if (link_target) {
if (link(link_target, dest) < 0) {
ovr = ask_and_unlink(dest, flags);
if (ovr <= 0)
return ovr;
if (link(link_target, dest) < 0) {
bb_perror_msg("can't create link '%s'", dest);
return -1;
}
}
return 0;
}
add_to_ino_dev_hashtable(&source_stat, dest);
}
src_fd = open_or_warn(source, O_RDONLY);
if (src_fd < 0)
return -1;
/* Do not try to open with weird mode fields */
new_mode = source_stat.st_mode;
if (!S_ISREG(source_stat.st_mode))
new_mode = 0666;
// POSIX way is a security problem versus (sym)link attacks
if (!ENABLE_FEATURE_NON_POSIX_CP) {
dst_fd = open(dest, O_WRONLY|O_CREAT|O_TRUNC, new_mode);
} else { /* safe way: */
dst_fd = open(dest, O_WRONLY|O_CREAT|O_EXCL, new_mode);
}
if (dst_fd == -1) {
ovr = ask_and_unlink(dest, flags);
if (ovr <= 0) {
close(src_fd);
return ovr;
}
/* It shouldn't exist. If it exists, do not open (symlink attack?) */
dst_fd = open3_or_warn(dest, O_WRONLY|O_CREAT|O_EXCL, new_mode);
if (dst_fd < 0) {
close(src_fd);
return -1;
}
}
#if ENABLE_SELINUX
if ((flags & (FILEUTILS_PRESERVE_SECURITY_CONTEXT|FILEUTILS_SET_SECURITY_CONTEXT))
&& is_selinux_enabled() > 0
) {
security_context_t con;
if (getfscreatecon(&con) == -1) {
bb_perror_msg("getfscreatecon");
return -1;
}
if (con) {
if (setfilecon(dest, con) == -1) {
bb_perror_msg("setfilecon:%s,%s", dest, con);
freecon(con);
return -1;
}
freecon(con);
}
}
#endif
if (bb_copyfd_eof(src_fd, dst_fd) == -1)
retval = -1;
/* Careful with writing... */
if (close(dst_fd) < 0) {
bb_perror_msg("error writing to '%s'", dest);
retval = -1;
}
/* ...but read size is already checked by bb_copyfd_eof */
close(src_fd);
/* "cp /dev/something new_file" should not
* copy mode of /dev/something */
if (!S_ISREG(source_stat.st_mode))
return retval;
goto preserve_mode_ugid_time;
}
dont_cat:
/* Source is a symlink or a special file */
/* We are lazy here, a bit lax with races... */
if (dest_exists) {
errno = EEXIST;
ovr = ask_and_unlink(dest, flags);
if (ovr <= 0)
return ovr;
}
if (S_ISLNK(source_stat.st_mode)) {
char *lpath = xmalloc_readlink_or_warn(source);
if (lpath) {
int r = symlink(lpath, dest);
free(lpath);
if (r < 0) {
bb_perror_msg("can't create symlink '%s'", dest);
return -1;
}
if (flags & FILEUTILS_PRESERVE_STATUS)
if (lchown(dest, source_stat.st_uid, source_stat.st_gid) < 0)
bb_perror_msg("can't preserve %s of '%s'", "ownership", dest);
}
/* _Not_ jumping to preserve_mode_ugid_time:
* symlinks don't have those */
return 0;
}
if (S_ISBLK(source_stat.st_mode) || S_ISCHR(source_stat.st_mode)
|| S_ISSOCK(source_stat.st_mode) || S_ISFIFO(source_stat.st_mode)
) {
if (mknod(dest, source_stat.st_mode, source_stat.st_rdev) < 0) {
bb_perror_msg("can't create '%s'", dest);
return -1;
}
} else {
bb_error_msg("unrecognized file '%s' with mode %x", source, source_stat.st_mode);
return -1;
}
preserve_mode_ugid_time:
if (flags & FILEUTILS_PRESERVE_STATUS
/* Cannot happen: */
/* && !(flags & (FILEUTILS_MAKE_SOFTLINK|FILEUTILS_MAKE_HARDLINK)) */
) {
struct timeval times[2];
times[1].tv_sec = times[0].tv_sec = source_stat.st_mtime;
times[1].tv_usec = times[0].tv_usec = 0;
/* BTW, utimes sets usec-precision time - just FYI */
if (utimes(dest, times) < 0)
bb_perror_msg("can't preserve %s of '%s'", "times", dest);
if (chown(dest, source_stat.st_uid, source_stat.st_gid) < 0) {
source_stat.st_mode &= ~(S_ISUID | S_ISGID);
bb_perror_msg("can't preserve %s of '%s'", "ownership", dest);
}
#if ENABLE_XATTR
/* Preserve extended attributes. We must copy it after chown()
* because it resets capabilities. */
if (copy_file_attr(source, dest) == -1)
bb_perror_msg("can't preserve %s of '%s'",
"extended attributes", dest);
#endif
if (chmod(dest, source_stat.st_mode) < 0)
bb_perror_msg("can't preserve %s of '%s'", "permissions", dest);
}
return retval;
}
int main(int argc, char **argv)
{
int i, init = 0, force_mode = 0;
int header = 1, opt;
int verify = 0;
int notrans = 0;
int error = 0;
int quiet = 0;
if (argc < 2)
usage(argv[0]);
while ((opt = getopt(argc, argv, "m:Nnf:P:p:Vq")) > 0) {
switch (opt) {
case 'n':
header = 0;
break;
case 'm':
force_mode = string_to_mode(optarg);
if (force_mode < 0) {
fprintf(stderr, "%s: mode %s is invalid\n", argv[0], optarg);
exit(1);
}
break;
case 'V':
verify = 1;
break;
case 'N':
notrans = 1;
set_matchpathcon_flags(MATCHPATHCON_NOTRANS);
break;
case 'f':
if (init) {
fprintf(stderr,
"%s: -f and -p are exclusive\n",
argv[0]);
exit(1);
}
init = 1;
if (matchpathcon_init(optarg)) {
fprintf(stderr,
"Error while processing %s: %s\n",
optarg,
errno ? strerror(errno) : "invalid");
exit(1);
}
break;
case 'P':
if (selinux_set_policy_root(optarg) < 0 ) {
fprintf(stderr,
"Error setting policy root %s: %s\n",
optarg,
errno ? strerror(errno) : "invalid");
exit(1);
}
break;
case 'p':
if (init) {
fprintf(stderr,
"%s: -f and -p are exclusive\n",
argv[0]);
exit(1);
}
init = 1;
if (matchpathcon_init_prefix(NULL, optarg)) {
fprintf(stderr,
"Error while processing %s: %s\n",
optarg,
errno ? strerror(errno) : "invalid");
exit(1);
}
break;
case 'q':
quiet = 1;
break;
default:
usage(argv[0]);
}
}
for (i = optind; i < argc; i++) {
int rc, mode = 0;
struct stat buf;
char *path = argv[i];
int len = strlen(path);
if (len > 1 && path[len - 1 ] == '/')
path[len - 1 ] = '\0';
if (lstat(path, &buf) == 0)
mode = buf.st_mode;
if (force_mode)
mode = force_mode;
if (verify) {
rc = selinux_file_context_verify(path, mode);
if (quiet) {
if (rc == 1)
continue;
else
exit(1);
}
if (rc == -1) {
printf("%s error: %s\n", path, strerror(errno));
exit(1);
} else if (rc == 1) {
printf("%s verified.\n", path);
} else {
char * con;
error = 1;
if (notrans)
rc = lgetfilecon_raw(path, &con);
else
rc = lgetfilecon(path, &con);
if (rc >= 0) {
printf("%s has context %s, should be ",
path, con);
printmatchpathcon(path, 0, mode);
freecon(con);
} else {
printf
("actual context unknown: %s, should be ",
strerror(errno));
printmatchpathcon(path, 0, mode);
}
}
} else {
error |= printmatchpathcon(path, header, mode);
}
}
matchpathcon_fini();
return error;
}