components/certificate_transparency/log_proof_fetcher.h

   1 // Copyright 2015 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef COMPONENTS_CERTIFICATE_TRANSPARENCY_LOG_PROOF_FETCHER_H_
   6 #define COMPONENTS_CERTIFICATE_TRANSPARENCY_LOG_PROOF_FETCHER_H_
   7
   8 #include <map>
   9 #include <string>
  10
  11 #include "base/callback.h"
  12 #include "base/macros.h"
  13 #include "base/memory/scoped_ptr.h"
  14 #include "base/memory/weak_ptr.h"
  15 #include "net/url_request/url_request.h"
  16
  17 namespace base {
  18 class Value;
  19 }  // namespace base
  20
  21 namespace net {
  22
  23 class URLRequestContext;
  24
  25 namespace ct {
  26 struct SignedTreeHead;
  27 }  // namespace ct
  28
  29 }  // namespace net
  30
  31 class GURL;
  32
  33 namespace certificate_transparency {
  34
  35 // Fetches Signed Tree Heads (STHs) and consistency proofs from Certificate
  36 // Transparency logs using the URLRequestContext provided during the instance
  37 // construction.
  38 // Must outlive the provided URLRequestContext.
  39 class LogProofFetcher : public net::URLRequest::Delegate {
  40  public:
  41   static const size_t kMaxLogResponseSizeInBytes = 600;
  42
  43   // Callback for successful retrieval of Signed Tree Heads. Called
  44   // with the log_id of the log the STH belogs to (as supplied by the caller
  45   // to FetchSignedTreeHead) and the STH itself.
  46   using SignedTreeHeadFetchedCallback =
  47       base::Callback<void(const std::string& log_id,
  48                           const net::ct::SignedTreeHead& signed_tree_head)>;
  49
  50   // Callback for failure of Signed Tree Head retrieval. Called with the log_id
  51   // that the log fetching was requested for and a net error code of the
  52   // failure.
  53   using FetchFailedCallback = base::Callback<
  54       void(const std::string& log_id, int net_error, int http_response_code)>;
  55
  56   explicit LogProofFetcher(net::URLRequestContext* request_context);
  57   ~LogProofFetcher() override;
  58
  59   // Fetch the latest Signed Tree Head from the log identified by |log_id|
  60   // from |base_log_url|. The |log_id| will be passed into the callbacks to
  61   // identify the log the retrieved Signed Tree Head belongs to.
  62   // The callbacks won't be invoked if the request is destroyed before
  63   // fetching is completed.
  64   // It is possible, but does not make a lot of sense, to have multiple
  65   // Signed Tree Head fetching requests going out to the same log, since
  66   // they are likely to return the same result.
  67   // TODO(eranm): Think further about whether multiple requests to the same
  68   // log imply cancellation of previous requests, should be coalesced or handled
  69   // independently.
  70   void FetchSignedTreeHead(
  71       const GURL& base_log_url,
  72       const std::string& log_id,
  73       const SignedTreeHeadFetchedCallback& fetched_callback,
  74       const FetchFailedCallback& failed_callback);
  75
  76   // net::URLRequest::Delegate
  77   void OnResponseStarted(net::URLRequest* request) override;
  78   void OnReadCompleted(net::URLRequest* request, int bytes_read) override;
  79
  80  private:
  81   struct FetchState;
  82   // Handles the final result of a URLRequest::Read call on |request|.
  83   // Returns true if another read should be started, false if the read
  84   // failed completely or we have to wait for OnResponseStarted to
  85   // be called.
  86   bool HandleReadResult(net::URLRequest* request,
  87                         FetchState* params,
  88                         int bytes_read);
  89
  90   // Calls URLRequest::Read on |request| repeatedly, until HandleReadResult
  91   // indicates it should no longer be called. Usually this would be when there
  92   // is pending IO that requires waiting for OnResponseStarted to be called.
  93   void StartNextRead(net::URLRequest* request, FetchState* params);
  94
  95   // Performs post-report cleanup.
  96   void RequestComplete(net::URLRequest* request);
  97   // Deletes the request and associated FetchState from the internal map.
  98   void CleanupRequest(net::URLRequest* request);
  99   // Invokes the failure callback with the supplied arguments, then cleans up
 100   // the request.
 101   void InvokeFailureCallback(net::URLRequest* request,
 102                              int net_error,
 103                              int http_response_code);
 104
 105   // Callbacks for parsing the STH's JSON by the SafeJsonParser
 106   void OnSTHJsonParseSuccess(net::URLRequest* request,
 107                              scoped_ptr<base::Value> parsed_json);
 108   void OnSTHJsonParseError(net::URLRequest* request, const std::string& error);
 109
 110   net::URLRequestContext* const request_context_;
 111
 112   // Owns the contained requests, as well as FetchState.
 113   std::map<net::URLRequest*, FetchState*> inflight_requests_;
 114
 115   base::WeakPtrFactory<LogProofFetcher> weak_factory_;
 116
 117   DISALLOW_COPY_AND_ASSIGN(LogProofFetcher);
 118 };
 119
 120 }  // namespace certificate_transparency
 121
 122 #endif  // COMPONENTS_CERTIFICATE_TRANSPARENCY_LOG_PROOF_FETCHER_H_