CommandListener.cpp revision 1c419e000eaee1758a04a5144dd07cdd20033c04
1/* 2 * Copyright (C) 2008 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#include <stdlib.h> 18#include <sys/mount.h> 19#include <sys/socket.h> 20#include <sys/stat.h> 21#include <sys/types.h> 22#include <sys/wait.h> 23#include <netinet/in.h> 24#include <arpa/inet.h> 25#include <dirent.h> 26#include <errno.h> 27#include <fcntl.h> 28#include <fs_mgr.h> 29#include <stdio.h> 30#include <string.h> 31#include <stdint.h> 32#include <inttypes.h> 33#include <ctype.h> 34 35#define LOG_TAG "VoldCmdListener" 36 37#include <android-base/logging.h> 38#include <android-base/stringprintf.h> 39#include <cutils/fs.h> 40 41#include <sysutils/SocketClient.h> 42#include <private/android_filesystem_config.h> 43 44#include "CommandListener.h" 45#include "VolumeManager.h" 46#include "VolumeBase.h" 47#include "ResponseCode.h" 48#include "Process.h" 49#include "Loop.h" 50#include "Devmapper.h" 51#include "MoveTask.h" 52#include "TrimTask.h" 53 54#define DUMP_ARGS 0 55 56CommandListener::CommandListener() : 57 FrameworkListener("vold", true) { 58 registerCmd(new DumpCmd()); 59 registerCmd(new VolumeCmd()); 60 registerCmd(new AsecCmd()); 61 registerCmd(new ObbCmd()); 62 registerCmd(new StorageCmd()); 63 registerCmd(new FstrimCmd()); 64 registerCmd(new AppFuseCmd()); 65} 66 67#if DUMP_ARGS 68void CommandListener::dumpArgs(int argc, char **argv, int argObscure) { 69 char buffer[4096]; 70 char *p = buffer; 71 72 memset(buffer, 0, sizeof(buffer)); 73 int i; 74 for (i = 0; i < argc; i++) { 75 unsigned int len = strlen(argv[i]) + 1; // Account for space 76 if (i == argObscure) { 77 len += 2; // Account for {} 78 } 79 if (((p - buffer) + len) < (sizeof(buffer)-1)) { 80 if (i == argObscure) { 81 *p++ = '{'; 82 *p++ = '}'; 83 *p++ = ' '; 84 continue; 85 } 86 strcpy(p, argv[i]); 87 p+= strlen(argv[i]); 88 if (i != (argc -1)) { 89 *p++ = ' '; 90 } 91 } 92 } 93 SLOGD("%s", buffer); 94} 95#else 96void CommandListener::dumpArgs(int /*argc*/, char ** /*argv*/, int /*argObscure*/) { } 97#endif 98 99int CommandListener::sendGenericOkFail(SocketClient *cli, int cond) { 100 if (!cond) { 101 return cli->sendMsg(ResponseCode::CommandOkay, "Command succeeded", false); 102 } else { 103 return cli->sendMsg(ResponseCode::OperationFailed, "Command failed", false); 104 } 105} 106 107CommandListener::DumpCmd::DumpCmd() : 108 VoldCommand("dump") { 109} 110 111int CommandListener::DumpCmd::runCommand(SocketClient *cli, 112 int /*argc*/, char ** /*argv*/) { 113 cli->sendMsg(0, "Dumping loop status", false); 114 if (Loop::dumpState(cli)) { 115 cli->sendMsg(ResponseCode::CommandOkay, "Loop dump failed", true); 116 } 117 cli->sendMsg(0, "Dumping DM status", false); 118 if (Devmapper::dumpState(cli)) { 119 cli->sendMsg(ResponseCode::CommandOkay, "Devmapper dump failed", true); 120 } 121 cli->sendMsg(0, "Dumping mounted filesystems", false); 122 FILE *fp = fopen("/proc/mounts", "r"); 123 if (fp) { 124 char line[1024]; 125 while (fgets(line, sizeof(line), fp)) { 126 line[strlen(line)-1] = '\0'; 127 cli->sendMsg(0, line, false);; 128 } 129 fclose(fp); 130 } 131 132 cli->sendMsg(ResponseCode::CommandOkay, "dump complete", false); 133 return 0; 134} 135 136CommandListener::VolumeCmd::VolumeCmd() : 137 VoldCommand("volume") { 138} 139 140int CommandListener::VolumeCmd::runCommand(SocketClient *cli, 141 int argc, char **argv) { 142 dumpArgs(argc, argv, -1); 143 144 if (argc < 2) { 145 cli->sendMsg(ResponseCode::CommandSyntaxError, "Missing Argument", false); 146 return 0; 147 } 148 149 VolumeManager *vm = VolumeManager::Instance(); 150 std::lock_guard<std::mutex> lock(vm->getLock()); 151 152 // TODO: tease out methods not directly related to volumes 153 154 std::string cmd(argv[1]); 155 if (cmd == "reset") { 156 return sendGenericOkFail(cli, vm->reset()); 157 158 } else if (cmd == "shutdown") { 159 return sendGenericOkFail(cli, vm->shutdown()); 160 161 } else if (cmd == "debug") { 162 return sendGenericOkFail(cli, vm->setDebug(true)); 163 164 } else if (cmd == "partition" && argc > 3) { 165 // partition [diskId] [public|private|mixed] [ratio] 166 std::string id(argv[2]); 167 auto disk = vm->findDisk(id); 168 if (disk == nullptr) { 169 return cli->sendMsg(ResponseCode::CommandSyntaxError, "Unknown disk", false); 170 } 171 172 std::string type(argv[3]); 173 if (type == "public") { 174 return sendGenericOkFail(cli, disk->partitionPublic()); 175 } else if (type == "private") { 176 return sendGenericOkFail(cli, disk->partitionPrivate()); 177 } else if (type == "mixed") { 178 if (argc < 4) { 179 return cli->sendMsg(ResponseCode::CommandSyntaxError, nullptr, false); 180 } 181 int frac = atoi(argv[4]); 182 return sendGenericOkFail(cli, disk->partitionMixed(frac)); 183 } else { 184 return cli->sendMsg(ResponseCode::CommandSyntaxError, nullptr, false); 185 } 186 187 } else if (cmd == "mkdirs" && argc > 2) { 188 // mkdirs [path] 189 return sendGenericOkFail(cli, vm->mkdirs(argv[2])); 190 191 } else if (cmd == "user_added" && argc > 3) { 192 // user_added [user] [serial] 193 return sendGenericOkFail(cli, vm->onUserAdded(atoi(argv[2]), atoi(argv[3]))); 194 195 } else if (cmd == "user_removed" && argc > 2) { 196 // user_removed [user] 197 return sendGenericOkFail(cli, vm->onUserRemoved(atoi(argv[2]))); 198 199 } else if (cmd == "user_started" && argc > 2) { 200 // user_started [user] 201 return sendGenericOkFail(cli, vm->onUserStarted(atoi(argv[2]))); 202 203 } else if (cmd == "user_stopped" && argc > 2) { 204 // user_stopped [user] 205 return sendGenericOkFail(cli, vm->onUserStopped(atoi(argv[2]))); 206 207 } else if (cmd == "mount" && argc > 2) { 208 // mount [volId] [flags] [user] 209 std::string id(argv[2]); 210 auto vol = vm->findVolume(id); 211 if (vol == nullptr) { 212 return cli->sendMsg(ResponseCode::CommandSyntaxError, "Unknown volume", false); 213 } 214 215 int mountFlags = (argc > 3) ? atoi(argv[3]) : 0; 216 userid_t mountUserId = (argc > 4) ? atoi(argv[4]) : -1; 217 218 vol->setMountFlags(mountFlags); 219 vol->setMountUserId(mountUserId); 220 221 int res = vol->mount(); 222 if (mountFlags & android::vold::VolumeBase::MountFlags::kPrimary) { 223 vm->setPrimary(vol); 224 } 225 return sendGenericOkFail(cli, res); 226 227 } else if (cmd == "unmount" && argc > 2) { 228 // unmount [volId] 229 std::string id(argv[2]); 230 auto vol = vm->findVolume(id); 231 if (vol == nullptr) { 232 return cli->sendMsg(ResponseCode::CommandSyntaxError, "Unknown volume", false); 233 } 234 235 return sendGenericOkFail(cli, vol->unmount()); 236 237 } else if (cmd == "format" && argc > 3) { 238 // format [volId] [fsType|auto] 239 std::string id(argv[2]); 240 std::string fsType(argv[3]); 241 auto vol = vm->findVolume(id); 242 if (vol == nullptr) { 243 return cli->sendMsg(ResponseCode::CommandSyntaxError, "Unknown volume", false); 244 } 245 246 return sendGenericOkFail(cli, vol->format(fsType)); 247 248 } else if (cmd == "move_storage" && argc > 3) { 249 // move_storage [fromVolId] [toVolId] 250 auto fromVol = vm->findVolume(std::string(argv[2])); 251 auto toVol = vm->findVolume(std::string(argv[3])); 252 if (fromVol == nullptr || toVol == nullptr) { 253 return cli->sendMsg(ResponseCode::CommandSyntaxError, "Unknown volume", false); 254 } 255 256 (new android::vold::MoveTask(fromVol, toVol))->start(); 257 return sendGenericOkFail(cli, 0); 258 259 } else if (cmd == "benchmark" && argc > 2) { 260 // benchmark [volId] 261 std::string id(argv[2]); 262 nsecs_t res = vm->benchmarkPrivate(id); 263 return cli->sendMsg(ResponseCode::CommandOkay, 264 android::base::StringPrintf("%" PRId64, res).c_str(), false); 265 266 } else if (cmd == "forget_partition" && argc > 2) { 267 // forget_partition [partGuid] 268 std::string partGuid(argv[2]); 269 return sendGenericOkFail(cli, vm->forgetPartition(partGuid)); 270 271 } else if (cmd == "remount_uid" && argc > 3) { 272 // remount_uid [uid] [none|default|read|write] 273 uid_t uid = atoi(argv[2]); 274 std::string mode(argv[3]); 275 return sendGenericOkFail(cli, vm->remountUid(uid, mode)); 276 } 277 278 return cli->sendMsg(ResponseCode::CommandSyntaxError, nullptr, false); 279} 280 281CommandListener::StorageCmd::StorageCmd() : 282 VoldCommand("storage") { 283} 284 285int CommandListener::StorageCmd::runCommand(SocketClient *cli, 286 int argc, char **argv) { 287 /* Guarantied to be initialized by vold's main() before the CommandListener is active */ 288 extern struct fstab *fstab; 289 290 dumpArgs(argc, argv, -1); 291 292 if (argc < 2) { 293 cli->sendMsg(ResponseCode::CommandSyntaxError, "Missing Argument", false); 294 return 0; 295 } 296 297 if (!strcmp(argv[1], "mountall")) { 298 if (argc != 2) { 299 cli->sendMsg(ResponseCode::CommandSyntaxError, "Usage: mountall", false); 300 return 0; 301 } 302 fs_mgr_mount_all(fstab); 303 cli->sendMsg(ResponseCode::CommandOkay, "Mountall ran successfully", false); 304 return 0; 305 } 306 if (!strcmp(argv[1], "users")) { 307 DIR *dir; 308 struct dirent *de; 309 310 if (argc < 3) { 311 cli->sendMsg(ResponseCode::CommandSyntaxError, "Missing Argument: user <mountpoint>", false); 312 return 0; 313 } 314 if (!(dir = opendir("/proc"))) { 315 cli->sendMsg(ResponseCode::OperationFailed, "Failed to open /proc", true); 316 return 0; 317 } 318 319 while ((de = readdir(dir))) { 320 int pid = Process::getPid(de->d_name); 321 322 if (pid < 0) { 323 continue; 324 } 325 326 char processName[255]; 327 Process::getProcessName(pid, processName, sizeof(processName)); 328 329 if (Process::checkFileDescriptorSymLinks(pid, argv[2]) || 330 Process::checkFileMaps(pid, argv[2]) || 331 Process::checkSymLink(pid, argv[2], "cwd") || 332 Process::checkSymLink(pid, argv[2], "root") || 333 Process::checkSymLink(pid, argv[2], "exe")) { 334 335 char msg[1024]; 336 snprintf(msg, sizeof(msg), "%d %s", pid, processName); 337 cli->sendMsg(ResponseCode::StorageUsersListResult, msg, false); 338 } 339 } 340 closedir(dir); 341 cli->sendMsg(ResponseCode::CommandOkay, "Storage user list complete", false); 342 } else { 343 cli->sendMsg(ResponseCode::CommandSyntaxError, "Unknown storage cmd", false); 344 } 345 return 0; 346} 347 348CommandListener::AsecCmd::AsecCmd() : 349 VoldCommand("asec") { 350} 351 352void CommandListener::AsecCmd::listAsecsInDirectory(SocketClient *cli, const char *directory) { 353 DIR *d = opendir(directory); 354 355 if (!d) { 356 cli->sendMsg(ResponseCode::OperationFailed, "Failed to open asec dir", true); 357 return; 358 } 359 360 size_t dirent_len = offsetof(struct dirent, d_name) + 361 fpathconf(dirfd(d), _PC_NAME_MAX) + 1; 362 363 struct dirent *dent = (struct dirent *) malloc(dirent_len); 364 if (dent == NULL) { 365 cli->sendMsg(ResponseCode::OperationFailed, "Failed to allocate memory", true); 366 return; 367 } 368 369 struct dirent *result; 370 371 while (!readdir_r(d, dent, &result) && result != NULL) { 372 if (dent->d_name[0] == '.') 373 continue; 374 if (dent->d_type != DT_REG) 375 continue; 376 size_t name_len = strlen(dent->d_name); 377 if (name_len > 5 && name_len < 260 && 378 !strcmp(&dent->d_name[name_len - 5], ".asec")) { 379 char id[255]; 380 memset(id, 0, sizeof(id)); 381 strlcpy(id, dent->d_name, name_len - 4); 382 cli->sendMsg(ResponseCode::AsecListResult, id, false); 383 } 384 } 385 closedir(d); 386 387 free(dent); 388} 389 390int CommandListener::AsecCmd::runCommand(SocketClient *cli, 391 int argc, char **argv) { 392 if (argc < 2) { 393 cli->sendMsg(ResponseCode::CommandSyntaxError, "Missing Argument", false); 394 return 0; 395 } 396 397 VolumeManager *vm = VolumeManager::Instance(); 398 int rc = 0; 399 400 if (!strcmp(argv[1], "list")) { 401 dumpArgs(argc, argv, -1); 402 403 listAsecsInDirectory(cli, VolumeManager::SEC_ASECDIR_EXT); 404 listAsecsInDirectory(cli, VolumeManager::SEC_ASECDIR_INT); 405 } else if (!strcmp(argv[1], "create")) { 406 dumpArgs(argc, argv, 5); 407 if (argc != 8) { 408 cli->sendMsg(ResponseCode::CommandSyntaxError, 409 "Usage: asec create <container-id> <size_mb> <fstype> <key> <ownerUid> " 410 "<isExternal>", false); 411 return 0; 412 } 413 414 unsigned long numSectors = (atoi(argv[3]) * (1024 * 1024)) / 512; 415 const bool isExternal = (atoi(argv[7]) == 1); 416 rc = vm->createAsec(argv[2], numSectors, argv[4], argv[5], atoi(argv[6]), isExternal); 417 } else if (!strcmp(argv[1], "resize")) { 418 dumpArgs(argc, argv, -1); 419 if (argc != 5) { 420 cli->sendMsg(ResponseCode::CommandSyntaxError, "Usage: asec resize <container-id> <size_mb> <key>", false); 421 return 0; 422 } 423 unsigned long numSectors = (atoi(argv[3]) * (1024 * 1024)) / 512; 424 rc = vm->resizeAsec(argv[2], numSectors, argv[4]); 425 } else if (!strcmp(argv[1], "finalize")) { 426 dumpArgs(argc, argv, -1); 427 if (argc != 3) { 428 cli->sendMsg(ResponseCode::CommandSyntaxError, "Usage: asec finalize <container-id>", false); 429 return 0; 430 } 431 rc = vm->finalizeAsec(argv[2]); 432 } else if (!strcmp(argv[1], "fixperms")) { 433 dumpArgs(argc, argv, -1); 434 if (argc != 5) { 435 cli->sendMsg(ResponseCode::CommandSyntaxError, "Usage: asec fixperms <container-id> <gid> <filename>", false); 436 return 0; 437 } 438 439 char *endptr; 440 gid_t gid = (gid_t) strtoul(argv[3], &endptr, 10); 441 if (*endptr != '\0') { 442 cli->sendMsg(ResponseCode::CommandSyntaxError, "Usage: asec fixperms <container-id> <gid> <filename>", false); 443 return 0; 444 } 445 446 rc = vm->fixupAsecPermissions(argv[2], gid, argv[4]); 447 } else if (!strcmp(argv[1], "destroy")) { 448 dumpArgs(argc, argv, -1); 449 if (argc < 3) { 450 cli->sendMsg(ResponseCode::CommandSyntaxError, "Usage: asec destroy <container-id> [force]", false); 451 return 0; 452 } 453 bool force = false; 454 if (argc > 3 && !strcmp(argv[3], "force")) { 455 force = true; 456 } 457 rc = vm->destroyAsec(argv[2], force); 458 } else if (!strcmp(argv[1], "mount")) { 459 dumpArgs(argc, argv, 3); 460 if (argc != 6) { 461 cli->sendMsg(ResponseCode::CommandSyntaxError, 462 "Usage: asec mount <namespace-id> <key> <ownerUid> <ro|rw>", false); 463 return 0; 464 } 465 bool readOnly = true; 466 if (!strcmp(argv[5], "rw")) { 467 readOnly = false; 468 } 469 rc = vm->mountAsec(argv[2], argv[3], atoi(argv[4]), readOnly); 470 } else if (!strcmp(argv[1], "unmount")) { 471 dumpArgs(argc, argv, -1); 472 if (argc < 3) { 473 cli->sendMsg(ResponseCode::CommandSyntaxError, "Usage: asec unmount <container-id> [force]", false); 474 return 0; 475 } 476 bool force = false; 477 if (argc > 3 && !strcmp(argv[3], "force")) { 478 force = true; 479 } 480 rc = vm->unmountAsec(argv[2], force); 481 } else if (!strcmp(argv[1], "rename")) { 482 dumpArgs(argc, argv, -1); 483 if (argc != 4) { 484 cli->sendMsg(ResponseCode::CommandSyntaxError, 485 "Usage: asec rename <old_id> <new_id>", false); 486 return 0; 487 } 488 rc = vm->renameAsec(argv[2], argv[3]); 489 } else if (!strcmp(argv[1], "path")) { 490 dumpArgs(argc, argv, -1); 491 if (argc != 3) { 492 cli->sendMsg(ResponseCode::CommandSyntaxError, "Usage: asec path <container-id>", false); 493 return 0; 494 } 495 char path[255]; 496 497 if (!(rc = vm->getAsecMountPath(argv[2], path, sizeof(path)))) { 498 cli->sendMsg(ResponseCode::AsecPathResult, path, false); 499 return 0; 500 } 501 } else if (!strcmp(argv[1], "fspath")) { 502 dumpArgs(argc, argv, -1); 503 if (argc != 3) { 504 cli->sendMsg(ResponseCode::CommandSyntaxError, "Usage: asec fspath <container-id>", false); 505 return 0; 506 } 507 char path[255]; 508 509 if (!(rc = vm->getAsecFilesystemPath(argv[2], path, sizeof(path)))) { 510 cli->sendMsg(ResponseCode::AsecPathResult, path, false); 511 return 0; 512 } 513 } else { 514 dumpArgs(argc, argv, -1); 515 cli->sendMsg(ResponseCode::CommandSyntaxError, "Unknown asec cmd", false); 516 } 517 518 if (!rc) { 519 cli->sendMsg(ResponseCode::CommandOkay, "asec operation succeeded", false); 520 } else { 521 rc = ResponseCode::convertFromErrno(); 522 cli->sendMsg(rc, "asec operation failed", true); 523 } 524 525 return 0; 526} 527 528CommandListener::ObbCmd::ObbCmd() : 529 VoldCommand("obb") { 530} 531 532int CommandListener::ObbCmd::runCommand(SocketClient *cli, 533 int argc, char **argv) { 534 if (argc < 2) { 535 cli->sendMsg(ResponseCode::CommandSyntaxError, "Missing Argument", false); 536 return 0; 537 } 538 539 VolumeManager *vm = VolumeManager::Instance(); 540 int rc = 0; 541 542 if (!strcmp(argv[1], "list")) { 543 dumpArgs(argc, argv, -1); 544 545 rc = vm->listMountedObbs(cli); 546 } else if (!strcmp(argv[1], "mount")) { 547 dumpArgs(argc, argv, 3); 548 if (argc != 5) { 549 cli->sendMsg(ResponseCode::CommandSyntaxError, 550 "Usage: obb mount <filename> <key> <ownerGid>", false); 551 return 0; 552 } 553 rc = vm->mountObb(argv[2], argv[3], atoi(argv[4])); 554 } else if (!strcmp(argv[1], "unmount")) { 555 dumpArgs(argc, argv, -1); 556 if (argc < 3) { 557 cli->sendMsg(ResponseCode::CommandSyntaxError, "Usage: obb unmount <source file> [force]", false); 558 return 0; 559 } 560 bool force = false; 561 if (argc > 3 && !strcmp(argv[3], "force")) { 562 force = true; 563 } 564 rc = vm->unmountObb(argv[2], force); 565 } else if (!strcmp(argv[1], "path")) { 566 dumpArgs(argc, argv, -1); 567 if (argc != 3) { 568 cli->sendMsg(ResponseCode::CommandSyntaxError, "Usage: obb path <source file>", false); 569 return 0; 570 } 571 char path[255]; 572 573 if (!(rc = vm->getObbMountPath(argv[2], path, sizeof(path)))) { 574 cli->sendMsg(ResponseCode::AsecPathResult, path, false); 575 return 0; 576 } 577 } else { 578 dumpArgs(argc, argv, -1); 579 cli->sendMsg(ResponseCode::CommandSyntaxError, "Unknown obb cmd", false); 580 } 581 582 if (!rc) { 583 cli->sendMsg(ResponseCode::CommandOkay, "obb operation succeeded", false); 584 } else { 585 rc = ResponseCode::convertFromErrno(); 586 cli->sendMsg(rc, "obb operation failed", true); 587 } 588 589 return 0; 590} 591 592CommandListener::FstrimCmd::FstrimCmd() : 593 VoldCommand("fstrim") { 594} 595int CommandListener::FstrimCmd::runCommand(SocketClient *cli, 596 int argc, char **argv) { 597 if ((cli->getUid() != 0) && (cli->getUid() != AID_SYSTEM)) { 598 cli->sendMsg(ResponseCode::CommandNoPermission, "No permission to run fstrim commands", false); 599 return 0; 600 } 601 602 if (argc < 2) { 603 cli->sendMsg(ResponseCode::CommandSyntaxError, "Missing Argument", false); 604 return 0; 605 } 606 607 VolumeManager *vm = VolumeManager::Instance(); 608 std::lock_guard<std::mutex> lock(vm->getLock()); 609 610 int flags = 0; 611 612 std::string cmd(argv[1]); 613 if (cmd == "dotrim") { 614 flags = 0; 615 } else if (cmd == "dotrimbench") { 616 flags = android::vold::TrimTask::Flags::kBenchmarkAfter; 617 } else if (cmd == "dodtrim") { 618 flags = android::vold::TrimTask::Flags::kDeepTrim; 619 } else if (cmd == "dodtrimbench") { 620 flags = android::vold::TrimTask::Flags::kDeepTrim 621 | android::vold::TrimTask::Flags::kBenchmarkAfter; 622 } 623 624 (new android::vold::TrimTask(flags))->start(); 625 return sendGenericOkFail(cli, 0); 626} 627 628static size_t kAppFuseMaxMountPointName = 32; 629 630static android::status_t getMountPath(uid_t uid, const std::string& name, std::string* path) { 631 if (name.size() > kAppFuseMaxMountPointName) { 632 LOG(ERROR) << "AppFuse mount name is too long."; 633 return -EINVAL; 634 } 635 for (size_t i = 0; i < name.size(); i++) { 636 if (!isalnum(name[i])) { 637 LOG(ERROR) << "AppFuse mount name contains invalid character."; 638 return -EINVAL; 639 } 640 } 641 *path = android::base::StringPrintf("/mnt/appfuse/%d_%s", uid, name.c_str()); 642 return android::OK; 643} 644 645static android::status_t mountInNamespace(uid_t uid, int device_fd, const std::string& path) { 646 // Remove existing mount. 647 android::vold::ForceUnmount(path); 648 649 const auto opts = android::base::StringPrintf( 650 "fd=%i," 651 "rootmode=40000," 652 "default_permissions," 653 "allow_other," 654 "user_id=%d,group_id=%d," 655 "context=\"u:object_r:app_fuse_file:s0\"," 656 "fscontext=u:object_r:app_fusefs:s0", 657 device_fd, 658 uid, 659 uid); 660 661 const int result = TEMP_FAILURE_RETRY(mount( 662 "/dev/fuse", path.c_str(), "fuse", 663 MS_NOSUID | MS_NODEV | MS_NOEXEC | MS_NOATIME, opts.c_str())); 664 if (result != 0) { 665 PLOG(ERROR) << "Failed to mount " << path; 666 return -errno; 667 } 668 669 return android::OK; 670} 671 672static android::status_t runCommandInNamespace(const std::string& command, 673 uid_t uid, 674 pid_t pid, 675 const std::string& path, 676 int device_fd) { 677 LOG(DEBUG) << "Run app fuse command " << command << " for the path " << path << " in namespace " 678 << uid; 679 680 const android::vold::ScopedDir dir(opendir("/proc")); 681 if (dir.get() == nullptr) { 682 PLOG(ERROR) << "Failed to open /proc"; 683 return -errno; 684 } 685 686 // Obtains process file descriptor. 687 const std::string pid_str = android::base::StringPrintf("%d", pid); 688 const android::vold::ScopedFd pid_fd( 689 openat(dirfd(dir.get()), pid_str.c_str(), O_RDONLY | O_DIRECTORY | O_CLOEXEC)); 690 if (pid_fd.get() == -1) { 691 PLOG(ERROR) << "Failed to open /proc/" << pid; 692 return -errno; 693 } 694 695 // Check UID of process. 696 { 697 struct stat sb; 698 const int result = fstat(pid_fd.get(), &sb); 699 if (result == -1) { 700 PLOG(ERROR) << "Failed to stat /proc/" << pid; 701 return -errno; 702 } 703 if (sb.st_uid != uid) { 704 LOG(ERROR) << "Mismatch UID expected=" << uid << ", actual=" << sb.st_uid; 705 return -EPERM; 706 } 707 } 708 709 // Matches so far, but refuse to touch if in root namespace 710 { 711 char rootName[PATH_MAX]; 712 char pidName[PATH_MAX]; 713 const int root_result = 714 android::vold::SaneReadLinkAt(dirfd(dir.get()), "1/ns/mnt", rootName, PATH_MAX); 715 const int pid_result = 716 android::vold::SaneReadLinkAt(pid_fd.get(), "ns/mnt", pidName, PATH_MAX); 717 if (root_result == -1) { 718 LOG(ERROR) << "Failed to readlink for /proc/1/ns/mnt"; 719 return -EPERM; 720 } 721 if (pid_result == -1) { 722 LOG(ERROR) << "Failed to readlink for /proc/" << pid << "/ns/mnt"; 723 return -EPERM; 724 } 725 if (!strcmp(rootName, pidName)) { 726 LOG(ERROR) << "Don't mount appfuse in root namespace"; 727 return -EPERM; 728 } 729 } 730 731 // We purposefully leave the namespace open across the fork 732 android::vold::ScopedFd ns_fd(openat(pid_fd.get(), "ns/mnt", O_RDONLY)); 733 if (ns_fd.get() < 0) { 734 PLOG(ERROR) << "Failed to open namespace for /proc/" << pid << "/ns/mnt"; 735 return -errno; 736 } 737 738 int child = fork(); 739 if (child == 0) { 740 if (setns(ns_fd.get(), CLONE_NEWNS) != 0) { 741 PLOG(ERROR) << "Failed to setns"; 742 _exit(-errno); 743 } 744 745 if (command == "mount") { 746 _exit(mountInNamespace(uid, device_fd, path)); 747 } else if (command == "unmount") { 748 android::vold::ForceUnmount(path); 749 _exit(android::OK); 750 } else { 751 LOG(ERROR) << "Unknown appfuse command " << command; 752 _exit(-EPERM); 753 } 754 } 755 756 if (child == -1) { 757 PLOG(ERROR) << "Failed to folk child process"; 758 return -errno; 759 } 760 761 android::status_t status; 762 TEMP_FAILURE_RETRY(waitpid(child, &status, 0)); 763 764 return status; 765} 766 767CommandListener::AppFuseCmd::AppFuseCmd() : VoldCommand("appfuse") {} 768 769int CommandListener::AppFuseCmd::runCommand(SocketClient *cli, int argc, char **argv) { 770 if (argc < 2) { 771 cli->sendMsg(ResponseCode::CommandSyntaxError, "Missing argument", false); 772 return 0; 773 } 774 775 const std::string command(argv[1]); 776 777 if (command == "mount" && argc == 5) { 778 const uid_t uid = atoi(argv[2]); 779 const pid_t pid = atoi(argv[3]); 780 const std::string name(argv[4]); 781 782 // Check mount point name. 783 std::string path; 784 if (getMountPath(uid, name, &path) != android::OK) { 785 return cli->sendMsg(ResponseCode::CommandParameterError, 786 "Invalid mount point name.", 787 false); 788 } 789 790 // Create directories. 791 { 792 const android::status_t result = android::vold::PrepareDir(path, 0700, 0, 0); 793 if (result != android::OK) { 794 PLOG(ERROR) << "Failed to prepare directory " << path; 795 return sendGenericOkFail(cli, result); 796 } 797 } 798 799 // Open device FD. 800 android::vold::ScopedFd device_fd(open("/dev/fuse", O_RDWR)); 801 if (device_fd.get() == -1) { 802 PLOG(ERROR) << "Failed to open /dev/fuse"; 803 return sendGenericOkFail(cli, -errno); 804 } 805 806 // Mount. 807 { 808 const android::status_t result = 809 runCommandInNamespace(command, uid, pid, path, device_fd.get()); 810 if (result != android::OK) { 811 return sendGenericOkFail(cli, result); 812 } 813 } 814 815 return sendFd(cli, device_fd.get()); 816 } else if (command == "unmount" && argc == 5) { 817 const uid_t uid = atoi(argv[2]); 818 const uid_t pid = atoi(argv[3]); 819 const std::string name(argv[4]); 820 821 // Check mount point name. 822 std::string path; 823 if (getMountPath(uid, name, &path) != android::OK) { 824 return cli->sendMsg(ResponseCode::CommandParameterError, 825 "Invalid mount point name.", 826 false); 827 } 828 829 const android::status_t result = 830 runCommandInNamespace(command, uid, pid, path, -1 /* device_fd */); 831 return sendGenericOkFail(cli, result); 832 } 833 834 return cli->sendMsg(ResponseCode::CommandSyntaxError, "Unknown appfuse cmd", false); 835} 836 837android::status_t CommandListener::AppFuseCmd::sendFd(SocketClient *cli, int fd) { 838 struct iovec data; 839 char dataBuffer[128]; 840 char controlBuffer[CMSG_SPACE(sizeof(int))]; 841 struct msghdr message; 842 843 // Message. 844 memset(&message, 0, sizeof(struct msghdr)); 845 message.msg_iov = &data; 846 message.msg_iovlen = 1; 847 message.msg_control = controlBuffer; 848 message.msg_controllen = CMSG_SPACE(sizeof(int)); 849 850 // Data. 851 data.iov_base = dataBuffer; 852 data.iov_len = snprintf(dataBuffer, 853 sizeof(dataBuffer), 854 "200 %d AppFuse command succeeded", 855 cli->getCmdNum()) + 1; 856 857 // Control. 858 struct cmsghdr* const controlMessage = CMSG_FIRSTHDR(&message); 859 memset(controlBuffer, 0, CMSG_SPACE(sizeof(int))); 860 controlMessage->cmsg_level = SOL_SOCKET; 861 controlMessage->cmsg_type = SCM_RIGHTS; 862 controlMessage->cmsg_len = CMSG_LEN(sizeof(int)); 863 *((int *) CMSG_DATA(controlMessage)) = fd; 864 865 const int result = TEMP_FAILURE_RETRY(sendmsg(cli->getSocket(), &message, 0)); 866 if (result == -1) { 867 PLOG(ERROR) << "Failed to send FD from vold"; 868 return -errno; 869 } 870 871 return android::OK; 872} 873