Line data    Source code

       1             : /*
       2             :     Copyright (c) 2007-2016 Contributors as noted in the AUTHORS file
       3             : 
       4             :     This file is part of libzmq, the ZeroMQ core engine in C++.
       5             : 
       6             :     libzmq is free software; you can redistribute it and/or modify it under
       7             :     the terms of the GNU Lesser General Public License (LGPL) as published
       8             :     by the Free Software Foundation; either version 3 of the License, or
       9             :     (at your option) any later version.
      10             : 
      11             :     As a special exception, the Contributors give you permission to link
      12             :     this library with independent modules to produce an executable,
      13             :     regardless of the license terms of these independent modules, and to
      14             :     copy and distribute the resulting executable under terms of your choice,
      15             :     provided that you also meet, for each linked independent module, the
      16             :     terms and conditions of the license of that module. An independent
      17             :     module is a module which is not derived from or based on this library.
      18             :     If you modify this library, you must extend this exception to your
      19             :     version of the library.
      20             : 
      21             :     libzmq is distributed in the hope that it will be useful, but WITHOUT
      22             :     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
      23             :     FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
      24             :     License for more details.
      25             : 
      26             :     You should have received a copy of the GNU Lesser General Public License
      27             :     along with this program.  If not, see <http://www.gnu.org/licenses/>.
      28             : */
      29             : 
      30             : #include "precompiled.hpp"
      31             : #include "macros.hpp"
      32             : #include "dealer.hpp"
      33             : #include "err.hpp"
      34             : #include "msg.hpp"
      35             : 
      36         708 : zmq::dealer_t::dealer_t (class ctx_t *parent_, uint32_t tid_, int sid_) :
      37             :     socket_base_t (parent_, tid_, sid_),
      38         708 :     probe_router (false)
      39             : {
      40         708 :     options.type = ZMQ_DEALER;
      41         708 : }
      42             : 
      43        1308 : zmq::dealer_t::~dealer_t ()
      44             : {
      45        1308 : }
      46             : 
      47         831 : void zmq::dealer_t::xattach_pipe (pipe_t *pipe_, bool subscribe_to_all_)
      48             : {
      49             :     LIBZMQ_UNUSED (subscribe_to_all_);
      50             : 
      51         831 :     zmq_assert (pipe_);
      52             : 
      53         831 :     if (probe_router) {
      54             :         msg_t probe_msg_;
      55           0 :         int rc = probe_msg_.init ();
      56           0 :         errno_assert (rc == 0);
      57             : 
      58           0 :         rc = pipe_->write (&probe_msg_);
      59             :         // zmq_assert (rc) is not applicable here, since it is not a bug.
      60           0 :         pipe_->flush ();
      61             : 
      62           0 :         rc = probe_msg_.close ();
      63           0 :         errno_assert (rc == 0);
      64             :     }
      65             : 
      66         831 :     fq.attach (pipe_);
      67         831 :     lb.attach (pipe_);
      68         831 : }
      69             : 
      70        1773 : int zmq::dealer_t::xsetsockopt (int option_, const void *optval_,
      71             :     size_t optvallen_)
      72             : {
      73        1773 :     bool is_int = (optvallen_ == sizeof (int));
      74        1773 :     int value = 0;
      75        1773 :     if (is_int) memcpy(&value, optval_, sizeof (int));
      76             : 
      77        1773 :     switch (option_) {
      78             :         case ZMQ_PROBE_ROUTER:
      79           0 :             if (is_int && value >= 0) {
      80           0 :                 probe_router = (value != 0);
      81           0 :                 return 0;
      82             :             }
      83             :             break;
      84             : 
      85             :         default:
      86             :             break;
      87             :     }
      88             : 
      89        1773 :     errno = EINVAL;
      90        1773 :     return -1;
      91             : }
      92             : 
      93         906 : int zmq::dealer_t::xsend (msg_t *msg_)
      94             : {
      95         906 :     return sendpipe (msg_, NULL);
      96             : }
      97             : 
      98     3147993 : int zmq::dealer_t::xrecv (msg_t *msg_)
      99             : {
     100     3147342 :     return recvpipe (msg_, NULL);
     101             : }
     102             : 
     103        1104 : bool zmq::dealer_t::xhas_in ()
     104             : {
     105        1104 :     return fq.has_in ();
     106             : }
     107             : 
     108        1104 : bool zmq::dealer_t::xhas_out ()
     109             : {
     110        1104 :     return lb.has_out ();
     111             : }
     112             : 
     113           0 : zmq::blob_t zmq::dealer_t::get_credential () const
     114             : {
     115           0 :     return fq.get_credential ();
     116             : }
     117             : 
     118             : 
     119         671 : void zmq::dealer_t::xread_activated (pipe_t *pipe_)
     120             : {
     121         671 :     fq.activated (pipe_);
     122         671 : }
     123             : 
     124           0 : void zmq::dealer_t::xwrite_activated (pipe_t *pipe_)
     125             : {
     126           0 :     lb.activated (pipe_);
     127           0 : }
     128             : 
     129         831 : void zmq::dealer_t::xpipe_terminated (pipe_t *pipe_)
     130             : {
     131         831 :     fq.pipe_terminated (pipe_);
     132         831 :     lb.pipe_terminated (pipe_);
     133         831 : }
     134             : 
     135         177 : int zmq::dealer_t::sendpipe (msg_t *msg_, pipe_t **pipe_)
     136             : {
     137        1083 :     return lb.sendpipe (msg_, pipe_);
     138             : }
     139             : 
     140         507 : int zmq::dealer_t::recvpipe (msg_t *msg_, pipe_t **pipe_)
     141             : {
     142     3148500 :     return fq.recvpipe (msg_, pipe_);
     143             : }