HTTPParser.h

Go to the documentation of this file.

// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
 
#ifndef O2_FRAMEWORK_HTTPPARSER_H_
#define O2_FRAMEWORK_HTTPPARSER_H_
 
#include <bit>
#include <cstdint>
#include <fmt/format.h>
#include <uv.h>
#include <string>
#include <vector>
#include <map>
 
namespace o2::framework
{
 
template <std::endian E>
struct __attribute__((__packed__)) WebSocketFrameTiny;
 
template <>
struct __attribute__((__packed__)) WebSocketFrameTiny<std::endian::little> {
  unsigned char opcode : 4;
  unsigned char rsv3 : 1;
  unsigned char rsv2 : 1;
  unsigned char rsv1 : 1;
  unsigned char fin : 1;
  unsigned char len : 7;
  unsigned char mask : 1;
};
 
template <>
struct __attribute__((__packed__)) WebSocketFrameTiny<std::endian::big> {
  unsigned char fin : 1;
  unsigned char rsv1 : 1;
  unsigned char rsv2 : 1;
  unsigned char rsv3 : 1;
  unsigned char opcode : 4;
  unsigned char mask : 1;
  unsigned char len : 7;
};
 
template <std::endian E>
struct __attribute__((__packed__)) WebSocketFrameShort;
 
template <>
struct __attribute__((__packed__)) WebSocketFrameShort<std::endian::little> {
  unsigned char opcode : 4;
  unsigned char rsv3 : 1;
  unsigned char rsv2 : 1;
  unsigned char rsv1 : 1;
  unsigned char fin : 1;
  unsigned char len : 7;
  unsigned char mask : 1;
  uint16_t len16;
};
 
template <>
struct __attribute__((__packed__)) WebSocketFrameShort<std::endian::big> {
  unsigned char fin : 1;
  unsigned char rsv1 : 1;
  unsigned char rsv2 : 1;
  unsigned char rsv3 : 1;
  unsigned char opcode : 4;
  unsigned char mask : 1;
  unsigned char len : 7;
  uint16_t len16;
};
 
template <std::endian E>
struct __attribute__((__packed__)) WebSocketFrameHuge;
 
template <>
struct __attribute__((__packed__)) WebSocketFrameHuge<std::endian::little> {
  unsigned char opcode : 4;
  unsigned char rsv3 : 1;
  unsigned char rsv2 : 1;
  unsigned char rsv1 : 1;
  unsigned char fin : 1;
  unsigned char len : 7;
  unsigned char mask : 1;
  uint64_t len64;
};
 
template <>
struct __attribute__((__packed__)) WebSocketFrameHuge<std::endian::big> {
  unsigned char fin : 1;
  unsigned char rsv1 : 1;
  unsigned char rsv2 : 1;
  unsigned char rsv3 : 1;
  unsigned char opcode : 4;
  unsigned char mask : 1;
  unsigned char len : 7;
  uint64_t len64;
};
 
enum struct WebSocketFrameKind {
  Tiny,
  Short,
  Huge
};
 
enum struct WebSocketOpCode : uint8_t {
  Continuation = 0,
  Text = 1,
  Binary = 2,
  Close = 8,
  Ping = 9,
  Pong = 10
};
 
struct WebSocketConstants {
  constexpr static size_t MaxChunkSize = 0x10000;
};
 
std::string encode_websocket_handshake_request(const char* path, const char* protocol, int version, char const* nonce,
                                               std::vector<std::pair<std::string, std::string>> headers = {});
 
std::string encode_websocket_handshake_reply(char const* nonce, char const* protocol = "");
 
void encode_websocket_frames(std::vector<uv_buf_t>& outputs, char const* src, size_t size, WebSocketOpCode opcode, uint32_t mask);
 
struct WebSocketHandler {
  virtual ~WebSocketHandler() = default;
 
  virtual void headers(std::map<std::string, std::string> const& headers) {};
  virtual void beginFragmentation() {};
  virtual void frame(char const* frame, size_t s) {}
  virtual void beginChunk() {}
  virtual void endChunk() {}
  virtual void endFragmentation() {}
  virtual void control(char const* frame, size_t s) {}
 
  size_t remainingSize = 0;
  size_t pendingSize = 0;
  char* pendingBuffer = nullptr;
  size_t pendingHeaderSize = 0;
  char* pendingHeader = nullptr;
};
 
void decode_websocket(char* src, size_t size, WebSocketHandler& handler);
 
enum struct HTTPState {
  IN_START,
  IN_START_REPLY,
  BEGIN_REPLY_VERSION,
  END_REPLY_VERSION,
  BEGIN_REPLY_CODE,
  END_REPLY_CODE,
  BEGIN_REPLY_MESSAGE,
  END_REPLY_MESSAGE,
  BEGIN_METHOD,
  END_METHOD,
  BEGIN_TARGET,
  END_TARGET,
  BEGIN_VERSION,
  END_VERSION,
  BEGIN_HEADERS,
  BEGIN_HEADER,
  BEGIN_HEADER_KEY,
  END_HEADER_KEY,
  BEGIN_HEADER_VALUE,
  END_HEADER_VALUE,
  END_HEADER,
  END_HEADERS,
  BEGIN_BODY,
  IN_DONE,
  IN_ERROR,
  IN_SKIP_CHARS,         
  IN_CAPTURE_DELIMITERS, 
  IN_CAPTURE_SEPARATOR,  
  IN_SEPARATOR,          
  IN_CHUNKED
};
 
struct HTTPParser {
  std::string remaining;
  std::string error;
  std::vector<HTTPState> states;
  virtual void method(std::string_view const& s) {};
  virtual void target(std::string_view const& s) {};
  virtual void version(std::string_view const& s) {};
  virtual void header(std::string_view const& k, std::string_view const& v) {};
  virtual void endHeaders() {};
  virtual void body(char* data, size_t s) {};
  virtual void replyVersion(std::string_view const& s) {};
  virtual void replyCode(std::string_view const& s) {};
  virtual void replyMessage(std::string_view const& s) {};
};
 
struct HTTPParserHelpers {
  static std::string calculateAccept(const char* nonce);
};
 
void parse_http_request(char* start, size_t size, HTTPParser* parser);
 
std::pair<std::string, unsigned short> parse_websocket_url(const char* s);
} // namespace o2::framework
#endif