third_party/ot-br-posix/repo/third_party/Simple-web-server/repo/client_http.hpp

   1 #ifndef CLIENT_HTTP_HPP
   2 #define CLIENT_HTTP_HPP
   3
   4 #include <boost/asio.hpp>
   5 #include <boost/utility/string_ref.hpp>
   6 #include <boost/algorithm/string/predicate.hpp>
   7 #include <boost/functional/hash.hpp>
   8
   9 #include <unordered_map>
  10 #include <map>
  11 #include <random>
  12 #include <mutex>
  13 #include <type_traits>
  14
  15 #ifndef CASE_INSENSITIVE_EQUALS_AND_HASH
  16 #define CASE_INSENSITIVE_EQUALS_AND_HASH
  17 //Based on http://www.boost.org/doc/libs/1_60_0/doc/html/unordered/hash_equality.html
  18 class case_insensitive_equals {
  19 public:
  20   bool operator()(const std::string &key1, const std::string &key2) const {
  21     return boost::algorithm::iequals(key1, key2);
  22   }
  23 };
  24 class case_insensitive_hash {
  25 public:
  26   size_t operator()(const std::string &key) const {
  27     std::size_t seed=0;
  28     for(auto &c: key)
  29       boost::hash_combine(seed, std::tolower(c));
  30     return seed;
  31   }
  32 };
  33 #endif
  34
  35 namespace SimpleWeb {
  36     template <class socket_type>
  37     class Client;
  38
  39     template <class socket_type>
  40     class ClientBase {
  41     public:
  42         virtual ~ClientBase() {}
  43
  44         class Response {
  45             friend class ClientBase<socket_type>;
  46             friend class Client<socket_type>;
  47         public:
  48             std::string http_version, status_code;
  49
  50             std::istream content;
  51
  52             std::unordered_multimap<std::string, std::string, case_insensitive_hash, case_insensitive_equals> header;
  53
  54         private:
  55             boost::asio::streambuf content_buffer;
  56
  57             Response(): content(&content_buffer) {}
  58         };
  59
  60         class Config {
  61             friend class ClientBase<socket_type>;
  62         private:
  63             Config() {}
  64         public:
  65             /// Set timeout on requests in seconds. Default value: 0 (no timeout).
  66             size_t timeout=0;
  67             /// Set connect timeout in seconds. Default value: 0 (Config::timeout is then used instead).
  68             size_t timeout_connect=0;
  69             /// Set proxy server (server:port)
  70             std::string proxy_server;
  71         };
  72
  73         /// Set before calling request
  74         Config config;
  75
  76         std::shared_ptr<Response> request(const std::string& request_type, const std::string& path="/", boost::string_ref content="",
  77                 const std::map<std::string, std::string>& header=std::map<std::string, std::string>()) {
  78             auto corrected_path=path;
  79             if(corrected_path=="")
  80                 corrected_path="/";
  81             if(!config.proxy_server.empty() && std::is_same<socket_type, boost::asio::ip::tcp::socket>::value)
  82                 corrected_path="http://"+host+':'+std::to_string(port)+corrected_path;
  83
  84             boost::asio::streambuf write_buffer;
  85             std::ostream write_stream(&write_buffer);
  86             write_stream << request_type << " " << corrected_path << " HTTP/1.1\r\n";
  87             write_stream << "Host: " << host << "\r\n";
  88             for(auto& h: header) {
  89                 write_stream << h.first << ": " << h.second << "\r\n";
  90             }
  91             if(content.size()>0)
  92                 write_stream << "Content-Length: " << content.size() << "\r\n";
  93             write_stream << "\r\n";
  94
  95             connect();
  96
  97             auto timer=get_timeout_timer();
  98             boost::asio::async_write(*socket, write_buffer,
  99                                      [this, &content, timer](const boost::system::error_code &ec, size_t /*bytes_transferred*/) {
 100                 if(timer)
 101                     timer->cancel();
 102                 if(!ec) {
 103                     if(!content.empty()) {
 104                         auto timer=get_timeout_timer();
 105                         boost::asio::async_write(*socket, boost::asio::buffer(content.data(), content.size()),
 106                                              [this, timer](const boost::system::error_code &ec, size_t /*bytes_transferred*/) {
 107                             if(timer)
 108                                 timer->cancel();
 109                             if(ec) {
 110                                 std::lock_guard<std::mutex> lock(socket_mutex);
 111                                 this->socket=nullptr;
 112                                 throw boost::system::system_error(ec);
 113                             }
 114                         });
 115                     }
 116                 }
 117                 else {
 118                     std::lock_guard<std::mutex> lock(socket_mutex);
 119                     socket=nullptr;
 120                     throw boost::system::system_error(ec);
 121                 }
 122             });
 123             io_service.reset();
 124             io_service.run();
 125
 126             return request_read();
 127         }
 128
 129         std::shared_ptr<Response> request(const std::string& request_type, const std::string& path, std::iostream& content,
 130                 const std::map<std::string, std::string>& header=std::map<std::string, std::string>()) {
 131             auto corrected_path=path;
 132             if(corrected_path=="")
 133                 corrected_path="/";
 134             if(!config.proxy_server.empty() && std::is_same<socket_type, boost::asio::ip::tcp::socket>::value)
 135                 corrected_path="http://"+host+':'+std::to_string(port)+corrected_path;
 136
 137             content.seekp(0, std::ios::end);
 138             auto content_length=content.tellp();
 139             content.seekp(0, std::ios::beg);
 140
 141             boost::asio::streambuf write_buffer;
 142             std::ostream write_stream(&write_buffer);
 143             write_stream << request_type << " " << corrected_path << " HTTP/1.1\r\n";
 144             write_stream << "Host: " << host << "\r\n";
 145             for(auto& h: header) {
 146                 write_stream << h.first << ": " << h.second << "\r\n";
 147             }
 148             if(content_length>0)
 149                 write_stream << "Content-Length: " << content_length << "\r\n";
 150             write_stream << "\r\n";
 151             if(content_length>0)
 152                 write_stream << content.rdbuf();
 153
 154             connect();
 155
 156             auto timer=get_timeout_timer();
 157             boost::asio::async_write(*socket, write_buffer,
 158                                      [this, timer](const boost::system::error_code &ec, size_t /*bytes_transferred*/) {
 159                 if(timer)
 160                     timer->cancel();
 161                 if(ec) {
 162                     std::lock_guard<std::mutex> lock(socket_mutex);
 163                     socket=nullptr;
 164                     throw boost::system::system_error(ec);
 165                 }
 166             });
 167             io_service.reset();
 168             io_service.run();
 169
 170             return request_read();
 171         }
 172
 173         void close() {
 174             std::lock_guard<std::mutex> lock(socket_mutex);
 175             if(socket) {
 176                 boost::system::error_code ec;
 177                 socket->lowest_layer().shutdown(boost::asio::ip::tcp::socket::shutdown_both, ec);
 178                 socket->lowest_layer().close();
 179             }
 180         }
 181
 182     protected:
 183         boost::asio::io_service io_service;
 184         boost::asio::ip::tcp::resolver resolver;
 185
 186         std::unique_ptr<socket_type> socket;
 187         std::mutex socket_mutex;
 188
 189         std::string host;
 190         unsigned short port;
 191
 192         ClientBase(const std::string& host_port, unsigned short default_port) : resolver(io_service) {
 193             auto parsed_host_port=parse_host_port(host_port, default_port);
 194             host=parsed_host_port.first;
 195             port=parsed_host_port.second;
 196         }
 197
 198         std::pair<std::string, unsigned short> parse_host_port(const std::string &host_port, unsigned short default_port) {
 199             std::pair<std::string, unsigned short> parsed_host_port;
 200             size_t host_end=host_port.find(':');
 201             if(host_end==std::string::npos) {
 202                 parsed_host_port.first=host_port;
 203                 parsed_host_port.second=default_port;
 204             }
 205             else {
 206                 parsed_host_port.first=host_port.substr(0, host_end);
 207                 parsed_host_port.second=static_cast<unsigned short>(stoul(host_port.substr(host_end+1)));
 208             }
 209             return parsed_host_port;
 210         }
 211
 212         virtual void connect()=0;
 213
 214         std::shared_ptr<boost::asio::deadline_timer> get_timeout_timer(size_t timeout=0) {
 215             if(timeout==0)
 216                 timeout=config.timeout;
 217             if(timeout==0)
 218                 return nullptr;
 219
 220             auto timer=std::make_shared<boost::asio::deadline_timer>(io_service);
 221             timer->expires_from_now(boost::posix_time::seconds(timeout));
 222             timer->async_wait([this](const boost::system::error_code& ec) {
 223                 if(!ec) {
 224                     close();
 225                 }
 226             });
 227             return timer;
 228         }
 229
 230         void parse_response_header(const std::shared_ptr<Response> &response) const {
 231             std::string line;
 232             getline(response->content, line);
 233             size_t version_end=line.find(' ');
 234             if(version_end!=std::string::npos) {
 235                 if(5<line.size())
 236                     response->http_version=line.substr(5, version_end-5);
 237                 if((version_end+1)<line.size())
 238                     response->status_code=line.substr(version_end+1, line.size()-(version_end+1)-1);
 239
 240                 getline(response->content, line);
 241                 size_t param_end;
 242                 while((param_end=line.find(':'))!=std::string::npos) {
 243                     size_t value_start=param_end+1;
 244                     if((value_start)<line.size()) {
 245                         if(line[value_start]==' ')
 246                             value_start++;
 247                         if(value_start<line.size())
 248                             response->header.insert(std::make_pair(line.substr(0, param_end), line.substr(value_start, line.size()-value_start-1)));
 249                     }
 250
 251                     getline(response->content, line);
 252                 }
 253             }
 254         }
 255
 256         std::shared_ptr<Response> request_read() {
 257             std::shared_ptr<Response> response(new Response());
 258
 259             boost::asio::streambuf chunked_streambuf;
 260
 261             auto timer=get_timeout_timer();
 262             boost::asio::async_read_until(*socket, response->content_buffer, "\r\n\r\n",
 263                                           [this, &response, &chunked_streambuf, timer](const boost::system::error_code& ec, size_t bytes_transferred) {
 264                 if(timer)
 265                     timer->cancel();
 266                 if(!ec) {
 267                     size_t num_additional_bytes=response->content_buffer.size()-bytes_transferred;
 268
 269                     parse_response_header(response);
 270
 271                     auto header_it=response->header.find("Content-Length");
 272                     if(header_it!=response->header.end()) {
 273                         auto content_length=stoull(header_it->second);
 274                         if(content_length>num_additional_bytes) {
 275                             auto timer=get_timeout_timer();
 276                             boost::asio::async_read(*socket, response->content_buffer,
 277                                                     boost::asio::transfer_exactly(content_length-num_additional_bytes),
 278                                                     [this, timer](const boost::system::error_code& ec, size_t /*bytes_transferred*/) {
 279                                 if(timer)
 280                                     timer->cancel();
 281                                 if(ec) {
 282                                     std::lock_guard<std::mutex> lock(socket_mutex);
 283                                     this->socket=nullptr;
 284                                     throw boost::system::system_error(ec);
 285                                 }
 286                             });
 287                         }
 288                     }
 289                     else if((header_it=response->header.find("Transfer-Encoding"))!=response->header.end() && header_it->second=="chunked") {
 290                         request_read_chunked(response, chunked_streambuf);
 291                     }
 292                     else if(response->http_version<"1.1" || ((header_it=response->header.find("Connection"))!=response->header.end() && header_it->second=="close")) {
 293                         auto timer=get_timeout_timer();
 294                         boost::asio::async_read(*socket, response->content_buffer,
 295                                                 [this, timer](const boost::system::error_code& ec, size_t /*bytes_transferred*/) {
 296                             if(timer)
 297                                     timer->cancel();
 298                             if(ec) {
 299                                 std::lock_guard<std::mutex> lock(socket_mutex);
 300                                 this->socket=nullptr;
 301                                 if(ec!=boost::asio::error::eof)
 302                                     throw boost::system::system_error(ec);
 303                             }
 304                         });
 305                     }
 306                 }
 307                 else {
 308                     std::lock_guard<std::mutex> lock(socket_mutex);
 309                     socket=nullptr;
 310                     throw boost::system::system_error(ec);
 311                 }
 312             });
 313             io_service.reset();
 314             io_service.run();
 315
 316             return response;
 317         }
 318
 319         void request_read_chunked(const std::shared_ptr<Response> &response, boost::asio::streambuf &streambuf) {
 320             auto timer=get_timeout_timer();
 321             boost::asio::async_read_until(*socket, response->content_buffer, "\r\n",
 322                                       [this, &response, &streambuf, timer](const boost::system::error_code& ec, size_t bytes_transferred) {
 323                 if(timer)
 324                     timer->cancel();
 325                 if(!ec) {
 326                     std::string line;
 327                     getline(response->content, line);
 328                     bytes_transferred-=line.size()+1;
 329                     line.pop_back();
 330                     std::streamsize length=stol(line, 0, 16);
 331
 332                     auto num_additional_bytes=static_cast<std::streamsize>(response->content_buffer.size()-bytes_transferred);
 333
 334                     auto post_process=[this, &response, &streambuf, length] {
 335                         std::ostream stream(&streambuf);
 336                         if(length>0) {
 337                             std::vector<char> buffer(static_cast<size_t>(length));
 338                             response->content.read(&buffer[0], length);
 339                             stream.write(&buffer[0], length);
 340                         }
 341
 342                         //Remove "\r\n"
 343                         response->content.get();
 344                         response->content.get();
 345
 346                         if(length>0)
 347                             request_read_chunked(response, streambuf);
 348                         else {
 349                             std::ostream response_stream(&response->content_buffer);
 350                             response_stream << stream.rdbuf();
 351                         }
 352                     };
 353
 354                     if((2+length)>num_additional_bytes) {
 355                         auto timer=get_timeout_timer();
 356                         boost::asio::async_read(*socket, response->content_buffer,
 357                                                 boost::asio::transfer_exactly(2+length-num_additional_bytes),
 358                                                 [this, post_process, timer](const boost::system::error_code& ec, size_t /*bytes_transferred*/) {
 359                             if(timer)
 360                                 timer->cancel();
 361                             if(!ec) {
 362                                 post_process();
 363                             }
 364                             else {
 365                                 std::lock_guard<std::mutex> lock(socket_mutex);
 366                                 this->socket=nullptr;
 367                                 throw boost::system::system_error(ec);
 368                             }
 369                         });
 370                     }
 371                     else
 372                         post_process();
 373                 }
 374                 else {
 375                     std::lock_guard<std::mutex> lock(socket_mutex);
 376                     socket=nullptr;
 377                     throw boost::system::system_error(ec);
 378                 }
 379             });
 380         }
 381     };
 382
 383     template<class socket_type>
 384     class Client : public ClientBase<socket_type> {};
 385
 386     typedef boost::asio::ip::tcp::socket HTTP;
 387
 388     template<>
 389     class Client<HTTP> : public ClientBase<HTTP> {
 390     public:
 391         Client(const std::string& server_port_path) : ClientBase<HTTP>::ClientBase(server_port_path, 80) {}
 392
 393     protected:
 394         void connect() {
 395             if(!socket || !socket->is_open()) {
 396                 std::unique_ptr<boost::asio::ip::tcp::resolver::query> query;
 397                 if(config.proxy_server.empty())
 398                     query=std::unique_ptr<boost::asio::ip::tcp::resolver::query>(new boost::asio::ip::tcp::resolver::query(host, std::to_string(port)));
 399                 else {
 400                     auto proxy_host_port=parse_host_port(config.proxy_server, 8080);
 401                     query=std::unique_ptr<boost::asio::ip::tcp::resolver::query>(new boost::asio::ip::tcp::resolver::query(proxy_host_port.first, std::to_string(proxy_host_port.second)));
 402                 }
 403                 resolver.async_resolve(*query, [this](const boost::system::error_code &ec,
 404                                                      boost::asio::ip::tcp::resolver::iterator it){
 405                     if(!ec) {
 406                         {
 407                             std::lock_guard<std::mutex> lock(socket_mutex);
 408                             socket=std::unique_ptr<HTTP>(new HTTP(io_service));
 409                         }
 410
 411                         auto timer=get_timeout_timer(config.timeout_connect);
 412                         boost::asio::async_connect(*socket, it, [this, timer]
 413                                 (const boost::system::error_code &ec, boost::asio::ip::tcp::resolver::iterator /*it*/){
 414                             if(timer)
 415                                 timer->cancel();
 416                             if(!ec) {
 417                                 boost::asio::ip::tcp::no_delay option(true);
 418                                 this->socket->set_option(option);
 419                             }
 420                             else {
 421                                 std::lock_guard<std::mutex> lock(socket_mutex);
 422                                 this->socket=nullptr;
 423                                 throw boost::system::system_error(ec);
 424                             }
 425                         });
 426                     }
 427                     else {
 428                         std::lock_guard<std::mutex> lock(socket_mutex);
 429                         socket=nullptr;
 430                         throw boost::system::system_error(ec);
 431                     }
 432                 });
 433                 io_service.reset();
 434                 io_service.run();
 435             }
 436         }
 437     };
 438 }
 439
 440 #endif  /* CLIENT_HTTP_HPP */