path: root/chrome/browser/policy/device_management_backend_impl.cc

// Copyright (c) 2010 The Chromium 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 "chrome/browser/policy/device_management_backend_impl.h"

#include <utility>
#include <vector>

#include "base/stl_util-inl.h"
#include "base/stringprintf.h"
#include "chrome/browser/browser_thread.h"
#include "chrome/common/net/url_request_context_getter.h"
#include "net/base/cookie_monster.h"
#include "net/base/escape.h"
#include "net/base/host_resolver.h"
#include "net/base/ssl_config_service_defaults.h"
#include "net/http/http_auth_handler_factory.h"
#include "net/http/http_network_layer.h"
#include "net/proxy/proxy_service.h"
#include "net/url_request/url_request_context.h"
#include "net/url_request/url_request_status.h"
#include "chrome/browser/browser_process.h"
#include "chrome/browser/io_thread.h"
#include "chrome/browser/net/chrome_net_log.h"
#include "chrome/common/chrome_version_info.h"

namespace policy {

namespace {

// Name constants for URL query parameters.
const char kServiceParamRequest[] = "request";
const char kServiceParamDeviceType[] = "devicetype";
const char kServiceParamDeviceID[] = "deviceid";
const char kServiceParamAgent[] = "agent";

// String constants for the device type and agent we report to the service.
const char kServiceValueDeviceType[] = "Chrome";
const char kServiceValueAgent[] =
    "%s enterprise management client version %s (%s)";

const char kServiceTokenAuthHeader[] = "Authorization: GoogleLogin auth=";
const char kDMTokenAuthHeader[] = "Authorization: GoogleDMToken token=";

}  // namespace

// Custom request context implementation that allows to override the user agent,
// amongst others. Using the default request context is not an option since this
// service may be constructed before the default request context is created
// (i.e. before the profile has been loaded).
class DeviceManagementBackendRequestContext : public URLRequestContext {
 public:
  explicit DeviceManagementBackendRequestContext(IOThread::Globals* io_globals);
  virtual ~DeviceManagementBackendRequestContext();

 private:
  virtual const std::string& GetUserAgent(const GURL& url) const;

  std::string user_agent_;
};

DeviceManagementBackendRequestContext::DeviceManagementBackendRequestContext(
    IOThread::Globals* io_globals) {
  net_log_ = io_globals->net_log.get();
  host_resolver_ = io_globals->host_resolver.get();
  proxy_service_ = net::ProxyService::CreateDirect();
  ssl_config_service_ = net::SSLConfigService::CreateSystemSSLConfigService();
  http_auth_handler_factory_ =
      net::HttpAuthHandlerFactory::CreateDefault(host_resolver_);
  http_transaction_factory_ =
      net::HttpNetworkLayer::CreateFactory(host_resolver_,
                                           io_globals->dnsrr_resolver.get(),
                                           NULL /* dns_cert_checker */,
                                           NULL /* ssl_host_info_factory */,
                                           proxy_service_,
                                           ssl_config_service_,
                                           http_auth_handler_factory_,
                                           NULL /* network_delegate */,
                                           net_log_);
  cookie_store_ = new net::CookieMonster(NULL, NULL);
  user_agent_ = DeviceManagementBackendImpl::GetAgentString();
  accept_language_ = "*";
  accept_charset_ = "*";
}

DeviceManagementBackendRequestContext
    ::~DeviceManagementBackendRequestContext() {
  delete http_transaction_factory_;
  delete http_auth_handler_factory_;
}

const std::string&
DeviceManagementBackendRequestContext::GetUserAgent(const GURL& url) const {
  return user_agent_;
}

// Request context holder.
class DeviceManagementBackendRequestContextGetter
    : public URLRequestContextGetter {
 public:
  DeviceManagementBackendRequestContextGetter()
      : io_thread_(g_browser_process->io_thread()) {}

  // URLRequestContextGetter overrides.
  virtual URLRequestContext* GetURLRequestContext();
  virtual scoped_refptr<base::MessageLoopProxy> GetIOMessageLoopProxy() const;

 private:
  scoped_refptr<URLRequestContext> context_;
  IOThread* io_thread_;
};


URLRequestContext*
DeviceManagementBackendRequestContextGetter::GetURLRequestContext() {
  if (!context_)
    context_ = new DeviceManagementBackendRequestContext(io_thread_->globals());

  return context_.get();
}

scoped_refptr<base::MessageLoopProxy>
DeviceManagementBackendRequestContextGetter::GetIOMessageLoopProxy() const {
  return BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO);
}

// Helper class for URL query parameter encoding/decoding.
class URLQueryParameters {
 public:
  URLQueryParameters() {}

  // Add a query parameter.
  void Put(const std::string& name, const std::string& value);

