text: /*
   * nghttp2 - HTTP/2 C Library
   *
   * Copyright (c) 2014 Tatsuhiro Tsujikawa
   *
   * Permission is hereby granted, free of charge, to any person obtaining
   * a copy of this software and associated documentation files (the
   * "Software"), to deal in the Software without restriction, including
   * without limitation the rights to use, copy, modify, merge, publish,
   * distribute, sublicense, and/or sell copies of the Software, and to
   * permit persons to whom the Software is furnished to do so, subject to
   * the following conditions:
   *
   * The above copyright notice and this permission notice shall be
   * included in all copies or substantial portions of the Software.
   *
   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
   * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
   * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
   * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
   * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
   * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
   * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
   */
  #include "h2load_http2_session.h"
  
  #include <cassert>
  #include <cerrno>
  #include <iostream>
  
  #include "h2load.h"
  #include "util.h"
  #include "template.h"
  
  using namespace nghttp2;
  
  namespace h2load {
  
  Http2Session::Http2Session(Client *client)
      : client_(client), session_(nullptr) {}
  
  Http2Session::~Http2Session() { nghttp2_session_del(session_); }
  
  namespace {
  int on_header_callback(nghttp2_session *session, const nghttp2_frame *frame,
                         const uint8_t *name, size_t namelen,
                         const uint8_t *value, size_t valuelen, uint8_t flags,
                         void *user_data) {
    auto client = static_cast<Client *>(user_data);
    if (frame->hd.type != NGHTTP2_HEADERS ||
        frame->headers.cat != NGHTTP2_HCAT_RESPONSE) {
      return 0;
    }
    client->on_header(frame->hd.stream_id, name, namelen, value, valuelen);
    client->worker->stats.bytes_head_decomp += namelen + valuelen;
  
    if (client->worker->config->verbose) {
      std::cout << "[stream_id=" << frame->hd.stream_id << "] ";
      std::cout.write(reinterpret_cast<const char *>(name), namelen);
      std::cout << ": ";
      std::cout.write(reinterpret_cast<const char *>(value), valuelen);
      std::cout << "\n";
    }
  
    return 0;
  }
  } // namespace
  
  namespace {
  int on_frame_recv_callback(nghttp2_session *session, const nghttp2_frame *frame,
                             void *user_data) {
    auto client = static_cast<Client *>(user_data);
    if (frame->hd.type != NGHTTP2_HEADERS ||
        frame->headers.cat != NGHTTP2_HCAT_RESPONSE) {
      return 0;
    }
    client->worker->stats.bytes_head +=
        frame->hd.length - frame->headers.padlen -
        ((frame->hd.flags & NGHTTP2_FLAG_PRIORITY) ? 5 : 0);
    if (frame->hd.flags & NGHTTP2_FLAG_END_STREAM) {
      client->record_ttfb();
    }
    return 0;
  }
  } // namespace
  
  namespace {
  int on_data_chunk_recv_callback(nghttp2_session *session, uint8_t flags,
                                  int32_t stream_id, const uint8_t *data,
                                  size_t len, void *user_data) {
    auto client = static_cast<Client *>(user_data);
    client->record_ttfb();
    client->worker->stats.bytes_body += len;
    return 0;
  }
  } // namespace
  
  namespace {
  int on_stream_close_callback(nghttp2_session *session, int32_t stream_id,
                               uint32_t error_code, void *user_data) {
    auto client = static_cast<Client *>(user_data);
    client->on_stream_close(stream_id, error_code == NGHTTP2_NO_ERROR);
  
    return 0;
  }
  } // namespace
  
  namespace {
  int on_frame_not_send_callback(nghttp2_session *session,
                                 const nghttp2_frame *frame, int lib_error_code,
                                 void *user_data) {
    if (frame->hd.type != NGHTTP2_HEADERS ||
        frame->headers.cat != NGHTTP2_HCAT_REQUEST) {
      return 0;
    }
  
    auto client = static_cast<Client *>(user_data);
    // request was not sent.  Mark it as error.
    client->on_stream_close(frame->hd.stream_id, false);
  
    return 0;
  }
  } // namespace
  
  namespace {
  int before_frame_send_callback(nghttp2_session *session,
                                 const nghttp2_frame *frame, void *user_data) {
    if (frame->hd.type != NGHTTP2_HEADERS ||
        frame->headers.cat != NGHTTP2_HCAT_REQUEST) {
      return 0;
    }
  
    auto client = static_cast<Client *>(user_data);
    auto req_stat = client->get_req_stat(frame->hd.stream_id);
    assert(req_stat);
    client->record_request_time(req_stat);
  
    return 0;
  }
  } // namespace
  
  namespace {
  ssize_t file_read_callback(nghttp2_session *session, int32_t stream_id,
                             uint8_t *buf, size_t max_length_to_read,
                             uint32_t *data_flags, nghttp2_data_source *source,
                             void *user_data) {
    auto client = static_cast<Client *>(user_data);
    auto config = client->worker->config;
    auto req_stat = client->get_req_stat(stream_id);
    assert(req_stat);
  
    int64_t request_content_length = config->data_length;
    int64_t base_offset = 0;
  
    // adjust a little bit the input to make the second case works
    if (config->use_many_request_file) {
      auto &request_data_info = config->request_data[source->fd];
  
      request_content_length = request_data_info.data_length;
      base_offset = request_data_info.data_offset_in_file;
  
      auto original_length = max_length_to_read;
      if (req_stat->data_offset + max_length_to_read > request_content_length) {
        max_length_to_read = request_content_length - req_stat->data_offset;
      }
  
      // std::cerr << "Filling request. idx data: " << source->fd
      //           << " data_length: " << request_content_length
      //           << " base offset: " << request_data_info.data_offset_in_file
      //           << " original_length: " << original_length
      //           << " max_length_to_read: " << max_length_to_read
      //           << " already read: " << req_stat->data_offset << std::endl;
  
      // std::cerr << std::endl;
    }
  
    // std::cerr << "Arguments."
    //           << " fd: " << config->data_fd << " buff: " << (uint64_t)buf
    //           << " length: " << max_length_to_read
    //           << " offset in file: " << (base_offset + req_stat->data_offset)
    //           << std::endl;
  
    ssize_t nread;
    while ((nread = pread(config->data_fd, buf, max_length_to_read,
                          base_offset + req_stat->data_offset)) == -1 &&
           errno == EINTR)
      ;
  
    if (nread == -1) {
      // std::cerr << "weird : " << errno << std::endl;
      return NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE;
    }
  
    req_stat->data_offset += nread;
  
    // std::cerr << "Done: " << req_stat->data_offset
    //           << " out of: " << request_content_length << std::endl;
  
    if (req_stat->data_offset == request_content_length) {
      *data_flags |= NGHTTP2_DATA_FLAG_EOF;
      return nread;
    }
  
    if (req_stat->data_offset > request_content_length || nread == 0) {
      return NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE;
    }
  
    return nread;
  }
  
  } // namespace
  
  namespace {
  ssize_t send_callback(nghttp2_session *session, const uint8_t *data,
                        size_t length, int flags, void *user_data) {
    auto client = static_cast<Client *>(user_data);
    auto &wb = client->wb;
  
    if (wb.rleft() >= BACKOFF_WRITE_BUFFER_THRES) {
      return NGHTTP2_ERR_WOULDBLOCK;
    }
  
    return wb.append(data, length);
  }
  } // namespace
  
  void Http2Session::on_connect() {
    int rv;
  
    // This is required with --disable-assert.
    (void)rv;
  
    nghttp2_session_callbacks *callbacks;
  
    nghttp2_session_callbacks_new(&callbacks);
  
    auto callbacks_deleter = defer(nghttp2_session_callbacks_del, callbacks);
  
    nghttp2_session_callbacks_set_on_frame_recv_callback(callbacks,
                                                         on_frame_recv_callback);
  
    nghttp2_session_callbacks_set_on_data_chunk_recv_callback(
        callbacks, on_data_chunk_recv_callback);
  
    nghttp2_session_callbacks_set_on_stream_close_callback(
        callbacks, on_stream_close_callback);
  
    nghttp2_session_callbacks_set_on_header_callback(callbacks,
                                                     on_header_callback);
  
    nghttp2_session_callbacks_set_on_frame_not_send_callback(
        callbacks, on_frame_not_send_callback);
  
    nghttp2_session_callbacks_set_before_frame_send_callback(
        callbacks, before_frame_send_callback);
  
    nghttp2_session_callbacks_set_send_callback(callbacks, send_callback);
  
    nghttp2_option *opt;
  
    rv = nghttp2_option_new(&opt);
    assert(rv == 0);
  
    auto config = client_->worker->config;
  
    if (config->encoder_header_table_size != NGHTTP2_DEFAULT_HEADER_TABLE_SIZE) {
      nghttp2_option_set_max_deflate_dynamic_table_size(
          opt, config->encoder_header_table_size);
    }
  
    nghttp2_session_client_new2(&session_, callbacks, client_, opt);
  
    nghttp2_option_del(opt);
  
    std::array<nghttp2_settings_entry, 3> iv;
    size_t niv = 2;
    iv[0].settings_id = NGHTTP2_SETTINGS_ENABLE_PUSH;
    iv[0].value = 0;
    iv[1].settings_id = NGHTTP2_SETTINGS_INITIAL_WINDOW_SIZE;
    iv[1].value = (1 << config->window_bits) - 1;
  
    if (config->header_table_size != NGHTTP2_DEFAULT_HEADER_TABLE_SIZE) {
      iv[niv].settings_id = NGHTTP2_SETTINGS_HEADER_TABLE_SIZE;
      iv[niv].value = config->header_table_size;
      ++niv;
    }
  
    rv = nghttp2_submit_settings(session_, NGHTTP2_FLAG_NONE, iv.data(), niv);
  
    assert(rv == 0);
  
    auto connection_window = (1 << config->connection_window_bits) - 1;
    nghttp2_session_set_local_window_size(session_, NGHTTP2_FLAG_NONE, 0,
                                          connection_window);
  
    client_->signal_write();
  }
  
  int Http2Session::submit_request() {
    if (nghttp2_session_check_request_allowed(session_) == 0) {
      return -1;
    }
  
    auto config = client_->worker->config;
    auto &nva = config->nva[client_->reqidx++];
  
    auto nva_size = nva.size();
    auto nva_data = nva.data();
  
    if (client_->reqidx == config->nva.size()) {
      client_->reqidx = 0;
    }
  
    nghttp2_data_provider prd{{0}, file_read_callback};
  
    if (config->use_many_request_file) {
      prd.source.fd =
          client_->current_request_data++; // index in vector request_data
      auto &rd = config->request_data[prd.source.fd];
  
      nva_data = rd.nva.data();
      nva_size = rd.nva.size();
  
      if (client_->current_request_data >= config->request_data.size()) {
        client_->current_request_data = 0;
      }
  
      // std::cerr << "Submitting request. idx data: " << prd.source.fd
      //           << " data_length: " << rd.data_length
      //           << " offset: " << rd.data_offset_in_file << std::endl;
      // for (auto &nv : rd.nva) {
      //   std::cerr << "Header. " << (char *)nv.name << ": " << (char *)nv.value
      //             << std::endl;
      // }
      // std::cerr << std::endl;
    }
  
    auto stream_id =
        nghttp2_submit_request(session_, nullptr, nva_data, nva_size,
                               config->data_fd == -1 ? nullptr : &prd, nullptr);
  
    if (stream_id < 0) {
      return -1;
    }
  
    client_->on_request(stream_id);
  
    return 0;
  }
  
  int Http2Session::on_read(const uint8_t *data, size_t len) {
    auto rv = nghttp2_session_mem_recv(session_, data, len);
    if (rv < 0) {
      return -1;
    }
  
    assert(static_cast<size_t>(rv) == len);
  
    if (nghttp2_session_want_read(session_) == 0 &&
        nghttp2_session_want_write(session_) == 0 && client_->wb.rleft() == 0) {
      return -1;
    }
  
    client_->signal_write();
  
    return 0;
  }
  
  int Http2Session::on_write() {
    auto rv = nghttp2_session_send(session_);
    if (rv != 0) {
      return -1;
    }
  
    if (nghttp2_session_want_read(session_) == 0 &&
        nghttp2_session_want_write(session_) == 0 && client_->wb.rleft() == 0) {
      return -1;
    }
  
    return 0;
  }
  
  void Http2Session::terminate() {
    nghttp2_session_terminate_session(session_, NGHTTP2_NO_ERROR);
  }
  
  size_t Http2Session::max_concurrent_streams() {
    return (size_t)client_->worker->config->max_concurrent_streams;
  }
  
  } // namespace h2load
  