Deprecating tracked_directories as a Vault parameter

cryptohome.cc

 // Copyright (c) 2009 The Chromium OS Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 // Cryptohome client that uses the dbus client interface
 
 #include <openssl/err.h>
 #include <openssl/evp.h>
 #include <openssl/rand.h>
 #include <openssl/sha.h>
@@ skipping 54 matching lines @@
     ACTION_REMOVE_TRACKED_SUBDIRS,
     ACTION_TPM_TAKE_OWNERSHIP,
     ACTION_TPM_CLEAR_STORED_PASSWORD,
     ACTION_TPM_WAIT_OWNERSHIP };
   static const char kUserSwitch[] = "user";
   static const char kPasswordSwitch[] = "password";
   static const char kOldPasswordSwitch[] = "old_password";
   static const char kForceSwitch[] = "force";
   static const char kAsyncSwitch[] = "async";
   static const char kCreateSwitch[] = "create";
-  static const char kTrackedDirsSwitch[] = "tracked_dirs";
 }  // namespace switches
 
 chromeos::Blob GetSystemSalt(const chromeos::dbus::Proxy& proxy) {
   chromeos::glib::ScopedError error;
   GArray* salt;
   if (!org_chromium_CryptohomeInterface_get_system_salt(proxy.gproxy(),
       &salt,
       &chromeos::Resetter(&error).lvalue())) {
     LOG(ERROR) << "GetSystemSalt failed: " << error->message;
     return chromeos::Blob();
@@ skipping 199 matching lines @@
 
     if (!GetUsername(cl, &user)) {
       printf("No username specified.\n");
       return 1;
     }
 
     GetPassword(proxy, cl, switches::kPasswordSwitch,
                 StringPrintf("Enter the password for <%s>", user.c_str()),
                 &password);
 
-    const char** tracked_subdirectories = NULL;
-    // Defined outside to keep the values in-scope for use in the functions
-    // below
-    std::vector<std::string> tracked_dirs;
-    if (cl->HasSwitch(switches::kTrackedDirsSwitch)) {
-      SplitString(cl->GetSwitchValueASCII(switches::kTrackedDirsSwitch), ',',
-                  &tracked_dirs);
-      tracked_subdirectories = new const char*[tracked_dirs.size() + 1];
-      int i = 0;
-      for (std::vector<std::string>::const_iterator itr = tracked_dirs.begin();
-           itr != tracked_dirs.end(); itr++, i++) {
-        tracked_subdirectories[i] = itr->c_str();
-      }
-      tracked_subdirectories[i] = NULL;
-    }
-
     gboolean done = false;
     gint mount_error = 0;
     chromeos::glib::ScopedError error;
 
     if (!cl->HasSwitch(switches::kAsyncSwitch)) {
       if (!org_chromium_CryptohomeInterface_mount(proxy.gproxy(),
                user.c_str(),
                password.c_str(),
                cl->HasSwitch(switches::kCreateSwitch),
-               (tracked_subdirectories != NULL),
-               tracked_subdirectories,
+               false,
+               NULL,
                &mount_error,
                &done,
                &chromeos::Resetter(&error).lvalue())) {
         printf("Mount call failed: %s, with reason code: %d.\n", error->message,
                mount_error);
       }
     } else {
       ClientLoop client_loop;
       client_loop.Initialize(proxy);
       gint async_id = -1;
       if (!org_chromium_CryptohomeInterface_async_mount(proxy.gproxy(),
                user.c_str(),
                password.c_str(),
                cl->HasSwitch(switches::kCreateSwitch),
-               (tracked_subdirectories != NULL),
-               tracked_subdirectories,
+               false,
+               NULL,
                &async_id,
                &chromeos::Resetter(&error).lvalue())) {
         printf("Mount call failed: %s.\n", error->message);
       } else {
         client_loop.Run(async_id);
         done = client_loop.get_return_status();
       }
     }
-    if (tracked_subdirectories) {
-      delete(tracked_subdirectories);
-    }
     if (!done) {
       printf("Mount failed.\n");
     } else {
       printf("Mount succeeded.\n");
     }
   } else if (!strcmp(switches::kActions[switches::ACTION_MOUNT_GUEST],
                 action.c_str())) {
     gboolean done = false;
     gint mount_error = 0;
     chromeos::glib::ScopedError error;
@@ skipping 234 matching lines @@
       blob.resize(serialized.tpm_public_key_hash().length());
       serialized.tpm_public_key_hash().copy(static_cast<char*>(blob.data()),
                                             serialized.tpm_key().length(), 0);
       printf("  TPM Public Key Hash:\n");
       printf("    %s\n", chromeos::AsciiEncode(blob).c_str());
     }
     if (serialized.has_password_rounds()) {
       printf("  Password rounds:\n");
       printf("    %d\n", serialized.password_rounds());
     }
-    if (serialized.tracked_subdirectories_size()) {
-      printf("  Tracked subdirectories:\n");
-      for (int index = 0; index < serialized.tracked_subdirectories_size();
-           index++) {
-        printf("    %s\n", serialized.tracked_subdirectories(index).c_str());
-      }
-    }
   } else if (!strcmp(switches::kActions[switches::ACTION_TPM_STATUS],
                      action.c_str())) {
     chromeos::glib::ScopedError error;
     gboolean result = false;
     if (!org_chromium_CryptohomeInterface_tpm_is_enabled(proxy.gproxy(),
         &result,
         &chromeos::Resetter(&error).lvalue())) {
       printf("TpmIsEnabled call failed: %s.\n", error->message);
     } else {
       printf("TPM Enabled: %s\n", (result ? "true" : "false"));
@@ skipping 98 matching lines @@
     printf("Unknown action or no action given.  Available actions:\n");
     for(int i = 0; /* loop forever */; i++) {
       if(!switches::kActions[i]) {
         break;
       }
       printf("  --action=%s\n", switches::kActions[i]);
     }
   }
   return 0;
 }