Botan::TLS::Extensions Class Reference

#include <tls_extensions.h>

Public Member Functions
void	add (Extension *extn)
void	deserialize (TLS_Data_Reader &reader)
std::set< Handshake_Extension_Type >	extension_types () const
	Extensions ()=default
	Extensions (TLS_Data_Reader &reader)
template<typename T >
T *	get () const
template<typename T >
bool	has () const
std::vector< uint8_t >	serialize () const

Detailed Description

Represents a block of extensions in a hello message

Definition at line 430 of file tls_extensions.h.

Constructor & Destructor Documentation

Botan::TLS::Extensions::Extensions ( )

default

Botan::TLS::Extensions::Extensions ( TLS_Data_Reader &  reader )

inlineexplicit

Definition at line 464 of file tls_extensions.h.

{ deserialize(reader); }

Member Function Documentation

void Botan::TLS::Extensions::add ( Extension *  extn )

inline

Definition at line 453 of file tls_extensions.h.

References Botan::TLS::Extension::type().

Referenced by Botan::TLS::Client_Hello::Client_Hello(), deserialize(), and Botan::TLS::Server_Hello::Server_Hello().

         {
         m_extensions[extn->type()].reset(extn);
         }

void Botan::TLS::Extensions::deserialize

(

TLS_Data_Reader &

reader

)

Definition at line 67 of file tls_extensions.cpp.

References add(), Botan::TLS::TLS_Data_Reader::discard_next(), Botan::TLS::TLS_Data_Reader::get_uint16_t(), Botan::TLS::TLS_Data_Reader::has_remaining(), and Botan::TLS::TLS_Data_Reader::remaining_bytes().

Referenced by Botan::TLS::Client_Hello::Client_Hello(), and Botan::TLS::Server_Hello::Server_Hello().

   {
   if(reader.has_remaining())
      {
      const uint16_t all_extn_size = reader.get_uint16_t();

      if(reader.remaining_bytes() != all_extn_size)
         throw Decoding_Error("Bad extension size");

      while(reader.has_remaining())
         {
         const uint16_t extension_code = reader.get_uint16_t();
         const uint16_t extension_size = reader.get_uint16_t();

         Extension* extn = make_extension(reader,
                                          extension_code,
                                          extension_size);

         if(extn)
            this->add(extn);
         else // unknown/unhandled extension
            reader.discard_next(extension_size);
         }
      }
   }

std::set< Handshake_Extension_Type > Botan::TLS::Extensions::extension_types

(

)

const

Definition at line 127 of file tls_extensions.cpp.

   {
   std::set<Handshake_Extension_Type> offers;
   for(auto i = m_extensions.begin(); i != m_extensions.end(); ++i)
      offers.insert(i->first);
   return offers;
   }

template<typename T >

T* Botan::TLS::Extensions::get ( ) const

inline

Definition at line 436 of file tls_extensions.h.

References type.

Referenced by Botan::TLS::Client_Hello::Client_Hello().

         {
         Handshake_Extension_Type type = T::static_type();

         auto i = m_extensions.find(type);

         if(i != m_extensions.end())
            return dynamic_cast<T*>(i->second.get());
         return nullptr;
         }

template<typename T >

bool Botan::TLS::Extensions::has ( ) const

inline

Definition at line 448 of file tls_extensions.h.

Referenced by Botan::TLS::Client_Hello::Client_Hello().

         {
         return get<T>() != nullptr;
         }

std::vector< uint8_t > Botan::TLS::Extensions::serialize

(

)

const

Definition at line 93 of file tls_extensions.cpp.

References Botan::get_byte().

   {
   std::vector<uint8_t> buf(2); // 2 bytes for length field

   for(auto& extn : m_extensions)
      {
      if(extn.second->empty())
         continue;

      const uint16_t extn_code = extn.second->type();

      std::vector<uint8_t> extn_val = extn.second->serialize();

      buf.push_back(get_byte(0, extn_code));
      buf.push_back(get_byte(1, extn_code));

      buf.push_back(get_byte(0, static_cast<uint16_t>(extn_val.size())));
      buf.push_back(get_byte(1, static_cast<uint16_t>(extn_val.size())));

      buf += extn_val;
      }

   const uint16_t extn_size = static_cast<uint16_t>(buf.size() - 2);

   buf[0] = get_byte(0, extn_size);
   buf[1] = get_byte(1, extn_size);

   // avoid sending a completely empty extensions block
   if(buf.size() == 2)
      return std::vector<uint8_t>();

   return buf;
   }

---

The documentation for this class was generated from the following files:

• src/lib/tls/tls_extensions.h
• src/lib/tls/tls_extensions.cpp