+++ /dev/null
-#include <msp/core/except.h>
-#include <msp/core/refptr.h>
-#include <msp/net/resolve.h>
-#include <msp/time/units.h>
-#include "client.h"
-#include "request.h"
-#include "response.h"
-
-using namespace std;
-
-namespace Msp {
-namespace Http {
-
-Client::Client():
- sock(0),
- event_disp(0),
- user_agent("libmsphttp/0.1"),
- request(0),
- response(0)
-{ }
-
-Client::~Client()
-{
- delete sock;
- delete request;
- delete response;
-}
-
-void Client::use_event_dispatcher(IO::EventDispatcher *ed)
-{
- if(event_disp && sock)
- event_disp->remove(*sock);
- event_disp = ed;
- if(event_disp && sock)
- event_disp->add(*sock);
-}
-
-void Client::start_request(const Request &r)
-{
- if(request)
- throw InvalidState("Already processing a request");
-
- string host = r.get_header("Host");
- if(host.find(':')==string::npos)
- host += ":80";
- RefPtr<Net::SockAddr> addr = Net::resolve(host);
-
- delete sock;
- sock = new Net::StreamSocket(addr->get_family());
- sock->set_block(false);
-
- sock->signal_data_available.connect(sigc::mem_fun(this, &Client::data_available));
- sock->signal_connect_finished.connect(sigc::mem_fun(this, &Client::connect_finished));
- if(event_disp)
- event_disp->add(*sock);
-
- sock->connect(*addr);
-
- request = new Request(r);
- if(!user_agent.empty())
- request->set_header("User-Agent", user_agent);
-
- delete response;
- response = 0;
- in_buf.clear();
-}
-
-const Response *Client::get_url(const std::string &url)
-{
- start_request(Request::from_url(url));
- wait_response();
- return response;
-}
-
-void Client::tick()
-{
- if(!request)
- return;
-
- while(IO::PollEvent ev = IO::poll(*sock, sock->get_events(), Time::zero))
- sock->event(ev);
-
- if(response && response->is_complete())
- {
- signal_response_complete.emit(*response);
-
- delete sock;
- sock = 0;
- delete request;
- request = 0;
- }
-}
-
-void Client::wait_response()
-{
- while(request && (!response || !response->is_complete()))
- tick();
-}
-
-void Client::abort()
-{
- delete sock;
- sock = 0;
- delete request;
- request = 0;
-}
-
-void Client::connect_finished(const exception *err)
-{
- if(err)
- {
- signal_socket_error.emit(err);
-
- delete request;
- request = 0;
- }
- else
- sock->write(request->str());
-}
-
-void Client::data_available()
-{
- char rbuf[4096];
- unsigned len;
- try
- {
- len = sock->read(rbuf, sizeof(rbuf));
- }
- catch(const exception &e)
- {
- signal_socket_error.emit(&e);
- return;
- }
-
- if(!len)
- return;
- in_buf.append(rbuf, len);
-
- if(!response)
- {
- if(in_buf.find("\r\n\r\n")!=string::npos || in_buf.find("\n\n")!=string::npos)
- {
- response = new Response(Response::parse(in_buf));
- response->set_user_data(request->get_user_data());
- in_buf = string();
- }
- }
- else
- {
- len = response->parse_content(in_buf);
- in_buf.erase(0, len);
- }
-
- if(response && response->is_complete())
- {
- signal_response_complete.emit(*response);
-
- delete request;
- request = 0;
- }
-}
-
-} // namespace Http
-} // namespace Msp
+++ /dev/null
-#ifndef MSP_HTTP_CLIENT_H_
-#define MSP_HTTP_CLIENT_H_
-
-#include <string>
-#include <sigc++/signal.h>
-#include <msp/io/eventdispatcher.h>
-#include <msp/net/streamsocket.h>
-
-namespace Msp {
-namespace Http {
-
-class Request;
-class Response;
-
-class Client
-{
-public:
- sigc::signal<void, const Response &> signal_response_complete;
- sigc::signal<void, const std::exception *> signal_socket_error;
-
-private:
- Net::StreamSocket *sock;
- IO::EventDispatcher *event_disp;
- std::string user_agent;
- Request *request;
- Response *response;
- std::string in_buf;
-
- Client(const Client &);
- Client &operator=(const Client &);
-public:
- Client();
- ~Client();
-
- void use_event_dispatcher(IO::EventDispatcher *);
- void set_user_agent(const std::string &);
- void start_request(const Request &);
- const Response *get_url(const std::string &);
- void tick();
- void wait_response();
- void abort();
- const Request *get_request() const { return request; }
- const Response *get_response() const { return response; }
-private:
- void connect_finished(const std::exception *);
- void data_available();
-};
-
-} // namespace Http
-} // namespace Msp
-
-#endif
--- /dev/null
+#include <msp/core/except.h>
+#include <msp/core/refptr.h>
+#include <msp/net/resolve.h>
+#include <msp/time/units.h>
+#include "client.h"
+#include "request.h"
+#include "response.h"
+
+using namespace std;
+
+namespace Msp {
+namespace Http {
+
+Client::Client():
+ sock(0),
+ event_disp(0),
+ user_agent("libmsphttp/0.1"),
+ request(0),
+ response(0)
+{ }
+
+Client::~Client()
+{
+ delete sock;
+ delete request;
+ delete response;
+}
+
+void Client::use_event_dispatcher(IO::EventDispatcher *ed)
+{
+ if(event_disp && sock)
+ event_disp->remove(*sock);
+ event_disp = ed;
+ if(event_disp && sock)
+ event_disp->add(*sock);
+}
+
+void Client::start_request(const Request &r)
+{
+ if(request)
+ throw InvalidState("Already processing a request");
+
+ string host = r.get_header("Host");
+ if(host.find(':')==string::npos)
+ host += ":80";
+ RefPtr<Net::SockAddr> addr = Net::resolve(host);
+
+ delete sock;
+ sock = new Net::StreamSocket(addr->get_family());
+ sock->set_block(false);
+
+ sock->signal_data_available.connect(sigc::mem_fun(this, &Client::data_available));
+ sock->signal_connect_finished.connect(sigc::mem_fun(this, &Client::connect_finished));
+ if(event_disp)
+ event_disp->add(*sock);
+
+ sock->connect(*addr);
+
+ request = new Request(r);
+ if(!user_agent.empty())
+ request->set_header("User-Agent", user_agent);
+
+ delete response;
+ response = 0;
+ in_buf.clear();
+}
+
+const Response *Client::get_url(const std::string &url)
+{
+ start_request(Request::from_url(url));
+ wait_response();
+ return response;
+}
+
+void Client::tick()
+{
+ if(!request)
+ return;
+
+ while(IO::PollEvent ev = IO::poll(*sock, sock->get_events(), Time::zero))
+ sock->event(ev);
+
+ if(response && response->is_complete())
+ {
+ signal_response_complete.emit(*response);
+
+ delete sock;
+ sock = 0;
+ delete request;
+ request = 0;
+ }
+}
+
+void Client::wait_response()
+{
+ while(request && (!response || !response->is_complete()))
+ tick();
+}
+
+void Client::abort()
+{
+ delete sock;
+ sock = 0;
+ delete request;
+ request = 0;
+}
+
+void Client::connect_finished(const exception *err)
+{
+ if(err)
+ {
+ signal_socket_error.emit(err);
+
+ delete request;
+ request = 0;
+ }
+ else
+ sock->write(request->str());
+}
+
+void Client::data_available()
+{
+ char rbuf[4096];
+ unsigned len;
+ try
+ {
+ len = sock->read(rbuf, sizeof(rbuf));
+ }
+ catch(const exception &e)
+ {
+ signal_socket_error.emit(&e);
+ return;
+ }
+
+ if(!len)
+ return;
+ in_buf.append(rbuf, len);
+
+ if(!response)
+ {
+ if(in_buf.find("\r\n\r\n")!=string::npos || in_buf.find("\n\n")!=string::npos)
+ {
+ response = new Response(Response::parse(in_buf));
+ response->set_user_data(request->get_user_data());
+ in_buf = string();
+ }
+ }
+ else
+ {
+ len = response->parse_content(in_buf);
+ in_buf.erase(0, len);
+ }
+
+ if(response && response->is_complete())
+ {
+ signal_response_complete.emit(*response);
+
+ delete request;
+ request = 0;
+ }
+}
+
+} // namespace Http
+} // namespace Msp
--- /dev/null
+#ifndef MSP_HTTP_CLIENT_H_
+#define MSP_HTTP_CLIENT_H_
+
+#include <string>
+#include <sigc++/signal.h>
+#include <msp/io/eventdispatcher.h>
+#include <msp/net/streamsocket.h>
+
+namespace Msp {
+namespace Http {
+
+class Request;
+class Response;
+
+class Client
+{
+public:
+ sigc::signal<void, const Response &> signal_response_complete;
+ sigc::signal<void, const std::exception *> signal_socket_error;
+
+private:
+ Net::StreamSocket *sock;
+ IO::EventDispatcher *event_disp;
+ std::string user_agent;
+ Request *request;
+ Response *response;
+ std::string in_buf;
+
+ Client(const Client &);
+ Client &operator=(const Client &);
+public:
+ Client();
+ ~Client();
+
+ void use_event_dispatcher(IO::EventDispatcher *);
+ void set_user_agent(const std::string &);
+ void start_request(const Request &);
+ const Response *get_url(const std::string &);
+ void tick();
+ void wait_response();
+ void abort();
+ const Request *get_request() const { return request; }
+ const Response *get_response() const { return response; }
+private:
+ void connect_finished(const std::exception *);
+ void data_available();
+};
+
+} // namespace Http
+} // namespace Msp
+
+#endif
--- /dev/null
+#include <cstdlib>
+#include <msp/core/maputils.h>
+#include <msp/strings/formatter.h>
+#include <msp/strings/utils.h>
+#include "message.h"
+
+using namespace std;
+
+namespace Msp {
+namespace Http {
+
+Message::Message():
+ http_version(0x11),
+ chunk_length(0),
+ complete(false)
+{ }
+
+void Message::set_header(const string &hdr, const string &val)
+{
+ headers[normalize_header_name(hdr)] = val;
+}
+
+bool Message::has_header(const string &hdr) const
+{
+ return headers.count(normalize_header_name(hdr));
+}
+
+const string &Message::get_header(const string &hdr) const
+{
+ return get_item(headers, normalize_header_name(hdr));
+}
+
+void Message::add_content(const string &d)
+{
+ content += d;
+ if(headers.count("Content-Type")==0)
+ set_header("Content-Type", "text/plain");
+ set_header("Content-Length", lexical_cast(content.size()));
+}
+
+void Message::set_user_data(const Variant &d)
+{
+ user_data = d;
+}
+
+unsigned Message::parse_content(const string &d)
+{
+ if(complete)
+ return 0;
+
+ HeaderMap::const_iterator i = headers.find("Content-Length");
+ if(i!=headers.end())
+ {
+ unsigned needed = lexical_cast<unsigned>(i->second)-content.size();
+ unsigned len = min(needed, d.size());
+
+ content.append(d, 0, len);
+
+ if(len==needed)
+ complete = true;
+
+ return len;
+ }
+
+ i = headers.find("Transfer-Encoding");
+ if(i!=headers.end() && strcasecmp(i->second, "chunked")==0)
+ {
+ unsigned pos = 0;
+ while(!complete && pos<d.size())
+ {
+ if(chunk_length==0)
+ {
+ unsigned lf = d.find('\n', pos);
+ if(lf==string::npos)
+ return pos;
+ chunk_length = lexical_cast<unsigned>(strip(d.substr(pos, lf-pos)), "x");
+ if(chunk_length==0)
+ complete = true;
+ pos = lf+1;
+ }
+ else
+ {
+ unsigned len = min(chunk_length, d.size()-pos);
+ content.append(d, pos, len);
+ chunk_length -= len;
+ if((pos = d.find('\n', pos+len))!=string::npos)
+ ++pos;
+ }
+ }
+
+ return pos;
+ }
+
+ complete = true;
+ return 0;
+}
+
+unsigned Message::parse_headers(const string &d)
+{
+ unsigned start = 0;
+ while(1)
+ {
+ unsigned lf = d.find('\n', start);
+ if(lf==string::npos)
+ throw invalid_argument("Message::parse_headers");
+ if(lf==start || (d[start]=='\r' && lf==start+1))
+ return lf+1;
+
+ unsigned colon = d.find(':', start);
+ if(colon>lf)
+ throw invalid_argument("Message::parse_headers");
+
+ set_header(d.substr(start, colon-start), strip(d.substr(colon+1, lf-colon-1)));
+
+ start = lf+1;
+ }
+}
+
+string Message::str_common() const
+{
+ string result;
+
+ for(HeaderMap::const_iterator i=headers.begin(); i!=headers.end(); ++i)
+ if(i->first[0]!='-')
+ result += format("%s: %s\r\n", i->first, i->second);
+ result += "\r\n";
+ result += content;
+
+ return result;
+}
+
+string Message::normalize_header_name(const string &hdr) const
+{
+ string result = hdr;
+ bool upper = true;
+ for(string::iterator i=result.begin(); i!=result.end(); ++i)
+ {
+ if(upper)
+ {
+ *i = toupper(*i);
+ upper = false;
+ }
+ else if(*i=='-')
+ upper = true;
+ else
+ *i = tolower(*i);
+ }
+ return result;
+}
+
+} // namespace Http
+} // namespace Msp
--- /dev/null
+#ifndef MSP_HTTP_MESSAGE_H_
+#define MSP_HTTP_MESSAGE_H_
+
+#include <map>
+#include <string>
+#include <msp/core/variant.h>
+#include "version.h"
+
+namespace Msp {
+namespace Http {
+
+class Message
+{
+protected:
+ typedef std::map<std::string, std::string> HeaderMap;
+
+ Version http_version;
+ HeaderMap headers;
+ std::string content;
+ unsigned chunk_length;
+ bool complete;
+ Variant user_data;
+
+ Message();
+public:
+ virtual ~Message() { }
+
+ void set_header(const std::string &, const std::string &);
+ bool has_header(const std::string &) const;
+ const std::string &get_header(const std::string &) const;
+ void add_content(const std::string &);
+ const std::string &get_content() const { return content; }
+ void set_user_data(const Variant &);
+ const Variant &get_user_data() const { return user_data; }
+ bool is_complete() const { return complete; }
+ unsigned parse_content(const std::string &);
+ virtual std::string str() const = 0;
+protected:
+ unsigned parse_headers(const std::string &);
+ std::string str_common() const;
+ std::string normalize_header_name(const std::string &) const;
+};
+
+} // namespace Http
+} // namespace Msp
+
+#endif
--- /dev/null
+#include <msp/strings/formatter.h>
+#include <msp/strings/regex.h>
+#include <msp/strings/utils.h>
+#include "request.h"
+#include "utils.h"
+
+using namespace std;
+
+namespace Msp {
+namespace Http {
+
+Request::Request(const string &m, const string &p):
+ method(m),
+ path(p)
+{ }
+
+string Request::str() const
+{
+ string result = format("%s %s %s\r\n", method, path, version_str(http_version));
+ result += str_common();
+
+ return result;
+}
+
+Request Request::parse(const string &str)
+{
+ unsigned lf = str.find('\n');
+ vector<string> parts = split(str.substr(0, lf-(str[lf-1]=='\r')), ' ', 2);
+ if(parts.size()<3)
+ throw invalid_argument("Request::parse");
+
+ Request result(parts[0], parts[1]);
+ result.http_version = parse_version(parts[2]);
+
+ lf += result.parse_headers(str.substr(lf+1));
+
+ result.parse_content(str.substr(lf+1));
+
+ return result;
+}
+
+Request Request::from_url(const string &str)
+{
+ Url url = parse_url(str);
+ if(url.scheme!="http")
+ throw invalid_argument("Request::from_url");
+
+ string path = url.path;
+ if(path.empty())
+ path = "/";
+ if(!url.query.empty())
+ {
+ path += '?';
+ path += url.query;
+ }
+
+ Request result("GET", path);
+ result.set_header("Host", url.host);
+ result.set_header("Connection", "close");
+
+ return result;
+}
+
+} // namespace Http
+} // namespace Msp
--- /dev/null
+#ifndef MSP_HTTP_REQUEST_H_
+#define MSP_HTTP_REQUEST_H_
+
+#include <string>
+#include "message.h"
+
+namespace Msp {
+namespace Http {
+
+class Request: public Message
+{
+private:
+ std::string method;
+ std::string path;
+
+public:
+ Request(const std::string &, const std::string &);
+ const std::string &get_method() const { return method; }
+ const std::string &get_path() const { return path; }
+ virtual std::string str() const;
+
+ static Request parse(const std::string &);
+ static Request from_url(const std::string &);
+};
+
+} // namespace Http
+} // namespace Msp
+
+#endif
--- /dev/null
+#include <msp/strings/formatter.h>
+#include <msp/strings/utils.h>
+#include "response.h"
+
+using namespace std;
+
+namespace Msp {
+namespace Http {
+
+Response::Response(Status s):
+ status(s)
+{ }
+
+string Response::str() const
+{
+ string result = format("%s %d %s\r\n", version_str(http_version), static_cast<int>(status), status);
+ result += str_common();
+
+ return result;
+}
+
+Response Response::parse(const string &str)
+{
+ Response result;
+
+ unsigned lf = str.find('\n');
+ vector<string> parts = split(str.substr(0, lf), ' ', 2);
+ if(parts.size()<2)
+ throw invalid_argument("Response::parse");
+
+ result.http_version = parse_version(parts[0]);
+ result.status = static_cast<Status>(lexical_cast<unsigned>(parts[1]));
+
+ lf += result.parse_headers(str.substr(lf+1));
+
+ result.parse_content(str.substr(lf+1));
+
+ return result;
+}
+
+} // namespace Http
+} // namespace Msp
--- /dev/null
+#ifndef MSP_HTTP_RESPONSE_H_
+#define MSP_HTTO_RESPONSE_H_
+
+#include "message.h"
+#include "status.h"
+
+namespace Msp {
+namespace Http {
+
+class Response: public Message
+{
+private:
+ Status status;
+
+ Response() { }
+public:
+ Response(Status);
+ Status get_status() const { return status; }
+ virtual std::string str() const;
+
+ static Response parse(const std::string &);
+};
+
+} // namespace Http
+} // namespace Msp
+
+#endif
--- /dev/null
+#include <exception>
+#include <msp/core/refptr.h>
+#include <msp/net/inet.h>
+#include <msp/net/resolve.h>
+#include <msp/net/streamsocket.h>
+#include <msp/strings/format.h>
+#include "request.h"
+#include "response.h"
+#include "server.h"
+
+using namespace std;
+
+namespace Msp {
+namespace Http {
+
+Server::Server(unsigned port):
+ sock(Net::INET),
+ event_disp(0)
+{
+ sock.signal_data_available.connect(sigc::mem_fun(this, &Server::data_available));
+ RefPtr<Net::SockAddr> addr = Net::resolve("*", format("%d", port));
+ sock.listen(*addr, 8);
+}
+
+unsigned Server::get_port() const
+{
+ const Net::SockAddr &addr = sock.get_local_address();
+ if(addr.get_family()==Net::INET)
+ return static_cast<const Net::InetAddr &>(addr).get_port();
+ return 0;
+}
+
+void Server::use_event_dispatcher(IO::EventDispatcher *ed)
+{
+ if(event_disp)
+ {
+ event_disp->remove(sock);
+ for(list<Client>::iterator i=clients.begin(); i!=clients.end(); ++i)
+ event_disp->remove(*i->sock);
+ }
+ event_disp = ed;
+ if(event_disp)
+ {
+ event_disp->add(sock);
+ for(list<Client>::iterator i=clients.begin(); i!=clients.end(); ++i)
+ event_disp->add(*i->sock);
+ }
+}
+
+void Server::delay_response(Response &resp)
+{
+ get_client_by_response(resp).async = true;
+}
+
+void Server::submit_response(Response &resp)
+{
+ Client &cl = get_client_by_response(resp);
+ if(cl.async)
+ {
+ cl.sock->write(resp.str());
+ cl.stale = true;
+ }
+}
+
+void Server::data_available()
+{
+ Net::StreamSocket *csock = sock.accept();
+ clients.push_back(Client(csock));
+ csock->signal_data_available.connect(sigc::bind(sigc::mem_fun(this, &Server::client_data_available), sigc::ref(clients.back())));
+ csock->signal_end_of_file.connect(sigc::bind(sigc::mem_fun(this, &Server::client_end_of_file), sigc::ref(clients.back())));
+ if(event_disp)
+ event_disp->add(*csock);
+}
+
+void Server::client_data_available(Client &cl)
+{
+ for(list<Client>::iterator i=clients.begin(); i!=clients.end(); ++i)
+ if(i->stale && &*i!=&cl)
+ {
+ clients.erase(i);
+ break;
+ }
+
+ char rbuf[4096];
+ unsigned len = cl.sock->read(rbuf, sizeof(rbuf));
+ cl.in_buf.append(rbuf, len);
+
+ RefPtr<Response> response;
+ if(!cl.request)
+ {
+ if(cl.in_buf.find("\r\n\r\n")!=string::npos || cl.in_buf.find("\n\n")!=string::npos)
+ {
+ try
+ {
+ cl.request = new Request(Request::parse(cl.in_buf));
+
+ string addr_str = cl.sock->get_peer_address().str();
+ unsigned colon = addr_str.find(':');
+ cl.request->set_header("-Client-Host", addr_str.substr(0, colon));
+
+ if(cl.request->get_method()!="GET" && cl.request->get_method()!="POST")
+ {
+ response = new Response(NOT_IMPLEMENTED);
+ response->add_content("Method not implemented\n");
+ }
+ }
+ catch(const exception &e)
+ {
+ response = new Response(BAD_REQUEST);
+ response->add_content(e.what());
+ }
+ cl.in_buf = string();
+ }
+ }
+ else
+ {
+ len = cl.request->parse_content(cl.in_buf);
+ cl.in_buf.erase(0, len);
+ }
+
+ if(cl.request && cl.request->is_complete() && !response)
+ {
+ response = new Response(NONE);
+ try
+ {
+ cl.response = response.get();
+ signal_request.emit(*cl.request, *response);
+ if(cl.async)
+ response.release();
+ else
+ {
+ cl.response = 0;
+ if(response->get_status()==NONE)
+ {
+ response = new Response(NOT_FOUND);
+ response->add_content("The requested resource was not found\n");
+ }
+ }
+ }
+ catch(const exception &e)
+ {
+ cl.response = 0;
+ response = new Response(INTERNAL_ERROR);
+ response->add_content(e.what());
+ }
+ }
+
+ if(response)
+ {
+ cl.sock->write(response->str());
+ cl.stale = true;
+ }
+}
+
+void Server::client_end_of_file(Client &cl)
+{
+ cl.stale = true;
+}
+
+Server::Client &Server::get_client_by_response(Response &resp)
+{
+ for(list<Client>::iterator i=clients.begin(); i!=clients.end(); ++i)
+ if(i->response==&resp)
+ return *i;
+
+ // XXX Do this differently
+ throw invalid_argument("Response does not belong to any client");
+}
+
+
+Server::Client::Client(RefPtr<Net::StreamSocket> s):
+ sock(s),
+ request(0),
+ response(0),
+ async(false),
+ stale(false)
+{ }
+
+Server::Client::~Client()
+{
+ delete request;
+ delete response;
+}
+
+} // namespace Http
+} // namespace Msp
--- /dev/null
+#ifndef MSP_HTTP_SERVER_H_
+#define MSP_HTTP_SERVER_H_
+
+#include <msp/core/refptr.h>
+#include <msp/io/eventdispatcher.h>
+#include <msp/net/streamserversocket.h>
+
+namespace Msp {
+namespace Http {
+
+class Request;
+class Response;
+
+class Server
+{
+public:
+ sigc::signal<void, const Request &, Response &> signal_request;
+
+private:
+ struct Client
+ {
+ RefPtr<Net::StreamSocket> sock;
+ std::string in_buf;
+ Request *request;
+ Response *response;
+ bool async;
+ bool stale;
+
+ Client(RefPtr<Net::StreamSocket>);
+ ~Client();
+ };
+
+ Net::StreamServerSocket sock;
+ std::list<Client> clients;
+ IO::EventDispatcher *event_disp;
+
+public:
+ Server(unsigned);
+ unsigned get_port() const;
+ void use_event_dispatcher(IO::EventDispatcher *);
+ void delay_response(Response &);
+ void submit_response(Response &);
+private:
+ void data_available();
+ void client_data_available(Client &);
+ void client_end_of_file(Client &);
+ Client &get_client_by_response(Response &);
+};
+
+} // namespace Http
+} // namespace Msp
+
+#endif
--- /dev/null
+#include "status.h"
+
+using namespace std;
+
+namespace Msp {
+namespace Http {
+
+ostream &operator<<(ostream &out, Status status)
+{
+ switch(status)
+ {
+ case NONE: out<<"None"; break;
+ case OK: out<<"OK"; break;
+ case BAD_REQUEST: out<<"Bad Request"; break;
+ case FORBIDDEN: out<<"Forbidden"; break;
+ case NOT_FOUND: out<<"Not Found"; break;
+ case INTERNAL_ERROR: out<<"Internal Error"; break;
+ case NOT_IMPLEMENTED: out<<"Not Implemented"; break;
+ default: out<<"Unknown Status"; break;
+ }
+
+ return out;
+}
+
+} // namespace Http
+} // namespace Msp
--- /dev/null
+#ifndef MSP_HTTPSERVER_STATUS_H_
+#define MSP_HTTPSERVER_STATUS_H_
+
+#include <ostream>
+
+namespace Msp {
+namespace Http {
+
+enum Status
+{
+ NONE = 0,
+ OK = 200,
+ BAD_REQUEST = 400,
+ FORBIDDEN = 403,
+ NOT_FOUND = 404,
+ INTERNAL_ERROR = 500,
+ NOT_IMPLEMENTED = 501
+};
+
+extern std::ostream &operator<<(std::ostream &, Status);
+
+} // namespace Http
+} // namespace Msp
+
+#endif
--- /dev/null
+#include <algorithm>
+#include <msp/strings/formatter.h>
+#include <msp/strings/regex.h>
+#include <msp/strings/utils.h>
+#include "utils.h"
+
+using namespace std;
+
+namespace {
+
+const char *reserved[]=
+{
+ " #%&+=?",
+ " #%&*+:;=?@[]",
+ " !#$%&'()*+,/:;=?@[]",
+};
+
+bool is_reserved(char c, unsigned level)
+{
+ for(const char *r=reserved[level]; *r; ++r)
+ if(c==*r)
+ return true;
+ return false;
+}
+
+}
+
+namespace Msp {
+namespace Http {
+
+string urlencode(const string &str, EncodeLevel level)
+{
+ string result;
+ for(string::const_iterator i=str.begin(); i!=str.end(); ++i)
+ {
+ if(is_reserved(*i, level))
+ result += format("%%%02X", *i);
+ else
+ result += *i;
+ }
+ return result;
+}
+
+string urlencode_plus(const string &str, EncodeLevel level)
+{
+ string result;
+ for(string::const_iterator i=str.begin(); i!=str.end(); ++i)
+ {
+ if(*i==' ')
+ result += '+';
+ else if(is_reserved(*i, level))
+ result += format("%%%02X", *i);
+ else
+ result += *i;
+ }
+ return result;
+}
+
+string urldecode(const string &str)
+{
+ string result;
+ for(unsigned i=0; i<str.size(); ++i)
+ {
+ char c = str[i];
+ if(c=='%')
+ {
+ if(i+3>str.size())
+ throw invalid_argument("urldecode");
+ result += lexical_cast<unsigned char>(str.substr(i+1, 2), "x");
+ i += 2;
+ }
+ else if(c=='+')
+ result += ' ';
+ else
+ result += c;
+ }
+ return result;
+}
+
+Url parse_url(const string &str)
+{
+ static Regex r_url("(([a-z]+)://)?([a-zA-Z0-9-]+(\\.[a-zA-Z0-9-]+)*(:[0-9])?)?(/[^?#]*)?(\\?([^#]+))?(#(.*))?");
+ if(RegMatch m = r_url.match(str))
+ {
+ Url url;
+ url.scheme = m[2].str;
+ url.host = m[3].str;
+ url.path = urldecode(m[6].str);
+ url.query = m[8].str;
+ url.fragment = m[10].str;
+ return url;
+ }
+ else
+ throw invalid_argument("parse_url");
+}
+
+string build_url(const Url &url)
+{
+ if(!url.path.empty() && url.path[0]!='/')
+ throw invalid_argument("build_url");
+
+ string str;
+ if(!url.scheme.empty())
+ str += url.scheme+"://";
+ str += url.host;
+ str += urlencode(url.path);
+ if(!url.query.empty())
+ {
+ str += '?';
+ str += url.query;
+ }
+ if(!url.fragment.empty())
+ {
+ str += '#';
+ str += url.fragment;
+ }
+ return str;
+}
+
+Query parse_query(const std::string &str)
+{
+ vector<string> parts = split(str, '&');
+ Query query;
+ for(vector<string>::const_iterator i=parts.begin(); i!=parts.end(); ++i)
+ {
+ unsigned equals = i->find('=');
+ string &value = query[urldecode(i->substr(0, equals))];
+ if(equals!=string::npos)
+ value = urldecode(i->substr(equals+1));
+ }
+ return query;
+}
+
+string build_query(const Query &query)
+{
+ string str;
+ for(Query::const_iterator i=query.begin(); i!=query.end(); ++i)
+ {
+ if(i!=query.begin())
+ str += '&';
+ str += urlencode_plus(i->first);
+ str += '=';
+ str += urlencode_plus(i->second);
+ }
+ return str;
+}
+
+} // namespace Http
+} // namespace Msp
--- /dev/null
+#ifndef MSP_HTTP_UTILS_H_
+#define MSP_HTTP_UTILS_H_
+
+#include <map>
+#include <string>
+
+namespace Msp {
+namespace Http {
+
+enum EncodeLevel
+{
+ MINIMAL,
+ SAFE,
+ PARANOID
+};
+
+struct Url
+{
+ std::string scheme;
+ std::string host;
+ std::string path;
+ std::string query;
+ std::string fragment;
+};
+
+typedef std::map<std::string, std::string> Query;
+
+std::string urlencode(const std::string &, EncodeLevel =SAFE);
+std::string urlencode_plus(const std::string &, EncodeLevel =SAFE);
+std::string urldecode(const std::string &);
+Url parse_url(const std::string &);
+std::string build_url(const Url &);
+Query parse_query(const std::string &);
+std::string build_query(const Query &);
+
+} // namespace Http
+} // namespace Msp
+
+#endif
--- /dev/null
+#include <msp/strings/formatter.h>
+#include <msp/strings/lexicalcast.h>
+#include <msp/strings/regex.h>
+#include "version.h"
+
+using namespace std;
+
+namespace Msp {
+namespace Http {
+
+Version parse_version(const std::string &ver)
+{
+ if(RegMatch match = Regex("^HTTP/([0-9]+).([0-9]+)$").match(ver))
+ return lexical_cast<unsigned>(match[1].str)<<4 | lexical_cast<unsigned>(match[2].str);
+ else
+ throw invalid_argument("parse_version");
+}
+
+string version_str(Version ver)
+{
+ return format("HTTP/%u.%u", (ver>>4)&0xF, ver&0xF);
+}
+
+} // namespace Http
+} // namespace Msp
--- /dev/null
+#ifndef MSP_HTTP_MISC_H_
+#define MSP_HTTP_MISC_H_
+
+#include <string>
+
+namespace Msp {
+namespace Http {
+
+typedef unsigned Version;
+
+Version parse_version(const std::string &);
+std::string version_str(Version);
+
+} // namespace Http
+} // namespace Msp
+
+#endif
+++ /dev/null
-#include <cstdlib>
-#include <msp/core/maputils.h>
-#include <msp/strings/formatter.h>
-#include <msp/strings/utils.h>
-#include "message.h"
-
-using namespace std;
-
-namespace Msp {
-namespace Http {
-
-Message::Message():
- http_version(0x11),
- chunk_length(0),
- complete(false)
-{ }
-
-void Message::set_header(const string &hdr, const string &val)
-{
- headers[normalize_header_name(hdr)] = val;
-}
-
-bool Message::has_header(const string &hdr) const
-{
- return headers.count(normalize_header_name(hdr));
-}
-
-const string &Message::get_header(const string &hdr) const
-{
- return get_item(headers, normalize_header_name(hdr));
-}
-
-void Message::add_content(const string &d)
-{
- content += d;
- if(headers.count("Content-Type")==0)
- set_header("Content-Type", "text/plain");
- set_header("Content-Length", lexical_cast(content.size()));
-}
-
-void Message::set_user_data(const Variant &d)
-{
- user_data = d;
-}
-
-unsigned Message::parse_content(const string &d)
-{
- if(complete)
- return 0;
-
- HeaderMap::const_iterator i = headers.find("Content-Length");
- if(i!=headers.end())
- {
- unsigned needed = lexical_cast<unsigned>(i->second)-content.size();
- unsigned len = min(needed, d.size());
-
- content.append(d, 0, len);
-
- if(len==needed)
- complete = true;
-
- return len;
- }
-
- i = headers.find("Transfer-Encoding");
- if(i!=headers.end() && strcasecmp(i->second, "chunked")==0)
- {
- unsigned pos = 0;
- while(!complete && pos<d.size())
- {
- if(chunk_length==0)
- {
- unsigned lf = d.find('\n', pos);
- if(lf==string::npos)
- return pos;
- chunk_length = lexical_cast<unsigned>(strip(d.substr(pos, lf-pos)), "x");
- if(chunk_length==0)
- complete = true;
- pos = lf+1;
- }
- else
- {
- unsigned len = min(chunk_length, d.size()-pos);
- content.append(d, pos, len);
- chunk_length -= len;
- if((pos = d.find('\n', pos+len))!=string::npos)
- ++pos;
- }
- }
-
- return pos;
- }
-
- complete = true;
- return 0;
-}
-
-unsigned Message::parse_headers(const string &d)
-{
- unsigned start = 0;
- while(1)
- {
- unsigned lf = d.find('\n', start);
- if(lf==string::npos)
- throw invalid_argument("Message::parse_headers");
- if(lf==start || (d[start]=='\r' && lf==start+1))
- return lf+1;
-
- unsigned colon = d.find(':', start);
- if(colon>lf)
- throw invalid_argument("Message::parse_headers");
-
- set_header(d.substr(start, colon-start), strip(d.substr(colon+1, lf-colon-1)));
-
- start = lf+1;
- }
-}
-
-string Message::str_common() const
-{
- string result;
-
- for(HeaderMap::const_iterator i=headers.begin(); i!=headers.end(); ++i)
- if(i->first[0]!='-')
- result += format("%s: %s\r\n", i->first, i->second);
- result += "\r\n";
- result += content;
-
- return result;
-}
-
-string Message::normalize_header_name(const string &hdr) const
-{
- string result = hdr;
- bool upper = true;
- for(string::iterator i=result.begin(); i!=result.end(); ++i)
- {
- if(upper)
- {
- *i = toupper(*i);
- upper = false;
- }
- else if(*i=='-')
- upper = true;
- else
- *i = tolower(*i);
- }
- return result;
-}
-
-} // namespace Http
-} // namespace Msp
+++ /dev/null
-#ifndef MSP_HTTP_MESSAGE_H_
-#define MSP_HTTP_MESSAGE_H_
-
-#include <map>
-#include <string>
-#include <msp/core/variant.h>
-#include "version.h"
-
-namespace Msp {
-namespace Http {
-
-class Message
-{
-protected:
- typedef std::map<std::string, std::string> HeaderMap;
-
- Version http_version;
- HeaderMap headers;
- std::string content;
- unsigned chunk_length;
- bool complete;
- Variant user_data;
-
- Message();
-public:
- virtual ~Message() { }
-
- void set_header(const std::string &, const std::string &);
- bool has_header(const std::string &) const;
- const std::string &get_header(const std::string &) const;
- void add_content(const std::string &);
- const std::string &get_content() const { return content; }
- void set_user_data(const Variant &);
- const Variant &get_user_data() const { return user_data; }
- bool is_complete() const { return complete; }
- unsigned parse_content(const std::string &);
- virtual std::string str() const = 0;
-protected:
- unsigned parse_headers(const std::string &);
- std::string str_common() const;
- std::string normalize_header_name(const std::string &) const;
-};
-
-} // namespace Http
-} // namespace Msp
-
-#endif
+++ /dev/null
-#include <msp/strings/formatter.h>
-#include <msp/strings/regex.h>
-#include <msp/strings/utils.h>
-#include "request.h"
-#include "utils.h"
-
-using namespace std;
-
-namespace Msp {
-namespace Http {
-
-Request::Request(const string &m, const string &p):
- method(m),
- path(p)
-{ }
-
-string Request::str() const
-{
- string result = format("%s %s %s\r\n", method, path, version_str(http_version));
- result += str_common();
-
- return result;
-}
-
-Request Request::parse(const string &str)
-{
- unsigned lf = str.find('\n');
- vector<string> parts = split(str.substr(0, lf-(str[lf-1]=='\r')), ' ', 2);
- if(parts.size()<3)
- throw invalid_argument("Request::parse");
-
- Request result(parts[0], parts[1]);
- result.http_version = parse_version(parts[2]);
-
- lf += result.parse_headers(str.substr(lf+1));
-
- result.parse_content(str.substr(lf+1));
-
- return result;
-}
-
-Request Request::from_url(const string &str)
-{
- Url url = parse_url(str);
- if(url.scheme!="http")
- throw invalid_argument("Request::from_url");
-
- string path = url.path;
- if(path.empty())
- path = "/";
- if(!url.query.empty())
- {
- path += '?';
- path += url.query;
- }
-
- Request result("GET", path);
- result.set_header("Host", url.host);
- result.set_header("Connection", "close");
-
- return result;
-}
-
-} // namespace Http
-} // namespace Msp
+++ /dev/null
-#ifndef MSP_HTTP_REQUEST_H_
-#define MSP_HTTP_REQUEST_H_
-
-#include <string>
-#include "message.h"
-
-namespace Msp {
-namespace Http {
-
-class Request: public Message
-{
-private:
- std::string method;
- std::string path;
-
-public:
- Request(const std::string &, const std::string &);
- const std::string &get_method() const { return method; }
- const std::string &get_path() const { return path; }
- virtual std::string str() const;
-
- static Request parse(const std::string &);
- static Request from_url(const std::string &);
-};
-
-} // namespace Http
-} // namespace Msp
-
-#endif
+++ /dev/null
-#include <msp/strings/formatter.h>
-#include <msp/strings/utils.h>
-#include "response.h"
-
-using namespace std;
-
-namespace Msp {
-namespace Http {
-
-Response::Response(Status s):
- status(s)
-{ }
-
-string Response::str() const
-{
- string result = format("%s %d %s\r\n", version_str(http_version), static_cast<int>(status), status);
- result += str_common();
-
- return result;
-}
-
-Response Response::parse(const string &str)
-{
- Response result;
-
- unsigned lf = str.find('\n');
- vector<string> parts = split(str.substr(0, lf), ' ', 2);
- if(parts.size()<2)
- throw invalid_argument("Response::parse");
-
- result.http_version = parse_version(parts[0]);
- result.status = static_cast<Status>(lexical_cast<unsigned>(parts[1]));
-
- lf += result.parse_headers(str.substr(lf+1));
-
- result.parse_content(str.substr(lf+1));
-
- return result;
-}
-
-} // namespace Http
-} // namespace Msp
+++ /dev/null
-#ifndef MSP_HTTP_RESPONSE_H_
-#define MSP_HTTO_RESPONSE_H_
-
-#include "message.h"
-#include "status.h"
-
-namespace Msp {
-namespace Http {
-
-class Response: public Message
-{
-private:
- Status status;
-
- Response() { }
-public:
- Response(Status);
- Status get_status() const { return status; }
- virtual std::string str() const;
-
- static Response parse(const std::string &);
-};
-
-} // namespace Http
-} // namespace Msp
-
-#endif
+++ /dev/null
-#include <exception>
-#include <msp/core/refptr.h>
-#include <msp/net/inet.h>
-#include <msp/net/resolve.h>
-#include <msp/net/streamsocket.h>
-#include <msp/strings/format.h>
-#include "request.h"
-#include "response.h"
-#include "server.h"
-
-using namespace std;
-
-namespace Msp {
-namespace Http {
-
-Server::Server(unsigned port):
- sock(Net::INET),
- event_disp(0)
-{
- sock.signal_data_available.connect(sigc::mem_fun(this, &Server::data_available));
- RefPtr<Net::SockAddr> addr = Net::resolve("*", format("%d", port));
- sock.listen(*addr, 8);
-}
-
-unsigned Server::get_port() const
-{
- const Net::SockAddr &addr = sock.get_local_address();
- if(addr.get_family()==Net::INET)
- return static_cast<const Net::InetAddr &>(addr).get_port();
- return 0;
-}
-
-void Server::use_event_dispatcher(IO::EventDispatcher *ed)
-{
- if(event_disp)
- {
- event_disp->remove(sock);
- for(list<Client>::iterator i=clients.begin(); i!=clients.end(); ++i)
- event_disp->remove(*i->sock);
- }
- event_disp = ed;
- if(event_disp)
- {
- event_disp->add(sock);
- for(list<Client>::iterator i=clients.begin(); i!=clients.end(); ++i)
- event_disp->add(*i->sock);
- }
-}
-
-void Server::delay_response(Response &resp)
-{
- get_client_by_response(resp).async = true;
-}
-
-void Server::submit_response(Response &resp)
-{
- Client &cl = get_client_by_response(resp);
- if(cl.async)
- {
- cl.sock->write(resp.str());
- cl.stale = true;
- }
-}
-
-void Server::data_available()
-{
- Net::StreamSocket *csock = sock.accept();
- clients.push_back(Client(csock));
- csock->signal_data_available.connect(sigc::bind(sigc::mem_fun(this, &Server::client_data_available), sigc::ref(clients.back())));
- csock->signal_end_of_file.connect(sigc::bind(sigc::mem_fun(this, &Server::client_end_of_file), sigc::ref(clients.back())));
- if(event_disp)
- event_disp->add(*csock);
-}
-
-void Server::client_data_available(Client &cl)
-{
- for(list<Client>::iterator i=clients.begin(); i!=clients.end(); ++i)
- if(i->stale && &*i!=&cl)
- {
- clients.erase(i);
- break;
- }
-
- char rbuf[4096];
- unsigned len = cl.sock->read(rbuf, sizeof(rbuf));
- cl.in_buf.append(rbuf, len);
-
- RefPtr<Response> response;
- if(!cl.request)
- {
- if(cl.in_buf.find("\r\n\r\n")!=string::npos || cl.in_buf.find("\n\n")!=string::npos)
- {
- try
- {
- cl.request = new Request(Request::parse(cl.in_buf));
-
- string addr_str = cl.sock->get_peer_address().str();
- unsigned colon = addr_str.find(':');
- cl.request->set_header("-Client-Host", addr_str.substr(0, colon));
-
- if(cl.request->get_method()!="GET" && cl.request->get_method()!="POST")
- {
- response = new Response(NOT_IMPLEMENTED);
- response->add_content("Method not implemented\n");
- }
- }
- catch(const exception &e)
- {
- response = new Response(BAD_REQUEST);
- response->add_content(e.what());
- }
- cl.in_buf = string();
- }
- }
- else
- {
- len = cl.request->parse_content(cl.in_buf);
- cl.in_buf.erase(0, len);
- }
-
- if(cl.request && cl.request->is_complete() && !response)
- {
- response = new Response(NONE);
- try
- {
- cl.response = response.get();
- signal_request.emit(*cl.request, *response);
- if(cl.async)
- response.release();
- else
- {
- cl.response = 0;
- if(response->get_status()==NONE)
- {
- response = new Response(NOT_FOUND);
- response->add_content("The requested resource was not found\n");
- }
- }
- }
- catch(const exception &e)
- {
- cl.response = 0;
- response = new Response(INTERNAL_ERROR);
- response->add_content(e.what());
- }
- }
-
- if(response)
- {
- cl.sock->write(response->str());
- cl.stale = true;
- }
-}
-
-void Server::client_end_of_file(Client &cl)
-{
- cl.stale = true;
-}
-
-Server::Client &Server::get_client_by_response(Response &resp)
-{
- for(list<Client>::iterator i=clients.begin(); i!=clients.end(); ++i)
- if(i->response==&resp)
- return *i;
-
- // XXX Do this differently
- throw invalid_argument("Response does not belong to any client");
-}
-
-
-Server::Client::Client(RefPtr<Net::StreamSocket> s):
- sock(s),
- request(0),
- response(0),
- async(false),
- stale(false)
-{ }
-
-Server::Client::~Client()
-{
- delete request;
- delete response;
-}
-
-} // namespace Http
-} // namespace Msp
+++ /dev/null
-#ifndef MSP_HTTP_SERVER_H_
-#define MSP_HTTP_SERVER_H_
-
-#include <msp/core/refptr.h>
-#include <msp/io/eventdispatcher.h>
-#include <msp/net/streamserversocket.h>
-
-namespace Msp {
-namespace Http {
-
-class Request;
-class Response;
-
-class Server
-{
-public:
- sigc::signal<void, const Request &, Response &> signal_request;
-
-private:
- struct Client
- {
- RefPtr<Net::StreamSocket> sock;
- std::string in_buf;
- Request *request;
- Response *response;
- bool async;
- bool stale;
-
- Client(RefPtr<Net::StreamSocket>);
- ~Client();
- };
-
- Net::StreamServerSocket sock;
- std::list<Client> clients;
- IO::EventDispatcher *event_disp;
-
-public:
- Server(unsigned);
- unsigned get_port() const;
- void use_event_dispatcher(IO::EventDispatcher *);
- void delay_response(Response &);
- void submit_response(Response &);
-private:
- void data_available();
- void client_data_available(Client &);
- void client_end_of_file(Client &);
- Client &get_client_by_response(Response &);
-};
-
-} // namespace Http
-} // namespace Msp
-
-#endif
+++ /dev/null
-#include "status.h"
-
-using namespace std;
-
-namespace Msp {
-namespace Http {
-
-ostream &operator<<(ostream &out, Status status)
-{
- switch(status)
- {
- case NONE: out<<"None"; break;
- case OK: out<<"OK"; break;
- case BAD_REQUEST: out<<"Bad Request"; break;
- case FORBIDDEN: out<<"Forbidden"; break;
- case NOT_FOUND: out<<"Not Found"; break;
- case INTERNAL_ERROR: out<<"Internal Error"; break;
- case NOT_IMPLEMENTED: out<<"Not Implemented"; break;
- default: out<<"Unknown Status"; break;
- }
-
- return out;
-}
-
-} // namespace Http
-} // namespace Msp
+++ /dev/null
-#ifndef MSP_HTTPSERVER_STATUS_H_
-#define MSP_HTTPSERVER_STATUS_H_
-
-#include <ostream>
-
-namespace Msp {
-namespace Http {
-
-enum Status
-{
- NONE = 0,
- OK = 200,
- BAD_REQUEST = 400,
- FORBIDDEN = 403,
- NOT_FOUND = 404,
- INTERNAL_ERROR = 500,
- NOT_IMPLEMENTED = 501
-};
-
-extern std::ostream &operator<<(std::ostream &, Status);
-
-} // namespace Http
-} // namespace Msp
-
-#endif
+++ /dev/null
-#include <algorithm>
-#include <msp/strings/formatter.h>
-#include <msp/strings/regex.h>
-#include <msp/strings/utils.h>
-#include "utils.h"
-
-using namespace std;
-
-namespace {
-
-const char *reserved[]=
-{
- " #%&+=?",
- " #%&*+:;=?@[]",
- " !#$%&'()*+,/:;=?@[]",
-};
-
-bool is_reserved(char c, unsigned level)
-{
- for(const char *r=reserved[level]; *r; ++r)
- if(c==*r)
- return true;
- return false;
-}
-
-}
-
-namespace Msp {
-namespace Http {
-
-string urlencode(const string &str, EncodeLevel level)
-{
- string result;
- for(string::const_iterator i=str.begin(); i!=str.end(); ++i)
- {
- if(is_reserved(*i, level))
- result += format("%%%02X", *i);
- else
- result += *i;
- }
- return result;
-}
-
-string urlencode_plus(const string &str, EncodeLevel level)
-{
- string result;
- for(string::const_iterator i=str.begin(); i!=str.end(); ++i)
- {
- if(*i==' ')
- result += '+';
- else if(is_reserved(*i, level))
- result += format("%%%02X", *i);
- else
- result += *i;
- }
- return result;
-}
-
-string urldecode(const string &str)
-{
- string result;
- for(unsigned i=0; i<str.size(); ++i)
- {
- char c = str[i];
- if(c=='%')
- {
- if(i+3>str.size())
- throw invalid_argument("urldecode");
- result += lexical_cast<unsigned char>(str.substr(i+1, 2), "x");
- i += 2;
- }
- else if(c=='+')
- result += ' ';
- else
- result += c;
- }
- return result;
-}
-
-Url parse_url(const string &str)
-{
- static Regex r_url("(([a-z]+)://)?([a-zA-Z0-9-]+(\\.[a-zA-Z0-9-]+)*(:[0-9])?)?(/[^?#]*)?(\\?([^#]+))?(#(.*))?");
- if(RegMatch m = r_url.match(str))
- {
- Url url;
- url.scheme = m[2].str;
- url.host = m[3].str;
- url.path = urldecode(m[6].str);
- url.query = m[8].str;
- url.fragment = m[10].str;
- return url;
- }
- else
- throw invalid_argument("parse_url");
-}
-
-string build_url(const Url &url)
-{
- if(!url.path.empty() && url.path[0]!='/')
- throw invalid_argument("build_url");
-
- string str;
- if(!url.scheme.empty())
- str += url.scheme+"://";
- str += url.host;
- str += urlencode(url.path);
- if(!url.query.empty())
- {
- str += '?';
- str += url.query;
- }
- if(!url.fragment.empty())
- {
- str += '#';
- str += url.fragment;
- }
- return str;
-}
-
-Query parse_query(const std::string &str)
-{
- vector<string> parts = split(str, '&');
- Query query;
- for(vector<string>::const_iterator i=parts.begin(); i!=parts.end(); ++i)
- {
- unsigned equals = i->find('=');
- string &value = query[urldecode(i->substr(0, equals))];
- if(equals!=string::npos)
- value = urldecode(i->substr(equals+1));
- }
- return query;
-}
-
-string build_query(const Query &query)
-{
- string str;
- for(Query::const_iterator i=query.begin(); i!=query.end(); ++i)
- {
- if(i!=query.begin())
- str += '&';
- str += urlencode_plus(i->first);
- str += '=';
- str += urlencode_plus(i->second);
- }
- return str;
-}
-
-} // namespace Http
-} // namespace Msp
+++ /dev/null
-#ifndef MSP_HTTP_UTILS_H_
-#define MSP_HTTP_UTILS_H_
-
-#include <map>
-#include <string>
-
-namespace Msp {
-namespace Http {
-
-enum EncodeLevel
-{
- MINIMAL,
- SAFE,
- PARANOID
-};
-
-struct Url
-{
- std::string scheme;
- std::string host;
- std::string path;
- std::string query;
- std::string fragment;
-};
-
-typedef std::map<std::string, std::string> Query;
-
-std::string urlencode(const std::string &, EncodeLevel =SAFE);
-std::string urlencode_plus(const std::string &, EncodeLevel =SAFE);
-std::string urldecode(const std::string &);
-Url parse_url(const std::string &);
-std::string build_url(const Url &);
-Query parse_query(const std::string &);
-std::string build_query(const Query &);
-
-} // namespace Http
-} // namespace Msp
-
-#endif
+++ /dev/null
-#include <msp/strings/formatter.h>
-#include <msp/strings/lexicalcast.h>
-#include <msp/strings/regex.h>
-#include "version.h"
-
-using namespace std;
-
-namespace Msp {
-namespace Http {
-
-Version parse_version(const std::string &ver)
-{
- if(RegMatch match = Regex("^HTTP/([0-9]+).([0-9]+)$").match(ver))
- return lexical_cast<unsigned>(match[1].str)<<4 | lexical_cast<unsigned>(match[2].str);
- else
- throw invalid_argument("parse_version");
-}
-
-string version_str(Version ver)
-{
- return format("HTTP/%u.%u", (ver>>4)&0xF, ver&0xF);
-}
-
-} // namespace Http
-} // namespace Msp
+++ /dev/null
-#ifndef MSP_HTTP_MISC_H_
-#define MSP_HTTP_MISC_H_
-
-#include <string>
-
-namespace Msp {
-namespace Http {
-
-typedef unsigned Version;
-
-Version parse_version(const std::string &);
-std::string version_str(Version);
-
-} // namespace Http
-} // namespace Msp
-
-#endif
projects / libs / net.git / commitdiff