domain_lawyer.h

Go to the documentation of this file.

/*
 * Copyright 2010 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http:///www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */


#ifndef NET_INSTAWEB_REWRITER_PUBLIC_DOMAIN_LAWYER_H_
#define NET_INSTAWEB_REWRITER_PUBLIC_DOMAIN_LAWYER_H_

#include <map>
#include <vector>

#include "pagespeed/kernel/base/basictypes.h"
#include "pagespeed/kernel/base/string.h"
#include "pagespeed/kernel/base/string_util.h"

namespace net_instaweb {
class GoogleUrl;
class MessageHandler;

class DomainLawyer {
 public:
  DomainLawyer() { Clear(); }
  ~DomainLawyer();

  DomainLawyer& operator=(const DomainLawyer& src) {
    if (&src != this) {
      Clear();
      Merge(src);
    }
    return *this;
  }

  DomainLawyer(const DomainLawyer& src) {
    Clear();
    Merge(src);
  }

  bool MapRequestToDomain(const GoogleUrl& original_request,
                          const StringPiece& resource_url,
                          GoogleString* mapped_domain_name,
                          GoogleUrl* resolved_request,
                          MessageHandler* handler) const;

  bool IsDomainAuthorized(const GoogleUrl& original_request,
                          const GoogleUrl& domain_to_check) const;


  bool IsOriginKnown(const GoogleUrl& domain_to_check) const;

  bool MapOrigin(const StringPiece& in, GoogleString* out,
                 GoogleString* host_header, bool* is_proxy) const;
  bool MapOriginUrl(const GoogleUrl& gurl, GoogleString* out,
                    GoogleString* host_header, bool* is_proxy) const;


  bool AddDomain(const StringPiece& domain_name, MessageHandler* handler);

  bool AddKnownDomain(const StringPiece& domain_name, MessageHandler* handler);

  bool AddRewriteDomainMapping(const StringPiece& to_domain,
                               const StringPiece& comma_separated_from_domains,
                               MessageHandler* handler);

  bool AddTwoProtocolRewriteDomainMapping(const StringPiece& to_domain_name,
                                          const StringPiece& from_domain_name,
                                          MessageHandler* handler);

  bool AddOriginDomainMapping(const StringPiece& to_domain,
                              const StringPiece& comma_separated_from_domains,
                              const StringPiece& host_header,
                              MessageHandler* handler);

  bool AddProxyDomainMapping(const StringPiece& proxy_domain,
                             const StringPiece& origin_domain,
                             const StringPiece& to_domain_name,
                             MessageHandler* handler);

  bool AddTwoProtocolOriginDomainMapping(const StringPiece& to_domain_name,
                                         const StringPiece& from_domain_name,
                                         const StringPiece& host_header,
                                         MessageHandler* handler);

  bool AddShard(const StringPiece& to_domain,
                const StringPiece& comma_separated_shards,
                MessageHandler* handler);

  bool ShardDomain(const StringPiece& domain_name, uint32 hash,
                   GoogleString* sharded_domain) const;

  void Merge(const DomainLawyer& src);

  void Clear();
  bool empty() const { return domain_map_.empty() && proxy_suffix_.empty(); }

  bool WillDomainChange(const GoogleUrl& url) const;

  bool IsProxyMapped(const GoogleUrl& url) const;

  bool can_rewrite_domains() const {
    return can_rewrite_domains_ || !proxy_suffix_.empty();
  }

  int num_wildcarded_domains() const { return wildcarded_domains_.size(); }

  bool DoDomainsServeSameContent(const StringPiece& domain1,
                                 const StringPiece& domain2) const;

  void FindDomainsRewrittenTo(
      const GoogleUrl& domain_name,
      ConstStringStarVector* from_domains) const;

  void set_proxy_suffix(const GoogleString& suffix) { proxy_suffix_ = suffix; }
  const GoogleString& proxy_suffix() const { return proxy_suffix_; }

  bool StripProxySuffix(const GoogleUrl& gurl,
                        GoogleString* url, GoogleString* host) const;

  bool AddProxySuffix(const GoogleUrl& base_url, GoogleString* href) const;

  GoogleString Signature() const;

  GoogleString ToString(StringPiece line_prefix) const;

  GoogleString ToString() const { return ToString(StringPiece()); }

 private:
  class Domain;
  friend class DomainLawyerTest;

  typedef bool (Domain::*SetDomainFn)(Domain* domain, MessageHandler* handler);

  static GoogleString NormalizeDomainName(const StringPiece& domain_name);

  static bool IsSchemeSafeToMapTo(const StringPiece& domain_name,
                                  bool allow_https_scheme);

  bool MapDomainHelper(
      const StringPiece& to_domain_name,
      const StringPiece& comma_separated_from_domains,
      const StringPiece& host_header,
      SetDomainFn set_domain_fn,
      bool allow_wildcards,
      bool allow_map_to_https,
      bool authorize,
      MessageHandler* handler);

  bool MapUrlHelper(const Domain& from_domain,
                    const Domain& to_domain,
                    const GoogleUrl& gurl,
                    GoogleUrl* mapped_gurl) const;

  bool DomainNameToTwoProtocols(const StringPiece& domain_name,
                                GoogleString* http_url,
                                GoogleString* https_url);

  bool TwoProtocolDomainHelper(
      const StringPiece& to_domain_name,
      const StringPiece& from_domain_name,
      const StringPiece& host_header,
      SetDomainFn set_domain_fn,
      bool authorize,
      MessageHandler* handler);

  Domain* AddDomainHelper(const StringPiece& domain_name,
                          bool warn_on_duplicate,
                          bool authorize,
                          bool is_proxy,
                          MessageHandler* handler);
  Domain* CloneAndAdd(const Domain* src);

  Domain* FindDomain(const GoogleUrl& gurl) const;

  typedef std::map<GoogleString, Domain*> DomainMap; 
  DomainMap domain_map_;
  typedef std::vector<Domain*> DomainVector; 
  DomainVector wildcarded_domains_;
  GoogleString proxy_suffix_;
  bool can_rewrite_domains_;
  bool authorize_all_domains_;

};

}  

#endif