fuzzed_stream.h 2.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384
  1. #pragma once
  2. #include <cstdint>
  3. #include <httplib.h>
  4. class FuzzedStream : public httplib::Stream {
  5. public:
  6. FuzzedStream(const uint8_t *data, size_t size)
  7. : data_(data), size_(size), read_pos_(0) {}
  8. ssize_t read(char *ptr, size_t size) override {
  9. if (size + read_pos_ > size_) { size = size_ - read_pos_; }
  10. memcpy(ptr, data_ + read_pos_, size);
  11. read_pos_ += size;
  12. // Like SocketStream, pull in more than was asked for, which the line
  13. // reader then takes through buffered_data(), so both of its paths run.
  14. buffered_end_ =
  15. (std::max)(buffered_end_, (std::min)(size_, read_pos_ + 4096));
  16. return static_cast<ssize_t>(size);
  17. }
  18. const char *buffered_data(size_t &size) const override {
  19. size = buffered_end_ > read_pos_ ? buffered_end_ - read_pos_ : 0;
  20. return size ? reinterpret_cast<const char *>(data_ + read_pos_) : nullptr;
  21. }
  22. void consume_buffered(size_t size) override { read_pos_ += size; }
  23. ssize_t write(const char *ptr, size_t size) override {
  24. response_.append(ptr, size);
  25. return static_cast<int>(size);
  26. }
  27. ssize_t write(const char *ptr) { return write(ptr, strlen(ptr)); }
  28. ssize_t write(const std::string &s) { return write(s.data(), s.size()); }
  29. bool is_readable() const override { return true; }
  30. bool wait_readable() const override { return true; }
  31. bool wait_writable() const override { return true; }
  32. void get_remote_ip_and_port(std::string &ip, int &port) const override {
  33. ip = "127.0.0.1";
  34. port = 8080;
  35. }
  36. void get_local_ip_and_port(std::string &ip, int &port) const override {
  37. ip = "127.0.0.1";
  38. port = 8080;
  39. }
  40. socket_t socket() const override { return 0; }
  41. time_t duration() const override { return 0; };
  42. const std::string &response() const { return response_; }
  43. private:
  44. const uint8_t *data_;
  45. size_t size_;
  46. size_t read_pos_;
  47. size_t buffered_end_ = 0;
  48. std::string response_;
  49. };
  50. class FuzzableServer : public httplib::Server {
  51. public:
  52. // A server that is not listening counts as shutting down, and then writes
  53. // no file. The socket is never used.
  54. void MarkAsRunning() { svr_sock_ = 0; }
  55. void ProcessFuzzedRequest(FuzzedStream &stream) {
  56. bool connection_close = false;
  57. process_request(stream,
  58. /*remote_addr=*/"",
  59. /*remote_port =*/0,
  60. /*local_addr=*/"",
  61. /*local_port =*/0,
  62. /*last_connection=*/false, connection_close, nullptr);
  63. }
  64. };