  // Produce the query string, taking care of properly encoding and assembling
  // the names and values.
  std::string Encode();

 private:
  typedef std::vector<std::pair<std::string, std::string> > ParameterMap;
  ParameterMap params_;

  DISALLOW_COPY_AND_ASSIGN(URLQueryParameters);
};

void URLQueryParameters::Put(const std::string& name,
                             const std::string& value) {
  params_.push_back(std::make_pair(name, value));
}

std::string URLQueryParameters::Encode() {
  std::string result;
  for (ParameterMap::const_iterator entry(params_.begin());
       entry != params_.end();
       ++entry) {
    if (entry != params_.begin())
      result += '&';
    result += EscapeUrlEncodedData(entry->first);
    result += '=';
    result += EscapeUrlEncodedData(entry->second);
  }
  return result;
}

// Wraps common response parsing and handling functionality.
class ResponseHandler {
 public:
  ResponseHandler() {}
  virtual ~ResponseHandler() {}

  // Handles the URL request response.
  void HandleResponse(const URLRequestStatus& status,
                      int response_code,
                      const ResponseCookies& cookies,
                      const std::string& data);

  // Forwards the given error to the delegate.
  virtual void OnError(DeviceManagementBackend::ErrorCode error) = 0;

 private:
  // Implemented by subclasses to handle the decoded response.
  virtual void ProcessResponse(
      const em::DeviceManagementResponse& response) = 0;
};

void ResponseHandler::HandleResponse(const URLRequestStatus& status,
                                     int response_code,
                                     const ResponseCookies& cookies,
                                     const std::string& data) {
  if (status.status() != URLRequestStatus::SUCCESS) {
    OnError(DeviceManagementBackend::kErrorRequestFailed);
    return;
  }

  if (response_code != 200) {
    OnError(DeviceManagementBackend::kErrorHttpStatus);
    return;
  }

  em::DeviceManagementResponse response;
  if (!response.ParseFromString(data)) {
    OnError(DeviceManagementBackend::kErrorResponseDecoding);
    return;
  }

  // Check service error code.
  switch (response.error()) {
    case em::DeviceManagementResponse::SUCCESS:
      break;
    case em::DeviceManagementResponse::DEVICE_MANAGEMENT_NOT_SUPPORTED:
      OnError(DeviceManagementBackend::kErrorServiceManagementNotSupported);
      return;
    case em::DeviceManagementResponse::DEVICE_NOT_FOUND:
      OnError(DeviceManagementBackend::kErrorServiceDeviceNotFound);
      return;
    case em::DeviceManagementResponse::DEVICE_MANAGEMENT_TOKEN_INVALID:
      OnError(DeviceManagementBackend::kErrorServiceManagementTokenInvalid);
      return;
    case em::DeviceManagementResponse::ACTIVATION_PENDING:
      OnError(DeviceManagementBackend::kErrorServiceActivationPending);
      return;
    default:
      // This should be caught by the protobuf decoder.
      NOTREACHED();
      OnError(DeviceManagementBackend::kErrorResponseDecoding);
      return;
  }

  ProcessResponse(response);
}

// Handles device registration responses.
class RegisterResponseHandler : public ResponseHandler {
 public:
  RegisterResponseHandler(
      DeviceManagementBackend::DeviceRegisterResponseDelegate* delegate)
      : delegate_(delegate) {}

 private:
  // ResponseHandler overrides.
  virtual void OnError(DeviceManagementBackend::ErrorCode error) {
    delegate_->OnError(error);
  }
  virtual void ProcessResponse(const em::DeviceManagementResponse& response) {
    delegate_->HandleRegisterResponse(response.register_response());
  }

  DeviceManagementBackend::DeviceRegisterResponseDelegate* delegate_;
};

// Handles device unregister responses.
class UnregisterResponseHandler : public ResponseHandler {
 public:
  UnregisterResponseHandler(
      DeviceManagementBackend::DeviceUnregisterResponseDelegate* delegate)
      : delegate_(delegate) {}

 private:
  // ResponseHandler overrides.
  virtual void OnError(DeviceManagementBackend::ErrorCode error) {
    delegate_->OnError(error);
  }
  virtual void ProcessResponse(const em::DeviceManagementResponse& response) {
    delegate_->HandleUnregisterResponse(response.unregister_response());
  }

  DeviceManagementBackend::DeviceUnregisterResponseDelegate* delegate_;
};

// Handles device policy responses.
class PolicyResponseHandler : public ResponseHandler {
 public:
  PolicyResponseHandler(
      DeviceManagementBackend::DevicePolicyResponseDelegate* delegate)
      : delegate_(delegate) {}

 private:
  // ResponseHandler overrides.
  virtual void OnError(DeviceManagementBackend::ErrorCode error) {
    delegate_->OnError(error);
  }
  virtual void ProcessResponse(const em::DeviceManagementResponse& response) {
    delegate_->HandlePolicyResponse(response.policy_response());
  }

