Beast-ന്റെ CONNECT ബഫർ TLS ഹാൻഡ്ഷേക്കിലേക്ക് കൊണ്ടുവരിക

Beast ഒരു പ്രോക്സിയുടെ CONNECT പ്രതികരണ ഹെഡർ വായിച്ച ശേഷം, പ്രതികരണത്തിന്റെ അവസ്ഥയും ചലനാത്മക ബഫറും പരിശോധിക്കുക. വായനാ പ്രവർത്തനം ഹെഡർ അവസാനിക്കുന്നതിനപ്പുറമുള്ള ബൈറ്റുകൾ കൊണ്ടുവന്ന് നൽകിയ ബഫറിൽ സൂക്ഷിച്ചേക്കാം. സോക്കറ്റ് മാത്രം വായിക്കുന്ന ഓവർലോഡ് ഉപയോഗിച്ച് TLS ആരംഭിച്ചാൽ, ആ സൂക്ഷിച്ച ബൈറ്റുകൾ TLS ഇൻപുട്ട് പാതയ്ക്ക് പുറത്ത് നിൽക്കും.

അടുത്ത പാളി SSL സ്ട്രീം ആയ WebSocket സ്ട്രീമിന്, ബഫർ ചെയ്ത ഹാൻഡ്ഷേക്ക് ഓവർലോഡ് ഉപയോഗിക്കുക. നിലവിലുള്ള yield_context സെഷനിൽ, എല്ലാ പ്രവർത്തനങ്ങളിലും buffer ജീവനോടെ നിർത്തി:

http::response_parser<http::empty_body> response;
http::async_read_header(
    beast::get_lowest_layer(ws), buffer, response, yield[ec]);
if (ec) return;

auto status = response.get().result_int();
if (status < 200 || status >= 300) return;

std::size_t used = ws.next_layer().async_handshake(
    ssl::stream_base::client, buffer.data(), yield[ec]);
if (ec) return;
buffer.consume(used);

ആദ്യകാല റിട്ടേണുകൾ സെഷന്റെ പരാജയ നിർഗമനങ്ങളാണ്; സാധാരണ പിശക് റിപ്പോർട്ടിംഗും വൃത്തിയാക്കലും അവിടെ ചേർക്കുക. വിജയകരമായ CONNECT പ്രതികരണം മാത്രമാണ് ടണൽ സ്ഥാപിക്കുന്നത്. നിരസിക്കൽ പേജ് TLS ഇൻപുട്ട് ആകരുത്.

ബഫർ ചെയ്ത ഓവർലോഡ് ഒരു പിശക് കോഡും ബൈറ്റ് എണ്ണവുമായി പൂർത്തിയാകുന്നു. ആ എണ്ണം നൽകിയ ബഫറുകളിൽ നിന്ന് എത്ര ബൈറ്റുകൾ ഉപഭോഗം ചെയ്തു എന്ന് വിവരിക്കുന്നു. പൂർത്തിയായ ശേഷം consume(used) ഉപയോഗിച്ച് ആ പ്രിഫിക്സ് കൃത്യമായി നീക്കം ചെയ്യുക. പ്രവർത്തനം തുടങ്ങുന്നതിന് മുമ്പ് ബഫർ ശൂന്യമാക്കരുത്, ഹാൻഡ്ഷേക്ക് കാത്തിരിക്കുമ്പോൾ അതിന്റെ സംഭരണം മാറ്റരുത്, പ്രവർത്തനം നൽകിയ എല്ലാ ബൈറ്റുകളും ഉപഭോഗം ചെയ്തു എന്ന് കരുതരുത്.

CONNECT-ന് ശേഷം ഉടൻ ക്ലയന്റ് ആരംഭിക്കുന്ന സാധാരണ TLS-ൽ ബഫർ ശൂന്യമായിരിക്കാം. ഓവർലോഡ് ആ സാഹചര്യവും കൈകാര്യം ചെയ്യുന്നു. അതിന്റെ ലക്ഷ്യം സ്ട്രീം അതിർത്തികൾ സംരക്ഷിക്കുക എന്നതാണ്; അത് ഏതെങ്കിലും അധിക പ്രോക്സി ഡാറ്റയെ സാധുവായ TLS ആക്കുന്നില്ല. ഹാൻഡ്ഷേക്കിന് മുമ്പ് SSL പാളിയിൽ ലക്ഷ്യ ഹോസ്റ്റ്നെയിം പരിശോധനയും SNI കോൺഫിഗറേഷനും നിലനിർത്തി, TLS വിജയിച്ച ശേഷം മാത്രം WebSocket അപ്ഗ്രേഡ് ആരംഭിക്കുക.