http1.h

Go to the documentation of this file.

/*
 * Copyright 2026 The A11 Authors
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef SYMBIAN_HTTP_HTTP1_H_
#define SYMBIAN_HTTP_HTTP1_H_
 
#include <cstddef>
#include <cstdint>
#include <optional>
#include <string>
#include <string_view>
 
#include <absl/status/status.h>
#include <absl/status/statusor.h>
 
#include "symbian/http/types.h"
 
namespace symbian::http::internal {
 
struct Http1RequestHead {
  std::string method;   
  std::string target;   
  std::string version;  
  Headers headers;      
};
 
struct Http1ResponseHead {
  int status = 0;       
  std::string reason;   
  std::string version;  
  Headers headers;      
};
 
enum class BodyFraming {
  kNone,           
  kContentLength,  
  kChunked,        
  kUntilClose,     
};
 
struct BodyPlan {
  BodyFraming framing = BodyFraming::kNone;
  std::size_t content_length = 0;
};
 
std::optional<std::size_t> FindHeaderBlockEnd(std::string_view data);
 
absl::StatusOr<Http1RequestHead> ParseRequestHead(std::string_view head_block);
absl::StatusOr<Http1ResponseHead> ParseResponseHead(
    std::string_view head_block);
 
absl::StatusOr<BodyPlan> PlanRequestBody(const Headers& headers);
absl::StatusOr<BodyPlan> PlanResponseBody(std::string_view request_method,
                                          int status, const Headers& headers);
 
class ChunkedDecoder {
 public:
  absl::Status Feed(std::string_view data, std::string* out, bool* complete);
 
  [[nodiscard]] bool complete() const { return state_ == State::kComplete; }
 
  [[nodiscard]] const Headers& trailers() const { return trailers_; }
 
 private:
  enum class State { kSize, kData, kDataCrlf, kTrailer, kComplete };
 
  State state_ = State::kSize;
  std::string pending_;          // Partial line (size line or trailer line).
  std::uint64_t remaining_ = 0;  // Bytes left in the current chunk's data.
  std::size_t metadata_bytes_ = 0;
  Headers trailers_;  // Trailer section, once the body completes.
};
 
std::string EncodeChunk(std::string_view data);
std::string EncodeLastChunk(const Headers& trailers = {});
 
void AppendHeaderBlock(const Headers& headers, std::string* out);
std::string SerializeRequest(std::string_view method, std::string_view target,
                             const Headers& headers);
std::string SerializeResponse(int status, const Headers& headers,
                              std::string_view reason = {});
 
std::string_view DefaultReasonPhrase(int status);
 
}  // namespace symbian::http::internal
 
#endif  // SYMBIAN_HTTP_HTTP1_H_