uvco::examples::anonymous_namespace{http_server.cc} Namespace Reference

Functions
Promise< std::optional< std::string > >	readHeaders (TcpStream &stream)
std::optional< std::tuple< std::string_view, std::string_view, std::string_view > >	parseRequestLine (std::string_view requestLine)
void	parseHeaders (std::string_view headersBlock, HttpRequest &request)
std::optional< HttpRequest >	parseRequest (std::string_view headersSection)
Promise< void >	handleBadRequest (TcpStream &stream)

Variables
const size_t	MAX_HEADER_SIZE = 8192

Function Documentation

handleBadRequest()

Promise< void > uvco::examples::anonymous_namespace{http_server.cc}::handleBadRequest

(

TcpStream &

stream

)

                                                  {
  HttpResponse response;
  response.statusCode = 400;
  response.statusMessage = "Bad Request";
  response.body = "Bad Request";
  co_await stream.write(response.toString());
  stream.close();
}

parseHeaders()

void uvco::examples::anonymous_namespace{http_server.cc}::parseHeaders	(	std::string_view	headersBlock,
		HttpRequest &	request )

                                                                     {
  size_t start = 0;
  while (start < headersBlock.size()) {
    const size_t end = headersBlock.find("\r\n", start);
    if (end == std::string_view::npos) {
      break;
    }
    const std::string_view headerLine = headersBlock.substr(start, end - start);
    if (headerLine.empty()) {
      start = end + 2;
      continue;
    }
    const size_t colonPos = headerLine.find(": ");
    if (colonPos != std::string_view::npos) {
      request.headers.emplace_back(headerLine.substr(0, colonPos),
                                   headerLine.substr(colonPos + 2));
    }
    start = end + 2;
  }
}

parseRequest()

std::optional< HttpRequest > uvco::examples::anonymous_namespace{http_server.cc}::parseRequest

(

std::string_view

headersSection

)

                                                                     {
  const size_t requestLineEnd = headersSection.find("\r\n");
  if (requestLineEnd == std::string_view::npos) {
    return std::nullopt;
  }
 
  const std::optional<
      std::tuple<std::string_view, std::string_view, std::string_view>>
      requestLineParts =
          parseRequestLine(headersSection.substr(0, requestLineEnd));
  if (!requestLineParts) {
    return std::nullopt;
  }
 
  HttpRequest request;
  std::tie(request.method, request.path, request.version) = *requestLineParts;
 
  const std::string_view headersBlock =
      headersSection.substr(requestLineEnd + 2);
  parseHeaders(headersBlock, request);
 
  return request;
}

parseRequestLine()

std::optional< std::tuple< std::string_view, std::string_view, std::string_view > > uvco::examples::anonymous_namespace{http_server.cc}::parseRequestLine

(

std::string_view

requestLine

)

                                             {
  const size_t methodEnd = requestLine.find(' ');
  if (methodEnd == std::string_view::npos) {
    return std::nullopt;
  }
  const std::string_view method = requestLine.substr(0, methodEnd);
  requestLine.remove_prefix(methodEnd + 1);
 
  const size_t pathEnd = requestLine.find(' ');
  if (pathEnd == std::string_view::npos) {
    return std::nullopt;
  }
  const std::string_view path = requestLine.substr(0, pathEnd);
  const std::string_view version = requestLine.substr(pathEnd + 1);
 
  if (method.empty() || path.empty() || version.empty()) {
    return std::nullopt;
  }
 
  return std::make_tuple(method, path, version);
}

readHeaders()

Promise< std::optional< std::string > > uvco::examples::anonymous_namespace{http_server.cc}::readHeaders

(

TcpStream &

stream

)

                                                               {
  std::string requestBuffer;
  char buffer[4096];
  size_t headersEndPos = std::string::npos;
 
  while (headersEndPos == std::string::npos) {
    if (requestBuffer.length() > MAX_HEADER_SIZE) {
      co_return std::nullopt;
    }
    auto bytesRead = co_await stream.read(std::span(buffer));
    if (bytesRead == 0) {
      co_return std::nullopt;
    }
    requestBuffer.append(buffer, bytesRead);
    headersEndPos = requestBuffer.find("\r\n\r\n");
  }
 
  co_return requestBuffer.substr(0, headersEndPos + 4);
}

Variable Documentation

MAX_HEADER_SIZE

const size_t uvco::examples::anonymous_namespace{http_server.cc}::MAX_HEADER_SIZE = 8192