request.hh

/*
 * This file is open source software, licensed to you under the terms
 * of the Apache License, Version 2.0 (the "License").  See the NOTICE file
 * distributed with this work for additional information regarding copyright
 * ownership.  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.
 */
/*
 * Copyright 2015 Cloudius Systems
 */
 
//
// request.hpp
// ~~~~~~~~~~~
//
// Copyright (c) 2003-2013 Christopher M. Kohlhoff (chris at kohlhoff dot com)
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
#pragma once
 
#include <seastar/core/iostream.hh>
#include <seastar/core/sstring.hh>
#include <string>
#include <vector>
#include <strings.h>
#include <seastar/http/common.hh>
#include <seastar/http/mime_types.hh>
#include <seastar/net/socket_defs.hh>
#include <seastar/core/iostream.hh>
#include <seastar/util/string_utils.hh>
 
namespace seastar {
 
namespace http {
 
namespace experimental { class connection; }
 
struct request {
    enum class ctclass
        : char {
            other, multipart, app_x_www_urlencoded,
    };
 
    socket_address _client_address;
    socket_address _server_address;
    sstring _method;
    sstring _url;
    sstring _version;
    ctclass content_type_class;
    size_t content_length = 0;
    mutable size_t _bytes_written = 0;
    std::unordered_map<sstring, sstring, seastar::internal::case_insensitive_hash, seastar::internal::case_insensitive_cmp> _headers;
    std::unordered_map<sstring, sstring> query_parameters;
    httpd::parameters param;
    sstring content; // server-side deprecated: use content_stream instead
    /*
     * The handler should read the contents of this stream till reaching eof (i.e., the end of this request's content). Failing to do so
     * will force the server to close this connection, and the client will not be able to reuse this connection for the next request.
     * The stream should not be closed by the handler, the server will close it for the handler.
     * */
    input_stream<char>* content_stream;
    std::unordered_map<sstring, sstring> trailing_headers;
    std::unordered_map<sstring, sstring> chunk_extensions;
    sstring protocol_name = "http";
    noncopyable_function<future<>(output_stream<char>&&)> body_writer; // for client
 
    const socket_address & get_client_address() const {
        return _client_address;
    }
 
    const socket_address & get_server_address() const {
        return _server_address;
    }
 
    sstring get_header(const sstring& name) const {
        auto res = _headers.find(name);
        if (res == _headers.end()) {
            return "";
        }
        return res->second;
    }
 
    sstring get_query_param(const sstring& name) const {
        auto res = query_parameters.find(name);
        if (res == query_parameters.end()) {
            return "";
        }
        return res->second;
    }
 
    sstring get_protocol_name() const {
        return protocol_name;
    }
 
    sstring get_url() const {
        return get_protocol_name() + "://" + get_header("Host") + _url;
    }
 
    bool is_multi_part() const {
        return content_type_class == ctclass::multipart;
    }
 
    bool is_form_post() const {
        return content_type_class == ctclass::app_x_www_urlencoded;
    }
 
    bool should_keep_alive() const {
        if (_version == "0.9") {
            return false;
        }
 
        // TODO: handle HTTP/2.0 when it releases
 
        auto it = _headers.find("Connection");
        if (_version == "1.0") {
            return it != _headers.end()
                 && seastar::internal::case_insensitive_cmp()(it->second, "keep-alive");
        } else { // HTTP/1.1
            return it == _headers.end() || !seastar::internal::case_insensitive_cmp()(it->second, "close");
        }
    }
 
    sstring parse_query_param();
 
    sstring format_url() const;
 
    void set_mime_type(const sstring& mime) {
        _headers["Content-Type"] = mime;
    }
 
    void set_content_type(const sstring& content_type = "html") {
        set_mime_type(http::mime_types::extension_to_type(content_type));
    }
 
    void write_body(const sstring& content_type, sstring content);
 
    void write_body(const sstring& content_type, noncopyable_function<future<>(output_stream<char>&&)>&& body_writer);
 
    void write_body(const sstring& content_type, size_t len, noncopyable_function<future<>(output_stream<char>&&)>&& body_writer);
 
    void set_expects_continue();
 
    static request make(sstring method, sstring host, sstring path);
 
    static request make(httpd::operation_type type, sstring host, sstring path);
 
private:
    void add_param(const std::string_view& param);
    sstring request_line() const;
    future<> write_request_headers(output_stream<char>& out) const;
    friend class experimental::connection;
};
 
} // namespace httpd
 
namespace httpd {
using request [[deprecated("Use http::request instead")]] = http::request;
}
 
}