pion  5.0.6
server.hpp
1 // ---------------------------------------------------------------------
2 // pion: a Boost C++ framework for building lightweight HTTP interfaces
3 // ---------------------------------------------------------------------
4 // Copyright (C) 2007-2014 Splunk Inc. (https://github.com/splunk/pion)
5 //
6 // Distributed under the Boost Software License, Version 1.0.
7 // See http://www.boost.org/LICENSE_1_0.txt
8 //
9 
10 #ifndef __PION_HTTP_SERVER_HEADER__
11 #define __PION_HTTP_SERVER_HEADER__
12 
13 #include <map>
14 #include <string>
15 #include <boost/asio.hpp>
16 #include <boost/function.hpp>
17 #include <boost/function/function2.hpp>
18 #include <boost/function/function3.hpp>
19 #include <boost/shared_ptr.hpp>
20 #include <boost/thread/mutex.hpp>
21 #include <pion/config.hpp>
22 #include <pion/tcp/server.hpp>
23 #include <pion/tcp/connection.hpp>
24 #include <pion/http/request.hpp>
25 #include <pion/http/auth.hpp>
26 #include <pion/http/parser.hpp>
27 
28 
29 namespace pion { // begin namespace pion
30 namespace http { // begin namespace http
31 
32 
36 class PION_API server :
37  public tcp::server
38 {
39 
40 public:
41 
43  typedef boost::function2<void, http::request_ptr&, tcp::connection_ptr&> request_handler_t;
44 
46  typedef boost::function3<void, http::request_ptr&, tcp::connection_ptr&,
47  const std::string&> error_handler_t;
48 
49 
51  virtual ~server() { if (is_listening()) stop(); }
52 
58  explicit server(const unsigned int tcp_port = 0)
59  : tcp::server(tcp_port),
60  m_bad_request_handler(server::handle_bad_request),
61  m_not_found_handler(server::handle_not_found_request),
62  m_server_error_handler(server::handle_server_error),
63  m_max_content_length(http::parser::DEFAULT_CONTENT_MAX)
64  {
65  set_logger(PION_GET_LOGGER("pion.http.server"));
66  }
67 
73  explicit server(const boost::asio::ip::tcp::endpoint& endpoint)
74  : tcp::server(endpoint),
75  m_bad_request_handler(server::handle_bad_request),
76  m_not_found_handler(server::handle_not_found_request),
77  m_server_error_handler(server::handle_server_error),
78  m_max_content_length(http::parser::DEFAULT_CONTENT_MAX)
79  {
80  set_logger(PION_GET_LOGGER("pion.http.server"));
81  }
82 
89  explicit server(scheduler& sched, const unsigned int tcp_port = 0)
90  : tcp::server(sched, tcp_port),
91  m_bad_request_handler(server::handle_bad_request),
92  m_not_found_handler(server::handle_not_found_request),
93  m_server_error_handler(server::handle_server_error),
94  m_max_content_length(http::parser::DEFAULT_CONTENT_MAX)
95  {
96  set_logger(PION_GET_LOGGER("pion.http.server"));
97  }
98 
105  server(scheduler& sched, const boost::asio::ip::tcp::endpoint& endpoint)
106  : tcp::server(sched, endpoint),
107  m_bad_request_handler(server::handle_bad_request),
108  m_not_found_handler(server::handle_not_found_request),
109  m_server_error_handler(server::handle_server_error),
110  m_max_content_length(http::parser::DEFAULT_CONTENT_MAX)
111  {
112  set_logger(PION_GET_LOGGER("pion.http.server"));
113  }
114 
121  void add_resource(const std::string& resource, request_handler_t request_handler);
122 
128  void remove_resource(const std::string& resource);
129 
136  void add_redirect(const std::string& requested_resource, const std::string& new_resource);
137 
139  inline void set_bad_request_handler(request_handler_t h) { m_bad_request_handler = h; }
140 
142  inline void set_not_found_handler(request_handler_t h) { m_not_found_handler = h; }
143 
145  inline void set_error_handler(error_handler_t h) { m_server_error_handler = h; }
146 
148  virtual void clear(void) {
149  if (is_listening()) stop();
150  boost::mutex::scoped_lock resource_lock(m_resource_mutex);
151  m_resources.clear();
152  }
153 
160  static inline std::string strip_trailing_slash(const std::string& str) {
161  std::string result(str);
162  if (!result.empty() && result[result.size()-1]=='/')
163  result.resize(result.size() - 1);
164  return result;
165  }
166 
173  static void handle_bad_request(http::request_ptr& http_request_ptr,
174  tcp::connection_ptr& tcp_conn);
175 
182  static void handle_not_found_request(http::request_ptr& http_request_ptr,
183  tcp::connection_ptr& tcp_conn);
184 
192  static void handle_server_error(http::request_ptr& http_request_ptr,
193  tcp::connection_ptr& tcp_conn,
194  const std::string& error_msg);
195 
203  static void handle_forbidden_request(http::request_ptr& http_request_ptr,
204  tcp::connection_ptr& tcp_conn,
205  const std::string& error_msg);
206 
214  static void handle_method_not_allowed(http::request_ptr& http_request_ptr,
215  tcp::connection_ptr& tcp_conn,
216  const std::string& allowed_methods = "");
217 
221  inline void set_authentication(http::auth_ptr auth) { m_auth_ptr = auth; }
222 
224  inline void set_max_content_length(std::size_t n) { m_max_content_length = n; }
225 
226 protected:
227 
233  virtual void handle_connection(tcp::connection_ptr& tcp_conn);
234 
242  virtual void handle_request(http::request_ptr& http_request_ptr,
243  tcp::connection_ptr& tcp_conn, const boost::system::error_code& ec);
244 
251  virtual bool find_request_handler(const std::string& resource,
252  request_handler_t& request_handler) const;
253 
254 
255 private:
256 
258  static const unsigned int MAX_REDIRECTS;
259 
261  typedef std::map<std::string, request_handler_t> resource_map_t;
262 
264  typedef std::map<std::string, std::string> redirect_map_t;
265 
266 
268  resource_map_t m_resources;
269 
271  redirect_map_t m_redirects;
272 
274  request_handler_t m_bad_request_handler;
275 
277  request_handler_t m_not_found_handler;
278 
280  error_handler_t m_server_error_handler;
281 
283  mutable boost::mutex m_resource_mutex;
284 
286  http::auth_ptr m_auth_ptr;
287 
289  std::size_t m_max_content_length;
290 };
291 
292 
294 typedef boost::shared_ptr<server> server_ptr;
295 
296 
297 } // end namespace http
298 } // end namespace pion
299 
300 #endif
server(scheduler &sched, const unsigned int tcp_port=0)
Definition: server.hpp:89
void set_error_handler(error_handler_t h)
sets the function that handles requests which match no other web services
Definition: server.hpp:145
void set_max_content_length(std::size_t n)
sets the maximum length for HTTP request payload content
Definition: server.hpp:224
server(scheduler &sched, const boost::asio::ip::tcp::endpoint &endpoint)
Definition: server.hpp:105
virtual ~server()
default destructor
Definition: server.hpp:51
boost::function2< void, http::request_ptr &, tcp::connection_ptr & > request_handler_t
type of function that is used to handle requests
Definition: server.hpp:43
void set_not_found_handler(request_handler_t h)
sets the function that handles requests which match no other web services
Definition: server.hpp:142
virtual void clear(void)
clears the collection of resources recognized by the HTTP server
Definition: server.hpp:148
boost::function3< void, http::request_ptr &, tcp::connection_ptr &, const std::string & > error_handler_t
handler for requests that result in "500 Server Error"
Definition: server.hpp:47
static std::string strip_trailing_slash(const std::string &str)
Definition: server.hpp:160
server(const unsigned int tcp_port=0)
Definition: server.hpp:58
void set_bad_request_handler(request_handler_t h)
sets the function that handles bad HTTP requests
Definition: server.hpp:139
server(const boost::asio::ip::tcp::endpoint &endpoint)
Definition: server.hpp:73
void set_authentication(http::auth_ptr auth)
Definition: server.hpp:221