File Coverage

/usr/local/lib/perl5/site_perl/5.26.1/x86_64-linux/Protocol/HTTP.x/i/panda/protocol/http/Request.h

Criterion	Covered	Total	%
statement	0	2	0.0
branch	0	2	0.0
condition			n/a
subroutine			n/a
pod			n/a
total	0	4	0.0

#pragma once
#include "Response.h"
#include
#include

namespace panda { namespace protocol { namespace http {


struct Request : Message, AllocatedObject {
    enum class Method {unspecified, OPTIONS, GET, HEAD, POST, PUT, DELETE, TRACE, CONNECT};
    enum class EncType {MULTIPART, URLENCODED, disabled};
    enum class FormStreaming { none, started, file, done };

    static inline string method_str(Request::Method rm) noexcept {
        using Method = Request::Method;
        switch (rm) {
            case Method::unspecified : return "[unspecified]";
            case Method::OPTIONS     : return "OPTIONS";
            case Method::GET         : return "GET";
            case Method::HEAD        : return "HEAD";
            case Method::POST        : return "POST";
            case Method::PUT         : return "PUT";
            case Method::DELETE      : return "DELETE";
            case Method::TRACE       : return "TRACE";
            case Method::CONNECT     : return "CONNECT";
            default: return "[UNKNOWN]";
        }
    }

    struct Builder; template  struct BuilderImpl;
    using Cookies = Fields;

    struct NamedString {
        string value;
        string name;
        string content_type;
    };

    struct Form: string_multimap {

        Form(EncType enc_type = EncType::disabled) noexcept :_enc_type(enc_type){}

        void enc_type (const EncType value) noexcept { _enc_type = value; }
        EncType enc_type () const noexcept { return _enc_type; }

        operator bool () const noexcept { return _enc_type != EncType::disabled; }

        void add(const string& key, const string& value, const string& filename = "", const string content_type = "") {
            insert({key, NamedString{value, filename, content_type}});
        }

    private:
        const URI* to_body (Body& body, uri::URI &uri, const URISP original_uri, const string& boundary) const noexcept;
        void to_uri  (URI& uri, const URISP original_uri) const ;
        EncType _enc_type = EncType::MULTIPART;
        friend struct Request;
    };


    URISP   uri;
    Cookies cookies;
    Form    form;

    compression::storage_t compression_prefs = Compression::IDENTITY;

    Request () {}

    Request (Method method, const URISP& uri, Headers&& header = Headers(), Body&& body = Body(), bool chunked = false, int http_version = 0) :
        Message(std::move(header), std::move(body), chunked, http_version), uri(uri), _method(method)
    {
    }

    bool expects_continue () const;

    std::vector to_vector () const;
    string              to_string () const { return Message::to_string(to_vector()); }

    virtual ResponseSP new_response () const { return make_iptr(); }


    template
    void allow_compression (PrefN... prefn) {
        return _allow_compression(prefn...);
    }

    Method method()     const noexcept;
    Method method_raw() const noexcept { return _method; }

    void   method_raw(Method value) noexcept { _method = value; }

    std::uint8_t allowed_compression (bool inverse = false) const noexcept;

    void form_stream() {
        if (_form_streaming == FormStreaming::none) {
            _form_streaming = FormStreaming::started;
            form._enc_type = EncType::MULTIPART;
            _form_boundary = _generate_boundary();
        }
        else if (_form_streaming != FormStreaming::started) {
            throw "invalid state for form streaming";
        }
    }

    bool form_streaming() noexcept { return  _form_streaming == FormStreaming::started; }

    wrapped_chunk form_finish();
    wrapped_chunk form_field(const string& name, const string& content, const string& filename = "", const string& mime_type = "");
    wrapped_chunk form_file(const string& name, const string filename = "", const string& mime_type = "application/octet-stream");
    wrapped_chunk form_data(const string& data);

protected:
    struct SerializationContext: Message::SerializationContext {
        const URI* uri;
    };

    string form_trailer(const string& boundary) const noexcept {
        auto sz = boundary.size() + 6;
        string r(sz);
        r += "--";
        r += boundary;
        r += "--\r\n";
        return r;
    }

    Method  _method = Method::unspecified;
    FormStreaming _form_streaming = FormStreaming::none;
    string _form_boundary;

    template
    void _allow_compression (Compression::Type p, PrefN... prefn) {
        compression::pack(this->compression_prefs, p);
        return _allow_compression(prefn...);
    }
    void _allow_compression () {}
    void form_file_finalize(string& out) noexcept;

    ~Request () {} // restrict stack allocation

private:
    friend struct RequestParser;

    static Method deduce_method (bool has_form, EncType form_enc, Method _method) noexcept;
    string _http_header (SerializationContext &ctx) const;
    static string _generate_boundary() noexcept;
};
using RequestSP = iptr;

template
struct Request::BuilderImpl : Message::Builder {
    using Message::Builder::Builder;

    T& method (Request::Method method) {
        this->_message->method_raw(method);
        return this->self();
    }

    T& uri (const string& uri) {
        this->_message->uri = new URI(uri);
        return this->self();
    }

    T& uri (const URISP& uri) {
        this->_message->uri = uri;
        return this->self();
    }

    T& cookie (const string& name, const string& value) {
        this->_message->cookies.add(name, value);
        return this->self();
    }

    template
    T& allow_compression(PrefN... prefn) {
        this->_message->allow_compression(prefn...);
        return this->self();
    }

    template
    T& form(Form&& form) {
        this->_message->form = std::forward(form);
        return this->self();
    }

    T& form_stream() {
        this->_message->form_stream();
        return this->self();
    }
};

struct Request::Builder : Request::BuilderImpl {
    Builder () : BuilderImpl(new Request()) {}
};

}}}