plain_client.cpp

Go to the documentation of this file.

/* SPDX-License-Identifier: MPL-2.0 */
 
#include "precompiled.hpp"
#include "macros.hpp"
 
#include <string>
#include <limits.h>
 
#include "msg.hpp"
#include "err.hpp"
#include "plain_client.hpp"
#include "session_base.hpp"
#include "plain_common.hpp"
 
zmq::plain_client_t::plain_client_t (session_base_t *const session_,
                                     const options_t &options_) :
    mechanism_base_t (session_, options_), _state (sending_hello)
{
}
 
zmq::plain_client_t::~plain_client_t ()
{
}
 
int zmq::plain_client_t::next_handshake_command (msg_t *msg_)
{
    int rc = 0;
 
    switch (_state) {
        case sending_hello:
            produce_hello (msg_);
            _state = waiting_for_welcome;
            break;
        case sending_initiate:
            produce_initiate (msg_);
            _state = waiting_for_ready;
            break;
        default:
            errno = EAGAIN;
            rc = -1;
    }
    return rc;
}
 
int zmq::plain_client_t::process_handshake_command (msg_t *msg_)
{
    const unsigned char *cmd_data =
      static_cast<unsigned char *> (msg_->data ());
    const size_t data_size = msg_->size ();
 
    int rc = 0;
    if (data_size >= welcome_prefix_len
        && !memcmp (cmd_data, welcome_prefix, welcome_prefix_len))
        rc = process_welcome (cmd_data, data_size);
    else if (data_size >= ready_prefix_len
             && !memcmp (cmd_data, ready_prefix, ready_prefix_len))
        rc = process_ready (cmd_data, data_size);
    else if (data_size >= error_prefix_len
             && !memcmp (cmd_data, error_prefix, error_prefix_len))
        rc = process_error (cmd_data, data_size);
    else {
        session->get_socket ()->event_handshake_failed_protocol (
          session->get_endpoint (), ZMQ_PROTOCOL_ERROR_ZMTP_UNEXPECTED_COMMAND);
        errno = EPROTO;
        rc = -1;
    }
 
    if (rc == 0) {
        rc = msg_->close ();
        errno_assert (rc == 0);
        rc = msg_->init ();
        errno_assert (rc == 0);
    }
 
    return rc;
}
 
zmq::mechanism_t::status_t zmq::plain_client_t::status () const
{
    switch (_state) {
        case ready:
            return mechanism_t::ready;
        case error_command_received:
            return mechanism_t::error;
        default:
            return mechanism_t::handshaking;
    }
}
 
void zmq::plain_client_t::produce_hello (msg_t *msg_) const
{
    const std::string username = options.plain_username;
    zmq_assert (username.length () <= UCHAR_MAX);
 
    const std::string password = options.plain_password;
    zmq_assert (password.length () <= UCHAR_MAX);
 
    const size_t command_size = hello_prefix_len + brief_len_size
                                + username.length () + brief_len_size
                                + password.length ();
 
    const int rc = msg_->init_size (command_size);
    errno_assert (rc == 0);
 
    unsigned char *ptr = static_cast<unsigned char *> (msg_->data ());
    memcpy (ptr, hello_prefix, hello_prefix_len);
    ptr += hello_prefix_len;
 
    *ptr++ = static_cast<unsigned char> (username.length ());
    memcpy (ptr, username.c_str (), username.length ());
    ptr += username.length ();
 
    *ptr++ = static_cast<unsigned char> (password.length ());
    memcpy (ptr, password.c_str (), password.length ());
}
 
int zmq::plain_client_t::process_welcome (const unsigned char *cmd_data_,
                                          size_t data_size_)
{
    LIBZMQ_UNUSED (cmd_data_);
 
    if (_state != waiting_for_welcome) {
        session->get_socket ()->event_handshake_failed_protocol (
          session->get_endpoint (), ZMQ_PROTOCOL_ERROR_ZMTP_UNEXPECTED_COMMAND);
        errno = EPROTO;
        return -1;
    }
    if (data_size_ != welcome_prefix_len) {
        session->get_socket ()->event_handshake_failed_protocol (
          session->get_endpoint (),
          ZMQ_PROTOCOL_ERROR_ZMTP_MALFORMED_COMMAND_WELCOME);
        errno = EPROTO;
        return -1;
    }
    _state = sending_initiate;
    return 0;
}
 
void zmq::plain_client_t::produce_initiate (msg_t *msg_) const
{
    make_command_with_basic_properties (msg_, initiate_prefix,
                                        initiate_prefix_len);
}
 
int zmq::plain_client_t::process_ready (const unsigned char *cmd_data_,
                                        size_t data_size_)
{
    if (_state != waiting_for_ready) {
        session->get_socket ()->event_handshake_failed_protocol (
          session->get_endpoint (), ZMQ_PROTOCOL_ERROR_ZMTP_UNEXPECTED_COMMAND);
        errno = EPROTO;
        return -1;
    }
    const int rc = parse_metadata (cmd_data_ + ready_prefix_len,
                                   data_size_ - ready_prefix_len);
    if (rc == 0)
        _state = ready;
    else
        session->get_socket ()->event_handshake_failed_protocol (
          session->get_endpoint (), ZMQ_PROTOCOL_ERROR_ZMTP_INVALID_METADATA);
 
    return rc;
}
 
int zmq::plain_client_t::process_error (const unsigned char *cmd_data_,
                                        size_t data_size_)
{
    if (_state != waiting_for_welcome && _state != waiting_for_ready) {
        session->get_socket ()->event_handshake_failed_protocol (
          session->get_endpoint (), ZMQ_PROTOCOL_ERROR_ZMTP_UNEXPECTED_COMMAND);
        errno = EPROTO;
        return -1;
    }
    const size_t start_of_error_reason = error_prefix_len + brief_len_size;
    if (data_size_ < start_of_error_reason) {
        session->get_socket ()->event_handshake_failed_protocol (
          session->get_endpoint (),
          ZMQ_PROTOCOL_ERROR_ZMTP_MALFORMED_COMMAND_ERROR);
        errno = EPROTO;
        return -1;
    }
    const size_t error_reason_len =
      static_cast<size_t> (cmd_data_[error_prefix_len]);
    if (error_reason_len > data_size_ - start_of_error_reason) {
        session->get_socket ()->event_handshake_failed_protocol (
          session->get_endpoint (),
          ZMQ_PROTOCOL_ERROR_ZMTP_MALFORMED_COMMAND_ERROR);
        errno = EPROTO;
        return -1;
    }
    const char *error_reason =
      reinterpret_cast<const char *> (cmd_data_) + start_of_error_reason;
    handle_error_reason (error_reason, error_reason_len);
    _state = error_command_received;
    return 0;
}