mirror of
https://github.com/klzgrad/naiveproxy.git
synced 2024-11-24 22:36:09 +03:00
110 lines
4.1 KiB
C++
110 lines
4.1 KiB
C++
// Copyright 2018 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.
|
|
//
|
|
// The proxy functionality is implemented as a separate thread namely
|
|
// “quic proxy thread”, managed by an instance of the QuicHttpProxyBackend
|
|
// class. The QuicHttpProxyBackend instance also manages an instance of the
|
|
// class net::URLRequestContext, that manages a single context for all the
|
|
// HTTP calls made to the backend server. Finally, the QuicHttpProxyBackend
|
|
// instance owns (creates/ destroys) the instances of QuicHttpProxyBackendStream
|
|
// to avoid orphan pointers of QuicHttpProxyBackendStream when the corresponding
|
|
// QUIC connection is destroyed on the main thread due to several reasons. The
|
|
// QUIC connection management and protocol parsing is performed by the main/quic
|
|
// thread, in the same way as the toy QUIC server.
|
|
//
|
|
// quic_http_proxy_backend_stream.h has a description of threads, the flow
|
|
// of packets in QUIC proxy in the forward and reverse directions.
|
|
|
|
#ifndef NET_TOOLS_QUIC_QUIC_HTTP_PROXY_BACKEND_H_
|
|
#define NET_TOOLS_QUIC_QUIC_HTTP_PROXY_BACKEND_H_
|
|
|
|
#include <stdint.h>
|
|
|
|
#include <memory>
|
|
#include <queue>
|
|
|
|
#include "base/base64.h"
|
|
#include "base/callback.h"
|
|
#include "base/logging.h"
|
|
#include "base/macros.h"
|
|
#include "base/single_thread_task_runner.h"
|
|
#include "base/threading/thread.h"
|
|
#include "base/threading/thread_task_runner_handle.h"
|
|
#include "base/values.h"
|
|
#include "net/third_party/quic/tools/quic_simple_server_backend.h"
|
|
#include "net/url_request/url_request_context.h"
|
|
#include "net/url_request/url_request_context_builder.h"
|
|
#include "url/gurl.h"
|
|
|
|
namespace base {
|
|
class SingleThreadTaskRunner;
|
|
} // namespace base
|
|
|
|
namespace quic {
|
|
class QuicSimpleServerBackend;
|
|
} // namespace quic
|
|
|
|
namespace net {
|
|
class QuicHttpProxyBackendStream;
|
|
|
|
// Manages the context to proxy HTTP requests to the backend server
|
|
// Owns instance of net::URLRequestContext.
|
|
class QuicHttpProxyBackend : public quic::QuicSimpleServerBackend {
|
|
public:
|
|
explicit QuicHttpProxyBackend();
|
|
~QuicHttpProxyBackend() override;
|
|
|
|
// Must be called from the backend thread of the quic proxy
|
|
net::URLRequestContext* GetURLRequestContext();
|
|
scoped_refptr<base::SingleThreadTaskRunner> GetProxyTaskRunner() const;
|
|
|
|
using ProxyBackendStreamMap =
|
|
std::unordered_map<quic::QuicSimpleServerBackend::RequestHandler*,
|
|
std::unique_ptr<QuicHttpProxyBackendStream>>;
|
|
const ProxyBackendStreamMap* proxy_backend_streams_map() const {
|
|
return &backend_stream_map_;
|
|
}
|
|
|
|
GURL backend_url() const { return backend_url_; }
|
|
|
|
// Implements the functions for interface quic::QuicSimpleServerBackend
|
|
bool InitializeBackend(const std::string& backend_url) override;
|
|
bool IsBackendInitialized() const override;
|
|
void FetchResponseFromBackend(
|
|
const spdy::SpdyHeaderBlock& request_headers,
|
|
const std::string& incoming_body,
|
|
quic::QuicSimpleServerBackend::RequestHandler* quic_stream) override;
|
|
void CloseBackendResponseStream(
|
|
quic::QuicSimpleServerBackend::RequestHandler* quic_stream) override;
|
|
|
|
private:
|
|
// Maps quic streams in the frontend to the corresponding http streams
|
|
// managed by |this|
|
|
ProxyBackendStreamMap backend_stream_map_;
|
|
|
|
bool ValidateBackendUrl(const std::string& backend_url);
|
|
void InitializeURLRequestContext();
|
|
QuicHttpProxyBackendStream* InitializeQuicProxyBackendStream(
|
|
quic::QuicSimpleServerBackend::RequestHandler* quic_server_stream);
|
|
|
|
// URLRequestContext to make URL requests to the backend
|
|
std::unique_ptr<net::URLRequestContext> context_; // owned by this
|
|
|
|
bool thread_initialized_;
|
|
// <scheme://hostname:port/ for the backend HTTP server
|
|
GURL backend_url_;
|
|
|
|
// Backend thread is owned by |this|
|
|
std::unique_ptr<base::Thread> proxy_thread_;
|
|
scoped_refptr<base::SingleThreadTaskRunner> proxy_task_runner_;
|
|
|
|
// Protects against concurrent access from quic (main) and proxy
|
|
// threads for adding and clearing a backend request handler
|
|
base::Lock backend_stream_mutex_;
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(QuicHttpProxyBackend);
|
|
};
|
|
} // namespace net
|
|
|
|
#endif // NET_TOOLS_QUIC_QUIC_HTTP_PROXY_BACKEND_H_
|