Botan::HTTP Namespace Reference

Classes
class	HTTP_Error
class	Response

Typedefs
typedef std::function< std::string(std::string_view, std::string_view, std::string_view)>	http_exch_fn

Functions
Response	GET_sync (std::string_view url, size_t allowable_redirects, std::chrono::milliseconds timeout)
Response	http_sync (const http_exch_fn &http_transact, std::string_view verb, std::string_view url, std::string_view content_type, const std::vector< uint8_t > &body, size_t allowable_redirects)
Response	http_sync (std::string_view verb, std::string_view url, std::string_view content_type, const std::vector< uint8_t > &body, size_t allowable_redirects, std::chrono::milliseconds timeout)
std::ostream &	operator<< (std::ostream &o, const Response &resp)
Response	POST_sync (std::string_view url, std::string_view content_type, const std::vector< uint8_t > &body, size_t allowable_redirects, std::chrono::milliseconds timeout)
std::string	url_encode (std::string_view in)

Typedef Documentation

http_exch_fn

typedef std::function<std::string(std::string_view, std::string_view, std::string_view)> Botan::HTTP::http_exch_fn

Definition at line 64 of file http_util.h.

Function Documentation

GET_sync()

Response BOTAN_TEST_API Botan::HTTP::GET_sync	(	std::string_view	url,
		size_t	allowable_redirects,
		std::chrono::milliseconds	timeout )

Definition at line 244 of file http_util.cpp.

                                                                                                 {
   return http_sync("GET", url, "", std::vector<uint8_t>(), allowable_redirects, timeout);
}

References http_sync().

Referenced by http_sync().

http_sync() [1/2]

Response Botan::HTTP::http_sync	(	const http_exch_fn &	http_transact,
		std::string_view	verb,
		std::string_view	url,
		std::string_view	content_type,
		const std::vector< uint8_t > &	body,
		size_t	allowable_redirects )

Definition at line 112 of file http_util.cpp.

                                               {
   if(url.empty()) {
      throw HTTP_Error("URL empty");
   }
 
   const auto protocol_host_sep = url.find("://");
   if(protocol_host_sep == std::string::npos) {
      throw HTTP_Error(fmt("Invalid URL '{}'", url));
   }
 
   const auto host_loc_sep = url.find('/', protocol_host_sep + 3);
 
   std::string hostname;
   std::string loc;
   std::string service;
 
   if(host_loc_sep == std::string::npos) {
      hostname = url.substr(protocol_host_sep + 3);
      loc = "/";
   } else {
      hostname = url.substr(protocol_host_sep + 3, host_loc_sep - protocol_host_sep - 3);
      loc = url.substr(host_loc_sep);
   }
 
   const auto port_sep = hostname.find(':');
   if(port_sep == std::string::npos) {
      service = "http";
      // hostname not modified
   } else {
      service = hostname.substr(port_sep + 1, std::string::npos);
      hostname = hostname.substr(0, port_sep);
   }
 
   std::ostringstream outbuf;
 
   outbuf << verb << " " << loc << " HTTP/1.0\r\n";
   outbuf << "Host: " << hostname << "\r\n";
 
   if(verb == "GET") {
      outbuf << "Accept: */*\r\n";
      outbuf << "Cache-Control: no-cache\r\n";
   } else if(verb == "POST") {
      outbuf << "Content-Length: " << body.size() << "\r\n";
   }
 
   if(!content_type.empty()) {
      outbuf << "Content-Type: " << content_type << "\r\n";
   }
   outbuf << "Connection: close\r\n\r\n";
   outbuf.write(cast_uint8_ptr_to_char(body.data()), body.size());
 
   std::istringstream io(http_transact(hostname, service, outbuf.str()));
 
   std::string line1;
   std::getline(io, line1);
   if(!io || line1.empty()) {
      throw HTTP_Error("No response");
   }
 
   std::stringstream response_stream(line1);
   std::string http_version;
   unsigned int status_code = 0;
   std::string status_message;
 
   response_stream >> http_version >> status_code;
 
   std::getline(response_stream, status_message);
 
   if(!response_stream || !http_version.starts_with("HTTP/")) {
      throw HTTP_Error("Not an HTTP response");
   }
 
   std::map<std::string, std::string> headers;
   std::string header_line;
   while(std::getline(io, header_line) && header_line != "\r") {
      auto sep = header_line.find(": ");
      if(sep == std::string::npos || sep > header_line.size() - 2) {
         throw HTTP_Error(fmt("Invalid HTTP header '{}'", header_line));
      }
      const std::string key = header_line.substr(0, sep);
 
      if(sep + 2 < header_line.size() - 1) {
         const std::string val = header_line.substr(sep + 2, (header_line.size() - 1) - (sep + 2));
         headers[key] = val;
      }
   }
 
   if(status_code == 301 && headers.contains("Location")) {
      if(allowable_redirects == 0) {
         throw HTTP_Error("HTTP redirection count exceeded");
      }
      return GET_sync(headers["Location"], allowable_redirects - 1);
   }
 
   std::vector<uint8_t> resp_body;
   std::vector<uint8_t> buf(4096);
   while(io.good()) {
      io.read(cast_uint8_ptr_to_char(buf.data()), buf.size());
      const size_t got = static_cast<size_t>(io.gcount());
      resp_body.insert(resp_body.end(), buf.data(), &buf[got]);
   }
 
   auto cl_hdr = headers.find("Content-Length");
   if(cl_hdr != headers.end()) {
      const std::string header_size = cl_hdr->second;
      if(resp_body.size() != to_u32bit(header_size)) {
         throw HTTP_Error(fmt("Content-Length disagreement, header says {} got {}", header_size, resp_body.size()));
      }
   }
 
   return Response(status_code, status_message, resp_body, headers);
}

