Line data    Source code

       1             : //
       2             : // Copyright (c) 2019 Vinnie Falco (vinnie.falco@gmail.com)
       3             : // Copyright (c) 2022 Alan de Freitas (alandefreitas@gmail.com)
       4             : //
       5             : // Distributed under the Boost Software License, Version 1.0. (See accompanying
       6             : // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
       7             : //
       8             : // Official repository: https://github.com/boostorg/url
       9             : //
      10             : 
      11             : #ifndef BOOST_URL_DETAIL_ENCODE_HPP
      12             : #define BOOST_URL_DETAIL_ENCODE_HPP
      13             : 
      14             : #include <boost/url/encoding_opts.hpp>
      15             : #include <boost/url/pct_string_view.hpp>
      16             : #include <boost/url/grammar/hexdig_chars.hpp>
      17             : #include <boost/core/ignore_unused.hpp>
      18             : #include <cstdlib>
      19             : 
      20             : namespace boost {
      21             : namespace urls {
      22             : namespace detail {
      23             : 
      24             : constexpr
      25             : char const* const hexdigs[] = {
      26             :     "0123456789ABCDEF",
      27             :     "0123456789abcdef" };
      28             : 
      29             : //------------------------------------------------
      30             : 
      31             : // re-encode is to percent-encode a
      32             : // string that can already contain
      33             : // escapes. Characters not in the
      34             : // unreserved set are escaped, and
      35             : // escapes are passed through unchanged.
      36             : //
      37             : template<class CharSet>
      38             : std::size_t
      39        1065 : re_encoded_size_unsafe(
      40             :     core::string_view s,
      41             :     CharSet const& unreserved) noexcept
      42             : {
      43        1065 :     std::size_t n = 0;
      44        1065 :     auto it = s.begin();
      45        1065 :     auto const end = s.end();
      46        4702 :     while(it != end)
      47             :     {
      48        3637 :         if(*it != '%')
      49             :         {
      50        3482 :             if( unreserved(*it) )
      51        3275 :                 n += 1;
      52             :             else
      53         207 :                 n += 3;
      54        3482 :             ++it;
      55             :         }
      56             :         else
      57             :         {
      58         155 :             BOOST_ASSERT(end - it >= 3);
      59         155 :             BOOST_ASSERT(
      60             :                     grammar::hexdig_value(
      61             :                             it[1]) >= 0);
      62         155 :             BOOST_ASSERT(
      63             :                     grammar::hexdig_value(
      64             :                             it[2]) >= 0);
      65         155 :             n += 3;
      66         155 :             it += 3;
      67             :         }
      68             :     }
      69        1065 :     return n;
      70             : }
      71             : 
      72             : // unchecked
      73             : // returns decoded size
      74             : template<class CharSet>
      75             : std::size_t
      76        1271 : re_encode_unsafe(
      77             :     char*& dest_,
      78             :     char const* const end,
      79             :     core::string_view s,
      80             :     CharSet const& unreserved) noexcept
      81             : {
      82             :     static constexpr bool lower_case = false;
      83        1271 :     char const* const hex = detail::hexdigs[lower_case];
      84        1271 :     auto const encode = [end, hex](
      85             :             char*& dest,
      86             :             char c0) noexcept
      87             :     {
      88         213 :         auto c = static_cast<unsigned char>(c0);
      89         213 :         ignore_unused(end);
      90         213 :         *dest++ = '%';
      91         213 :         BOOST_ASSERT(dest != end);
      92         213 :         *dest++ = hex[c>>4];
      93         213 :         BOOST_ASSERT(dest != end);
      94         213 :         *dest++ = hex[c&0xf];
      95             :     };
      96             :     ignore_unused(end);
      97             : 
      98        1271 :     auto dest = dest_;
      99        1271 :     auto const dest0 = dest;
     100        1271 :     auto const last = s.end();
     101        1271 :     std::size_t dn = 0;
     102        1271 :     auto it = s.begin();
     103        5054 :     while(it != last)
     104             :     {
     105        3783 :         BOOST_ASSERT(dest != end);
     106        3783 :         if(*it != '%')
     107             :         {
     108        3625 :             if(unreserved(*it))
     109             :             {
     110        3412 :                 *dest++ = *it;
     111             :             }
     112             :             else
     113             :             {
     114         213 :                 encode(dest, *it);
     115         213 :                 dn += 2;
     116             :             }
     117        3625 :             ++it;
     118             :         }
     119             :         else
     120             :         {
     121         158 :             *dest++ = *it++;
     122         158 :             BOOST_ASSERT(dest != end);
     123         158 :             *dest++ = *it++;
     124         158 :             BOOST_ASSERT(dest != end);
     125         158 :             *dest++ = *it++;
     126         158 :             dn += 2;
     127             :         }
     128             :     }
     129        1271 :     dest_ = dest;
     130        1271 :     return dest - dest0 - dn;
     131             : }
     132             : 
     133             : } // detail
     134             : } // urls
     135             : } // boost
     136             : 
     137             : #endif