blob: 2bbbc716307105ab761572c28ad1cbb6ce8a965b [file] [log] [blame]
// Copyright (c) 2012 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 <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <string>
#include <base/memory/scoped_ptr.h>
#include <curl/curl.h>
#include <libxml/parser.h>
#include "update_engine/action.h"
#include "update_engine/http_fetcher.h"
// The Omaha Request action makes a request to Omaha and can output
// the response on the output ActionPipe.
namespace chromeos_update_engine {
// Encodes XML entities in a given string with libxml2. input must be
// UTF-8 formatted. Output will be UTF-8 formatted.
std::string XmlEncode(const std::string& input);
// This struct encapsulates the data Omaha's response for the request.
// These strings in this struct are not XML escaped.
struct OmahaResponse {
: update_exists(false),
prompt(false) {}
// True iff there is an update to be downloaded.
bool update_exists;
// If non-zero, server-dictated poll frequency in seconds.
int poll_interval;
// These are only valid if update_exists is true:
std::string display_version;
std::string codebase;
std::string more_info_url;
std::string hash;
std::string deadline;
off_t size;
bool needs_admin;
bool prompt;
COMPILE_ASSERT(sizeof(off_t) == 8, off_t_not_64bit);
// This struct encapsulates the Omaha event information. For a
// complete list of defined event types and results, see
struct OmahaEvent {
// The Type values correspond to EVENT_TYPE values of Omaha.
enum Type {
kTypeUnknown = 0,
kTypeDownloadComplete = 1,
kTypeInstallComplete = 2,
kTypeUpdateComplete = 3,
kTypeUpdateDownloadStarted = 13,
kTypeUpdateDownloadFinished = 14,
// The Result values correspond to EVENT_RESULT values of Omaha.
enum Result {
kResultError = 0,
kResultSuccess = 1,
kResultSuccessReboot = 2,
kResultUpdateDeferred = 9, // When we ignore/defer updates due to policy.
: type(kTypeUnknown),
error_code(kActionCodeError) {}
explicit OmahaEvent(Type in_type)
: type(in_type),
error_code(kActionCodeSuccess) {}
OmahaEvent(Type in_type, Result in_result, ActionExitCode in_error_code)
: type(in_type),
error_code(in_error_code) {}
Type type;
Result result;
ActionExitCode error_code;
class NoneType;
class OmahaRequestAction;
struct OmahaRequestParams;
class PrefsInterface;
class ActionTraits<OmahaRequestAction> {
// Takes parameters on the input pipe.
typedef NoneType InputObjectType;
// On UpdateCheck success, puts the Omaha response on output. Event
// requests do not have an output pipe.
typedef OmahaResponse OutputObjectType;
class OmahaRequestAction : public Action<OmahaRequestAction>,
public HttpFetcherDelegate {
static const int kNeverPinged = -1;
static const int kPingTimeJump = -2;
// These are the possible outcome upon checking whether we satisfied
// the wall-clock-based-wait.
enum WallClockWaitResult {
// The ctor takes in all the parameters that will be used for making
// the request to Omaha. For some of them we have constants that
// should be used.
// Takes ownership of the passed in HttpFetcher. Useful for testing.
// Takes ownership of the passed in OmahaEvent. If |event| is NULL,
// this is an UpdateCheck request, otherwise it's an Event request.
// Event requests always succeed.
// A good calling pattern is:
// OmahaRequestAction(..., new OmahaEvent(...), new WhateverHttpFetcher);
// or
// OmahaRequestAction(..., NULL, new WhateverHttpFetcher);
OmahaRequestAction(PrefsInterface* prefs,
OmahaRequestParams* params,
OmahaEvent* event,
HttpFetcher* http_fetcher,
bool ping_only);
virtual ~OmahaRequestAction();
typedef ActionTraits<OmahaRequestAction>::InputObjectType InputObjectType;
typedef ActionTraits<OmahaRequestAction>::OutputObjectType OutputObjectType;
void PerformAction();
void TerminateProcessing();
int GetHTTPResponseCode() { return http_fetcher_->http_response_code(); }
// Debugging/logging
static std::string StaticType() { return "OmahaRequestAction"; }
std::string Type() const { return StaticType(); }
// Delegate methods (see http_fetcher.h)
virtual void ReceivedBytes(HttpFetcher *fetcher,
const char* bytes, int length);
virtual void TransferComplete(HttpFetcher *fetcher, bool successful);
// Returns true if this is an Event request, false if it's an UpdateCheck.
bool IsEvent() const { return event_.get() != NULL; }
// If this is an update check request, initializes
// |ping_active_days_| and |ping_roll_call_days_| to values that may
// be sent as pings to Omaha.
void InitPingDays();
// Based on the persistent preference store values, calculates the
// number of days since the last ping sent for |key|.
int CalculatePingDays(const std::string& key);
// Returns true if the download of a new update should be deferred.
// False if the update can be downloaded.
bool ShouldDeferDownload(xmlNode* updatecheck_node);
// Returns true if the basic wall-clock-based waiting period has been
// satisfied based on the scattering policy setting. False otherwise.
// If true, it also indicates whether the additional update-check-count-based
// waiting period also needs to be satisfied before the download can begin.
WallClockWaitResult IsWallClockBasedWaitingSatisfied(
xmlNode* updatecheck_node);
// Returns true if the update-check-count-based waiting period has been
// satisfied. False otherwise.
bool IsUpdateCheckCountBasedWaitingSatisfied(xmlNode* updatecheck_node);
// Access to the preferences store.
PrefsInterface* prefs_;
// Contains state that is relevant in the processing of the Omaha request.
OmahaRequestParams* params_;
// Pointer to the OmahaEvent info. This is an UpdateCheck request if NULL.
scoped_ptr<OmahaEvent> event_;
// pointer to the HttpFetcher that does the http work
scoped_ptr<HttpFetcher> http_fetcher_;
// If true, only include the <ping> element in the request.
bool ping_only_;
// Stores the response from the omaha server
std::vector<char> response_buffer_;
// Initialized by InitPingDays to values that may be sent to Omaha
// as part of a ping message. Note that only positive values and -1
// are sent to Omaha.
int ping_active_days_;
int ping_roll_call_days_;
} // namespace chromeos_update_engine