[login_manager] Clean up error message logging/glib error reporting

session_manager_service.cc

 // Copyright (c) 2009-2010 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.
 
 #include "login_manager/session_manager_service.h"
 
 #include <dbus/dbus-glib-lowlevel.h>
 #include <errno.h>
 #include <glib.h>
 #include <grp.h>
@@ skipping 447 matching lines @@
   }
 
   return FALSE;
 }
 
 gboolean SessionManagerService::StartSession(gchar* email_address,
                                              gchar* unique_identifier,
                                              gboolean* OUT_done,
                                              GError** error) {
   if (session_started_) {
-    SetGError(error,
-              CHROMEOS_LOGIN_ERROR_SESSION_EXISTS,
-              "Can't start a session while a session is already active.");
-    *OUT_done = FALSE;
-    return FALSE;
+    const char msg[] = "Can't start session while session is already active.";
+    LOG(ERROR) << msg;
+    SetGError(error, CHROMEOS_LOGIN_ERROR_SESSION_EXISTS, msg);
+    return *OUT_done = FALSE;
   }
   if (!ValidateAndCacheUserEmail(email_address, error)) {
     *OUT_done = FALSE;
     return FALSE;
   }
   // If the current user is the owner, and isn't whitelisted or set
   // as the cros.device.owner pref, then do so.  This attempt only succeeds
   // if the current user has access to the private half of the owner's
   // registered public key.
   StoreOwnerProperties(NULL);
@@ skipping 108 matching lines @@
                   NULL);
   // TODO(cmasone): re-enable these when we try to enable logout without exiting
   //                the session manager
   // child_job_->StopSession();
   // session_started_ = false;
   return *OUT_done = TRUE;
 }
 
 gboolean SessionManagerService::SetOwnerKey(GArray* public_key_der,
                                             GError** error) {
-  SetGError(error,
-            CHROMEOS_LOGIN_ERROR_ILLEGAL_PUBKEY,
-            "The session_manager now sets the Owner's public key.");
+  const char msg[] = "The session_manager now sets the Owner's public key.";
+  LOG(ERROR) << msg;
+  SetGError(error, CHROMEOS_LOGIN_ERROR_ILLEGAL_PUBKEY, msg);
   // Just to be safe, send back a nACK in addition to returning an error.
   SendSignal(chromium::kOwnerKeySetSignal, false);
   return FALSE;
 }
 
 gboolean SessionManagerService::Unwhitelist(gchar* email_address,
                                             GArray* signature,
                                             GError** error) {
   LOG(INFO) << "Unwhitelisting " << email_address;
   if (!key_->IsPopulated()) {
-    SetGError(error,
-              CHROMEOS_LOGIN_ERROR_NO_OWNER_KEY,
-              "Attempt to unwhitelist before owner's key is set.");
+    const char msg[] = "Attempt to unwhitelist before owner's key is set.";
+    LOG(ERROR) << msg;
+    SetGError(error, CHROMEOS_LOGIN_ERROR_NO_OWNER_KEY, msg);
     return FALSE;
   }
   if (!key_->Verify(email_address,
                     strlen(email_address),
                     signature->data,
                     signature->len)) {
-    SetGError(error,
-              CHROMEOS_LOGIN_ERROR_VERIFY_FAIL,
-              "Signature could not be verified in Unwhitelist.");
+    const char msg[] = "Signature could not be verified in Unwhitelist.";
+    LOG(ERROR) << msg;
+    SetGError(error, CHROMEOS_LOGIN_ERROR_VERIFY_FAIL, msg);
     return FALSE;
   }
   store_->Unwhitelist(email_address);
   io_thread_.message_loop()->PostTask(
       FROM_HERE,
       NewRunnableMethod(this, &SessionManagerService::PersistWhitelist));
   return TRUE;
 }
 
 gboolean SessionManagerService::CheckWhitelist(gchar* email_address,
                                                GArray** OUT_signature,
                                                GError** error) {
   std::string encoded;
   if (!store_->GetFromWhitelist(email_address, &encoded)) {
-    SetGError(error,
-              CHROMEOS_LOGIN_ERROR_ILLEGAL_USER,
-              "The user is not whitelisted.");
+    const char msg[] = "The user is not whitelisted.";
+    LOG(INFO) << msg;
+    SetGError(error, CHROMEOS_LOGIN_ERROR_ILLEGAL_USER, msg);
     return FALSE;
   }
   std::string decoded;
   if (!base::Base64Decode(encoded, &decoded)) {
-    SetGError(error,
-              CHROMEOS_LOGIN_ERROR_DECODE_FAIL,
-              "Signature could not be decoded in CheckWhitelist.");
+    const char msg[] = "Signature could not be decoded in CheckWhitelist.";
+    LOG(ERROR) << msg;
+    SetGError(error, CHROMEOS_LOGIN_ERROR_DECODE_FAIL, msg);
     return FALSE;
   }
 
   *OUT_signature = g_array_sized_new(FALSE, FALSE, 1, decoded.length());
   g_array_append_vals(*OUT_signature, decoded.c_str(), decoded.length());
   return TRUE;
 }
 
 gboolean SessionManagerService::EnumerateWhitelisted(gchar*** OUT_whitelist,
                                                      GError** error) {
   std::vector<std::string> the_whitelisted;
   store_->EnumerateWhitelisted(&the_whitelisted);
   uint num_whitelisted = the_whitelisted.size();
   *OUT_whitelist = g_new(gchar*, num_whitelisted + 1);
   (*OUT_whitelist)[num_whitelisted] = NULL;
 
   for (uint i = 0; i < num_whitelisted; ++i) {
     (*OUT_whitelist)[i] = g_strndup(the_whitelisted[i].c_str(),
                                     the_whitelisted[i].length());
   }
   return TRUE;
 }
 
 gboolean SessionManagerService::Whitelist(gchar* email_address,
                                           GArray* signature,
                                           GError** error) {
   LOG(INFO) << "Whitelisting " << email_address;
   if (!key_->IsPopulated()) {
-    SetGError(error,
-              CHROMEOS_LOGIN_ERROR_NO_OWNER_KEY,
-              "Attempt to whitelist before owner's key is set.");
+    const char msg[] = "Attempt to whitelist before owner's key is set.";
+    LOG(ERROR) << msg;
+    SetGError(error, CHROMEOS_LOGIN_ERROR_NO_OWNER_KEY, msg);
     return FALSE;
   }
   if (!key_->Verify(email_address,
                     strlen(email_address),
                     signature->data,
                     signature->len)) {
-    SetGError(error,
-              CHROMEOS_LOGIN_ERROR_VERIFY_FAIL,
-              "Signature could not be verified in Whitelist.");
+    const char msg[] = "Signature could not be verified in Whitelist.";
+    LOG(ERROR) << msg;
+    SetGError(error, CHROMEOS_LOGIN_ERROR_VERIFY_FAIL, msg);
     return FALSE;
   }
   std::string data(signature->data, signature->len);
   return WhitelistHelper(email_address, data, error);
 }
 
 gboolean SessionManagerService::StoreProperty(gchar* name,
                                               gchar* value,
                                               GArray* signature,
                                               GError** error) {
   LOG(INFO) << "Setting pref " << name << "=" << value;
   if (!key_->IsPopulated()) {
-    SetGError(error,
-              CHROMEOS_LOGIN_ERROR_NO_OWNER_KEY,
-              "Attempt to store property before owner's key is set.");
+    const char msg[] = "Attempt to store property before owner's key is set.";
+    LOG(ERROR) << msg;
+    SetGError(error, CHROMEOS_LOGIN_ERROR_NO_OWNER_KEY, msg);
     return FALSE;
   }
   std::string was_signed = base::StringPrintf("%s=%s", name, value);
   if (!key_->Verify(was_signed.c_str(),
                     was_signed.length(),
                     signature->data,
                     signature->len)) {
-    SetGError(error,
-              CHROMEOS_LOGIN_ERROR_VERIFY_FAIL,
-              "Signature could not be verified in StoreProperty.");
+    const char msg[] = "Signature could not be verified in StoreProperty.";
+    LOG(ERROR) << msg;
+    SetGError(error, CHROMEOS_LOGIN_ERROR_VERIFY_FAIL, msg);
     return FALSE;
   }
   std::string data(signature->data, signature->len);
   return SetPropertyHelper(name, value, data, error);
 }
 
 gboolean SessionManagerService::RetrieveProperty(gchar* name,
                                                  gchar** OUT_value,
                                                  GArray** OUT_signature,
                                                  GError** error) {
@@ skipping 40 matching lines @@
                                            GError** error) {
   int child_pid = pid;
   std::vector<int>::iterator child_pid_it =
       std::find(child_pids_.begin(), child_pids_.end(), child_pid);
   size_t child_index = child_pid_it - child_pids_.begin();
 
   if (child_pid_it == child_pids_.end() ||
       child_jobs_[child_index]->GetName() != "chrome") {
     // If we didn't find the pid, or we don't think that job was chrome...
     *OUT_done = FALSE;
-    SetGError(error,
-              CHROMEOS_LOGIN_ERROR_UNKNOWN_PID,
-              "Provided pid is unknown.");
+    const char msg[] = "Provided pid is unknown.";
+    LOG(ERROR) << msg;
+    SetGError(error, CHROMEOS_LOGIN_ERROR_UNKNOWN_PID, msg);
     return FALSE;
   }
 
   // Waiting for Chrome to shutdown takes too much time.
   // We're killing it immediately hoping that data Chrome uses before
   // logging in is not corrupted.
   // TODO(avayvod): Remove RestartJob when crosbug.com/6924 is fixed.
   KillChild(child_jobs_[child_index], child_pid);
 
   char arguments_buffer[kMaxArgumentsSize + 1];
@@ skipping 138 matching lines @@
   message_loop_->PostTask(
       FROM_HERE, NewRunnableMethod(this, &SessionManagerService::SendSignal,
                                    chromium::kPropertyChangeCompleteSignal,
                                    what_happened));
 }
 
 // static
 void SessionManagerService::SetGError(GError** error,
                                       ChromeOSLoginError code,
                                       const char* message) {
-  LOG(ERROR) << message;
   g_set_error(error, CHROMEOS_LOGIN_ERROR, code, "Login error: %s", message);
 }
 
 
 ///////////////////////////////////////////////////////////////////////////////
 // Utility Methods
 
 // This can probably be more efficient, if it needs to be.
 // static
 bool SessionManagerService::ValidateEmail(const string& email_address) {
@@ skipping 89 matching lines @@
   std::string decoded;
   if (!GetPropertyHelper(kDeviceOwnerPref, &value, &decoded, error))
     return FALSE;
   std::string was_signed = base::StringPrintf("%s=%s",
                                               kDeviceOwnerPref,
                                               value.c_str());
   if (!key_->Verify(was_signed.c_str(),
                     was_signed.length(),
                     decoded.c_str(),
                     decoded.length())) {
-    SetGError(error,
-              CHROMEOS_LOGIN_ERROR_VERIFY_FAIL,
-              "Owner pref signature could not be verified.");
+    const char msg[] = "Owner pref signature could not be verified.";
+    LOG(ERROR) << msg;
+    SetGError(error, CHROMEOS_LOGIN_ERROR_VERIFY_FAIL, msg);
     return FALSE;
   }
   return value == current_user_;
 }
 
 gboolean SessionManagerService::CurrentUserHasOwnerKey(
     const std::vector<uint8>& pub_key,
     GError** error) {
   if (!nss_->OpenUserDB()) {
-    SetGError(error,
-              CHROMEOS_LOGIN_ERROR_NO_USER_NSSDB,
-              "Could not open the current user's NSS database.");
+    const char msg[] = "Could not open the current user's NSS database.";
+    LOG(ERROR) << msg;
+    SetGError(error, CHROMEOS_LOGIN_ERROR_NO_USER_NSSDB, msg);
     return FALSE;
   }
   if (!nss_->GetPrivateKey(pub_key)) {
-    SetGError(error,
-              CHROMEOS_LOGIN_ERROR_ILLEGAL_PUBKEY,
-              "Could not verify that public key belongs to the owner.");
+    const char msg[] = "Could not verify that public key belongs to the owner.";
+    LOG(WARNING) << msg;
+    SetGError(error, CHROMEOS_LOGIN_ERROR_ILLEGAL_PUBKEY, msg);
     return FALSE;
   }
   return TRUE;
 }
 
 gboolean SessionManagerService::ValidateAndCacheUserEmail(
     const gchar* email_address,
     GError** error) {
   // basic validity checking; avoid buffer overflows here, and
   // canonicalize the email address a little.
   char email[kMaxEmailSize + 1];
   snprintf(email, sizeof(email), "%s", email_address);
   email[kMaxEmailSize] = '\0';  // Just to be sure.
   string email_string(email);
   if (email_string != kIncognitoUser && !ValidateEmail(email_string)) {
-    SetGError(error,
-              CHROMEOS_LOGIN_ERROR_INVALID_EMAIL,
-              "Provided email address is not valid.  ASCII only.");
+    const char msg[] = "Provided email address is not valid.  ASCII only.";
+    LOG(ERROR) << msg;
+    SetGError(error, CHROMEOS_LOGIN_ERROR_INVALID_EMAIL, msg);
     return FALSE;
   }
   current_user_ = StringToLowerASCII(email_string);
   return TRUE;
 }
 
 int SessionManagerService::FindChildByPid(int pid) {
   for (int i = 0; i < child_pids_.size(); ++i) {
     if (child_pids_[i] == pid)
       return i;
@@ skipping 39 matching lines @@
 
 gboolean SessionManagerService::SignAndStoreProperty(const std::string& name,
                                                      const std::string& value,
                                                      const std::string& err_msg,
                                                      GError** error) {
   std::vector<uint8> signature;
   std::string to_sign = base::StringPrintf("%s=%s",
                                            kDeviceOwnerPref,
                                            current_user_.c_str());
   if (!key_->Sign(to_sign.c_str(), to_sign.length(), &signature)) {
+    LOG_IF(ERROR, error) << err_msg;
+    LOG_IF(WARNING, !error) << err_msg;
     SetGError(error, CHROMEOS_LOGIN_ERROR_ILLEGAL_PUBKEY, err_msg.c_str());
     return FALSE;
   }
   std::string signature_string(reinterpret_cast<const char*>(&signature[0]),
                                signature.size());
   return SetPropertyHelper(kDeviceOwnerPref,
                            current_user_,
                            signature_string,
                            error);
 }
 
 gboolean SessionManagerService::SignAndWhitelist(const std::string& email,
                                                  const std::string& err_msg,
                                                  GError** error) {
   std::vector<uint8> signature;
   if (!key_->Sign(current_user_.c_str(), current_user_.length(), &signature)) {
+    LOG_IF(ERROR, error) << err_msg;
+    LOG_IF(WARNING, !error) << err_msg;
     SetGError(error, CHROMEOS_LOGIN_ERROR_ILLEGAL_PUBKEY, err_msg.c_str());
     return FALSE;
   }
   std::string signature_string(reinterpret_cast<const char*>(&signature[0]),
                                signature.size());
   return WhitelistHelper(current_user_, signature_string, error);
 }
 
 gboolean SessionManagerService::SetPropertyHelper(const std::string& name,
                                                   const std::string& value,
                                                   const std::string& signature,
                                                   GError** error) {
   std::string encoded;
   if (!base::Base64Encode(signature, &encoded)) {
-    SetGError(error,
-              CHROMEOS_LOGIN_ERROR_ENCODE_FAIL,
-              "Signature could not be verified in SetPropertyHelper.");
+    const char msg[] = "Signature could not be encoded.";
+    LOG(ERROR) << msg;
+    SetGError(error, CHROMEOS_LOGIN_ERROR_ENCODE_FAIL, msg);
     return FALSE;
   }
   store_->Set(name, value, encoded);
   io_thread_.message_loop()->PostTask(
       FROM_HERE, NewRunnableMethod(this, &SessionManagerService::PersistStore));
   return TRUE;
 }
 
 gboolean SessionManagerService::WhitelistHelper(const std::string& email,
                                                 const std::string& signature,
                                                 GError** error) {
   std::string encoded;
   if (!base::Base64Encode(signature, &encoded)) {
-    SetGError(error,
-              CHROMEOS_LOGIN_ERROR_ENCODE_FAIL,
-              "Signature could not be encoded in WhitelistHelper.");
+    const char msg[] = "Signature could not be encoded.";
+    LOG(ERROR) << msg;
+    SetGError(error, CHROMEOS_LOGIN_ERROR_ENCODE_FAIL, msg);
     return FALSE;
   }
   store_->Whitelist(email, encoded);
   io_thread_.message_loop()->PostTask(
       FROM_HERE,
       NewRunnableMethod(this, &SessionManagerService::PersistWhitelist));
   return TRUE;
 }
 
 gboolean SessionManagerService::GetPropertyHelper(const std::string& name,
                                                   std::string* OUT_value,
                                                   std::string* OUT_signature,
                                                   GError** error) {
   std::string encoded;
   if (!store_->Get(name, OUT_value, &encoded)) {
-    std::string error_string =
+    std::string error_msg =
         base::StringPrintf("The requested property %s is unknown.",
                            name.c_str());
-    SetGError(error,
-              CHROMEOS_LOGIN_ERROR_UNKNOWN_PROPERTY,
-              error_string.c_str());
+    LOG(WARNING) << error_msg;
+    SetGError(error, CHROMEOS_LOGIN_ERROR_UNKNOWN_PROPERTY, error_msg.c_str());
     return FALSE;
   }
   if (!base::Base64Decode(encoded, OUT_signature)) {
-    SetGError(error,
-              CHROMEOS_LOGIN_ERROR_DECODE_FAIL,
-              "Signature could not be decoded in GetPropertyHelper.");
+    const char msg[] = "Signature could not be decoded.";
+    LOG(ERROR) << msg;
+    SetGError(error, CHROMEOS_LOGIN_ERROR_DECODE_FAIL, msg);
     return FALSE;
   }
   return TRUE;
 }
 
 void SessionManagerService::SendSignal(const char signal_name[],
                                        bool succeeded) {
   system_->SendSignalToChromium(signal_name, succeeded ? "success" : "failure");
 }
 
@@ skipping 12 matching lines @@
       arg_list.push_back(args[i_arg]);
     }
   }
   if (arg_list.size()) {
     arg_lists.push_back(arg_list);
   }
   return arg_lists;
 }
 
 }  // namespace login_manager