CommandListener.cpp revision 5a6bfca1638760b87cf64c5ffb48ff3557cc0563
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/socket.h> 19#include <sys/types.h> 20#include <netinet/in.h> 21#include <arpa/inet.h> 22#include <dirent.h> 23#include <errno.h> 24#include <fcntl.h> 25#include <fs_mgr.h> 26#include <stdio.h> 27#include <string.h> 28#include <stdint.h> 29#include <inttypes.h> 30 31#define LOG_TAG "VoldCmdListener" 32 33#include <base/stringprintf.h> 34#include <cutils/fs.h> 35#include <cutils/log.h> 36 37#include <sysutils/SocketClient.h> 38#include <private/android_filesystem_config.h> 39 40#include "CommandListener.h" 41#include "VolumeManager.h" 42#include "VolumeBase.h" 43#include "ResponseCode.h" 44#include "Process.h" 45#include "Loop.h" 46#include "Devmapper.h" 47#include "cryptfs.h" 48#include "fstrim.h" 49#include "MoveTask.h" 50 51#define DUMP_ARGS 0 52 53CommandListener::CommandListener() : 54 FrameworkListener("vold", true) { 55 registerCmd(new DumpCmd()); 56 registerCmd(new VolumeCmd()); 57 registerCmd(new AsecCmd()); 58 registerCmd(new ObbCmd()); 59 registerCmd(new StorageCmd()); 60 registerCmd(new CryptfsCmd()); 61 registerCmd(new FstrimCmd()); 62} 63 64#if DUMP_ARGS 65void CommandListener::dumpArgs(int argc, char **argv, int argObscure) { 66 char buffer[4096]; 67 char *p = buffer; 68 69 memset(buffer, 0, sizeof(buffer)); 70 int i; 71 for (i = 0; i < argc; i++) { 72 unsigned int len = strlen(argv[i]) + 1; // Account for space 73 if (i == argObscure) { 74 len += 2; // Account for {} 75 } 76 if (((p - buffer) + len) < (sizeof(buffer)-1)) { 77 if (i == argObscure) { 78 *p++ = '{'; 79 *p++ = '}'; 80 *p++ = ' '; 81 continue; 82 } 83 strcpy(p, argv[i]); 84 p+= strlen(argv[i]); 85 if (i != (argc -1)) { 86 *p++ = ' '; 87 } 88 } 89 } 90 SLOGD("%s", buffer); 91} 92#else 93void CommandListener::dumpArgs(int /*argc*/, char ** /*argv*/, int /*argObscure*/) { } 94#endif 95 96int CommandListener::sendGenericOkFail(SocketClient *cli, int cond) { 97 if (!cond) { 98 return cli->sendMsg(ResponseCode::CommandOkay, "Command succeeded", false); 99 } else { 100 return cli->sendMsg(ResponseCode::OperationFailed, "Command failed", false); 101 } 102} 103 104CommandListener::DumpCmd::DumpCmd() : 105 VoldCommand("dump") { 106} 107 108int CommandListener::DumpCmd::runCommand(SocketClient *cli, 109 int /*argc*/, char ** /*argv*/) { 110 cli->sendMsg(0, "Dumping loop status", false); 111 if (Loop::dumpState(cli)) { 112 cli->sendMsg(ResponseCode::CommandOkay, "Loop dump failed", true); 113 } 114 cli->sendMsg(0, "Dumping DM status", false); 115 if (Devmapper::dumpState(cli)) { 116 cli->sendMsg(ResponseCode::CommandOkay, "Devmapper dump failed", true); 117 } 118 cli->sendMsg(0, "Dumping mounted filesystems", false); 119 FILE *fp = fopen("/proc/mounts", "r"); 120 if (fp) { 121 char line[1024]; 122 while (fgets(line, sizeof(line), fp)) { 123 line[strlen(line)-1] = '\0'; 124 cli->sendMsg(0, line, false);; 125 } 126 fclose(fp); 127 } 128 129 cli->sendMsg(ResponseCode::CommandOkay, "dump complete", false); 130 return 0; 131} 132 133CommandListener::VolumeCmd::VolumeCmd() : 134 VoldCommand("volume") { 135} 136 137int CommandListener::VolumeCmd::runCommand(SocketClient *cli, 138 int argc, char **argv) { 139 dumpArgs(argc, argv, -1); 140 141 if (argc < 2) { 142 cli->sendMsg(ResponseCode::CommandSyntaxError, "Missing Argument", false); 143 return 0; 144 } 145 146 VolumeManager *vm = VolumeManager::Instance(); 147 std::lock_guard<std::mutex> lock(vm->getLock()); 148 149 // TODO: tease out methods not directly related to volumes 150 151 std::string cmd(argv[1]); 152 if (cmd == "reset") { 153 return sendGenericOkFail(cli, vm->reset()); 154 155 } else if (cmd == "shutdown") { 156 return sendGenericOkFail(cli, vm->shutdown()); 157 158 } else if (cmd == "debug") { 159 return sendGenericOkFail(cli, vm->setDebug(true)); 160 161 } else if (cmd == "partition" && argc > 3) { 162 // partition [diskId] [public|private|mixed] [ratio] 163 std::string id(argv[2]); 164 auto disk = vm->findDisk(id); 165 if (disk == nullptr) { 166 return cli->sendMsg(ResponseCode::CommandSyntaxError, "Unknown disk", false); 167 } 168 169 std::string type(argv[3]); 170 if (type == "public") { 171 return sendGenericOkFail(cli, disk->partitionPublic()); 172 } else if (type == "private") { 173 return sendGenericOkFail(cli, disk->partitionPrivate()); 174 } else if (type == "mixed") { 175 if (argc < 4) { 176 return cli->sendMsg(ResponseCode::CommandSyntaxError, nullptr, false); 177 } 178 int frac = atoi(argv[4]); 179 return sendGenericOkFail(cli, disk->partitionMixed(frac)); 180 } else { 181 return cli->sendMsg(ResponseCode::CommandSyntaxError, nullptr, false); 182 } 183 184 } else if (cmd == "mkdirs" && argc > 2) { 185 // mkdirs [path] 186 return sendGenericOkFail(cli, vm->mkdirs(argv[2])); 187 188 } else if (cmd == "start_user" && argc > 2) { 189 // start_user [user] 190 return sendGenericOkFail(cli, vm->startUser(atoi(argv[2]))); 191 192 } else if (cmd == "cleanup_user" && argc > 2) { 193 // cleanup_user [user] 194 return sendGenericOkFail(cli, vm->cleanupUser(atoi(argv[2]))); 195 196 } else if (cmd == "mount" && argc > 2) { 197 // mount [volId] [flags] [user] 198 std::string id(argv[2]); 199 auto vol = vm->findVolume(id); 200 if (vol == nullptr) { 201 return cli->sendMsg(ResponseCode::CommandSyntaxError, "Unknown volume", false); 202 } 203 204 int mountFlags = (argc > 3) ? atoi(argv[3]) : 0; 205 userid_t mountUserId = (argc > 4) ? atoi(argv[4]) : -1; 206 207 vol->setMountFlags(mountFlags); 208 vol->setMountUserId(mountUserId); 209 210 int res = vol->mount(); 211 if (mountFlags & android::vold::VolumeBase::MountFlags::kPrimary) { 212 vm->setPrimary(vol); 213 } 214 return sendGenericOkFail(cli, res); 215 216 } else if (cmd == "unmount" && argc > 2) { 217 // unmount [volId] 218 std::string id(argv[2]); 219 auto vol = vm->findVolume(id); 220 if (vol == nullptr) { 221 return cli->sendMsg(ResponseCode::CommandSyntaxError, "Unknown volume", false); 222 } 223 224 return sendGenericOkFail(cli, vol->unmount()); 225 226 } else if (cmd == "format" && argc > 2) { 227 // format [volId] 228 std::string id(argv[2]); 229 auto vol = vm->findVolume(id); 230 if (vol == nullptr) { 231 return cli->sendMsg(ResponseCode::CommandSyntaxError, "Unknown volume", false); 232 } 233 234 return sendGenericOkFail(cli, vol->format()); 235 236 } else if (cmd == "move_storage" && argc > 3) { 237 // move_storage [fromVolId] [toVolId] 238 auto fromVol = vm->findVolume(std::string(argv[2])); 239 auto toVol = vm->findVolume(std::string(argv[3])); 240 if (fromVol == nullptr || toVol == nullptr) { 241 return cli->sendMsg(ResponseCode::CommandSyntaxError, "Unknown volume", false); 242 } 243 244 (new android::vold::MoveTask(fromVol, toVol))->start(); 245 return sendGenericOkFail(cli, 0); 246 247 } else if (cmd == "benchmark" && argc > 2) { 248 // benchmark [volId] 249 std::string id(argv[2]); 250 nsecs_t res = vm->benchmarkVolume(id); 251 return cli->sendMsg(ResponseCode::CommandOkay, 252 android::base::StringPrintf("%" PRId64, res).c_str(), false); 253 } 254 255 return cli->sendMsg(ResponseCode::CommandSyntaxError, nullptr, false); 256} 257 258CommandListener::StorageCmd::StorageCmd() : 259 VoldCommand("storage") { 260} 261 262int CommandListener::StorageCmd::runCommand(SocketClient *cli, 263 int argc, char **argv) { 264 /* Guarantied to be initialized by vold's main() before the CommandListener is active */ 265 extern struct fstab *fstab; 266 267 dumpArgs(argc, argv, -1); 268 269 if (argc < 2) { 270 cli->sendMsg(ResponseCode::CommandSyntaxError, "Missing Argument", false); 271 return 0; 272 } 273 274 if (!strcmp(argv[1], "mountall")) { 275 if (argc != 2) { 276 cli->sendMsg(ResponseCode::CommandSyntaxError, "Usage: mountall", false); 277 return 0; 278 } 279 fs_mgr_mount_all(fstab); 280 cli->sendMsg(ResponseCode::CommandOkay, "Mountall ran successfully", false); 281 return 0; 282 } 283 if (!strcmp(argv[1], "users")) { 284 DIR *dir; 285 struct dirent *de; 286 287 if (argc < 3) { 288 cli->sendMsg(ResponseCode::CommandSyntaxError, "Missing Argument: user <mountpoint>", false); 289 return 0; 290 } 291 if (!(dir = opendir("/proc"))) { 292 cli->sendMsg(ResponseCode::OperationFailed, "Failed to open /proc", true); 293 return 0; 294 } 295 296 while ((de = readdir(dir))) { 297 int pid = Process::getPid(de->d_name); 298 299 if (pid < 0) { 300 continue; 301 } 302 303 char processName[255]; 304 Process::getProcessName(pid, processName, sizeof(processName)); 305 306 if (Process::checkFileDescriptorSymLinks(pid, argv[2]) || 307 Process::checkFileMaps(pid, argv[2]) || 308 Process::checkSymLink(pid, argv[2], "cwd") || 309 Process::checkSymLink(pid, argv[2], "root") || 310 Process::checkSymLink(pid, argv[2], "exe")) { 311 312 char msg[1024]; 313 snprintf(msg, sizeof(msg), "%d %s", pid, processName); 314 cli->sendMsg(ResponseCode::StorageUsersListResult, msg, false); 315 } 316 } 317 closedir(dir); 318 cli->sendMsg(ResponseCode::CommandOkay, "Storage user list complete", false); 319 } else { 320 cli->sendMsg(ResponseCode::CommandSyntaxError, "Unknown storage cmd", false); 321 } 322 return 0; 323} 324 325CommandListener::AsecCmd::AsecCmd() : 326 VoldCommand("asec") { 327} 328 329void CommandListener::AsecCmd::listAsecsInDirectory(SocketClient *cli, const char *directory) { 330 DIR *d = opendir(directory); 331 332 if (!d) { 333 cli->sendMsg(ResponseCode::OperationFailed, "Failed to open asec dir", true); 334 return; 335 } 336 337 size_t dirent_len = offsetof(struct dirent, d_name) + 338 fpathconf(dirfd(d), _PC_NAME_MAX) + 1; 339 340 struct dirent *dent = (struct dirent *) malloc(dirent_len); 341 if (dent == NULL) { 342 cli->sendMsg(ResponseCode::OperationFailed, "Failed to allocate memory", true); 343 return; 344 } 345 346 struct dirent *result; 347 348 while (!readdir_r(d, dent, &result) && result != NULL) { 349 if (dent->d_name[0] == '.') 350 continue; 351 if (dent->d_type != DT_REG) 352 continue; 353 size_t name_len = strlen(dent->d_name); 354 if (name_len > 5 && name_len < 260 && 355 !strcmp(&dent->d_name[name_len - 5], ".asec")) { 356 char id[255]; 357 memset(id, 0, sizeof(id)); 358 strlcpy(id, dent->d_name, name_len - 4); 359 cli->sendMsg(ResponseCode::AsecListResult, id, false); 360 } 361 } 362 closedir(d); 363 364 free(dent); 365} 366 367int CommandListener::AsecCmd::runCommand(SocketClient *cli, 368 int argc, char **argv) { 369 if (argc < 2) { 370 cli->sendMsg(ResponseCode::CommandSyntaxError, "Missing Argument", false); 371 return 0; 372 } 373 374 VolumeManager *vm = VolumeManager::Instance(); 375 int rc = 0; 376 377 if (!strcmp(argv[1], "list")) { 378 dumpArgs(argc, argv, -1); 379 380 listAsecsInDirectory(cli, VolumeManager::SEC_ASECDIR_EXT); 381 listAsecsInDirectory(cli, VolumeManager::SEC_ASECDIR_INT); 382 } else if (!strcmp(argv[1], "create")) { 383 dumpArgs(argc, argv, 5); 384 if (argc != 8) { 385 cli->sendMsg(ResponseCode::CommandSyntaxError, 386 "Usage: asec create <container-id> <size_mb> <fstype> <key> <ownerUid> " 387 "<isExternal>", false); 388 return 0; 389 } 390 391 unsigned int numSectors = (atoi(argv[3]) * (1024 * 1024)) / 512; 392 const bool isExternal = (atoi(argv[7]) == 1); 393 rc = vm->createAsec(argv[2], numSectors, argv[4], argv[5], atoi(argv[6]), isExternal); 394 } else if (!strcmp(argv[1], "resize")) { 395 dumpArgs(argc, argv, -1); 396 if (argc != 5) { 397 cli->sendMsg(ResponseCode::CommandSyntaxError, "Usage: asec resize <container-id> <size_mb> <key>", false); 398 return 0; 399 } 400 unsigned int numSectors = (atoi(argv[3]) * (1024 * 1024)) / 512; 401 rc = vm->resizeAsec(argv[2], numSectors, argv[4]); 402 } else if (!strcmp(argv[1], "finalize")) { 403 dumpArgs(argc, argv, -1); 404 if (argc != 3) { 405 cli->sendMsg(ResponseCode::CommandSyntaxError, "Usage: asec finalize <container-id>", false); 406 return 0; 407 } 408 rc = vm->finalizeAsec(argv[2]); 409 } else if (!strcmp(argv[1], "fixperms")) { 410 dumpArgs(argc, argv, -1); 411 if (argc != 5) { 412 cli->sendMsg(ResponseCode::CommandSyntaxError, "Usage: asec fixperms <container-id> <gid> <filename>", false); 413 return 0; 414 } 415 416 char *endptr; 417 gid_t gid = (gid_t) strtoul(argv[3], &endptr, 10); 418 if (*endptr != '\0') { 419 cli->sendMsg(ResponseCode::CommandSyntaxError, "Usage: asec fixperms <container-id> <gid> <filename>", false); 420 return 0; 421 } 422 423 rc = vm->fixupAsecPermissions(argv[2], gid, argv[4]); 424 } else if (!strcmp(argv[1], "destroy")) { 425 dumpArgs(argc, argv, -1); 426 if (argc < 3) { 427 cli->sendMsg(ResponseCode::CommandSyntaxError, "Usage: asec destroy <container-id> [force]", false); 428 return 0; 429 } 430 bool force = false; 431 if (argc > 3 && !strcmp(argv[3], "force")) { 432 force = true; 433 } 434 rc = vm->destroyAsec(argv[2], force); 435 } else if (!strcmp(argv[1], "mount")) { 436 dumpArgs(argc, argv, 3); 437 if (argc != 6) { 438 cli->sendMsg(ResponseCode::CommandSyntaxError, 439 "Usage: asec mount <namespace-id> <key> <ownerUid> <ro|rw>", false); 440 return 0; 441 } 442 bool readOnly = true; 443 if (!strcmp(argv[5], "rw")) { 444 readOnly = false; 445 } 446 rc = vm->mountAsec(argv[2], argv[3], atoi(argv[4]), readOnly); 447 } else if (!strcmp(argv[1], "unmount")) { 448 dumpArgs(argc, argv, -1); 449 if (argc < 3) { 450 cli->sendMsg(ResponseCode::CommandSyntaxError, "Usage: asec unmount <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->unmountAsec(argv[2], force); 458 } else if (!strcmp(argv[1], "rename")) { 459 dumpArgs(argc, argv, -1); 460 if (argc != 4) { 461 cli->sendMsg(ResponseCode::CommandSyntaxError, 462 "Usage: asec rename <old_id> <new_id>", false); 463 return 0; 464 } 465 rc = vm->renameAsec(argv[2], argv[3]); 466 } else if (!strcmp(argv[1], "path")) { 467 dumpArgs(argc, argv, -1); 468 if (argc != 3) { 469 cli->sendMsg(ResponseCode::CommandSyntaxError, "Usage: asec path <container-id>", false); 470 return 0; 471 } 472 char path[255]; 473 474 if (!(rc = vm->getAsecMountPath(argv[2], path, sizeof(path)))) { 475 cli->sendMsg(ResponseCode::AsecPathResult, path, false); 476 return 0; 477 } 478 } else if (!strcmp(argv[1], "fspath")) { 479 dumpArgs(argc, argv, -1); 480 if (argc != 3) { 481 cli->sendMsg(ResponseCode::CommandSyntaxError, "Usage: asec fspath <container-id>", false); 482 return 0; 483 } 484 char path[255]; 485 486 if (!(rc = vm->getAsecFilesystemPath(argv[2], path, sizeof(path)))) { 487 cli->sendMsg(ResponseCode::AsecPathResult, path, false); 488 return 0; 489 } 490 } else { 491 dumpArgs(argc, argv, -1); 492 cli->sendMsg(ResponseCode::CommandSyntaxError, "Unknown asec cmd", false); 493 } 494 495 if (!rc) { 496 cli->sendMsg(ResponseCode::CommandOkay, "asec operation succeeded", false); 497 } else { 498 rc = ResponseCode::convertFromErrno(); 499 cli->sendMsg(rc, "asec operation failed", true); 500 } 501 502 return 0; 503} 504 505CommandListener::ObbCmd::ObbCmd() : 506 VoldCommand("obb") { 507} 508 509int CommandListener::ObbCmd::runCommand(SocketClient *cli, 510 int argc, char **argv) { 511 if (argc < 2) { 512 cli->sendMsg(ResponseCode::CommandSyntaxError, "Missing Argument", false); 513 return 0; 514 } 515 516 VolumeManager *vm = VolumeManager::Instance(); 517 int rc = 0; 518 519 if (!strcmp(argv[1], "list")) { 520 dumpArgs(argc, argv, -1); 521 522 rc = vm->listMountedObbs(cli); 523 } else if (!strcmp(argv[1], "mount")) { 524 dumpArgs(argc, argv, 3); 525 if (argc != 5) { 526 cli->sendMsg(ResponseCode::CommandSyntaxError, 527 "Usage: obb mount <filename> <key> <ownerGid>", false); 528 return 0; 529 } 530 rc = vm->mountObb(argv[2], argv[3], atoi(argv[4])); 531 } else if (!strcmp(argv[1], "unmount")) { 532 dumpArgs(argc, argv, -1); 533 if (argc < 3) { 534 cli->sendMsg(ResponseCode::CommandSyntaxError, "Usage: obb unmount <source file> [force]", false); 535 return 0; 536 } 537 bool force = false; 538 if (argc > 3 && !strcmp(argv[3], "force")) { 539 force = true; 540 } 541 rc = vm->unmountObb(argv[2], force); 542 } else if (!strcmp(argv[1], "path")) { 543 dumpArgs(argc, argv, -1); 544 if (argc != 3) { 545 cli->sendMsg(ResponseCode::CommandSyntaxError, "Usage: obb path <source file>", false); 546 return 0; 547 } 548 char path[255]; 549 550 if (!(rc = vm->getObbMountPath(argv[2], path, sizeof(path)))) { 551 cli->sendMsg(ResponseCode::AsecPathResult, path, false); 552 return 0; 553 } 554 } else { 555 dumpArgs(argc, argv, -1); 556 cli->sendMsg(ResponseCode::CommandSyntaxError, "Unknown obb cmd", false); 557 } 558 559 if (!rc) { 560 cli->sendMsg(ResponseCode::CommandOkay, "obb operation succeeded", false); 561 } else { 562 rc = ResponseCode::convertFromErrno(); 563 cli->sendMsg(rc, "obb operation failed", true); 564 } 565 566 return 0; 567} 568 569CommandListener::CryptfsCmd::CryptfsCmd() : 570 VoldCommand("cryptfs") { 571} 572 573static int getType(const char* type) 574{ 575 if (!strcmp(type, "default")) { 576 return CRYPT_TYPE_DEFAULT; 577 } else if (!strcmp(type, "password")) { 578 return CRYPT_TYPE_PASSWORD; 579 } else if (!strcmp(type, "pin")) { 580 return CRYPT_TYPE_PIN; 581 } else if (!strcmp(type, "pattern")) { 582 return CRYPT_TYPE_PATTERN; 583 } else { 584 return -1; 585 } 586} 587 588int CommandListener::CryptfsCmd::runCommand(SocketClient *cli, 589 int argc, char **argv) { 590 if ((cli->getUid() != 0) && (cli->getUid() != AID_SYSTEM)) { 591 cli->sendMsg(ResponseCode::CommandNoPermission, "No permission to run cryptfs commands", false); 592 return 0; 593 } 594 595 if (argc < 2) { 596 cli->sendMsg(ResponseCode::CommandSyntaxError, "Missing Argument", false); 597 return 0; 598 } 599 600 int rc = 0; 601 602 if (!strcmp(argv[1], "checkpw")) { 603 if (argc != 3) { 604 cli->sendMsg(ResponseCode::CommandSyntaxError, "Usage: cryptfs checkpw <passwd>", false); 605 return 0; 606 } 607 dumpArgs(argc, argv, 2); 608 rc = cryptfs_check_passwd(argv[2]); 609 } else if (!strcmp(argv[1], "restart")) { 610 if (argc != 2) { 611 cli->sendMsg(ResponseCode::CommandSyntaxError, "Usage: cryptfs restart", false); 612 return 0; 613 } 614 dumpArgs(argc, argv, -1); 615 rc = cryptfs_restart(); 616 } else if (!strcmp(argv[1], "cryptocomplete")) { 617 if (argc != 2) { 618 cli->sendMsg(ResponseCode::CommandSyntaxError, "Usage: cryptfs cryptocomplete", false); 619 return 0; 620 } 621 dumpArgs(argc, argv, -1); 622 rc = cryptfs_crypto_complete(); 623 } else if (!strcmp(argv[1], "enablecrypto")) { 624 const char* syntax = "Usage: cryptfs enablecrypto <wipe|inplace> " 625 "default|password|pin|pattern [passwd]"; 626 if ( (argc != 4 && argc != 5) 627 || (strcmp(argv[2], "wipe") && strcmp(argv[2], "inplace")) ) { 628 cli->sendMsg(ResponseCode::CommandSyntaxError, syntax, false); 629 return 0; 630 } 631 dumpArgs(argc, argv, 4); 632 633 int tries; 634 for (tries = 0; tries < 2; ++tries) { 635 int type = getType(argv[3]); 636 if (type == -1) { 637 cli->sendMsg(ResponseCode::CommandSyntaxError, syntax, 638 false); 639 return 0; 640 } else if (type == CRYPT_TYPE_DEFAULT) { 641 rc = cryptfs_enable_default(argv[2], /*allow_reboot*/false); 642 } else { 643 rc = cryptfs_enable(argv[2], type, argv[4], 644 /*allow_reboot*/false); 645 } 646 647 if (rc == 0) { 648 break; 649 } else if (tries == 0) { 650 Process::killProcessesWithOpenFiles(DATA_MNT_POINT, SIGKILL); 651 } 652 } 653 } else if (!strcmp(argv[1], "changepw")) { 654 const char* syntax = "Usage: cryptfs changepw " 655 "default|password|pin|pattern [newpasswd]"; 656 const char* password; 657 if (argc == 3) { 658 password = ""; 659 } else if (argc == 4) { 660 password = argv[3]; 661 } else { 662 cli->sendMsg(ResponseCode::CommandSyntaxError, syntax, false); 663 return 0; 664 } 665 int type = getType(argv[2]); 666 if (type == -1) { 667 cli->sendMsg(ResponseCode::CommandSyntaxError, syntax, false); 668 return 0; 669 } 670 SLOGD("cryptfs changepw %s {}", argv[2]); 671 rc = cryptfs_changepw(type, password); 672 } else if (!strcmp(argv[1], "verifypw")) { 673 if (argc != 3) { 674 cli->sendMsg(ResponseCode::CommandSyntaxError, "Usage: cryptfs verifypw <passwd>", false); 675 return 0; 676 } 677 SLOGD("cryptfs verifypw {}"); 678 rc = cryptfs_verify_passwd(argv[2]); 679 } else if (!strcmp(argv[1], "getfield")) { 680 char *valbuf; 681 int valbuf_len = PROPERTY_VALUE_MAX; 682 683 if (argc != 3) { 684 cli->sendMsg(ResponseCode::CommandSyntaxError, "Usage: cryptfs getfield <fieldname>", false); 685 return 0; 686 } 687 dumpArgs(argc, argv, -1); 688 689 // Increase the buffer size until it is big enough for the field value stored. 690 while (1) { 691 valbuf = (char*)malloc(valbuf_len); 692 if (valbuf == NULL) { 693 cli->sendMsg(ResponseCode::OperationFailed, "Failed to allocate memory", false); 694 return 0; 695 } 696 rc = cryptfs_getfield(argv[2], valbuf, valbuf_len); 697 if (rc != CRYPTO_GETFIELD_ERROR_BUF_TOO_SMALL) { 698 break; 699 } 700 free(valbuf); 701 valbuf_len *= 2; 702 } 703 if (rc == CRYPTO_GETFIELD_OK) { 704 cli->sendMsg(ResponseCode::CryptfsGetfieldResult, valbuf, false); 705 } 706 free(valbuf); 707 } else if (!strcmp(argv[1], "setfield")) { 708 if (argc != 4) { 709 cli->sendMsg(ResponseCode::CommandSyntaxError, "Usage: cryptfs setfield <fieldname> <value>", false); 710 return 0; 711 } 712 dumpArgs(argc, argv, -1); 713 rc = cryptfs_setfield(argv[2], argv[3]); 714 } else if (!strcmp(argv[1], "mountdefaultencrypted")) { 715 SLOGD("cryptfs mountdefaultencrypted"); 716 dumpArgs(argc, argv, -1); 717 rc = cryptfs_mount_default_encrypted(); 718 } else if (!strcmp(argv[1], "getpwtype")) { 719 SLOGD("cryptfs getpwtype"); 720 dumpArgs(argc, argv, -1); 721 switch(cryptfs_get_password_type()) { 722 case CRYPT_TYPE_PASSWORD: 723 cli->sendMsg(ResponseCode::PasswordTypeResult, "password", false); 724 return 0; 725 case CRYPT_TYPE_PATTERN: 726 cli->sendMsg(ResponseCode::PasswordTypeResult, "pattern", false); 727 return 0; 728 case CRYPT_TYPE_PIN: 729 cli->sendMsg(ResponseCode::PasswordTypeResult, "pin", false); 730 return 0; 731 case CRYPT_TYPE_DEFAULT: 732 cli->sendMsg(ResponseCode::PasswordTypeResult, "default", false); 733 return 0; 734 default: 735 /** @TODO better error and make sure handled by callers */ 736 cli->sendMsg(ResponseCode::OpFailedStorageNotFound, "Error", false); 737 return 0; 738 } 739 } else if (!strcmp(argv[1], "getpw")) { 740 SLOGD("cryptfs getpw"); 741 dumpArgs(argc, argv, -1); 742 const char* password = cryptfs_get_password(); 743 if (password) { 744 char* message = 0; 745 int size = asprintf(&message, "{{sensitive}} %s", password); 746 if (size != -1) { 747 cli->sendMsg(ResponseCode::CommandOkay, message, false); 748 memset(message, 0, size); 749 free (message); 750 return 0; 751 } 752 } 753 rc = -1; 754 } else if (!strcmp(argv[1], "clearpw")) { 755 SLOGD("cryptfs clearpw"); 756 dumpArgs(argc, argv, -1); 757 cryptfs_clear_password(); 758 rc = 0; 759 } else { 760 dumpArgs(argc, argv, -1); 761 cli->sendMsg(ResponseCode::CommandSyntaxError, "Unknown cryptfs cmd", false); 762 return 0; 763 } 764 765 // Always report that the command succeeded and return the error code. 766 // The caller will check the return value to see what the error was. 767 char msg[255]; 768 snprintf(msg, sizeof(msg), "%d", rc); 769 cli->sendMsg(ResponseCode::CommandOkay, msg, false); 770 771 return 0; 772} 773 774CommandListener::FstrimCmd::FstrimCmd() : 775 VoldCommand("fstrim") { 776} 777int CommandListener::FstrimCmd::runCommand(SocketClient *cli, 778 int argc, char **argv) { 779 if ((cli->getUid() != 0) && (cli->getUid() != AID_SYSTEM)) { 780 cli->sendMsg(ResponseCode::CommandNoPermission, "No permission to run fstrim commands", false); 781 return 0; 782 } 783 784 if (argc < 2) { 785 cli->sendMsg(ResponseCode::CommandSyntaxError, "Missing Argument", false); 786 return 0; 787 } 788 789 int rc = 0; 790 791 if (!strcmp(argv[1], "dotrim")) { 792 if (argc != 2) { 793 cli->sendMsg(ResponseCode::CommandSyntaxError, "Usage: fstrim dotrim", false); 794 return 0; 795 } 796 dumpArgs(argc, argv, -1); 797 rc = fstrim_filesystems(0); 798 } else if (!strcmp(argv[1], "dodtrim")) { 799 if (argc != 2) { 800 cli->sendMsg(ResponseCode::CommandSyntaxError, "Usage: fstrim dodtrim", false); 801 return 0; 802 } 803 dumpArgs(argc, argv, -1); 804 rc = fstrim_filesystems(1); /* Do Deep Discard trim */ 805 } else { 806 dumpArgs(argc, argv, -1); 807 cli->sendMsg(ResponseCode::CommandSyntaxError, "Unknown fstrim cmd", false); 808 } 809 810 // Always report that the command succeeded and return the error code. 811 // The caller will check the return value to see what the error was. 812 char msg[255]; 813 snprintf(msg, sizeof(msg), "%d", rc); 814 cli->sendMsg(ResponseCode::CommandOkay, msg, false); 815 816 return 0; 817} 818