ceph/src/Beast/test/websocket/frame.cpp

   1 //
   2 // Copyright (c) 2013-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
   8 #include <beast/websocket/detail/frame.hpp>
   9 #include <beast/websocket/detail/stream_base.hpp>
  10 #include <beast/unit_test/suite.hpp>
  11 #include <initializer_list>
  12 #include <climits>
  13
  14 namespace beast {
  15 namespace websocket {
  16 namespace detail {
  17
  18 static
  19 bool
  20 operator==(frame_header const& lhs, frame_header const& rhs)
  21 {
  22     return
  23         lhs.op == rhs.op &&
  24         lhs.fin == rhs.fin &&
  25         lhs.mask == rhs.mask &&
  26         lhs.rsv1 == rhs.rsv1 &&
  27         lhs.rsv2 == rhs.rsv2 &&
  28         lhs.rsv3 == rhs.rsv3 &&
  29         lhs.len == rhs.len &&
  30         lhs.key == rhs.key;
  31 }
  32
  33 class frame_test : public beast::unit_test::suite
  34 {
  35 public:
  36     void testCloseCodes()
  37     {
  38         BEAST_EXPECT(! is_valid_close_code(0));
  39         BEAST_EXPECT(! is_valid_close_code(1));
  40         BEAST_EXPECT(! is_valid_close_code(999));
  41         BEAST_EXPECT(! is_valid_close_code(1004));
  42         BEAST_EXPECT(! is_valid_close_code(1005));
  43         BEAST_EXPECT(! is_valid_close_code(1006));
  44         BEAST_EXPECT(! is_valid_close_code(1016));
  45         BEAST_EXPECT(! is_valid_close_code(2000));
  46         BEAST_EXPECT(! is_valid_close_code(2999));
  47         BEAST_EXPECT(is_valid_close_code(1000));
  48         BEAST_EXPECT(is_valid_close_code(1002));
  49         BEAST_EXPECT(is_valid_close_code(3000));
  50         BEAST_EXPECT(is_valid_close_code(4000));
  51         BEAST_EXPECT(is_valid_close_code(5000));
  52     }
  53
  54     struct test_fh : frame_header
  55     {
  56         test_fh()
  57         {
  58             op = opcode::text;
  59             fin = false;
  60             mask = false;
  61             rsv1 = false;
  62             rsv2 = false;
  63             rsv3 = false;
  64             len = 0;
  65             key = 0;
  66         }
  67     };
  68
  69     void testFrameHeader()
  70     {
  71         // good frame fields
  72         {
  73             role_type role = role_type::client;
  74
  75             auto check =
  76                 [&](frame_header const& fh)
  77                 {
  78                     fh_streambuf sb;
  79                     write(sb, fh);
  80                     close_code code;
  81                     stream_base stream;
  82                     stream.open(role);
  83                     detail::frame_header fh1;
  84                     auto const n =
  85                         stream.read_fh1(fh1, sb, code);
  86                     if(! BEAST_EXPECT(! code))
  87                         return;
  88                     if(! BEAST_EXPECT(sb.size() == n))
  89                         return;
  90                     stream.read_fh2(fh1, sb, code);
  91                     if(! BEAST_EXPECT(! code))
  92                         return;
  93                     if(! BEAST_EXPECT(sb.size() == 0))
  94                         return;
  95                     BEAST_EXPECT(fh1 == fh);
  96                 };
  97
  98             test_fh fh;
  99
 100             check(fh);
 101
 102             role = role_type::server;
 103             fh.mask = true;
 104             fh.key = 1;
 105             check(fh);
 106
 107             fh.len = 1;
 108             check(fh);
 109
 110             fh.len = 126;
 111             check(fh);
 112
 113             fh.len = 65535;
 114             check(fh);
 115
 116             fh.len = 65536;
 117             check(fh);
 118
 119             fh.len = 65537;
 120             check(fh);
 121         }
 122
 123         // bad frame fields
 124         {
 125             role_type role = role_type::client;
 126
 127             auto check =
 128                 [&](frame_header const& fh)
 129                 {
 130                     fh_streambuf sb;
 131                     write(sb, fh);
 132                     close_code code;
 133                     stream_base stream;
 134                     stream.open(role);
 135                     detail::frame_header fh1;
 136                     auto const n =
 137                         stream.read_fh1(fh1, sb, code);
 138                     if(code)
 139                     {
 140                         pass();
 141                         return;
 142                     }
 143                     if(! BEAST_EXPECT(sb.size() == n))
 144                         return;
 145                     stream.read_fh2(fh1, sb, code);
 146                     if(! BEAST_EXPECT(code))
 147                         return;
 148                     if(! BEAST_EXPECT(sb.size() == 0))
 149                         return;
 150                 };
 151
 152             test_fh fh;
 153
 154             fh.op = opcode::close;
 155             fh.fin = true;
 156             fh.len = 126;
 157             check(fh);
 158             fh.len = 0;
 159
 160             fh.rsv1 = true;
 161             check(fh);
 162             fh.rsv1 = false;
 163
 164             fh.rsv2 = true;
 165             check(fh);
 166             fh.rsv2 = false;
 167
 168             fh.rsv3 = true;
 169             check(fh);
 170             fh.rsv3 = false;
 171
 172             fh.op = opcode::rsv3;
 173             check(fh);
 174             fh.op = opcode::text;
 175
 176             fh.op = opcode::ping;
 177             fh.fin = false;
 178             check(fh);
 179             fh.fin = true;
 180
 181             fh.mask = true;
 182             check(fh);
 183
 184             role = role_type::server;
 185             fh.mask = false;
 186             check(fh);
 187         }
 188     }
 189
 190     void bad(std::initializer_list<std::uint8_t> bs)
 191     {
 192         using boost::asio::buffer;
 193         using boost::asio::buffer_copy;
 194         static role_type constexpr role = role_type::client;
 195         std::vector<std::uint8_t> v{bs};
 196         fh_streambuf sb;
 197         sb.commit(buffer_copy(sb.prepare(v.size()), buffer(v)));
 198         stream_base stream;
 199         stream.open(role);
 200         close_code code;
 201         detail::frame_header fh;
 202         auto const n =
 203             stream.read_fh1(fh, sb, code);
 204         if(code)
 205         {
 206             pass();
 207             return;
 208         }
 209         if(! BEAST_EXPECT(sb.size() == n))
 210             return;
 211         stream.read_fh2(fh, sb, code);
 212         if(! BEAST_EXPECT(code))
 213             return;
 214         if(! BEAST_EXPECT(sb.size() == 0))
 215             return;
 216     }
 217
 218     void testBadFrameHeaders()
 219     {
 220         // bad frame fields
 221         //
 222         // can't be created by the library
 223         // so we produce them manually.
 224
 225         bad({0, 126, 0, 125});
 226         bad({0, 127, 0, 0, 0, 0, 0, 0, 255, 255});
 227     }
 228
 229     void run() override
 230     {
 231         testCloseCodes();
 232         testFrameHeader();
 233         testBadFrameHeaders();
 234     }
 235 };
 236
 237 BEAST_DEFINE_TESTSUITE(frame,websocket,beast);
 238
 239 } // detail
 240 } // websocket
 241 } // beast