vold: Bloat reduction

Signed-off-by: San Mehat <san@google.com>

1 files changed, 169 insertions, 265 deletions

diff --git a/CommandListener.cpp b/CommandListener.cpp
index e5ebb46..bb503d3 100644
--- a/CommandListener.cpp
+++ b/CommandListener.cpp
@@ -33,60 +33,69 @@
 
 CommandListener::CommandListener() :
                  FrameworkListener("vold") {
-    registerCmd(new ListVolumesCmd());
-    registerCmd(new MountCmd());
-    registerCmd(new UnmountCmd());
+    registerCmd(new VolumeCmd());
+    registerCmd(new AsecCmd());
     registerCmd(new ShareCmd());
-    registerCmd(new UnshareCmd());
-    registerCmd(new ShareAvailableCmd());
-    registerCmd(new SimulateCmd());
-    registerCmd(new FormatCmd());
-    registerCmd(new CreateAsecCmd());
-    registerCmd(new FinalizeAsecCmd());
-    registerCmd(new DestroyAsecCmd());
-    registerCmd(new MountAsecCmd());
-    registerCmd(new UnmountAsecCmd());
-    registerCmd(new RenameAsecCmd());
-    registerCmd(new ListAsecCmd());
-    registerCmd(new AsecPathCmd());
 }
 