References Botan::cast_uint8_ptr_to_char(), Botan::fmt(), GET_sync(), and Botan::to_u32bit().

Referenced by GET_sync(), http_sync(), and POST_sync().

http_sync() [2/2]

Response Botan::HTTP::http_sync	(	std::string_view	verb,
		std::string_view	url,
		std::string_view	content_type,
		const std::vector< uint8_t > &	body,
		size_t	allowable_redirects,
		std::chrono::milliseconds	timeout )

Definition at line 230 of file http_util.cpp.

                                                  {
   auto transact_with_timeout = [timeout](
                                   std::string_view hostname, std::string_view service, std::string_view message) {
      return http_transact(hostname, service, message, timeout);
   };
 
   return http_sync(transact_with_timeout, verb, url, content_type, body, allowable_redirects);
}

References http_sync().

operator<<()

BOTAN_TEST_API std::ostream & Botan::HTTP::operator<<	(	std::ostream &	o,
		const Response &	resp )

Definition at line 102 of file http_util.cpp.

                                                            {
   o << "HTTP " << resp.status_code() << " " << resp.status_message() << "\n";
   for(const auto& h : resp.headers()) {
      o << "Header '" << h.first << "' = '" << h.second << "'\n";
   }
   o << "Body " << std::to_string(resp.body().size()) << " bytes:\n";
   o.write(cast_uint8_ptr_to_char(resp.body().data()), resp.body().size());
   return o;
}

References Botan::HTTP::Response::body(), Botan::cast_uint8_ptr_to_char(), Botan::HTTP::Response::headers(), Botan::HTTP::Response::status_code(), and Botan::HTTP::Response::status_message().

POST_sync()

Response Botan::HTTP::POST_sync	(	std::string_view	url,
		std::string_view	content_type,
		const std::vector< uint8_t > &	body,
		size_t	allowable_redirects,
		std::chrono::milliseconds	timeout )

Definition at line 248 of file http_util.cpp.

                                                  {
   return http_sync("POST", url, content_type, body, allowable_redirects, timeout);
}

References http_sync().

url_encode()

std::string Botan::HTTP::url_encode

(

std::string_view

in

)

Definition at line 87 of file http_util.cpp.

                                        {
   std::ostringstream out;
 
   for(auto c : in) {
      if(needs_url_encoding(c)) {
         out << '%' << std::uppercase << std::hex << std::setfill('0') << std::setw(2) << static_cast<int>(c);
         out << std::dec << std::nouppercase;  // reset flags
      } else {
         out << c;
      }
   }
 
   return out.str();
}