/* SPDX-License-Identifier: MPL-2.0 */

#include "precompiled.hpp"

#include "macros.hpp"

#include "req.hpp"

#include "err.hpp"

#include "msg.hpp"

#include "wire.hpp"

#include "random.hpp"

#include "likely.hpp"

zmq::req_t::req_t (class ctx_t *parent_, uint32_t tid_, int sid_) :

    dealer_t (parent_, tid_, sid_),

    _receiving_reply (false),

    _message_begins (true),

    _reply_pipe (NULL),

    _request_id_frames_enabled (false),

    _request_id (generate_random ()),

    _strict (true)

{

    options.type = ZMQ_REQ;

}

zmq::req_t::~req_t ()

{

}

int zmq::req_t::xsend (msg_t *msg_)

{

    //  If we've sent a request and we still haven't got the reply,

    //  we can't send another request unless the strict option is disabled.

    if (_receiving_reply) {

        if (_strict) {

            errno = EFSM;

            return -1;

        }

        _receiving_reply = false;

        _message_begins = true;

    }

    //  First part of the request is the request routing id.

    if (_message_begins) {

        _reply_pipe = NULL;

        if (_request_id_frames_enabled) {

            _request_id++;

            msg_t id;

            int rc = id.init_size (sizeof (uint32_t));

            memcpy (id.data (), &_request_id, sizeof (uint32_t));

            errno_assert (rc == 0);

            id.set_flags (msg_t::more);

            rc = dealer_t::sendpipe (&id, &_reply_pipe);

            if (rc != 0) {

                return -1;

            }

        }

        msg_t bottom;

        int rc = bottom.init ();

        errno_assert (rc == 0);

        bottom.set_flags (msg_t::more);

        rc = dealer_t::sendpipe (&bottom, &_reply_pipe);

        if (rc != 0)

            return -1;

        zmq_assert (_reply_pipe);

        _message_begins = false;

        // Eat all currently available messages before the request is fully

        // sent. This is done to avoid:

        //   REQ sends request to A, A replies, B replies too.

        //   A's reply was first and matches, that is used.

        //   An hour later REQ sends a request to B. B's old reply is used.

        msg_t drop;

        while (true) {

            rc = drop.init ();

            errno_assert (rc == 0);

            rc = dealer_t::xrecv (&drop);

            if (rc != 0)

                break;

            drop.close ();

        }

    }

    bool more = (msg_->flags () & msg_t::more) != 0;

    int rc = dealer_t::xsend (msg_);

    if (rc != 0)

        return rc;

    //  If the request was fully sent, flip the FSM into reply-receiving state.

    if (!more) {

        _receiving_reply = true;

        _message_begins = true;

    }

    return 0;

}

int zmq::req_t::xrecv (msg_t *msg_)

{

    //  If request wasn't send, we can't wait for reply.

    if (!_receiving_reply) {

        errno = EFSM;

        return -1;

    }

    //  Skip messages until one with the right first frames is found.

    while (_message_begins) {

        //  If enabled, the first frame must have the correct request_id.

        if (_request_id_frames_enabled) {

            int rc = recv_reply_pipe (msg_);

            if (rc != 0)

                return rc;

            if (unlikely (!(msg_->flags () & msg_t::more)

                          || msg_->size () != sizeof (_request_id)

                          || *static_cast<uint32_t *> (msg_->data ())

                               != _request_id)) {

                //  Skip the remaining frames and try the next message

                while (msg_->flags () & msg_t::more) {

                    rc = recv_reply_pipe (msg_);

                    errno_assert (rc == 0);

                }

                continue;

            }

        }

        //  The next frame must be 0.

        // TODO: Failing this check should also close the connection with the peer!

        int rc = recv_reply_pipe (msg_);

        if (rc != 0)

            return rc;

        if (unlikely (!(msg_->flags () & msg_t::more) || msg_->size () != 0)) {

            //  Skip the remaining frames and try the next message

            while (msg_->flags () & msg_t::more) {

                rc = recv_reply_pipe (msg_);

                errno_assert (rc == 0);

            }

            continue;

        }

        _message_begins = false;

    }

    const int rc = recv_reply_pipe (msg_);

    if (rc != 0)

        return rc;

    //  If the reply is fully received, flip the FSM into request-sending state.

    if (!(msg_->flags () & msg_t::more)) {

        _receiving_reply = false;

        _message_begins = true;

    }

    return 0;

}

bool zmq::req_t::xhas_in ()

{

    //  TODO: Duplicates should be removed here.

    if (!_receiving_reply)

        return false;

    return dealer_t::xhas_in ();

}

bool zmq::req_t::xhas_out ()

{

    if (_receiving_reply && _strict)

        return false;

    return dealer_t::xhas_out ();

}

int zmq::req_t::xsetsockopt (int option_,

                             const void *optval_,

                             size_t optvallen_)

{

    const bool is_int = (optvallen_ == sizeof (int));

    int value = 0;

    if (is_int)

        memcpy (&value, optval_, sizeof (int));

    switch (option_) {

        case ZMQ_REQ_CORRELATE:

            if (is_int && value >= 0) {

                _request_id_frames_enabled = (value != 0);

                return 0;

            }

            break;

        case ZMQ_REQ_RELAXED:

            if (is_int && value >= 0) {

                _strict = (value == 0);

                return 0;

            }

            break;

        default:

            break;

    }

    return dealer_t::xsetsockopt (option_, optval_, optvallen_);

}

void zmq::req_t::xpipe_terminated (pipe_t *pipe_)

{

    if (_reply_pipe == pipe_)

        _reply_pipe = NULL;

    dealer_t::xpipe_terminated (pipe_);

}

int zmq::req_t::recv_reply_pipe (msg_t *msg_)

{

    while (true) {

        pipe_t *pipe = NULL;

        const int rc = dealer_t::recvpipe (msg_, &pipe);

        if (rc != 0)

            return rc;

        if (!_reply_pipe || pipe == _reply_pipe)

            return 0;

    }

}

zmq::req_session_t::req_session_t (io_thread_t *io_thread_,

                                   bool connect_,

                                   socket_base_t *socket_,

                                   const options_t &options_,

                                   address_t *addr_) :

    session_base_t (io_thread_, connect_, socket_, options_, addr_),

    _state (bottom)

{

}

zmq::req_session_t::~req_session_t ()

{

}

int zmq::req_session_t::push_msg (msg_t *msg_)

{

    //  Ignore commands, they are processed by the engine and should not

    //  affect the state machine.

    if (unlikely (msg_->flags () & msg_t::command))

        return 0;

    switch (_state) {

        case bottom:

            if (msg_->flags () == msg_t::more) {

                //  In case option ZMQ_CORRELATE is on, allow request_id to be

                //  transferred as first frame (would be too cumbersome to check

                //  whether the option is actually on or not).

                if (msg_->size () == sizeof (uint32_t)) {

                    _state = request_id;

                    return session_base_t::push_msg (msg_);

                }

                if (msg_->size () == 0) {

                    _state = body;

                    return session_base_t::push_msg (msg_);

                }

            }

            break;

        case request_id:

            if (msg_->flags () == msg_t::more && msg_->size () == 0) {

                _state = body;

                return session_base_t::push_msg (msg_);

            }

            break;

        case body:

            if (msg_->flags () == msg_t::more)

                return session_base_t::push_msg (msg_);

            if (msg_->flags () == 0) {

                _state = bottom;

                return session_base_t::push_msg (msg_);

            }

            break;

    }

    errno = EFAULT;

    return -1;

}

void zmq::req_session_t::reset ()

{

    session_base_t::reset ();

    _state = bottom;

}