/* * libjingle * Copyright 2004--2005, Google Inc. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * 1. Redistributions of source code must retain the above copyright notice, * this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright notice, * this list of conditions and the following disclaimer in the documentation * and/or other materials provided with the distribution. * 3. The name of the author may not be used to endorse or promote products * derived from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #ifndef TALK_BASE_HTTPCOMMON_H__ #define TALK_BASE_HTTPCOMMON_H__ #include #include #include #include "talk/base/basictypes.h" #include "talk/base/scoped_ptr.h" #include "talk/base/stringutils.h" #include "talk/base/stream.h" namespace talk_base { class CryptString; class SocketAddress; ////////////////////////////////////////////////////////////////////// // Constants ////////////////////////////////////////////////////////////////////// enum HttpCode { HC_OK = 200, HC_NON_AUTHORITATIVE = 203, HC_NO_CONTENT = 204, HC_PARTIAL_CONTENT = 206, HC_MULTIPLE_CHOICES = 300, HC_MOVED_PERMANENTLY = 301, HC_FOUND = 302, HC_SEE_OTHER = 303, HC_NOT_MODIFIED = 304, HC_MOVED_TEMPORARILY = 307, HC_BAD_REQUEST = 400, HC_UNAUTHORIZED = 401, HC_FORBIDDEN = 403, HC_NOT_FOUND = 404, HC_PROXY_AUTHENTICATION_REQUIRED = 407, HC_GONE = 410, HC_INTERNAL_SERVER_ERROR = 500 }; enum HttpVersion { HVER_1_0, HVER_1_1, HVER_LAST = HVER_1_1 }; enum HttpVerb { HV_GET, HV_POST, HV_PUT, HV_DELETE, HV_CONNECT, HV_HEAD, HV_LAST = HV_HEAD }; enum HttpError { HE_NONE, HE_PROTOCOL, HE_DISCONNECTED, HE_OVERFLOW, HE_SOCKET, HE_SHUTDOWN, HE_OPERATION_CANCELLED, HE_AUTH, // Proxy Authentication Required HE_CERTIFICATE_EXPIRED, // During SSL negotiation HE_STREAM, // Problem reading or writing to the document HE_CACHE, // Problem reading from cache HE_DEFAULT }; enum HttpHeader { HH_AGE, HH_CACHE_CONTROL, HH_CONNECTION, HH_CONTENT_LENGTH, HH_CONTENT_RANGE, HH_CONTENT_TYPE, HH_COOKIE, HH_DATE, HH_ETAG, HH_EXPIRES, HH_HOST, HH_IF_MODIFIED_SINCE, HH_IF_NONE_MATCH, HH_KEEP_ALIVE, HH_LAST_MODIFIED, HH_LOCATION, HH_PROXY_AUTHENTICATE, HH_PROXY_AUTHORIZATION, HH_PROXY_CONNECTION, HH_RANGE, HH_SET_COOKIE, HH_TE, HH_TRAILERS, HH_TRANSFER_ENCODING, HH_UPGRADE, HH_USER_AGENT, HH_WWW_AUTHENTICATE, HH_LAST = HH_WWW_AUTHENTICATE }; const uint16 HTTP_DEFAULT_PORT = 80; const uint16 HTTP_SECURE_PORT = 443; ////////////////////////////////////////////////////////////////////// // Utility Functions ////////////////////////////////////////////////////////////////////// inline HttpError mkerr(HttpError err, HttpError def_err = HE_DEFAULT) { return (err != HE_NONE) ? err : def_err; } const char* ToString(HttpVersion version); bool FromString(HttpVersion& version, const std::string& str); const char* ToString(HttpVerb verb); bool FromString(HttpVerb& verb, const std::string& str); const char* ToString(HttpHeader header); bool FromString(HttpHeader& header, const std::string& str); inline bool HttpCodeIsInformational(uint32 code) { return ((code / 100) == 1); } inline bool HttpCodeIsSuccessful(uint32 code) { return ((code / 100) == 2); } inline bool HttpCodeIsRedirection(uint32 code) { return ((code / 100) == 3); } inline bool HttpCodeIsClientError(uint32 code) { return ((code / 100) == 4); } inline bool HttpCodeIsServerError(uint32 code) { return ((code / 100) == 5); } bool HttpCodeHasBody(uint32 code); bool HttpCodeIsCacheable(uint32 code); bool HttpHeaderIsEndToEnd(HttpHeader header); bool HttpHeaderIsCollapsible(HttpHeader header); struct HttpData; bool HttpShouldKeepAlive(const HttpData& data); typedef std::pair HttpAttribute; typedef std::vector HttpAttributeList; void HttpParseAttributes(const char * data, size_t len, HttpAttributeList& attributes); bool HttpHasAttribute(const HttpAttributeList& attributes, const std::string& name, std::string* value); bool HttpHasNthAttribute(HttpAttributeList& attributes, size_t index, std::string* name, std::string* value); // Convert RFC1123 date (DoW, DD Mon YYYY HH:MM:SS TZ) to unix timestamp bool HttpDateToSeconds(const std::string& date, unsigned long* seconds); inline const uint16 UrlDefaultPort(bool secure) { return secure ? HTTP_SECURE_PORT : HTTP_DEFAULT_PORT; } // functional for insensitive std::string compare struct iless { bool operator()(const std::string& lhs, const std::string& rhs) const { return (::_stricmp(lhs.c_str(), rhs.c_str()) < 0); } }; ////////////////////////////////////////////////////////////////////// // Url ////////////////////////////////////////////////////////////////////// template class Url { public: typedef typename Traits::string string; // TODO: Implement Encode/Decode static int Encode(const CTYPE* source, CTYPE* destination, size_t len); static int Encode(const string& source, string& destination); static int Decode(const CTYPE* source, CTYPE* destination, size_t len); static int Decode(const string& source, string& destination); Url(const string& url); Url(const string& path, const string& server, uint16 port = HTTP_DEFAULT_PORT) : m_server(server), m_path(path), m_port(port), m_secure(HTTP_SECURE_PORT == port) { ASSERT(m_path.empty() || (m_path[0] == static_cast('/'))); } bool valid() const { return !m_server.empty(); } const string& server() const { return m_server; } // Note: path() was renamed to path_, because it now uses the stricter sense // of not including a query string. I'm trying to think of a clearer name. const string& path_() const { return m_path; } const string& query() const { return m_query; } string full_path(); string url(); uint16 port() const { return m_port; } bool secure() const { return m_secure; } void set_server(const string& val) { m_server = val; } void set_path(const string& val) { ASSERT(val.empty() || (val[0] == static_cast('/'))); m_path = val; } void set_query(const string& val) { ASSERT(val.empty() || (val[0] == static_cast('?'))); m_query = val; } void set_port(uint16 val) { m_port = val; } void set_secure(bool val) { m_secure = val; } private: string m_server, m_path, m_query; uint16 m_port; bool m_secure; }; ////////////////////////////////////////////////////////////////////// // HttpData ////////////////////////////////////////////////////////////////////// struct HttpData { typedef std::multimap HeaderMap; typedef HeaderMap::const_iterator const_iterator; HttpVersion version; scoped_ptr document; HttpData() : version(HVER_1_1) { } enum HeaderCombine { HC_YES, HC_NO, HC_AUTO, HC_REPLACE, HC_NEW }; void changeHeader(const std::string& name, const std::string& value, HeaderCombine combine); inline void addHeader(const std::string& name, const std::string& value, bool append = true) { changeHeader(name, value, append ? HC_AUTO : HC_NO); } inline void setHeader(const std::string& name, const std::string& value, bool overwrite = true) { changeHeader(name, value, overwrite ? HC_REPLACE : HC_NEW); } void clearHeader(const std::string& name); // keep in mind, this may not do what you want in the face of multiple headers bool hasHeader(const std::string& name, std::string* value) const; inline const_iterator begin() const { return m_headers.begin(); } inline const_iterator end() const { return m_headers.end(); } inline const_iterator begin(const std::string& name) const { return m_headers.lower_bound(name); } inline const_iterator end(const std::string& name) const { return m_headers.upper_bound(name); } // Convenience methods using HttpHeader inline void changeHeader(HttpHeader header, const std::string& value, HeaderCombine combine) { changeHeader(ToString(header), value, combine); } inline void addHeader(HttpHeader header, const std::string& value, bool append = true) { addHeader(ToString(header), value, append); } inline void setHeader(HttpHeader header, const std::string& value, bool overwrite = true) { setHeader(ToString(header), value, overwrite); } inline void clearHeader(HttpHeader header) { clearHeader(ToString(header)); } inline bool hasHeader(HttpHeader header, std::string* value) const { return hasHeader(ToString(header), value); } inline const_iterator begin(HttpHeader header) const { return m_headers.lower_bound(ToString(header)); } inline const_iterator end(HttpHeader header) const { return m_headers.upper_bound(ToString(header)); } void setContent(const std::string& content_type, StreamInterface* document); virtual size_t formatLeader(char* buffer, size_t size) = 0; virtual HttpError parseLeader(const char* line, size_t len) = 0; protected: virtual ~HttpData() { } void clear(bool release_document); private: HeaderMap m_headers; }; struct HttpRequestData : public HttpData { HttpVerb verb; std::string path; HttpRequestData() : verb(HV_GET) { } void clear(bool release_document); virtual size_t formatLeader(char* buffer, size_t size); virtual HttpError parseLeader(const char* line, size_t len); }; struct HttpResponseData : public HttpData { uint32 scode; std::string message; HttpResponseData() : scode(HC_INTERNAL_SERVER_ERROR) { } void clear(bool release_document); // Convenience methods void set_success(uint32 scode = HC_OK); void set_success(const std::string& content_type, StreamInterface* document, uint32 scode = HC_OK); void set_redirect(const std::string& location, uint32 scode = HC_MOVED_TEMPORARILY); void set_error(uint32 scode); virtual size_t formatLeader(char* buffer, size_t size); virtual HttpError parseLeader(const char* line, size_t len); }; ////////////////////////////////////////////////////////////////////// // Http Authentication ////////////////////////////////////////////////////////////////////// struct HttpAuthContext { std::string auth_method; HttpAuthContext(const std::string& auth) : auth_method(auth) { } virtual ~HttpAuthContext() { } }; enum HttpAuthResult { HAR_RESPONSE, HAR_IGNORE, HAR_CREDENTIALS, HAR_ERROR }; // 'context' is used by this function to record information between calls. // Start by passing a null pointer, then pass the same pointer each additional // call. When the authentication attempt is finished, delete the context. HttpAuthResult HttpAuthenticate( const char * challenge, size_t len, const SocketAddress& server, const std::string& method, const std::string& uri, const std::string& username, const CryptString& password, HttpAuthContext *& context, std::string& response, std::string& auth_method); ////////////////////////////////////////////////////////////////////// } // namespace talk_base #endif // TALK_BASE_HTTPCOMMON_H__