updates library for new URI api

src/processors/hybi.hpp

@@ -35,6 +35,7 @@
 
 #include <boost/algorithm/string.hpp>
 
+
 namespace websocketpp {
 namespace processor {
 
@@ -125,32 +126,37 @@ public:
 		}
 	}
 	
-	uri get_uri(const http::parser::request& request) const {
-		uri connection_uri;
+	uri_ptr get_uri(const http::parser::request& request) const {
+		//uri connection_uri;
 		
-		connection_uri.secure = m_secure;
+		
+		//connection_uri.secure = m_secure;
 		
 		std::string h = request.header("Host");
 		
+		//std::string host;
+		//std::string port;
+		
 		size_t found = h.find(":");
 		if (found == std::string::npos) {
-			connection_uri.host = h;
-			connection_uri.port = (m_secure ? DEFAULT_SECURE_PORT : DEFAULT_PORT);
+			return uri_ptr(new uri(m_secure,h,request.uri()));
 		} else {
-			uint16_t p = atoi(h.substr(found+1).c_str());
+			return uri_ptr(new uri(m_secure,h.substr(0,found),h.substr(found+1),request.uri()));
+			
+			/*uint16_t p = atoi(h.substr(found+1).c_str());
 			
 			if (p == 0) {
 				throw(http::exception("Could not determine request uri. Check host header.",http::status_code::BAD_REQUEST));
 			} else {
 				connection_uri.host = h.substr(0,found);
 				connection_uri.port = p;
-			}
+			}*/
 		}
 		
 		// TODO: check if get_uri is a full uri
-		connection_uri.resource = request.uri();
+		//connection_uri.resource = request.uri();
 		
-		return connection_uri;
+		//return uri(m_secure,host,port,request.uri());
 	}
 	
 	void handshake_response(const http::parser::request& request,http::parser::response& response) {

src/processors/processor.hpp

@@ -94,7 +94,7 @@ public:
 	// Extracts client origin from a handshake request
 	virtual std::string get_origin(const http::parser::request& request) const = 0;
 	// Extracts client uri from a handshake request
-	virtual uri get_uri(const http::parser::request& request) const = 0;
+	virtual uri_ptr get_uri(const http::parser::request& request) const = 0;
 	
 	// consume bytes, throw on exception
 	virtual void consume(std::istream& s) = 0;

src/roles/server.hpp

@@ -36,6 +36,7 @@
 #include <boost/asio.hpp>
 #include <boost/bind.hpp>
 #include <boost/shared_ptr.hpp>
+#include <boost/scoped_ptr.hpp>
 
 #include <iostream>
 #include <stdexcept>
@@ -65,17 +66,19 @@ public:
 		}
 		
 		// Information about the requested URI
+		// valid only after URIs are loaded
+		// TODO: check m_uri for NULLness
 		bool get_secure() const {
-			return m_uri.secure;
+			return m_uri->get_secure();
 		}
 		std::string get_host() const {
-			return m_uri.host;
+			return m_uri->get_host();
 		}
 		std::string get_resource() const {
-			return m_uri.resource;
+			return m_uri->get_resource();
 		}
-		unsigned short get_port() const {
-			return m_uri.port;
+		uint16_t get_port() const {
+			return m_uri->get_port();
 		}
 		
 		// Valid for CONNECTING state
@@ -140,7 +143,8 @@ public:
 		connection(endpoint& e)
 		 : m_endpoint(e),
 		   m_connection(static_cast< connection_type& >(*this)),
-		   m_version(-1) {}
+		   m_version(-1),
+		   m_uri() {}
 		
 		// initializes the websocket connection
 		void async_init() {
@@ -219,34 +223,32 @@ public:
 					
 					// should there be a more encapsulated http processor here?
 					m_origin = m_request.header("Origin");
-					m_uri.secure = m_endpoint.is_secure();
 					
+					// Set URI
 					std::string h = m_request.header("Host");
 					
 					size_t found = h.find(":");
 					if (found == std::string::npos) {
-						m_uri.host = h;
-						m_uri.port = (m_uri.secure ? DEFAULT_SECURE_PORT : DEFAULT_PORT);
+						// TODO: this makes the assumption that WS and HTTP
+						// default ports are the same.
+						m_uri.reset(new uri(m_endpoint.is_secure(),h,m_request.uri()));
 					} else {
-						uint16_t p = atoi(h.substr(found+1).c_str());
-						
-						if (p == 0) {
-							throw(http::exception("Could not determine request uri. Check host header.",http::status_code::BAD_REQUEST));
-						} else {
-							m_uri.host = h.substr(0,found);
-							m_uri.port = p;
-						}
+						m_uri.reset(new uri(m_endpoint.is_secure(),
+									h.substr(0,found),
+									h.substr(found+1),
+									m_request.uri()));
 					}
 					
-					// TODO: check if get_uri is a full uri
-					m_uri.resource = m_request.uri();
-					
 					m_response.set_status(http::status_code::OK);
 				}
 			} catch (const http::exception& e) {
 				m_endpoint.elog().at(log::elevel::ERROR) << e.what() << log::endl;
 				m_response.set_status(e.m_error_code,e.m_error_msg);
 				m_response.set_body(e.m_body);
+			} catch (const uri_exception& e) {
+				// there was some error building the uri
+				m_endpoint.elog().at(log::elevel::ERROR) << e.what() << log::endl;
+				m_response.set_status(http::status_code::BAD_REQUEST);
 			}
 			
 			write_response();
@@ -327,7 +329,7 @@ public:
 			<< m_connection.get_raw_socket().remote_endpoint() << " "
 			<< (m_version == -1 ? "" : version.str())
 			<< (get_request_header("User-Agent") == "" ? "NULL" : get_request_header("User-Agent")) 
-			<< " " << m_uri.resource << " " << m_response.status_code() 
+			<< " " << m_uri->get_resource() << " " << m_response.status_code() 
 			<< log::endl;
 		}
 		
