| OLD | NEW |
|---|
| (Empty) |
| 1 /* | |
| 2 * Copyright 2004 The WebRTC Project Authors. All rights reserved. | |
| 3 * | |
| 4 * Use of this source code is governed by a BSD-style license | |
| 5 * that can be found in the LICENSE file in the root of the source | |
| 6 * tree. An additional intellectual property rights grant can be found | |
| 7 * in the file PATENTS. All contributing project authors may | |
| 8 * be found in the AUTHORS file in the root of the source tree. | |
| 9 */ | |
| 10 | |
| 11 #ifndef WEBRTC_BASE_HTTPCOMMON_H__ | |
| 12 #define WEBRTC_BASE_HTTPCOMMON_H__ | |
| 13 | |
| 14 #include <map> | |
| 15 #include <memory> | |
| 16 #include <string> | |
| 17 #include <vector> | |
| 18 #include "webrtc/base/basictypes.h" | |
| 19 #include "webrtc/base/checks.h" | |
| 20 #include "webrtc/base/stringutils.h" | |
| 21 #include "webrtc/base/stream.h" | |
| 22 | |
| 23 namespace rtc { | |
| 24 | |
| 25 class CryptString; | |
| 26 class SocketAddress; | |
| 27 | |
| 28 ////////////////////////////////////////////////////////////////////// | |
| 29 // Constants | |
| 30 ////////////////////////////////////////////////////////////////////// | |
| 31 | |
| 32 enum HttpCode { | |
| 33 HC_OK = 200, | |
| 34 HC_NON_AUTHORITATIVE = 203, | |
| 35 HC_NO_CONTENT = 204, | |
| 36 HC_PARTIAL_CONTENT = 206, | |
| 37 | |
| 38 HC_MULTIPLE_CHOICES = 300, | |
| 39 HC_MOVED_PERMANENTLY = 301, | |
| 40 HC_FOUND = 302, | |
| 41 HC_SEE_OTHER = 303, | |
| 42 HC_NOT_MODIFIED = 304, | |
| 43 HC_MOVED_TEMPORARILY = 307, | |
| 44 | |
| 45 HC_BAD_REQUEST = 400, | |
| 46 HC_UNAUTHORIZED = 401, | |
| 47 HC_FORBIDDEN = 403, | |
| 48 HC_NOT_FOUND = 404, | |
| 49 HC_PROXY_AUTHENTICATION_REQUIRED = 407, | |
| 50 HC_GONE = 410, | |
| 51 | |
| 52 HC_INTERNAL_SERVER_ERROR = 500, | |
| 53 HC_NOT_IMPLEMENTED = 501, | |
| 54 HC_SERVICE_UNAVAILABLE = 503, | |
| 55 }; | |
| 56 | |
| 57 enum HttpVersion { | |
| 58 HVER_1_0, HVER_1_1, HVER_UNKNOWN, | |
| 59 HVER_LAST = HVER_UNKNOWN | |
| 60 }; | |
| 61 | |
| 62 enum HttpVerb { | |
| 63 HV_GET, HV_POST, HV_PUT, HV_DELETE, HV_CONNECT, HV_HEAD, | |
| 64 HV_LAST = HV_HEAD | |
| 65 }; | |
| 66 | |
| 67 enum HttpError { | |
| 68 HE_NONE, | |
| 69 HE_PROTOCOL, // Received non-valid HTTP data | |
| 70 HE_DISCONNECTED, // Connection closed unexpectedly | |
| 71 HE_OVERFLOW, // Received too much data for internal buffers | |
| 72 HE_CONNECT_FAILED, // The socket failed to connect. | |
| 73 HE_SOCKET_ERROR, // An error occurred on a connected socket | |
| 74 HE_SHUTDOWN, // Http object is being destroyed | |
| 75 HE_OPERATION_CANCELLED, // Connection aborted locally | |
| 76 HE_AUTH, // Proxy Authentication Required | |
| 77 HE_CERTIFICATE_EXPIRED, // During SSL negotiation | |
| 78 HE_STREAM, // Problem reading or writing to the document | |
| 79 HE_CACHE, // Problem reading from cache | |
| 80 HE_DEFAULT | |
| 81 }; | |
| 82 | |
| 83 enum HttpHeader { | |
| 84 HH_AGE, | |
| 85 HH_CACHE_CONTROL, | |
| 86 HH_CONNECTION, | |
| 87 HH_CONTENT_DISPOSITION, | |
| 88 HH_CONTENT_LENGTH, | |
| 89 HH_CONTENT_RANGE, | |
| 90 HH_CONTENT_TYPE, | |
| 91 HH_COOKIE, | |
| 92 HH_DATE, | |
| 93 HH_ETAG, | |
| 94 HH_EXPIRES, | |
| 95 HH_HOST, | |
| 96 HH_IF_MODIFIED_SINCE, | |
| 97 HH_IF_NONE_MATCH, | |
| 98 HH_KEEP_ALIVE, | |
| 99 HH_LAST_MODIFIED, | |
| 100 HH_LOCATION, | |
| 101 HH_PROXY_AUTHENTICATE, | |
| 102 HH_PROXY_AUTHORIZATION, | |
| 103 HH_PROXY_CONNECTION, | |
| 104 HH_RANGE, | |
| 105 HH_SET_COOKIE, | |
| 106 HH_TE, | |
| 107 HH_TRAILERS, | |
| 108 HH_TRANSFER_ENCODING, | |
| 109 HH_UPGRADE, | |
| 110 HH_USER_AGENT, | |
| 111 HH_WWW_AUTHENTICATE, | |
| 112 HH_LAST = HH_WWW_AUTHENTICATE | |
| 113 }; | |
| 114 | |
| 115 const uint16_t HTTP_DEFAULT_PORT = 80; | |
| 116 const uint16_t HTTP_SECURE_PORT = 443; | |
| 117 | |
| 118 ////////////////////////////////////////////////////////////////////// | |
| 119 // Utility Functions | |
| 120 ////////////////////////////////////////////////////////////////////// | |
| 121 | |
| 122 inline HttpError mkerr(HttpError err, HttpError def_err = HE_DEFAULT) { | |
| 123 return (err != HE_NONE) ? err : def_err; | |
| 124 } | |
| 125 | |
| 126 const char* ToString(HttpVersion version); | |
| 127 bool FromString(HttpVersion& version, const std::string& str); | |
| 128 | |
| 129 const char* ToString(HttpVerb verb); | |
| 130 bool FromString(HttpVerb& verb, const std::string& str); | |
| 131 | |
| 132 const char* ToString(HttpHeader header); | |
| 133 bool FromString(HttpHeader& header, const std::string& str); | |
| 134 | |
| 135 inline bool HttpCodeIsInformational(uint32_t code) { | |
| 136 return ((code / 100) == 1); | |
| 137 } | |
| 138 inline bool HttpCodeIsSuccessful(uint32_t code) { | |
| 139 return ((code / 100) == 2); | |
| 140 } | |
| 141 inline bool HttpCodeIsRedirection(uint32_t code) { | |
| 142 return ((code / 100) == 3); | |
| 143 } | |
| 144 inline bool HttpCodeIsClientError(uint32_t code) { | |
| 145 return ((code / 100) == 4); | |
| 146 } | |
| 147 inline bool HttpCodeIsServerError(uint32_t code) { | |
| 148 return ((code / 100) == 5); | |
| 149 } | |
| 150 | |
| 151 bool HttpCodeHasBody(uint32_t code); | |
| 152 bool HttpCodeIsCacheable(uint32_t code); | |
| 153 bool HttpHeaderIsEndToEnd(HttpHeader header); | |
| 154 bool HttpHeaderIsCollapsible(HttpHeader header); | |
| 155 | |
| 156 struct HttpData; | |
| 157 bool HttpShouldKeepAlive(const HttpData& data); | |
| 158 | |
| 159 typedef std::pair<std::string, std::string> HttpAttribute; | |
| 160 typedef std::vector<HttpAttribute> HttpAttributeList; | |
| 161 void HttpComposeAttributes(const HttpAttributeList& attributes, char separator, | |
| 162 std::string* composed); | |
| 163 void HttpParseAttributes(const char * data, size_t len, | |
| 164 HttpAttributeList& attributes); | |
| 165 bool HttpHasAttribute(const HttpAttributeList& attributes, | |
| 166 const std::string& name, | |
| 167 std::string* value); | |
| 168 bool HttpHasNthAttribute(HttpAttributeList& attributes, | |
| 169 size_t index, | |
| 170 std::string* name, | |
| 171 std::string* value); | |
| 172 | |
| 173 // Convert RFC1123 date (DoW, DD Mon YYYY HH:MM:SS TZ) to unix timestamp | |
| 174 bool HttpDateToSeconds(const std::string& date, time_t* seconds); | |
| 175 | |
| 176 inline uint16_t HttpDefaultPort(bool secure) { | |
| 177 return secure ? HTTP_SECURE_PORT : HTTP_DEFAULT_PORT; | |
| 178 } | |
| 179 | |
| 180 // Returns the http server notation for a given address | |
| 181 std::string HttpAddress(const SocketAddress& address, bool secure); | |
| 182 | |
| 183 // functional for insensitive std::string compare | |
| 184 struct iless { | |
| 185 bool operator()(const std::string& lhs, const std::string& rhs) const { | |
| 186 return (::_stricmp(lhs.c_str(), rhs.c_str()) < 0); | |
| 187 } | |
| 188 }; | |
| 189 | |
| 190 // put quotes around a string and escape any quotes inside it | |
| 191 std::string quote(const std::string& str); | |
| 192 | |
| 193 ////////////////////////////////////////////////////////////////////// | |
| 194 // Url | |
| 195 ////////////////////////////////////////////////////////////////////// | |
| 196 | |
| 197 template<class CTYPE> | |
| 198 class Url { | |
| 199 public: | |
| 200 typedef typename Traits<CTYPE>::string string; | |
| 201 | |
| 202 // TODO: Implement Encode/Decode | |
| 203 static int Encode(const CTYPE* source, CTYPE* destination, size_t len); | |
| 204 static int Encode(const string& source, string& destination); | |
| 205 static int Decode(const CTYPE* source, CTYPE* destination, size_t len); | |
| 206 static int Decode(const string& source, string& destination); | |
| 207 | |
| 208 Url(const string& url) { do_set_url(url.c_str(), url.size()); } | |
| 209 Url(const string& path, const string& host, uint16_t port = HTTP_DEFAULT_PORT) | |
| 210 : host_(host), port_(port), secure_(HTTP_SECURE_PORT == port) { | |
| 211 set_full_path(path); | |
| 212 } | |
| 213 | |
| 214 bool valid() const { return !host_.empty(); } | |
| 215 void clear() { | |
| 216 host_.clear(); | |
| 217 port_ = HTTP_DEFAULT_PORT; | |
| 218 secure_ = false; | |
| 219 path_.assign(1, static_cast<CTYPE>('/')); | |
| 220 query_.clear(); | |
| 221 } | |
| 222 | |
| 223 void set_url(const string& val) { | |
| 224 do_set_url(val.c_str(), val.size()); | |
| 225 } | |
| 226 string url() const { | |
| 227 string val; do_get_url(&val); return val; | |
| 228 } | |
| 229 | |
| 230 void set_address(const string& val) { | |
| 231 do_set_address(val.c_str(), val.size()); | |
| 232 } | |
| 233 string address() const { | |
| 234 string val; do_get_address(&val); return val; | |
| 235 } | |
| 236 | |
| 237 void set_full_path(const string& val) { | |
| 238 do_set_full_path(val.c_str(), val.size()); | |
| 239 } | |
| 240 string full_path() const { | |
| 241 string val; do_get_full_path(&val); return val; | |
| 242 } | |
| 243 | |
| 244 void set_host(const string& val) { host_ = val; } | |
| 245 const string& host() const { return host_; } | |
| 246 | |
| 247 void set_port(uint16_t val) { port_ = val; } | |
| 248 uint16_t port() const { return port_; } | |
| 249 | |
| 250 void set_secure(bool val) { secure_ = val; } | |
| 251 bool secure() const { return secure_; } | |
| 252 | |
| 253 void set_path(const string& val) { | |
| 254 if (val.empty()) { | |
| 255 path_.assign(1, static_cast<CTYPE>('/')); | |
| 256 } else { | |
| 257 RTC_DCHECK(val[0] == static_cast<CTYPE>('/')); | |
| 258 path_ = val; | |
| 259 } | |
| 260 } | |
| 261 const string& path() const { return path_; } | |
| 262 | |
| 263 void set_query(const string& val) { | |
| 264 RTC_DCHECK(val.empty() || (val[0] == static_cast<CTYPE>('?'))); | |
| 265 query_ = val; | |
| 266 } | |
| 267 const string& query() const { return query_; } | |
| 268 | |
| 269 bool get_attribute(const string& name, string* value) const; | |
| 270 | |
| 271 private: | |
| 272 void do_set_url(const CTYPE* val, size_t len); | |
| 273 void do_set_address(const CTYPE* val, size_t len); | |
| 274 void do_set_full_path(const CTYPE* val, size_t len); | |
| 275 | |
| 276 void do_get_url(string* val) const; | |
| 277 void do_get_address(string* val) const; | |
| 278 void do_get_full_path(string* val) const; | |
| 279 | |
| 280 string host_, path_, query_; | |
| 281 uint16_t port_; | |
| 282 bool secure_; | |
| 283 }; | |
| 284 | |
| 285 ////////////////////////////////////////////////////////////////////// | |
| 286 // HttpData | |
| 287 ////////////////////////////////////////////////////////////////////// | |
| 288 | |
| 289 struct HttpData { | |
| 290 typedef std::multimap<std::string, std::string, iless> HeaderMap; | |
| 291 typedef HeaderMap::const_iterator const_iterator; | |
| 292 typedef HeaderMap::iterator iterator; | |
| 293 | |
| 294 HttpVersion version; | |
| 295 std::unique_ptr<StreamInterface> document; | |
| 296 | |
| 297 HttpData(); | |
| 298 | |
| 299 enum HeaderCombine { HC_YES, HC_NO, HC_AUTO, HC_REPLACE, HC_NEW }; | |
| 300 void changeHeader(const std::string& name, const std::string& value, | |
| 301 HeaderCombine combine); | |
| 302 inline void addHeader(const std::string& name, const std::string& value, | |
| 303 bool append = true) { | |
| 304 changeHeader(name, value, append ? HC_AUTO : HC_NO); | |
| 305 } | |
| 306 inline void setHeader(const std::string& name, const std::string& value, | |
| 307 bool overwrite = true) { | |
| 308 changeHeader(name, value, overwrite ? HC_REPLACE : HC_NEW); | |
| 309 } | |
| 310 // Returns count of erased headers | |
| 311 size_t clearHeader(const std::string& name); | |
| 312 // Returns iterator to next header | |
| 313 iterator clearHeader(iterator header); | |
| 314 | |
| 315 // keep in mind, this may not do what you want in the face of multiple headers | |
| 316 bool hasHeader(const std::string& name, std::string* value) const; | |
| 317 | |
| 318 inline const_iterator begin() const { | |
| 319 return headers_.begin(); | |
| 320 } | |
| 321 inline const_iterator end() const { | |
| 322 return headers_.end(); | |
| 323 } | |
| 324 inline iterator begin() { | |
| 325 return headers_.begin(); | |
| 326 } | |
| 327 inline iterator end() { | |
| 328 return headers_.end(); | |
| 329 } | |
| 330 inline const_iterator begin(const std::string& name) const { | |
| 331 return headers_.lower_bound(name); | |
| 332 } | |
| 333 inline const_iterator end(const std::string& name) const { | |
| 334 return headers_.upper_bound(name); | |
| 335 } | |
| 336 inline iterator begin(const std::string& name) { | |
| 337 return headers_.lower_bound(name); | |
| 338 } | |
| 339 inline iterator end(const std::string& name) { | |
| 340 return headers_.upper_bound(name); | |
| 341 } | |
| 342 | |
| 343 // Convenience methods using HttpHeader | |
| 344 inline void changeHeader(HttpHeader header, const std::string& value, | |
| 345 HeaderCombine combine) { | |
| 346 changeHeader(ToString(header), value, combine); | |
| 347 } | |
| 348 inline void addHeader(HttpHeader header, const std::string& value, | |
| 349 bool append = true) { | |
| 350 addHeader(ToString(header), value, append); | |
| 351 } | |
| 352 inline void setHeader(HttpHeader header, const std::string& value, | |
| 353 bool overwrite = true) { | |
| 354 setHeader(ToString(header), value, overwrite); | |
| 355 } | |
| 356 inline void clearHeader(HttpHeader header) { | |
| 357 clearHeader(ToString(header)); | |
| 358 } | |
| 359 inline bool hasHeader(HttpHeader header, std::string* value) const { | |
| 360 return hasHeader(ToString(header), value); | |
| 361 } | |
| 362 inline const_iterator begin(HttpHeader header) const { | |
| 363 return headers_.lower_bound(ToString(header)); | |
| 364 } | |
| 365 inline const_iterator end(HttpHeader header) const { | |
| 366 return headers_.upper_bound(ToString(header)); | |
| 367 } | |
| 368 inline iterator begin(HttpHeader header) { | |
| 369 return headers_.lower_bound(ToString(header)); | |
| 370 } | |
| 371 inline iterator end(HttpHeader header) { | |
| 372 return headers_.upper_bound(ToString(header)); | |
| 373 } | |
| 374 | |
| 375 void setContent(const std::string& content_type, StreamInterface* document); | |
| 376 void setDocumentAndLength(StreamInterface* document); | |
| 377 | |
| 378 virtual size_t formatLeader(char* buffer, size_t size) const = 0; | |
| 379 virtual HttpError parseLeader(const char* line, size_t len) = 0; | |
| 380 | |
| 381 protected: | |
| 382 virtual ~HttpData(); | |
| 383 void clear(bool release_document); | |
| 384 void copy(const HttpData& src); | |
| 385 | |
| 386 private: | |
| 387 HeaderMap headers_; | |
| 388 }; | |
| 389 | |
| 390 struct HttpRequestData : public HttpData { | |
| 391 HttpVerb verb; | |
| 392 std::string path; | |
| 393 | |
| 394 HttpRequestData() : verb(HV_GET) { } | |
| 395 | |
| 396 void clear(bool release_document); | |
| 397 void copy(const HttpRequestData& src); | |
| 398 | |
| 399 size_t formatLeader(char* buffer, size_t size) const override; | |
| 400 HttpError parseLeader(const char* line, size_t len) override; | |
| 401 | |
| 402 bool getAbsoluteUri(std::string* uri) const; | |
| 403 bool getRelativeUri(std::string* host, std::string* path) const; | |
| 404 }; | |
| 405 | |
| 406 struct HttpResponseData : public HttpData { | |
| 407 uint32_t scode; | |
| 408 std::string message; | |
| 409 | |
| 410 HttpResponseData() : scode(HC_INTERNAL_SERVER_ERROR) { } | |
| 411 void clear(bool release_document); | |
| 412 void copy(const HttpResponseData& src); | |
| 413 | |
| 414 // Convenience methods | |
| 415 void set_success(uint32_t scode = HC_OK); | |
| 416 void set_success(const std::string& content_type, | |
| 417 StreamInterface* document, | |
| 418 uint32_t scode = HC_OK); | |
| 419 void set_redirect(const std::string& location, | |
| 420 uint32_t scode = HC_MOVED_TEMPORARILY); | |
| 421 void set_error(uint32_t scode); | |
| 422 | |
| 423 size_t formatLeader(char* buffer, size_t size) const override; | |
| 424 HttpError parseLeader(const char* line, size_t len) override; | |
| 425 }; | |
| 426 | |
| 427 struct HttpTransaction { | |
| 428 HttpRequestData request; | |
| 429 HttpResponseData response; | |
| 430 }; | |
| 431 | |
| 432 ////////////////////////////////////////////////////////////////////// | |
| 433 // Http Authentication | |
| 434 ////////////////////////////////////////////////////////////////////// | |
| 435 | |
| 436 struct HttpAuthContext { | |
| 437 std::string auth_method; | |
| 438 HttpAuthContext(const std::string& auth) : auth_method(auth) { } | |
| 439 virtual ~HttpAuthContext() { } | |
| 440 }; | |
| 441 | |
| 442 enum HttpAuthResult { HAR_RESPONSE, HAR_IGNORE, HAR_CREDENTIALS, HAR_ERROR }; | |
| 443 | |
| 444 // 'context' is used by this function to record information between calls. | |
| 445 // Start by passing a null pointer, then pass the same pointer each additional | |
| 446 // call. When the authentication attempt is finished, delete the context. | |
| 447 HttpAuthResult HttpAuthenticate( | |
| 448 const char * challenge, size_t len, | |
| 449 const SocketAddress& server, | |
| 450 const std::string& method, const std::string& uri, | |
| 451 const std::string& username, const CryptString& password, | |
| 452 HttpAuthContext *& context, std::string& response, std::string& auth_method); | |
| 453 | |
| 454 ////////////////////////////////////////////////////////////////////// | |
| 455 | |
| 456 } // namespace rtc | |
| 457 | |
| 458 #endif // WEBRTC_BASE_HTTPCOMMON_H__ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2731673002:
Removing HTTPS and SOCKS proxy server code. (Closed)
