vold_prepare_subdirs.cpp

   1 /*
   2  * Copyright (C) 2017 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 /*
  18  * Tool to create a directory with the right SELinux context applied, or
  19  * apply the context if it's absent. Also fixes mode, uid, gid.
  20  */
  21
  22 #include <iostream>
  23 #include <string>
  24 #include <vector>
  25
  26 #include <dirent.h>
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <sys/stat.h>
  30 #include <sys/types.h>
  31
  32 #include <android-base/logging.h>
  33 #include <android-base/scopeguard.h>
  34
  35 #include <cutils/fs.h>
  36 #include <selinux/android.h>
  37
  38 #include "Utils.h"
  39 #include "android/os/IVold.h"
  40
  41 #include <private/android_filesystem_config.h>
  42
  43 static void usage(const char* progname) {
  44     std::cerr << "Usage: " << progname << " [ prepare | destroy ] <volume_uuid> <user_id> <flags>"
  45               << std::endl;
  46     exit(-1);
  47 }
  48
  49 static bool small_int(const std::string& s) {
  50     return !s.empty() && s.size() < 7 && s.find_first_not_of("0123456789") == std::string::npos;
  51 }
  52
  53 static bool valid_uuid(const std::string& s) {
  54     return s.size() < 40 && s.find_first_not_of("0123456789abcdefABCDEF-_") == std::string::npos;
  55 }
  56
  57 static bool prepare_dir_for_user(struct selabel_handle* sehandle, mode_t mode, uid_t uid, gid_t gid,
  58                                  const std::string& path, uid_t user_id) {
  59     auto clearfscreatecon = android::base::make_scope_guard([] { setfscreatecon(nullptr); });
  60     auto secontext = std::unique_ptr<char, void (*)(char*)>(nullptr, freecon);
  61     if (sehandle) {
  62         char* tmp_secontext;
  63
  64         if (selabel_lookup(sehandle, &tmp_secontext, path.c_str(), S_IFDIR) == 0) {
  65             secontext.reset(tmp_secontext);
  66
  67             if (user_id != (uid_t)-1) {
  68                 if (selinux_android_context_with_level(secontext.get(), &tmp_secontext, user_id,
  69                                                        (uid_t)-1) != 0) {
  70                     PLOG(ERROR) << "Unable to create context with level for: " << path;
  71                     return false;
  72                 }
  73                 secontext.reset(tmp_secontext);  // Free the context
  74             }
  75         }
  76     }
  77
  78     LOG(DEBUG) << "Setting up mode " << std::oct << mode << std::dec << " uid " << uid << " gid "
  79                << gid << " context " << (secontext ? secontext.get() : "null")
  80                << " on path: " << path;
  81     if (secontext) {
  82         if (setfscreatecon(secontext.get()) != 0) {
  83             PLOG(ERROR) << "Unable to setfscreatecon for: " << path;
  84             return false;
  85         }
  86     }
  87     if (fs_prepare_dir(path.c_str(), mode, uid, gid) != 0) {
  88         return false;
  89     }
  90     if (secontext) {
  91         char* tmp_oldsecontext = nullptr;
  92         if (lgetfilecon(path.c_str(), &tmp_oldsecontext) < 0) {
  93             PLOG(ERROR) << "Unable to read secontext for: " << path;
  94             return false;
  95         }
  96         auto oldsecontext = std::unique_ptr<char, void (*)(char*)>(tmp_oldsecontext, freecon);
  97         if (strcmp(secontext.get(), oldsecontext.get()) != 0) {
  98             LOG(INFO) << "Relabelling from " << ((char*)oldsecontext.get()) << " to "
  99                       << ((char*)secontext.get()) << ": " << path;
 100             if (lsetfilecon(path.c_str(), secontext.get()) != 0) {
 101                 PLOG(ERROR) << "Relabelling failed for: " << path;
 102                 return false;
 103             }
 104         }
 105     }
 106     return true;
 107 }
 108
 109 static bool prepare_dir(struct selabel_handle* sehandle, mode_t mode, uid_t uid, gid_t gid,
 110                         const std::string& path) {
 111     return prepare_dir_for_user(sehandle, mode, uid, gid, path, (uid_t)-1);
 112 }
 113
 114 static bool rmrf_contents(const std::string& path) {
 115     auto dirp = std::unique_ptr<DIR, int (*)(DIR*)>(opendir(path.c_str()), closedir);
 116     if (!dirp) {
 117         PLOG(ERROR) << "Unable to open directory: " << path;
 118         return false;
 119     }
 120     bool res = true;
 121     for (;;) {
 122         errno = 0;
 123         auto const entry = readdir(dirp.get());
 124         if (!entry) {
 125             if (errno) {
 126                 PLOG(ERROR) << "readdir failed on: " << path;
 127                 return false;
 128             }
 129             return res;
 130         }
 131         if (entry->d_name[0] == '.') continue;
 132         auto subdir = path + "/" + entry->d_name;
 133         if (0 !=
 134             android::vold::ForkExecvp(std::vector<std::string>{"/system/bin/rm", "-rf", subdir})) {
 135             LOG(ERROR) << "rm -rf failed on " << subdir;
 136             res = false;
 137         }
 138     }
 139 }
 140
 141 static bool prepare_apex_subdirs(struct selabel_handle* sehandle, const std::string& path) {
 142     if (!prepare_dir(sehandle, 0711, 0, 0, path + "/apexdata")) return false;
 143
 144     auto dirp = std::unique_ptr<DIR, int (*)(DIR*)>(opendir("/apex"), closedir);
 145     if (!dirp) {
 146         PLOG(ERROR) << "Unable to open apex directory";
 147         return false;
 148     }
 149     struct dirent* entry;
 150     while ((entry = readdir(dirp.get())) != nullptr) {
 151         if (entry->d_type != DT_DIR) continue;
 152
 153         const char* name = entry->d_name;
 154         // skip any starting with "."
 155         if (name[0] == '.') continue;
 156
 157         if (strchr(name, '@') != NULL) continue;
 158
 159         if (!prepare_dir(sehandle, 0771, AID_ROOT, AID_SYSTEM, path + "/apexdata/" + name)) {
 160             return false;
 161         }
 162     }
 163     return true;
 164 }
 165
 166 static bool prepare_subdirs(const std::string& volume_uuid, int user_id, int flags) {
 167     struct selabel_handle* sehandle = selinux_android_file_context_handle();
 168
 169     if (flags & android::os::IVold::STORAGE_FLAG_DE) {
 170         auto user_de_path = android::vold::BuildDataUserDePath(volume_uuid, user_id);
 171         if (!prepare_dir_for_user(sehandle, 0771, AID_SYSTEM, AID_SYSTEM, user_de_path, user_id)) {
 172             return false;
 173         }
 174
 175         if (volume_uuid.empty()) {
 176             auto misc_de_path = android::vold::BuildDataMiscDePath(user_id);
 177             if (!prepare_dir(sehandle, 0700, 0, 0, misc_de_path + "/vold")) return false;
 178             if (!prepare_dir(sehandle, 0700, 0, 0, misc_de_path + "/storaged")) return false;
 179             if (!prepare_dir(sehandle, 0700, 0, 0, misc_de_path + "/rollback")) return false;
 180             // TODO: Return false if this returns false once sure this should succeed.
 181             prepare_dir(sehandle, 0700, 0, 0, misc_de_path + "/apexrollback");
 182             prepare_apex_subdirs(sehandle, misc_de_path);
 183
 184             auto profiles_de_path = android::vold::BuildDataProfilesDePath(user_id);
 185             if (!prepare_dir_for_user(sehandle, 0771, AID_SYSTEM, AID_SYSTEM, profiles_de_path,
 186                                       user_id)) {
 187                 return false;
 188             }
 189
 190             auto vendor_de_path = android::vold::BuildDataVendorDePath(user_id);
 191             if (!prepare_dir(sehandle, 0700, AID_SYSTEM, AID_SYSTEM, vendor_de_path + "/fpdata")) {
 192                 return false;
 193             }
 194             auto facedata_path = vendor_de_path + "/facedata";
 195             if (!prepare_dir(sehandle, 0700, AID_SYSTEM, AID_SYSTEM, facedata_path)) {
 196                 return false;
 197             }
 198         }
 199     }
 200     if (flags & android::os::IVold::STORAGE_FLAG_CE) {
 201         auto user_ce_path = android::vold::BuildDataUserCePath(volume_uuid, user_id);
 202         if (!prepare_dir_for_user(sehandle, 0771, AID_SYSTEM, AID_SYSTEM, user_ce_path, user_id)) {
 203             return false;
 204         }
 205
 206         if (volume_uuid.empty()) {
 207             auto misc_ce_path = android::vold::BuildDataMiscCePath(user_id);
 208             if (!prepare_dir(sehandle, 0700, 0, 0, misc_ce_path + "/vold")) return false;
 209             if (!prepare_dir(sehandle, 0700, 0, 0, misc_ce_path + "/storaged")) return false;
 210             if (!prepare_dir(sehandle, 0700, 0, 0, misc_ce_path + "/rollback")) return false;
 211
 212             // TODO: Return false if this returns false once sure this should succeed.
 213             prepare_dir(sehandle, 0700, 0, 0, misc_ce_path + "/apexrollback");
 214             prepare_apex_subdirs(sehandle, misc_ce_path);
 215
 216             auto system_ce_path = android::vold::BuildDataSystemCePath(user_id);
 217             if (!prepare_dir(sehandle, 0700, AID_SYSTEM, AID_SYSTEM, system_ce_path + "/backup")) {
 218                 return false;
 219             }
 220             if (!prepare_dir(sehandle, 0700, AID_SYSTEM, AID_SYSTEM,
 221                              system_ce_path + "/backup_stage")) {
 222                 return false;
 223             }
 224             auto vendor_ce_path = android::vold::BuildDataVendorCePath(user_id);
 225             auto facedata_path = vendor_ce_path + "/facedata";
 226             if (!prepare_dir(sehandle, 0700, AID_SYSTEM, AID_SYSTEM, facedata_path)) {
 227                 return false;
 228             }
 229         }
 230     }
 231     return true;
 232 }
 233
 234 static bool destroy_subdirs(const std::string& volume_uuid, int user_id, int flags) {
 235     bool res = true;
 236     if (volume_uuid.empty()) {
 237         if (flags & android::os::IVold::STORAGE_FLAG_CE) {
 238             auto misc_ce_path = android::vold::BuildDataMiscCePath(user_id);
 239             res &= rmrf_contents(misc_ce_path);
 240
 241             auto vendor_ce_path = android::vold::BuildDataVendorCePath(user_id);
 242             res &= rmrf_contents(vendor_ce_path);
 243         }
 244         if (flags & android::os::IVold::STORAGE_FLAG_DE) {
 245             auto misc_de_path = android::vold::BuildDataMiscDePath(user_id);
 246             res &= rmrf_contents(misc_de_path);
 247
 248             auto vendor_de_path = android::vold::BuildDataVendorDePath(user_id);
 249             res &= rmrf_contents(vendor_de_path);
 250         }
 251     }
 252     return res;
 253 }
 254
 255 int main(int argc, const char* const argv[]) {
 256     android::base::InitLogging(const_cast<char**>(argv));
 257     std::vector<std::string> args(argv + 1, argv + argc);
 258
 259     if (args.size() != 4 || !valid_uuid(args[1]) || !small_int(args[2]) || !small_int(args[3])) {
 260         usage(argv[0]);
 261         return -1;
 262     }
 263
 264     auto volume_uuid = args[1];
 265     int user_id = stoi(args[2]);
 266     int flags = stoi(args[3]);
 267     if (args[0] == "prepare") {
 268         if (!prepare_subdirs(volume_uuid, user_id, flags)) return -1;
 269     } else if (args[0] == "destroy") {
 270         if (!destroy_subdirs(volume_uuid, user_id, flags)) return -1;
 271     } else {
 272         usage(argv[0]);
 273         return -1;
 274     }
 275     return 0;
 276 }