  DeviceManagementBackend::DevicePolicyResponseDelegate* delegate_;
};

DeviceManagementBackendImpl::DeviceManagementBackendImpl(
    const std::string& server_url)
    : server_url_(server_url),
      request_context_getter_(
          new DeviceManagementBackendRequestContextGetter()) {
}

DeviceManagementBackendImpl::~DeviceManagementBackendImpl() {
  // Cancel all pending requests.
  STLDeleteContainerPairPointers(response_handlers_.begin(),
                                 response_handlers_.end());
}

void DeviceManagementBackendImpl::ProcessRegisterRequest(
    const std::string& auth_token,
    const std::string& device_id,
    const em::DeviceRegisterRequest& request,
    DeviceRegisterResponseDelegate* delegate) {
  em::DeviceManagementRequest request_wrapper;
  request_wrapper.mutable_register_request()->CopyFrom(request);

  URLQueryParameters params;
  PutCommonQueryParameters(&params);
  params.Put(kServiceParamRequest, "register");
  params.Put(kServiceParamDeviceID, device_id);

  CreateFetcher(request_wrapper,
                new RegisterResponseHandler(delegate),
                params.Encode(),
                kServiceTokenAuthHeader + auth_token);
}

void DeviceManagementBackendImpl::ProcessUnregisterRequest(
    const std::string& device_management_token,
    const em::DeviceUnregisterRequest& request,
    DeviceUnregisterResponseDelegate* delegate) {
  em::DeviceManagementRequest request_wrapper;
  request_wrapper.mutable_unregister_request()->CopyFrom(request);

  URLQueryParameters params;
  PutCommonQueryParameters(&params);
  params.Put(kServiceParamRequest, "unregister");

  CreateFetcher(request_wrapper,
                new UnregisterResponseHandler(delegate),
                params.Encode(),
                kDMTokenAuthHeader + device_management_token);
}

void DeviceManagementBackendImpl::ProcessPolicyRequest(
    const std::string& device_management_token,
    const em::DevicePolicyRequest& request,
    DevicePolicyResponseDelegate* delegate) {
  em::DeviceManagementRequest request_wrapper;
  request_wrapper.mutable_policy_request()->CopyFrom(request);

  URLQueryParameters params;
  PutCommonQueryParameters(&params);
  params.Put(kServiceParamRequest, "policy");

  CreateFetcher(request_wrapper,
                new PolicyResponseHandler(delegate),
                params.Encode(),
                kDMTokenAuthHeader + device_management_token);
}

// static
std::string DeviceManagementBackendImpl::GetAgentString() {
  chrome::VersionInfo version_info;
  return base::StringPrintf(kServiceValueAgent,
                            version_info.Name().c_str(),
                            version_info.Version().c_str(),
                            version_info.LastChange().c_str());
}

void DeviceManagementBackendImpl::OnURLFetchComplete(
    const URLFetcher* source,
    const GURL& url,
    const URLRequestStatus& status,
    int response_code,
    const ResponseCookies& cookies,
    const std::string& data) {
  ResponseHandlerMap::iterator entry(response_handlers_.find(source));
  if (entry != response_handlers_.end()) {
    ResponseHandler* handler = entry->second;
    handler->HandleResponse(status, response_code, cookies, data);
    response_handlers_.erase(entry);
    delete handler;
  } else {
    NOTREACHED() << "Callback from foreign URL fetcher";
  }
  delete source;
}

void DeviceManagementBackendImpl::CreateFetcher(
    const em::DeviceManagementRequest& request,
    ResponseHandler* handler,
    const std::string& query_params,
    const std::string& extra_headers) {
  scoped_ptr<ResponseHandler> handler_ptr(handler);

  // Construct the payload.
  std::string payload;
  if (!request.SerializeToString(&payload)) {
    handler->OnError(DeviceManagementBackend::kErrorRequestInvalid);
    return;
  }

  // Instantiate the fetcher.
  GURL url(server_url_ + '?' + query_params);
  URLFetcher* fetcher = URLFetcher::Create(0, url, URLFetcher::POST, this);
  fetcher->set_request_context(request_context_getter_.get());
  fetcher->set_upload_data("application/octet-stream", payload);
  fetcher->set_extra_request_headers(extra_headers);
  response_handlers_[fetcher] = handler_ptr.release();

  // Start the request. The fetcher will call OnURLFetchComplete when done.
  fetcher->Start();
}

void DeviceManagementBackendImpl::PutCommonQueryParameters(
    URLQueryParameters* params) {
  params->Put(kServiceParamDeviceType, kServiceValueDeviceType);
  params->Put(kServiceParamAgent, GetAgentString());
}

}  // namespace policy