void zmq::zmq_init_t::finalise () { if (sent && received) { // Disconnect the engine from the init object. engine->unplug (); session_t *session = NULL; // If we have the session ordinal, let's use it to find the session. // If it is not found, it means socket is already being shut down // and the session have been deallocated. // TODO: We should check whether the name of the peer haven't changed // upon reconnection. if (session_ordinal) { session = owner->find_session (session_ordinal); if (!session) { term (); return; } } // If the peer has a unique name, find the associated session. If it // doesn't exist, create it. else if (!peer_identity.empty ()) { session = owner->find_session (peer_identity.c_str ()); if (!session) { session = new (std::nothrow) session_t ( choose_io_thread (options.affinity), owner, options, peer_identity.c_str ()); zmq_assert (session); send_plug (session); send_own (owner, session); // Reserve a sequence number for following 'attach' command. session->inc_seqnum (); } } // If the other party has no specific identity, let's create a // transient session. else { session = new (std::nothrow) session_t ( choose_io_thread (options.affinity), owner, options, NULL); zmq_assert (session); send_plug (session); send_own (owner, session); // Reserve a sequence number for following 'attach' command. session->inc_seqnum (); } // No need to increment seqnum as it was laready incremented above. send_attach (session, engine, false); // Destroy the init object. engine = NULL; term (); } }
void zmq::zmq_connecter_t::out_event () { fd_t fd = tcp_connecter.connect (); rm_fd (handle); handle_valid = false; // Handle the error condition by attempt to reconnect. if (fd == retired_fd) { tcp_connecter.close (); wait = true; add_timer (); return; } // Create an init object. zmq_init_t *init = new (std::nothrow) zmq_init_t ( choose_io_thread (options.affinity), owner, fd, options, true, address.c_str (), session_ordinal); zmq_assert (init); send_plug (init); send_own (owner, init); // Ask owner socket to shut the connecter down. term (); }
void zmq::session_t::detach (owned_t *reconnecter_) { // Plug in the reconnecter object if any. if (reconnecter_) { send_plug (reconnecter_); send_own (owner, reconnecter_); } // Engine is terminating itself. No need to deallocate it from here. engine = NULL; // Get rid of half-processed messages in the out pipe. Flush any // unflushed messages upstream. if (out_pipe) { out_pipe->rollback (); out_pipe->flush (); } // Remove any half-read message from the in pipe. if (in_pipe) { while (incomplete_in) { zmq_msg_t msg; zmq_msg_init (&msg); if (!read (&msg)) { zmq_assert (!incomplete_in); break; } zmq_msg_close (&msg); } } // Terminate transient session. if (!ordinal && (peer_identity.empty () || peer_identity [0] == 0)) term (); }
int zmq::socket_base_t::bind (const char *addr_) { if (unlikely (app_thread->is_terminated ())) { errno = ETERM; return -1; } // Parse addr_ string. std::string addr_type; std::string addr_args; std::string addr (addr_); std::string::size_type pos = addr.find ("://"); if (pos == std::string::npos) { errno = EINVAL; return -1; } addr_type = addr.substr (0, pos); addr_args = addr.substr (pos + 3); if (addr_type == "inproc") return register_endpoint (addr_args.c_str (), this); if (addr_type == "tcp" || addr_type == "ipc") { #if defined ZMQ_HAVE_WINDOWS || defined ZMQ_HAVE_OPENVMS if (addr_type == "ipc") { errno = EPROTONOSUPPORT; return -1; } #endif zmq_listener_t *listener = new (std::nothrow) zmq_listener_t ( choose_io_thread (options.affinity), this, options); zmq_assert (listener); int rc = listener->set_address (addr_type.c_str(), addr_args.c_str ()); if (rc != 0) { delete listener; return -1; } send_plug (listener); send_own (this, listener); return 0; } #if defined ZMQ_HAVE_OPENPGM if (addr_type == "pgm" || addr_type == "epgm") { // In the case of PGM bind behaves the same like connect. return connect (addr_); } #endif // Unknown protocol. errno = EPROTONOSUPPORT; return -1; }
void zmq::own_t::launch_child (own_t *object_) { // Specify the owner of the object. object_->set_owner (this); // Plug the object into the I/O thread. send_plug (object_); // Take ownership of the object. send_own (this, object_); }
void zmq::zmq_init_t::detach (owned_t *reconnecter_) { // This function is called by engine when disconnection occurs. // If required, launch the reconnecter. if (reconnecter_) { send_plug (reconnecter_); send_own (owner, reconnecter_); } // The engine will destroy itself, so let's just drop the pointer here and // start termination of the init object. engine = NULL; term (); }
void zmq::session_t::detach (owned_t *reconnecter_) { // Plug in the reconnecter object if any. if (reconnecter_) { send_plug (reconnecter_); send_own (owner, reconnecter_); } // Engine is terminating itself. No need to deallocate it from here. engine = NULL; // Terminate transient session. if (!ordinal && (peer_identity.empty () || peer_identity [0] == 0)) term (); }
void zmq::zmq_listener_t::in_event () { fd_t fd = tcp_listener.accept (); // If connection was reset by the peer in the meantime, just ignore it. // TODO: Handle specific errors like ENFILE/EMFILE etc. if (fd == retired_fd) return; // Create an init object. io_thread_t *io_thread = choose_io_thread (options.affinity); zmq_init_t *init = new (std::nothrow) zmq_init_t ( io_thread, owner, fd, options, false, NULL, 0); zmq_assert (init); send_plug (init); send_own (owner, init); }
void zmq::own_t::launch_sibling (own_t *object_) { // At this point it is important that object is plugged in before its // owner has a chance to terminate it. Thus, 'plug' command is sent before // the 'own' command. Given that the mailbox preserves ordering of // commands, 'term' command from the owner cannot make it to the object // before the already written 'plug' command. // Specify the owner of the object. object_->set_owner (owner); // Plug the object into its I/O thread. send_plug (object_); // Make parent own the object. send_own (owner, object_); }
int zmq::socket_base_t::connect (const char *addr_) { if (unlikely (app_thread->is_terminated ())) { errno = ETERM; return -1; } // Parse addr_ string. std::string addr_type; std::string addr_args; std::string addr (addr_); std::string::size_type pos = addr.find ("://"); if (pos == std::string::npos) { errno = EINVAL; return -1; } addr_type = addr.substr (0, pos); addr_args = addr.substr (pos + 3); if (addr_type == "inproc") { // TODO: inproc connect is specific with respect to creating pipes // as there's no 'reconnect' functionality implemented. Once that // is in place we should follow generic pipe creation algorithm. // Find the peer socket. socket_base_t *peer = find_endpoint (addr_args.c_str ()); if (!peer) return -1; pipe_t *in_pipe = NULL; pipe_t *out_pipe = NULL; // Create inbound pipe, if required. if (options.requires_in) { in_pipe = new (std::nothrow) pipe_t (this, peer, options.hwm); zmq_assert (in_pipe); } // Create outbound pipe, if required. if (options.requires_out) { out_pipe = new (std::nothrow) pipe_t (peer, this, options.hwm); zmq_assert (out_pipe); } // Attach the pipes to this socket object. attach_pipes (in_pipe ? &in_pipe->reader : NULL, out_pipe ? &out_pipe->writer : NULL, blob_t ()); // Attach the pipes to the peer socket. Note that peer's seqnum // was incremented in find_endpoint function. The callee is notified // about the fact via the last parameter. send_bind (peer, out_pipe ? &out_pipe->reader : NULL, in_pipe ? &in_pipe->writer : NULL, options.identity, false); return 0; } // Create unnamed session. io_thread_t *io_thread = choose_io_thread (options.affinity); session_t *session = new (std::nothrow) session_t (io_thread, this, options); zmq_assert (session); // If 'immediate connect' feature is required, we'll created the pipes // to the session straight away. Otherwise, they'll be created by the // session once the connection is established. if (options.immediate_connect) { pipe_t *in_pipe = NULL; pipe_t *out_pipe = NULL; // Create inbound pipe, if required. if (options.requires_in) { in_pipe = new (std::nothrow) pipe_t (this, session, options.hwm); zmq_assert (in_pipe); } // Create outbound pipe, if required. if (options.requires_out) { out_pipe = new (std::nothrow) pipe_t (session, this, options.hwm); zmq_assert (out_pipe); } // Attach the pipes to the socket object. attach_pipes (in_pipe ? &in_pipe->reader : NULL, out_pipe ? &out_pipe->writer : NULL, blob_t ()); // Attach the pipes to the session object. session->attach_pipes (out_pipe ? &out_pipe->reader : NULL, in_pipe ? &in_pipe->writer : NULL, blob_t ()); } // Activate the session. send_plug (session); send_own (this, session); if (addr_type == "tcp" || addr_type == "ipc") { #if defined ZMQ_HAVE_WINDOWS || defined ZMQ_HAVE_OPENVMS // Windows named pipes are not compatible with Winsock API. // There's no UNIX domain socket implementation on OpenVMS. if (addr_type == "ipc") { errno = EPROTONOSUPPORT; return -1; } #endif // Create the connecter object. Supply it with the session name // so that it can bind the new connection to the session once // it is established. zmq_connecter_t *connecter = new (std::nothrow) zmq_connecter_t ( choose_io_thread (options.affinity), this, options, session->get_ordinal (), false); zmq_assert (connecter); int rc = connecter->set_address (addr_type.c_str(), addr_args.c_str ()); if (rc != 0) { delete connecter; return -1; } send_plug (connecter); send_own (this, connecter); return 0; } #if defined ZMQ_HAVE_OPENPGM if (addr_type == "pgm" || addr_type == "epgm") { // If the socket type requires bi-directional communication // multicast is not an option (it is uni-directional). if (options.requires_in && options.requires_out) { errno = ENOCOMPATPROTO; return -1; } // For epgm, pgm transport with UDP encapsulation is used. bool udp_encapsulation = (addr_type == "epgm"); // At this point we'll create message pipes to the session straight // away. There's no point in delaying it as no concept of 'connect' // exists with PGM anyway. if (options.requires_out) { // PGM sender. pgm_sender_t *pgm_sender = new (std::nothrow) pgm_sender_t ( choose_io_thread (options.affinity), options); zmq_assert (pgm_sender); int rc = pgm_sender->init (udp_encapsulation, addr_args.c_str ()); if (rc != 0) { delete pgm_sender; return -1; } send_attach (session, pgm_sender, blob_t ()); } else if (options.requires_in) { // PGM receiver. pgm_receiver_t *pgm_receiver = new (std::nothrow) pgm_receiver_t ( choose_io_thread (options.affinity), options); zmq_assert (pgm_receiver); int rc = pgm_receiver->init (udp_encapsulation, addr_args.c_str ()); if (rc != 0) { delete pgm_receiver; return -1; } send_attach (session, pgm_receiver, blob_t ()); } else zmq_assert (false); return 0; } #endif // Unknown protoco. errno = EPROTONOSUPPORT; return -1; }