ceph/src/boost/boost/beast/websocket/impl/stream.ipp

   1 //
   2 // Copyright (c) 2016-2017 Vinnie Falco (vinnie dot falco at gmail dot com)
   3 //
   4 // Distributed under the Boost Software License, Version 1.0. (See accompanying
   5 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   6 //
   7 // Official repository: https://github.com/boostorg/beast
   8 //
   9
  10 #ifndef BOOST_BEAST_WEBSOCKET_IMPL_STREAM_IPP
  11 #define BOOST_BEAST_WEBSOCKET_IMPL_STREAM_IPP
  12
  13 #include <boost/beast/websocket/rfc6455.hpp>
  14 #include <boost/beast/websocket/teardown.hpp>
  15 #include <boost/beast/websocket/detail/hybi13.hpp>
  16 #include <boost/beast/websocket/detail/pmd_extension.hpp>
  17 #include <boost/beast/version.hpp>
  18 #include <boost/beast/http/read.hpp>
  19 #include <boost/beast/http/write.hpp>
  20 #include <boost/beast/http/rfc7230.hpp>
  21 #include <boost/beast/core/buffers_cat.hpp>
  22 #include <boost/beast/core/buffers_prefix.hpp>
  23 #include <boost/beast/core/buffers_suffix.hpp>
  24 #include <boost/beast/core/flat_static_buffer.hpp>
  25 #include <boost/beast/core/type_traits.hpp>
  26 #include <boost/beast/core/detail/clamp.hpp>
  27 #include <boost/beast/core/detail/type_traits.hpp>
  28 #include <boost/assert.hpp>
  29 #include <boost/endian/buffers.hpp>
  30 #include <boost/make_unique.hpp>
  31 #include <boost/throw_exception.hpp>
  32 #include <algorithm>
  33 #include <memory>
  34 #include <stdexcept>
  35 #include <utility>
  36
  37 #include <iostream>
  38
  39 namespace boost {
  40 namespace beast {
  41 namespace websocket {
  42
  43 template<class NextLayer>
  44 template<class... Args>
  45 stream<NextLayer>::
  46 stream(Args&&... args)
  47     : stream_(std::forward<Args>(args)...)
  48     , tok_(1)
  49 {
  50     BOOST_ASSERT(rd_buf_.max_size() >=
  51         max_control_frame_size);
  52 }
  53
  54 template<class NextLayer>
  55 std::size_t
  56 stream<NextLayer>::
  57 read_size_hint(
  58     std::size_t initial_size) const
  59 {
  60     using beast::detail::clamp;
  61     std::size_t result;
  62     BOOST_ASSERT(initial_size > 0);
  63     if(! pmd_ || (! rd_done_ && ! pmd_->rd_set))
  64     {
  65         // current message is uncompressed
  66
  67         if(rd_done_)
  68         {
  69             // first message frame
  70             result = initial_size;
  71             goto done;
  72         }
  73         else if(rd_fh_.fin)
  74         {
  75             // last message frame
  76             BOOST_ASSERT(rd_remain_ > 0);
  77             result = clamp(rd_remain_);
  78             goto done;
  79         }
  80     }
  81     result = (std::max)(
  82         initial_size, clamp(rd_remain_));
  83 done:
  84     BOOST_ASSERT(result != 0);
  85     return result;
  86 }
  87
  88 template<class NextLayer>
  89 template<class DynamicBuffer, class>
  90 std::size_t
  91 stream<NextLayer>::
  92 read_size_hint(DynamicBuffer& buffer) const
  93 {
  94     static_assert(
  95         boost::asio::is_dynamic_buffer<DynamicBuffer>::value,
  96         "DynamicBuffer requirements not met");
  97     auto const initial_size = (std::min)(
  98         +tcp_frame_size,
  99         buffer.max_size() - buffer.size());
 100     if(initial_size == 0)
 101         return 1; // buffer is full
 102     return read_size_hint(initial_size);
 103 }
 104
 105 template<class NextLayer>
 106 void
 107 stream<NextLayer>::
 108 set_option(permessage_deflate const& o)
 109 {
 110     if( o.server_max_window_bits > 15 ||
 111         o.server_max_window_bits < 9)
 112         BOOST_THROW_EXCEPTION(std::invalid_argument{
 113             "invalid server_max_window_bits"});
 114     if( o.client_max_window_bits > 15 ||
 115         o.client_max_window_bits < 9)
 116         BOOST_THROW_EXCEPTION(std::invalid_argument{
 117             "invalid client_max_window_bits"});
 118     if( o.compLevel < 0 ||
 119         o.compLevel > 9)
 120         BOOST_THROW_EXCEPTION(std::invalid_argument{
 121             "invalid compLevel"});
 122     if( o.memLevel < 1 ||
 123         o.memLevel > 9)
 124         BOOST_THROW_EXCEPTION(std::invalid_argument{
 125             "invalid memLevel"});
 126     pmd_opts_ = o;
 127 }
 128
 129 //------------------------------------------------------------------------------
 130
 131 template<class NextLayer>
 132 void
 133 stream<NextLayer>::
 134 open(role_type role)
 135 {
 136     // VFALCO TODO analyze and remove dupe code in reset()
 137     role_ = role;
 138     status_ = status::open;
 139     rd_remain_ = 0;
 140     rd_cont_ = false;
 141     rd_done_ = true;
 142     // Can't clear this because accept uses it
 143     //rd_buf_.reset();
 144     rd_fh_.fin = false;
 145     rd_close_ = false;
 146     wr_close_ = false;
 147     wr_block_.reset();
 148     rd_block_.reset();
 149     cr_.code = close_code::none;
 150
 151     wr_cont_ = false;
 152     wr_buf_size_ = 0;
 153
 154     if(((role_ == role_type::client && pmd_opts_.client_enable) ||
 155         (role_ == role_type::server && pmd_opts_.server_enable)) &&
 156             pmd_config_.accept)
 157     {
 158         pmd_normalize(pmd_config_);
 159         pmd_.reset(new pmd_t);
 160         if(role_ == role_type::client)
 161         {
 162             pmd_->zi.reset(
 163                 pmd_config_.server_max_window_bits);
 164             pmd_->zo.reset(
 165                 pmd_opts_.compLevel,
 166                 pmd_config_.client_max_window_bits,
 167                 pmd_opts_.memLevel,
 168                 zlib::Strategy::normal);
 169         }
 170         else
 171         {
 172             pmd_->zi.reset(
 173                 pmd_config_.client_max_window_bits);
 174             pmd_->zo.reset(
 175                 pmd_opts_.compLevel,
 176                 pmd_config_.server_max_window_bits,
 177                 pmd_opts_.memLevel,
 178                 zlib::Strategy::normal);
 179         }
 180     }
 181 }
 182
 183 template<class NextLayer>
 184 void
 185 stream<NextLayer>::
 186 close()
 187 {
 188     wr_buf_.reset();
 189     pmd_.reset();
 190 }
 191
 192 template<class NextLayer>
 193 void
 194 stream<NextLayer>::
 195 reset()
 196 {
 197     BOOST_ASSERT(status_ != status::open);
 198     rd_remain_ = 0;
 199     rd_cont_ = false;
 200     rd_done_ = true;
 201     rd_buf_.consume(rd_buf_.size());
 202     rd_fh_.fin = false;
 203     rd_close_ = false;
 204     wr_close_ = false;
 205     wr_cont_ = false;
 206     wr_block_.reset();
 207     rd_block_.reset();
 208     cr_.code = close_code::none;
 209 }
 210
 211 // Called before each write frame
 212 template<class NextLayer>
 213 void
 214 stream<NextLayer>::
 215 begin_msg()
 216 {
 217     wr_frag_ = wr_frag_opt_;
 218     wr_compress_ = static_cast<bool>(pmd_);
 219
 220     // Maintain the write buffer
 221     if( wr_compress_ ||
 222         role_ == role_type::client)
 223     {
 224         if(! wr_buf_ || wr_buf_size_ != wr_buf_opt_)
 225         {
 226             wr_buf_size_ = wr_buf_opt_;
 227             wr_buf_ = boost::make_unique_noinit<
 228                 std::uint8_t[]>(wr_buf_size_);
 229         }
 230     }
 231     else
 232     {
 233         wr_buf_size_ = wr_buf_opt_;
 234         wr_buf_.reset();
 235     }
 236 }
 237
 238 //------------------------------------------------------------------------------
 239
 240 // Attempt to read a complete frame header.
 241 // Returns `false` if more bytes are needed
 242 template<class NextLayer>
 243 template<class DynamicBuffer>
 244 bool
 245 stream<NextLayer>::
 246 parse_fh(
 247     detail::frame_header& fh,
 248     DynamicBuffer& b,
 249     close_code& code)
 250 {
 251     using boost::asio::buffer;
 252     using boost::asio::buffer_copy;
 253     using boost::asio::buffer_size;
 254     auto const err =
 255         [&](close_code cv)
 256         {
 257             code = cv;
 258             return false;
 259         };
 260     if(buffer_size(b.data()) < 2)
 261     {
 262         code = close_code::none;
 263         return false;
 264     }
 265     buffers_suffix<typename
 266         DynamicBuffer::const_buffers_type> cb{
 267             b.data()};
 268     std::size_t need;
 269     {
 270         std::uint8_t tmp[2];
 271         cb.consume(buffer_copy(buffer(tmp), cb));
 272         fh.len = tmp[1] & 0x7f;
 273         switch(fh.len)
 274         {
 275             case 126: need = 2; break;
 276             case 127: need = 8; break;
 277             default:
 278                 need = 0;
 279         }
 280         fh.mask = (tmp[1] & 0x80) != 0;
 281         if(fh.mask)
 282             need += 4;
 283         if(buffer_size(cb) < need)
 284         {
 285             code = close_code::none;
 286             return false;
 287         }
 288         fh.op   = static_cast<
 289             detail::opcode>(tmp[0] & 0x0f);
 290         fh.fin  = (tmp[0] & 0x80) != 0;
 291         fh.rsv1 = (tmp[0] & 0x40) != 0;
 292         fh.rsv2 = (tmp[0] & 0x20) != 0;
 293         fh.rsv3 = (tmp[0] & 0x10) != 0;
 294     }
 295     switch(fh.op)
 296     {
 297     case detail::opcode::binary:
 298     case detail::opcode::text:
 299         if(rd_cont_)
 300         {
 301             // new data frame when continuation expected
 302             return err(close_code::protocol_error);
 303         }
 304         if((fh.rsv1 && ! pmd_) ||
 305             fh.rsv2 || fh.rsv3)
 306         {
 307             // reserved bits not cleared
 308             return err(close_code::protocol_error);
 309         }
 310         if(pmd_)
 311             pmd_->rd_set = fh.rsv1;
 312         break;
 313
 314     case detail::opcode::cont:
 315         if(! rd_cont_)
 316         {
 317             // continuation without an active message
 318             return err(close_code::protocol_error);
 319         }
 320         if(fh.rsv1 || fh.rsv2 || fh.rsv3)
 321         {
 322             // reserved bits not cleared
 323             return err(close_code::protocol_error);
 324         }
 325         break;
 326
 327     default:
 328         if(detail::is_reserved(fh.op))
 329         {
 330             // reserved opcode
 331             return err(close_code::protocol_error);
 332         }
 333         if(! fh.fin)
 334         {
 335             // fragmented control message
 336             return err(close_code::protocol_error);
 337         }
 338         if(fh.len > 125)
 339         {
 340             // invalid length for control message
 341             return err(close_code::protocol_error);
 342         }
 343         if(fh.rsv1 || fh.rsv2 || fh.rsv3)
 344         {
 345             // reserved bits not cleared
 346             return err(close_code::protocol_error);
 347         }
 348         break;
 349     }
 350     // unmasked frame from client
 351     if(role_ == role_type::server && ! fh.mask)
 352         return err(close_code::protocol_error);
 353     // masked frame from server
 354     if(role_ == role_type::client && fh.mask)
 355         return err(close_code::protocol_error);
 356     if(detail::is_control(fh.op) &&
 357         buffer_size(cb) < need + fh.len)
 358     {
 359         // Make the entire control frame payload
 360         // get read in before we return `true`
 361         return false;
 362     }
 363     switch(fh.len)
 364     {
 365     case 126:
 366     {
 367         std::uint8_t tmp[2];
 368         BOOST_ASSERT(buffer_size(cb) >= sizeof(tmp));
 369         cb.consume(buffer_copy(buffer(tmp), cb));
 370         fh.len = detail::big_uint16_to_native(&tmp[0]);
 371         // length not canonical
 372         if(fh.len < 126)
 373             return err(close_code::protocol_error);
 374         break;
 375     }
 376     case 127:
 377     {
 378         std::uint8_t tmp[8];
 379         BOOST_ASSERT(buffer_size(cb) >= sizeof(tmp));
 380         cb.consume(buffer_copy(buffer(tmp), cb));
 381         fh.len = detail::big_uint64_to_native(&tmp[0]);
 382         // length not canonical
 383         if(fh.len < 65536)
 384             return err(close_code::protocol_error);
 385         break;
 386     }
 387     }
 388     if(fh.mask)
 389     {
 390         std::uint8_t tmp[4];
 391         BOOST_ASSERT(buffer_size(cb) >= sizeof(tmp));
 392         cb.consume(buffer_copy(buffer(tmp), cb));
 393         fh.key = detail::little_uint32_to_native(&tmp[0]);
 394         detail::prepare_key(rd_key_, fh.key);
 395     }
 396     else
 397     {
 398         // initialize this otherwise operator== breaks
 399         fh.key = 0;
 400     }
 401     if(! detail::is_control(fh.op))
 402     {
 403         if(fh.op != detail::opcode::cont)
 404         {
 405             rd_size_ = 0;
 406             rd_op_ = fh.op;
 407         }
 408         else
 409         {
 410             if(rd_size_ > (std::numeric_limits<
 411                     std::uint64_t>::max)() - fh.len)
 412                 return err(close_code::too_big);
 413         }
 414         if(! pmd_ || ! pmd_->rd_set)
 415         {
 416             if(rd_msg_max_ && beast::detail::sum_exceeds(
 417                 rd_size_, fh.len, rd_msg_max_))
 418                 return err(close_code::too_big);
 419         }
 420         rd_cont_ = ! fh.fin;
 421         rd_remain_ = fh.len;
 422     }
 423     b.consume(b.size() - buffer_size(cb));
 424     code = close_code::none;
 425     return true;
 426 }
 427
 428 template<class NextLayer>
 429 template<class DynamicBuffer>
 430 void
 431 stream<NextLayer>::
 432 write_close(DynamicBuffer& db, close_reason const& cr)
 433 {
 434     using namespace boost::endian;
 435     detail::frame_header fh;
 436     fh.op = detail::opcode::close;
 437     fh.fin = true;
 438     fh.rsv1 = false;
 439     fh.rsv2 = false;
 440     fh.rsv3 = false;
 441     fh.len = cr.code == close_code::none ?
 442         0 : 2 + cr.reason.size();
 443     if(role_ == role_type::client)
 444     {
 445         fh.mask = true;
 446         fh.key = wr_gen_();
 447     }
 448     else
 449     {
 450         fh.mask = false;
 451     }
 452     detail::write(db, fh);
 453     if(cr.code != close_code::none)
 454     {
 455         detail::prepared_key key;
 456         if(fh.mask)
 457             detail::prepare_key(key, fh.key);
 458         {
 459             std::uint8_t tmp[2];
 460             ::new(&tmp[0]) big_uint16_buf_t{
 461                 (std::uint16_t)cr.code};
 462             auto mb = db.prepare(2);
 463             boost::asio::buffer_copy(mb,
 464                 boost::asio::buffer(tmp));
 465             if(fh.mask)
 466                 detail::mask_inplace(mb, key);
 467             db.commit(2);
 468         }
 469         if(! cr.reason.empty())
 470         {
 471             auto mb = db.prepare(cr.reason.size());
 472             boost::asio::buffer_copy(mb,
 473                 boost::asio::const_buffer(
 474                     cr.reason.data(), cr.reason.size()));
 475             if(fh.mask)
 476                 detail::mask_inplace(mb, key);
 477             db.commit(cr.reason.size());
 478         }
 479     }
 480 }
 481
 482 template<class NextLayer>
 483 template<class DynamicBuffer>
 484 void
 485 stream<NextLayer>::
 486 write_ping(DynamicBuffer& db,
 487     detail::opcode code, ping_data const& data)
 488 {
 489     detail::frame_header fh;
 490     fh.op = code;
 491     fh.fin = true;
 492     fh.rsv1 = false;
 493     fh.rsv2 = false;
 494     fh.rsv3 = false;
 495     fh.len = data.size();
 496     fh.mask = role_ == role_type::client;
 497     if(fh.mask)
 498         fh.key = wr_gen_();
 499     detail::write(db, fh);
 500     if(data.empty())
 501         return;
 502     detail::prepared_key key;
 503     if(fh.mask)
 504         detail::prepare_key(key, fh.key);
 505     auto mb = db.prepare(data.size());
 506     boost::asio::buffer_copy(mb,
 507         boost::asio::const_buffer(
 508             data.data(), data.size()));
 509     if(fh.mask)
 510         detail::mask_inplace(mb, key);
 511     db.commit(data.size());
 512 }
 513
 514 //------------------------------------------------------------------------------
 515
 516 template<class NextLayer>
 517 template<class Decorator>
 518 request_type
 519 stream<NextLayer>::
 520 build_request(detail::sec_ws_key_type& key,
 521     string_view host,
 522         string_view target,
 523             Decorator const& decorator)
 524 {
 525     request_type req;
 526     req.target(target);
 527     req.version(11);
 528     req.method(http::verb::get);
 529     req.set(http::field::host, host);
 530     req.set(http::field::upgrade, "websocket");
 531     req.set(http::field::connection, "upgrade");
 532     detail::make_sec_ws_key(key, wr_gen_);
 533     req.set(http::field::sec_websocket_key, key);
 534     req.set(http::field::sec_websocket_version, "13");
 535     if(pmd_opts_.client_enable)
 536     {
 537         detail::pmd_offer config;
 538         config.accept = true;
 539         config.server_max_window_bits =
 540             pmd_opts_.server_max_window_bits;
 541         config.client_max_window_bits =
 542             pmd_opts_.client_max_window_bits;
 543         config.server_no_context_takeover =
 544             pmd_opts_.server_no_context_takeover;
 545         config.client_no_context_takeover =
 546             pmd_opts_.client_no_context_takeover;
 547         detail::pmd_write(req, config);
 548     }
 549     decorator(req);
 550     if(! req.count(http::field::user_agent))
 551         req.set(http::field::user_agent,
 552             BOOST_BEAST_VERSION_STRING);
 553     return req;
 554 }
 555
 556 template<class NextLayer>
 557 template<class Body, class Allocator, class Decorator>
 558 response_type
 559 stream<NextLayer>::
 560 build_response(http::request<Body,
 561     http::basic_fields<Allocator>> const& req,
 562         Decorator const& decorator)
 563 {
 564     auto const decorate =
 565         [&decorator](response_type& res)
 566         {
 567             decorator(res);
 568             if(! res.count(http::field::server))
 569             {
 570                 BOOST_STATIC_ASSERT(sizeof(BOOST_BEAST_VERSION_STRING) < 20);
 571                 static_string<20> s(BOOST_BEAST_VERSION_STRING);
 572                 res.set(http::field::server, s);
 573             }
 574         };
 575     auto err =
 576         [&](std::string const& text)
 577         {
 578             response_type res;
 579             res.version(req.version());
 580             res.result(http::status::bad_request);
 581             res.body() = text;
 582             res.prepare_payload();
 583             decorate(res);
 584             return res;
 585         };
 586     if(req.version() < 11)
 587         return err("HTTP version 1.1 required");
 588     if(req.method() != http::verb::get)
 589         return err("Wrong method");
 590     if(! is_upgrade(req))
 591         return err("Expected Upgrade request");
 592     if(! req.count(http::field::host))
 593         return err("Missing Host");
 594     if(! req.count(http::field::sec_websocket_key))
 595         return err("Missing Sec-WebSocket-Key");
 596     auto const key = req[http::field::sec_websocket_key];
 597     if(key.size() > detail::sec_ws_key_type::max_size_n)
 598         return err("Invalid Sec-WebSocket-Key");
 599     {
 600         auto const version =
 601             req[http::field::sec_websocket_version];
 602         if(version.empty())
 603             return err("Missing Sec-WebSocket-Version");
 604         if(version != "13")
 605         {
 606             response_type res;
 607             res.result(http::status::upgrade_required);
 608             res.version(req.version());
 609             res.set(http::field::sec_websocket_version, "13");
 610             res.prepare_payload();
 611             decorate(res);
 612             return res;
 613         }
 614     }
 615
 616     response_type res;
 617     {
 618         detail::pmd_offer offer;
 619         detail::pmd_offer unused;
 620         pmd_read(offer, req);
 621         pmd_negotiate(res, unused, offer, pmd_opts_);
 622     }
 623     res.result(http::status::switching_protocols);
 624     res.version(req.version());
 625     res.set(http::field::upgrade, "websocket");
 626     res.set(http::field::connection, "upgrade");
 627     {
 628         detail::sec_ws_accept_type acc;
 629         detail::make_sec_ws_accept(acc, key);
 630         res.set(http::field::sec_websocket_accept, acc);
 631     }
 632     decorate(res);
 633     return res;
 634 }
 635
 636 template<class NextLayer>
 637 void
 638 stream<NextLayer>::
 639 on_response(response_type const& res,
 640     detail::sec_ws_key_type const& key, error_code& ec)
 641 {
 642     bool const success = [&]()
 643     {
 644         if(res.version() < 11)
 645             return false;
 646         if(res.result() != http::status::switching_protocols)
 647             return false;
 648         if(! http::token_list{res[http::field::connection]}.exists("upgrade"))
 649             return false;
 650         if(! http::token_list{res[http::field::upgrade]}.exists("websocket"))
 651             return false;
 652         if(res.count(http::field::sec_websocket_accept) != 1)
 653             return false;
 654         detail::sec_ws_accept_type acc;
 655         detail::make_sec_ws_accept(acc, key);
 656         if(acc.compare(
 657                 res[http::field::sec_websocket_accept]) != 0)
 658             return false;
 659         return true;
 660     }();
 661     if(! success)
 662     {
 663         ec = error::handshake_failed;
 664         return;
 665     }
 666     ec.assign(0, ec.category());
 667     detail::pmd_offer offer;
 668     pmd_read(offer, res);
 669     // VFALCO see if offer satisfies pmd_config_,
 670     //        return an error if not.
 671     pmd_config_ = offer; // overwrite for now
 672     open(role_type::client);
 673 }
 674
 675 // _Fail the WebSocket Connection_
 676 template<class NextLayer>
 677 void
 678 stream<NextLayer>::
 679 do_fail(
 680     std::uint16_t code,         // if set, send a close frame first
 681     error_code ev,              // error code to use upon success
 682     error_code& ec)             // set to the error, else set to ev
 683 {
 684     BOOST_ASSERT(ev);
 685     status_ = status::closing;
 686     if(code != close_code::none && ! wr_close_)
 687     {
 688         wr_close_ = true;
 689         detail::frame_buffer fb;
 690         write_close<
 691             flat_static_buffer_base>(fb, code);
 692         boost::asio::write(stream_, fb.data(), ec);
 693         if(! check_ok(ec))
 694             return;
 695     }
 696     using beast::websocket::teardown;
 697     teardown(role_, stream_, ec);
 698     if(ec == boost::asio::error::eof)
 699     {
 700         // Rationale:
 701         // http://stackoverflow.com/questions/25587403/boost-asio-ssl-async-shutdown-always-finishes-with-an-error
 702         ec.assign(0, ec.category());
 703     }
 704     if(! ec)
 705         ec = ev;
 706     if(ec && ec != error::closed)
 707         status_ = status::failed;
 708     else
 709         status_ = status::closed;
 710     close();
 711 }
 712
 713 } // websocket
 714 } // beast
 715 } // boost
 716
 717 #endif