-CommandListener::ListVolumesCmd::ListVolumesCmd() :
-                 VoldCommand("list_volumes") {
+CommandListener::VolumeCmd::VolumeCmd() :
+                 VoldCommand("volume") {
 }
 
-int CommandListener::ListVolumesCmd::runCommand(SocketClient *cli,
+int CommandListener::VolumeCmd::runCommand(SocketClient *cli,
                                                       int argc, char **argv) {
-    return VolumeManager::Instance()->listVolumes(cli);
-}
-
-CommandListener::MountCmd::MountCmd() :
-                 VoldCommand("mount") {
-}
+    if (argc < 2) {
+        cli->sendMsg(ResponseCode::CommandSyntaxError, "Missing Argument", false);
+        return 0;
+    }
 
-int CommandListener::MountCmd::runCommand(SocketClient *cli,
-                                                      int argc, char **argv) {
-    /* Synchronously mount a volume */
-    if (VolumeManager::Instance()->mountVolume(argv[1])) {
-        cli->sendMsg(ResponseCode::OperationFailed, "Failed to mount volume.", true);
+    VolumeManager *vm = VolumeManager::Instance();
+    int rc = 0;
+
+    if (!strcmp(argv[1], "list")) {
+        return vm->listVolumes(cli);
+    } else if (!strcmp(argv[1], "mount")) {
+        rc = vm->mountVolume(argv[2]);
+    } else if (!strcmp(argv[1], "unmount")) {
+        rc = vm->unmountVolume(argv[2]);
+    } else if (!strcmp(argv[1], "format")) {
+        rc = vm->formatVolume(argv[2]);
+    } else if (!strcmp(argv[1], "share")) {
+        rc = vm->shareVolume(argv[1], argv[2]);
+    } else if (!strcmp(argv[1], "unshare")) {
+        rc = vm->unshareVolume(argv[1], argv[2]);
+    } else if (!strcmp(argv[1], "shared")) {
+        bool enabled = false;
+
+        if (vm->shareEnabled(argv[1], argv[2], &enabled)) {
+            cli->sendMsg(
+                    ResponseCode::OperationFailed, "Failed to determine share enable state", true);
+        } else {
+            cli->sendMsg(ResponseCode::ShareEnabledResult,
+                    (enabled ? "Share enabled" : "Share disabled"), false);
+        }
     } else {
-        cli->sendMsg(ResponseCode::CommandOkay, "Volume mounted.", false);
+        cli->sendMsg(ResponseCode::CommandSyntaxError, "Unknown volume cmd", false);
     }
 
-    return 0;
-}
-
-CommandListener::UnmountCmd::UnmountCmd() :
-                 VoldCommand("unmount") {
-}
-
-int CommandListener::UnmountCmd::runCommand(SocketClient *cli,
-                                                      int argc, char **argv) {
-    /* Synchronously unmount a volume */
-    if (VolumeManager::Instance()->unmountVolume(argv[1])) {
-        cli->sendMsg(ResponseCode::OperationFailed, "Failed to unmount volume.", true);
+    if (!rc) {
+        cli->sendMsg(ResponseCode::CommandOkay, "volume operation succeeded", false);
     } else {
-        cli->sendMsg(ResponseCode::CommandOkay, "Volume unmounted.", false);
+        /*
+         * Failed
+         */
+        if (errno == ENODEV) {
+            rc = ResponseCode::OpFailedNoMedia;
+        } else if (errno == ENODATA) {
+            rc = ResponseCode::OpFailedMediaBlank;
+        } else if (errno == EIO) {
+            rc = ResponseCode::OpFailedMediaCorrupt;
+        } else if (errno == EBUSY) {
+            rc = ResponseCode::OpFailedVolBusy;
+        } else {
+            rc = ResponseCode::OperationFailed;
+        }
+        cli->sendMsg(rc, "volume operation failed", true);
     }
 
     return 0;
@@ -98,254 +107,149 @@ CommandListener::ShareCmd::ShareCmd() :
 
 int CommandListener::ShareCmd::runCommand(SocketClient *cli,
                                                       int argc, char **argv) {
-    if (VolumeManager::Instance()->shareVolume(argv[1], argv[2])) {
-        cli->sendMsg(ResponseCode::OperationFailed, "Failed to share volume.", true);
-    } else {
-        cli->sendMsg(ResponseCode::CommandOkay, "Volume shared.", false);
-    }
-
-    return 0;
-}
-
-CommandListener::UnshareCmd::UnshareCmd() :
-                 VoldCommand("unshare") {
-}
-
-int CommandListener::UnshareCmd::runCommand(SocketClient *cli,
-                                                      int argc, char **argv) {
-    if (VolumeManager::Instance()->unshareVolume(argv[1], argv[2])) {
-        cli->sendMsg(ResponseCode::OperationFailed, "Failed to unshare volume.", true);
-    } else {
-        cli->sendMsg(ResponseCode::CommandOkay, "Volume unshared.", false);
-    }
-
-    return 0;
-}
-
-CommandListener::ShareAvailableCmd::ShareAvailableCmd() :
-                 VoldCommand("share_available") {
-}
-
-int CommandListener::ShareAvailableCmd::runCommand(SocketClient *cli,
-                                                      int argc, char **argv) {
-    bool avail = false;
-
-    if (VolumeManager::Instance()->shareAvailable(argv[1], &avail)) {
-        cli->sendMsg(ResponseCode::OperationFailed,
-                     "Failed to determine share availability", true);
-    } else {
-        cli->sendMsg(ResponseCode::ShareAvailabilityResult,
-                     (avail ? "Share available" : "Share unavailable"),
-                     false);
-    }
-    return 0;
-}
-
-CommandListener::SimulateCmd::SimulateCmd() :
-                 VoldCommand("simulate") {
-}
-
-int CommandListener::SimulateCmd::runCommand(SocketClient *cli,
-                                            int argc, char **argv) {
-    if (VolumeManager::Instance()->simulate(argv[1], argv[2])) {
-        cli->sendMsg(ResponseCode::OperationFailed, "Failed to execute.", true);
-    } else {
-        cli->sendMsg(ResponseCode::CommandOkay, "Simulation executed.", false);
-    }
-
-    return 0;
-}
-
-CommandListener::FormatCmd::FormatCmd() :
-                 VoldCommand("format") {
-}
-
-int CommandListener::FormatCmd::runCommand(SocketClient *cli,
-                                            int argc, char **argv) {
-    if (VolumeManager::Instance()->formatVolume(argv[1])) {
-        cli->sendMsg(ResponseCode::OperationFailed, "Failed to format", true);
-    } else {
-        cli->sendMsg(ResponseCode::CommandOkay, "Volume formatted.", false);
-    }
-
-    return 0;
-}
-
-CommandListener::CreateAsecCmd::CreateAsecCmd() :
-                 VoldCommand("create_asec") {
-}
-
-int CommandListener::CreateAsecCmd::runCommand(SocketClient *cli,
-                                            int argc, char **argv) {
-    if (argc != 6) {
-        cli->sendMsg(ResponseCode::CommandSyntaxError,
-                     "Usage: create_asec <namespace-id> <size_mb> <fstype> <key> <ownerUid>",
-                     false);
+    if (argc < 2) {
+        cli->sendMsg(ResponseCode::CommandSyntaxError, "Missing Argument", false);
         return 0;
     }
 
-    unsigned int numSectors = (atoi(argv[2]) * (1024 * 1024)) / 512;
-    if (VolumeManager::Instance()->createAsec(argv[1], numSectors,
-                                              argv[3], argv[4],
-                                              atoi(argv[5]))) {
-        cli->sendMsg(ResponseCode::OperationFailed, "Container creation failed", true);
-    } else {
-        cli->sendMsg(ResponseCode::CommandOkay, "Container created", false);
-    }
+    VolumeManager *vm = VolumeManager::Instance();
+    int rc = 0;
 
-    return 0;
-}
+    if (!strcmp(argv[1], "status")) {
+        bool avail = false;
 
-CommandListener::FinalizeAsecCmd::FinalizeAsecCmd() :
-                 VoldCommand("finalize_asec") {
-}
-
-int CommandListener::FinalizeAsecCmd::runCommand(SocketClient *cli,
-                                            int argc, char **argv) {
-    if (argc != 2) {
-        cli->sendMsg(ResponseCode::CommandSyntaxError,
-                     "Usage: finalize_asec <namespace-id>", false);
-        return 0;
-    }
-
-    if (VolumeManager::Instance()->finalizeAsec(argv[1])) {
-        cli->sendMsg(ResponseCode::OperationFailed, "Container finalize failed", true);
-    } else {
-        cli->sendMsg(ResponseCode::CommandOkay, "Container finalized", false);
-    }
-    return 0;
-}
-
-CommandListener::DestroyAsecCmd::DestroyAsecCmd() :
-                 VoldCommand("destroy_asec") {
-}
-
-int CommandListener::DestroyAsecCmd::runCommand(SocketClient *cli,
-                                            int argc, char **argv) {
-    if (argc != 2) {
-        cli->sendMsg(ResponseCode::CommandSyntaxError,
-                     "Usage: destroy_asec <namespace-id>", false);
-        return 0;
-    }
-
-    if (VolumeManager::Instance()->destroyAsec(argv[1])) {
-        cli->sendMsg(ResponseCode::OperationFailed, "Destroy failed", true);
-    } else {
-        cli->sendMsg(ResponseCode::CommandOkay, "Container Destroyed", false);
-    }
-    return 0;
-}
-
-CommandListener::MountAsecCmd::MountAsecCmd() :
-                 VoldCommand("mount_asec") {
-}
-
-int CommandListener::MountAsecCmd::runCommand(SocketClient *cli,
-                                            int argc, char **argv) {
-    if (argc != 4) {
-        cli->sendMsg(ResponseCode::CommandSyntaxError,
-                     "Usage: mount_asec <namespace-id> <key> <ownerUid>", false);
-        return 0;
-    }
-
-    if (VolumeManager::Instance()->mountAsec(argv[1], argv[2], atoi(argv[3]))) {
-        cli->sendMsg(ResponseCode::OperationFailed, "Mount failed", true);
+        if (vm->shareAvailable(argv[2], &avail)) {
+            cli->sendMsg(
+                    ResponseCode::OperationFailed, "Failed to determine share availability", true);
+        } else {
+            cli->sendMsg(ResponseCode::ShareStatusResult,
+                    (avail ? "Share available" : "Share unavailable"), false);
+        }
     } else {
-        cli->sendMsg(ResponseCode::CommandOkay, "Mount succeeded", false);
+        cli->sendMsg(ResponseCode::CommandSyntaxError, "Unknown share cmd", false);
     }
-    return 0;
-}
-
-CommandListener::UnmountAsecCmd::UnmountAsecCmd() :
-                 VoldCommand("unmount_asec") {
-}
 
-int CommandListener::UnmountAsecCmd::runCommand(SocketClient *cli,
-                                            int argc, char **argv) {
-    if (argc != 2) {
-        cli->sendMsg(ResponseCode::CommandSyntaxError,
-                     "Usage: unmount_asec <namespace-id>", false);
-        return 0;
-    }
-
-    if (VolumeManager::Instance()->unmountAsec(argv[1])) {
-        cli->sendMsg(ResponseCode::OperationFailed, "Unmount failed", true);
-    } else {
-        cli->sendMsg(ResponseCode::CommandOkay, "Unmount succeeded", false);
-    }
     return 0;
 }
 
-CommandListener::RenameAsecCmd::RenameAsecCmd() :
-                 VoldCommand("rename_asec") {
+CommandListener::AsecCmd::AsecCmd() :
+                 VoldCommand("asec") {
 }
 
-int CommandListener::RenameAsecCmd::runCommand(SocketClient *cli,
-                                            int argc, char **argv) {
-    if (argc != 3) {
-        cli->sendMsg(ResponseCode::CommandSyntaxError,
-                     "Usage: rename_asec <id1> <id2>", false);
+int CommandListener::AsecCmd::runCommand(SocketClient *cli,
+                                                      int argc, char **argv) {
+    if (argc < 2) {
+        cli->sendMsg(ResponseCode::CommandSyntaxError, "Missing Argument", false);
         return 0;
     }
 
-    if (VolumeManager::Instance()->renameAsec(argv[1], argv[2])) {
-        cli->sendMsg(ResponseCode::OperationFailed, "Rename failed", true);
-    } else {
-        cli->sendMsg(ResponseCode::CommandOkay, "Rename succeeded", false);
-    }
-    return 0;
-}
-
-CommandListener::ListAsecCmd::ListAsecCmd() :
-                 VoldCommand("list_asec") {
-
-}
+    VolumeManager *vm = VolumeManager::Instance();
+    int rc = 0;
 
-int CommandListener::ListAsecCmd::runCommand(SocketClient *cli,
-                                            int argc, char **argv) {
-    DIR *d = opendir("/sdcard/android_secure");
+    if (!strcmp(argv[1], "list")) {
+        DIR *d = opendir("/sdcard/android_secure");
 
-    if (!d) {
-        cli->sendMsg(ResponseCode::OperationFailed, "Failed to open asec dir", true);
-        return 0;  
-    }
+        if (!d) {
+            cli->sendMsg(ResponseCode::OperationFailed, "Failed to open asec dir", true);
+            return 0;
+        }
 
-    struct dirent *dent;
-    while ((dent = readdir(d))) {
-        if (dent->d_name[0] == '.')
-            continue;
-        if (!strcmp(&dent->d_name[strlen(dent->d_name)-5], ".asec")) {
-            char id[255];
-            memset(id, 0, sizeof(id));
-            strncpy(id, dent->d_name, strlen(dent->d_name) -5);
-            cli->sendMsg(ResponseCode::AsecListResult, id, false);
+        struct dirent *dent;
+        while ((dent = readdir(d))) {
+            if (dent->d_name[0] == '.')
+                continue;
+            if (!strcmp(&dent->d_name[strlen(dent->d_name)-5], ".asec")) {
+                char id[255];
+                memset(id, 0, sizeof(id));
+                strncpy(id, dent->d_name, strlen(dent->d_name) -5);
+                cli->sendMsg(ResponseCode::AsecListResult, id, false);
+            }
+        }
+        closedir(d);
+        cli->sendMsg(ResponseCode::CommandOkay, "ASEC listing complete", false);
+    } else if (!strcmp(argv[1], "create")) {
+        if (argc != 7) {
+            cli->sendMsg(ResponseCode::CommandSyntaxError,
+                    "Usage: asec create <container-id> <size_mb> <fstype> <key> <ownerUid>", false);
+            return 0;
         }
-    }
-    closedir(d);
-    cli->sendMsg(ResponseCode::CommandOkay, "ASEC listing complete", false);
 
-    return 0;
-}
+        unsigned int numSectors = (atoi(argv[3]) * (1024 * 1024)) / 512;
+        if (vm->createAsec(argv[2], numSectors, argv[4], argv[5], atoi(argv[6]))) {
+            cli->sendMsg(ResponseCode::OperationFailed, "Container creation failed", true);
+        } else {
+            cli->sendMsg(ResponseCode::CommandOkay, "Container created", false);
+        }
+    } else if (!strcmp(argv[1], "finalize")) {
+        if (argc != 3) {
+            cli->sendMsg(ResponseCode::CommandSyntaxError, "Usage: asec finalize <container-id>", false);
+            return 0;
+        }
+        if (vm->finalizeAsec(argv[2])) {
+            cli->sendMsg(ResponseCode::OperationFailed, "Container finalize failed", true);
+        } else {
+            cli->sendMsg(ResponseCode::CommandOkay, "Container finalized", false);
+        }
+    } else if (!strcmp(argv[1], "destroy")) {
+        if (argc != 3) {
+            cli->sendMsg(ResponseCode::CommandSyntaxError, "Usage: asec destroy <container-id>", false);
+            return 0;
+        }
+        if (vm->destroyAsec(argv[2])) {
+            cli->sendMsg(ResponseCode::OperationFailed, "Container destroy failed", true);
+        } else {
+            cli->sendMsg(ResponseCode::CommandOkay, "Container destroyed", false);
+        }
+    } else if (!strcmp(argv[1], "mount")) {
+        if (argc != 5) {
+            cli->sendMsg(ResponseCode::CommandSyntaxError,
+                    "Usage: asec mount <namespace-id> <key> <ownerUid>", false);
+            return 0;
+        }
 
-CommandListener::AsecPathCmd::AsecPathCmd() :
-                 VoldCommand("asec_path") {
-}
+        int rc = vm->mountAsec(argv[2], argv[3], atoi(argv[4]));
 
-int CommandListener::AsecPathCmd::runCommand(SocketClient *cli,
-                                            int argc, char **argv) {
-    if (argc != 2) {
-        cli->sendMsg(ResponseCode::CommandSyntaxError,
-                     "Usage: asec_path <namespace-id>", false);
-        return 0;
-    }
+        if (rc < 0) {
+            cli->sendMsg(ResponseCode::OperationFailed, "Mount failed", true);
+        } else {
+            cli->sendMsg(ResponseCode::CommandOkay, "Mount succeeded", false);
+        }
 
-    char mountPath[255];
+    } else if (!strcmp(argv[1], "unmount")) {
+        if (argc != 3) {
+            cli->sendMsg(ResponseCode::CommandSyntaxError, "Usage: asec unmount <container-id>", false);
+            return 0;
+        }
+        if (vm->unmountAsec(argv[2])) {
+            cli->sendMsg(ResponseCode::OperationFailed, "Container unmount failed", true);
+        } else {
+            cli->sendMsg(ResponseCode::CommandOkay, "Container unmounted", false);
+        }
+    } else if (!strcmp(argv[1], "rename")) {
+        if (argc != 4) {
+            cli->sendMsg(ResponseCode::CommandSyntaxError,
+                    "Usage: asec rename <old_id> <new_id>", false);
+            return 0;
+        }
+        if (vm->renameAsec(argv[2], argv[3])) {
+            cli->sendMsg(ResponseCode::OperationFailed, "Container rename failed", true);
+        } else {
+            cli->sendMsg(ResponseCode::CommandOkay, "Container renamed", false);
+        }
+    } else if (!strcmp(argv[1], "path")) {
+        if (argc != 3) {
+            cli->sendMsg(ResponseCode::CommandSyntaxError, "Usage: asec path <container-id>", false);
+            return 0;
+        }
+        char path[255];
 
-    if (VolumeManager::Instance()->getAsecMountPath(argv[1], mountPath,
-                                                    sizeof(mountPath))) {
-        cli->sendMsg(ResponseCode::OperationFailed, "Failed to get mount path", true);
+        if (vm->getAsecMountPath(argv[2], path, sizeof(path))) {
+            cli->sendMsg(ResponseCode::OperationFailed, "Failed to get path", true);
+        } else {
+            cli->sendMsg(ResponseCode::AsecPathResult, path, false);
+        }
     } else {
-        cli->sendMsg(ResponseCode::AsecPathResult, mountPath, false);
+        cli->sendMsg(ResponseCode::CommandSyntaxError, "Unknown asec cmd", false);
     }
 
     return 0;