@@ -336,7 +338,7 @@ public:
 		connection_type&			m_connection;
 		
 		int							m_version;
-		uri							m_uri;
+		uri_ptr						m_uri;
 		std::string					m_origin;
 		std::vector<std::string>	m_requested_subprotocols;
 		std::vector<std::string>	m_requested_extensions;

src/uri.cpp

@@ -71,6 +71,12 @@ uri::uri(bool secure, const std::string& host, uint16_t port, const std::string&
    m_port(port),
    m_resource(resource == "" ? "/" : resource) {}
 
+uri::uri(bool secure, const std::string& host, const std::string& resource) 
+: m_secure(secure),
+  m_host(host), 
+  m_port(m_secure ? DEFAULT_SECURE_PORT : DEFAULT_PORT),
+  m_resource(resource == "" ? "/" : resource) {}
+
 uri::uri(bool secure, 
          const std::string& host, 
          const std::string& port, 

src/uri.hpp

@@ -32,6 +32,8 @@
 #include <stdint.h>
 #include <string>
 
+#include <boost/shared_ptr.hpp>
+
 namespace websocketpp {
 
 // WebSocket URI only (not http/etc) 
@@ -53,8 +55,9 @@ public:
     static const int DEFAULT_PORT = 80;
     static const int DEFAULT_SECURE_PORT = 443;
     
-    uri(const std::string& uri);
+    explicit uri(const std::string& uri);
     uri(bool secure, const std::string& host, uint16_t port, const std::string& resource);
+	uri(bool secure, const std::string& host, const std::string& resource);
     uri(bool secure, const std::string& host, const std::string& port, const std::string& resource);
     
     bool get_secure() const;
@@ -90,6 +93,8 @@ private:
     std::string m_resource;
 };
 
+typedef boost::shared_ptr<uri> uri_ptr;
+	
 } // namespace websocketpp
 
 #endif // WEBSOCKETPP_URI_HPP