diff --git a/src/ServiceDiscovery/ServiceDiscovery.cpp b/src/ServiceDiscovery/ServiceDiscovery.cpp
index 23c8b8c..607a537 100644
--- a/src/ServiceDiscovery/ServiceDiscovery.cpp
+++ b/src/ServiceDiscovery/ServiceDiscovery.cpp
@@ -529,7 +529,7 @@ void* ServiceDiscovery::MulticastListenThread(void* arg){
     mreq.imr_interface.s_addr = htonl(INADDR_ANY);         
     if (setsockopt(sock.at(i), IPPROTO_IP, IP_ADD_MEMBERSHIP,&mreq, sizeof(mreq)) < 0) {
       perror("setsockopt mreq");
-      printf("Failed to goin multicast group listen thread");
+      printf("Failed to join multicast group listen thread");
       exit(1);
     }         
   
diff --git a/src/ServiceDiscovery/Services.cpp b/src/ServiceDiscovery/Services.cpp
index 47a96f9..c4df97d 100644
--- a/src/ServiceDiscovery/Services.cpp
+++ b/src/ServiceDiscovery/Services.cpp
@@ -27,21 +27,24 @@ bool Services::Init(Store &m_variables, zmq::context_t* context_in, SlowControlC
   if(!m_variables.Get("service_name",m_name)) m_name="test_service";
   if(!m_variables.Get("db_name",m_dbname)) m_dbname="daq";
   
-  
-    
   if(!m_backend_client.Initialise(m_variables)){
     std::clog<<"error initialising slowcontrol client"<<std::endl;
     return false;
   }
    
-  // TODO FIXME with better mechanism
-  // after Initilising the slow control client needs ~15 seconds for the middleman to connect
-  std::this_thread::sleep_for(std::chrono::seconds(15));
-  // hopefully the middleman has found us by now
+  // wait for the middleman to connect. ServiceDiscovery broadcasts are sent out intermittently,
+  // so we need to wait for the middleman to receive one & connect before we can communicate with it.
+  int pub_period=5;
+  m_variables.Get("service_publish_sec",pub_period);
+  Ready(pub_period*1000);
   
   return true;
 }
 
+bool Services::Ready(const unsigned int timeout){
+  return m_backend_client.Ready(timeout);
+}
+
 // ===========================================================================
 // Write Functions
 // ---------------
diff --git a/src/ServiceDiscovery/Services.h b/src/ServiceDiscovery/Services.h
index 97d466e..0018ca7 100644
--- a/src/ServiceDiscovery/Services.h
+++ b/src/ServiceDiscovery/Services.h
@@ -28,6 +28,7 @@ namespace ToolFramework {
     Services();
     ~Services();
     bool Init(Store &m_variables, zmq::context_t* context_in, SlowControlCollection* sc_vars_in, bool new_service=false);
+    bool Ready(const unsigned int timeout=10000); // default service discovery broadcast period is 5s, middleman also checks intermittently, compound total time should be <10s...
     
     bool SQLQuery(const std::string& database, const std::string& query, std::vector<std::string>& responses, const unsigned int timeout=SERVICES_DEFAULT_TIMEOUT);
     bool SQLQuery(const std::string& database, const std::string& query, std::string& response, const unsigned int timeout=SERVICES_DEFAULT_TIMEOUT);
diff --git a/src/ServiceDiscovery/ServicesBackend.cpp b/src/ServiceDiscovery/ServicesBackend.cpp
index ca64947..b8557df 100644
--- a/src/ServiceDiscovery/ServicesBackend.cpp
+++ b/src/ServiceDiscovery/ServicesBackend.cpp
@@ -2,7 +2,7 @@
 
 using namespace ToolFramework;
 
-Command::Command(std::string command_in, char type_in, std::string topic_in){
+Command::Command(std::string command_in, char type_in, std::string topic_in, const unsigned int timeout_ms_in){
 	command = command_in;
 	type = type_in;
 	topic=topic_in;
@@ -10,6 +10,7 @@ Command::Command(std::string command_in, char type_in, std::string topic_in){
 	response=std::vector<std::string>{};
 	err="";
 	msg_id=0;
+	timeout_ms=timeout_ms_in;
 }
 
 Command::Command(){
@@ -20,12 +21,14 @@ Command::Command(){
 	response=std::vector<std::string>{};
 	err="";
 	msg_id=0;
+	timeout_ms=0;
 }
 
 void Command::Print() const {
 	std::cout<<"command="<<command<<std::endl;
 	std::cout<<"type="<<type<<std::endl;
 	std::cout<<"topic="<<topic<<std::endl;
+	std::cout<<"timeout="<<timeout_ms<<std::endl;
 	std::cout<<"success="<<success<<std::endl;
 	std::cout<<"err="<<err<<std::endl;
 	std::cout<<"id="<<msg_id<<std::endl;
@@ -43,6 +46,7 @@ Command::Command(const Command& cmd_in){
 	response = cmd_in.response;
 	err = cmd_in.err;
 	msg_id = cmd_in.msg_id;
+	timeout_ms = cmd_in.timeout_ms;
 }
 
 Command::Command(Command&& cmd_in){
@@ -53,12 +57,14 @@ Command::Command(Command&& cmd_in){
 	response = std::move(cmd_in.response);
 	err = cmd_in.err;
 	msg_id = cmd_in.msg_id;
+	timeout_ms = cmd_in.timeout_ms;
 	cmd_in.command="";
 	cmd_in.type='\0';
 	cmd_in.topic="";
 	cmd_in.success=0;
 	cmd_in.msg_id=0;
 	cmd_in.response=std::vector<std::string>{};
+	cmd_in.timeout_ms=0;
 }
 
 Command& Command::operator=(Command&& cmd_in){
@@ -70,12 +76,14 @@ Command& Command::operator=(Command&& cmd_in){
 		response = std::move(cmd_in.response);
 		err = cmd_in.err;
 		msg_id = cmd_in.msg_id;
+		timeout_ms = cmd_in.timeout_ms;
 		cmd_in.command="";
 		cmd_in.type='\0';
 		cmd_in.topic="";
 		cmd_in.success=0;
 		cmd_in.msg_id=0;
 		cmd_in.response=std::vector<std::string>{};
+		cmd_in.timeout_ms=0;
 	}
 	return *this;
 }
@@ -387,20 +395,14 @@ bool ServicesBackend::SendMulticast(std::string command, std::string* err){
 	return true;
 }
 
-//////////////////////////////////////////////////////////////////////////////////////////////////////////
-// FIXME ok, i think the combination of SendCommand and DoCommand are an over-complication.             //
-// SendCommand is basically a pointless wrapper that spawns a thread to do what it could do itself.     //
-// This would remove the surplus promise/future layer. The only change to DoCommand required            //
-// would be that the timeouts from each stage (wait for send, wait for reply)                           //
-// would need to be appropriately modified -.e.g if total timeout is 300ms and it takes 100ms to send,  //
-// then we would only wait for 200ms for the reply.                                                     //
-//////////////////////////////////////////////////////////////////////////////////////////////////////////
-
 bool ServicesBackend::SendCommand(const std::string& topic, const std::string& command, std::vector<std::string>* results, const unsigned int* timeout_ms, std::string* err){
 	// send a command and receive response.
 	// This is a wrapper that ensures we always return within the requested timeout.
 	if(verbosity>10) std::cout<<"ServicesBackend::SendCommand invoked with command '"<<command<<"'"<<std::endl;
 	
+	int timeout=command_timeout;            // default timeout for submission of command and receipt of response
+	if(timeout_ms) timeout=*timeout_ms;     // override by user if a custom timeout is given
+	
 	// encapsulate the command in an object.
 	// We need this since we can only get one return value from an asynchronous function call,
 	// and we want both a response string and error flag.
@@ -429,52 +431,18 @@ bool ServicesBackend::SendCommand(const std::string& topic, const std::string& c
 	// can use with ZMQ_SUBSCRIBE to filter out particular messages.
 	// In fact it's useful to indicate a topic in all cases, even when the actual message will
 	// (for now) go over a dealer/router combination that cannot filter on the topic.
-	Command cmd{command, type, topic.substr(2,std::string::npos)};
-	
-	// submit the command asynchrously.
-	// This way we have control over how long we wait for the response
-	// The response will be a Command object with remaining members populated.
-	//std::future<Command> response = std::async(std::launch::async, &ServicesBackend::DoCommand, this, cmd);
-	// std::async returns a std::future that will block on destruction until the promise returns.
-	// if we don't want that to happen, i.e. we want to abandon it if it times out,
-	// we instead need to obtain a future from a promise (which is somehow not blocking?),
-	// and run our code in a detached thread, using the promise to pass back the result.
-	// tbh i don't quite get why this is different but there we go.
-	// see https://stackoverflow.com/a/23454840/3544936 and https://stackoverflow.com/a/23460094/3544936
-	std::promise<Command> returnval;
-	std::future<Command> response = returnval.get_future();
-	if(verbosity>10) std::cout<<"ServicesBackend::SendCommand spinning up new thread"<<std::endl;
-	std::thread{&ServicesBackend::DoCommand, this, cmd, std::move(returnval)}.detach();
-	
-	// the return from a std::async call is a 'future' object
-	// this object will be populated with the return value when it becomes available,
-	// but we can wait for a given timeout and then bail if it hasn't resolved in time.
+	// forward the timeout to the Command (and thus zmq::poll in PollAndSend...) ... is this sensible? HMMMMM FIXME
+	Command cmd{command, type, topic.substr(2,std::string::npos),timeout};
 	
-	int timeout=command_timeout;            // default timeout for submission of command and receipt of response
-	if(timeout_ms) timeout=*timeout_ms;     // override by user if a custom timeout is given
-	std::chrono::milliseconds span(timeout);
-	// wrap our attempt to get the future in a try-catch, in case of exception
+	// wrap our attempt to get the response in try/catch, just in case?
 	try {
-		// wait_for will return either when the result is ready, or when it times out
-		if(verbosity>10) std::cout<<"ServicesBackend::SendCommand waiting for response"<<std::endl;
-		if(response.wait_for(span)!=std::future_status::timeout){
-			// we got a response in time. retrieve and parse return value
-			if(verbosity>10) std::cout<<"ServicesBackend::SendCommand fetching response"<<std::endl;
-			cmd = response.get();
-			if(verbosity>10) std::cout<<"ServicesBackend::SendCommand response is "<<cmd.response.size()
-			                          <<" parts"<<std::endl;
-			if(results) *results = cmd.response;
-			if(err) *err = cmd.err;
-			return cmd.success;
-		} else {
-			// timed out
-			std::string errmsg="Timed out after waiting "+std::to_string(timeout)+"ms for response "
-			                   "from command '"+command+"'";
-			if(verbosity>3) std::cerr<<errmsg<<std::endl;
-			if(err) *err=errmsg;
-			//std::cout<<"SendCommand returning false"<<std::endl;
-			return false;
-		}
+		if(verbosity>10) std::cout<<"ServicesBackend::SendCommand calling DoCommand"<<std::endl;
+		DoCommand(cmd, timeout);
+		if(verbosity>10) std::cout<<"ServicesBackend::SendCommand response is "<<cmd.response.size()
+		                          <<" parts"<<std::endl;
+		if(results) *results = cmd.response;
+		if(err) *err = cmd.err;
+		return cmd.success;
 	} catch(std::exception& e){
 		// one thing that can cause an exception is if we terminate the application
 		// before the promise is fulfilled (i.e. the response came, or zmq timed out)
@@ -498,7 +466,7 @@ bool ServicesBackend::SendCommand(const std::string& topic, const std::string& c
 	return ret;
 }
 
-bool ServicesBackend::DoCommand(Command cmd, std::promise<Command> result){
+bool ServicesBackend::DoCommand(Command& cmd, int timeout_ms){
 	if(verbosity>10) std::cout<<"ServicesBackend::DoCommand received command"<<std::endl;
 	// submit a command, wait for the response and return it
 	
@@ -506,6 +474,18 @@ bool ServicesBackend::DoCommand(Command cmd, std::promise<Command> result){
 	uint32_t thismsgid = ++msg_id;
 	cmd.msg_id = thismsgid;
 	
+	// we submit the command asynchrously.
+	// This way we control how long we wait for the response, ensuring we don't block the caller indefinitely.
+	// The response will be a Command object with remaining members populated.
+	// initial guess would have been to use:
+	//std::future<Command> response = std::async(std::launch::async, &ServicesBackend::DoCommand, this, cmd);
+	// but std::async returns a std::future that will block on destruction until the function returns.
+	// if we don't want that to happen, i.e. we want to abandon it if it times out,
+	// we instead need to obtain a future from a promise (which is somehow not blocking?),
+	// and run our code in a detached thread, using the promise to pass back the result.
+	// tbh i don't quite get why this is different but there we go.
+	// see https://stackoverflow.com/a/23454840/3544936 and https://stackoverflow.com/a/23460094/3544936
+	
 	// zmq sockets aren't thread-safe, so we have one central sender.
 	// we submit our command and keep a ticket to retrieve the return status on completion.
 	// similarly, the next response received may not be for us, so a central dealer receives
@@ -530,9 +510,27 @@ bool ServicesBackend::DoCommand(Command cmd, std::promise<Command> result){
 	waiting_senders.emplace(cmd, std::move(send_ticket));
 	send_queue_mutex.unlock();
 	
-	// wait for our number to come up. loooong timeout, but don't hang forever.
 	if(verbosity>10) std::cout<<"ServicesBackend::DoCommand waiting for send confirmation"<<std::endl;
-	if(send_receipt.wait_for(std::chrono::seconds(30))==std::future_status::timeout){
+	// make a note of the time
+	auto send_start = std::chrono::high_resolution_clock::now();
+	// wait for confirmation of sending
+	bool timedout=false;
+	if(send_receipt.wait_for(std::chrono::milliseconds(timeout_ms))==std::future_status::timeout){
+		// wait_for timed out.
+		timedout=true;
+	} else {
+		// got the response before timeout!
+		// See how long that took to send, and subtract that from our total time allotment
+		// to see how long we have to wait for the response to arrive.
+		auto send_end = std::chrono::high_resolution_clock::now();
+		int send_time_ms = std::chrono::duration_cast<std::chrono::milliseconds>(send_end - send_start).count();
+		timeout_ms -= send_time_ms;
+		// juuuust in case, ensure our remaining time is not negative. :)
+		if(timeout_ms<0) timedout=true;
+	}
+	
+	// did we get a response in time?
+	if(timedout){
 		if(verbosity>10) std::cerr<<"ServicesBackend::DoCommand timeout"<<std::endl;
 		// sending timed out
 		if(cmd.type=='w') ++write_commands_failed;
@@ -540,23 +538,23 @@ bool ServicesBackend::DoCommand(Command cmd, std::promise<Command> result){
 		Log("Timed out sending command "+std::to_string(thismsgid),v_warning,verbosity);
 		cmd.success = false;
 		cmd.err = "Timed out sending command";
-		result.set_value(cmd);
 		
-		// since we are giving up waiting for the response, remove ourselves from
-		// the list of waiting recipients
+		// since we are giving up waiting for the response, remove ourselves
+		// from the list of recipients awaiting response
 		if(verbosity>10) std::cout<<"ServicesBackend::DoCommand de-registering for response on id "<<thismsgid<<std::endl;
 		send_queue_mutex.lock();
 		waiting_recipients.erase(thismsgid);
 		send_queue_mutex.unlock();
 		
-		return true;
-	} // else got a return value
+		return false;
+	} // else got send confirmation in time
 	
 	// so we got response about our send request, but did it go through?
-	// check for errors sending
+	// check for errors in sending
 	if(verbosity>10) std::cout<<"ServicesBackend::DoCommand got send confirmation"<<std::endl;
 	int ret = send_receipt.get();
 	std::string errmsg;
+	if(ret==-4) errmsg="No connection on out socket in PollAndSend!";
 	if(ret==-3) errmsg="Error polling out socket in PollAndSend! Is socket closed?";
 	if(ret==-2) errmsg="No listener on out socket in PollAndSend!";
 	if(ret==-1) errmsg="Error sending in PollAndSend!";
@@ -568,7 +566,6 @@ bool ServicesBackend::DoCommand(Command cmd, std::promise<Command> result){
 		Log(errmsg,v_debug,verbosity);
 		cmd.success = false;
 		cmd.err = errmsg;
-		result.set_value(cmd);
 		
 		// since the send failed we don't expect a response, so remove ourselves
 		// from the list of recipients awaiting response
@@ -584,7 +581,7 @@ bool ServicesBackend::DoCommand(Command cmd, std::promise<Command> result){
 	
 	// if we succeeded in sending the message, we now need to wait for a repsonse.
 	if(verbosity>10) std::cout<<"ServicesBackend::DoCommand waiting for response"<<std::endl;
-	if(response_reciept.wait_for(std::chrono::seconds(30))==std::future_status::timeout){
+	if(response_reciept.wait_for(std::chrono::milliseconds(timeout_ms))==std::future_status::timeout){
 		if(verbosity>10) std::cout<<"ServicesBackend::DoCommand response timeout"<<std::endl;
 		// timed out
 		if(cmd.type=='w') ++write_commands_failed;
@@ -592,19 +589,17 @@ bool ServicesBackend::DoCommand(Command cmd, std::promise<Command> result){
 		Log("Timed out waiting for response for command "+std::to_string(thismsgid),v_warning,verbosity);
 		cmd.success = false;
 		cmd.err = "Timed out waiting for response";
-		result.set_value(cmd);
 		return false;
 	} else {
 		// got a response!
 		if(verbosity>10) std::cout<<"ServicesBackend::DoCommand got a response for command "<<cmd.msg_id
 		                          <<", passing back to caller"<<std::endl;
 		try{
-			result.set_value(response_reciept.get());
+			cmd = response_reciept.get();
 		} catch(std::exception& e){
 			Log("ServicesBackend response for command "+std::to_string(cmd.msg_id)+" was exception "+e.what(),v_error,verbosity);
 			cmd.err=e.what();
 			cmd.success=false;
-			result.set_value(cmd);
 			return false;
 		}
 		return true;
@@ -725,9 +720,6 @@ bool ServicesBackend::SendNextCommand(){
 		//Log(logmsg.str(),v_debug,verbosity);
 	}
 	
-	// write commands go to the pub socket, read commands to the dealer
-	zmq::socket_t* thesocket = (cmd.type=='w') ? clt_pub_socket : clt_dlr_socket;
-	
 	// send out the command
 	// commands should be formatted as 4 parts:
 	// 0. pub topic (used by ZMQ_SUBSCRIBE for pub, but send it always)
@@ -741,10 +733,11 @@ bool ServicesBackend::SendNextCommand(){
 	if(verbosity>10) std::cout<<"ServicesBackend::SendNextCommand calling PollAndSend"
 	                          <<", message type: "<<cmd.type<<", topic '"<<cmd.topic<<"'"<<std::endl;
 	if(cmd.type=='w'){
-		ret = PollAndSend(thesocket, out_polls.at(1), outpoll_timeout, cmd.topic, clt_ID, cmd.msg_id, cmd.command);
+		// write commands go to the pub socket, read commands to the dealer
+		ret = PollAndSend(clt_pub_socket, out_polls.at(0), cmd.timeout_ms, cmd.topic, clt_ID, cmd.msg_id, cmd.command);
 	} else {
 		// clt_ID already added by dealer socket
-		ret = PollAndSend(thesocket, out_polls.at(1), outpoll_timeout, cmd.topic, cmd.msg_id, cmd.command);
+		ret = PollAndSend(clt_dlr_socket, out_polls.at(1), cmd.timeout_ms, cmd.topic, cmd.msg_id, cmd.command);
 	}
 	if(verbosity>10) std::cout<<"ServicesBackend::SendNextCommand send returned "<<ret<<", passing to recipient"<<std::endl;
 	dlr_socket_mutex.unlock();
@@ -822,7 +815,6 @@ bool ServicesBackend::Send(zmq::socket_t* sock, bool more, std::string messageda
 	if(verbosity>10) std::cout<<__PRETTY_FUNCTION__<<" called"<<std::endl;
 	// form the zmq::message_t
 	zmq::message_t message(messagedata.size());
-	//snprintf((char*)message.data(), messagedata.size()+1, "%s", messagedata.c_str());
 	memcpy(message.data(), messagedata.data(), message.size());
 	
 	// send it with given SNDMORE flag
@@ -850,7 +842,6 @@ bool ServicesBackend::Send(zmq::socket_t* sock, bool more, std::vector<std::stri
 		// form zmq::message_t
 		zmq::message_t message(messages.at(i).size());
 		memcpy(message.data(), messages.at(i).data(), messages.at(i).size());
-		//snprintf((char*)message.data(), messages.at(i).size()+1, "%s", messages.at(i).c_str());
 		
 		// send this part
 		bool send_ok = sock->send(message, ZMQ_SNDMORE);
@@ -865,7 +856,6 @@ bool ServicesBackend::Send(zmq::socket_t* sock, bool more, std::vector<std::stri
 	// form the zmq::message_t for the last part
 	zmq::message_t message(messages.back().size());
 	memcpy(message.data(), messages.back().data(), messages.back().size());
-	//snprintf((char*)message.data(), messages.back().size()+1, "%s", messages.back().c_str());
 	
 	// send it with, or without SNDMORE flag as requested
 	bool send_ok;
@@ -939,3 +929,30 @@ bool ServicesBackend::Receive(zmq::socket_t* sock, std::vector<zmq::message_t>&
 	return true;
 }
 
+bool ServicesBackend::Ready(int timeout){
+	
+	// poll the output sockets for listeners
+	// only poll dealer socket, pub sockets always return true immediately so ignore the timeout
+	// polling the input socket checks for a message, so don't do that.
+	int ret;
+	try {
+		dlr_socket_mutex.lock();
+		ret = zmq::poll(&out_polls.at(1), 1, timeout);
+		dlr_socket_mutex.unlock();
+	} catch (zmq::error_t& err){
+		std::cerr<<"ServicesBackend::Ready caught "<<err.what()<<std::endl;
+		return false;
+	}
+	if(ret<0){
+		// error polling - is the socket closed?
+		std::cerr<<"ServicesBackend::Ready error: "<<zmq_strerror(errno)<<std::endl;
+		return false;
+	} else if(ret==0){
+		// 'resource temoprarily unavailable' - no-one connected.
+	} else if(out_polls.at(1).revents & ZMQ_POLLOUT){
+		return true;
+	}
+	
+	return false;
+	
+}
diff --git a/src/ServiceDiscovery/ServicesBackend.h b/src/ServiceDiscovery/ServicesBackend.h
index a776dc9..116f548 100644
--- a/src/ServiceDiscovery/ServicesBackend.h
+++ b/src/ServiceDiscovery/ServicesBackend.h
@@ -27,7 +27,7 @@
 namespace ToolFramework {
 
 struct Command {
-	Command(std::string command_in, char cmd_type_in, std::string topic_in);
+	Command(std::string command_in, char cmd_type_in, std::string topic_in, const unsigned int timeout_ms_in);
 	
 	Command(const Command& cmd_in);  // copy constructor
 	Command(Command&& cmd_in);       // move constructor
@@ -41,6 +41,7 @@ struct Command {
 	uint32_t success;            // middleman treats this as BOOL: 1=success, 0=fail
 	std::string err;
 	uint32_t msg_id;
+	uint32_t timeout_ms;
 };
 
 
@@ -51,6 +52,7 @@ class ServicesBackend {
 	ServicesBackend(){};
 	~ServicesBackend(){};
 	void SetUp(zmq::context_t* in_context, std::function<void(std::string msg, int msg_verb, int verbosity)> log=nullptr); // possibly move to constructor
+	bool Ready(int timeout); // check if zmq sockets have connections
 	bool Initialise(std::string configfile);
 	bool Initialise(Store &varaibles_in);
 	bool Finalise();
@@ -101,7 +103,7 @@ class ServicesBackend {
 	bool InitMulticast(); // private
 	bool RegisterServices(); //private
 	// wrapper funtion; add command to outgoing queue, receive response. ~30s timeout.
-	bool DoCommand(Command cmd, std::promise<Command>); //private
+	bool DoCommand(Command& cmd, int timeout_ms); //private
 	// actual send/receive functions
 	bool SendNextCommand(); //private
 	bool GetNextResponse(); //priavte
@@ -206,6 +208,9 @@ class ServicesBackend {
 		if(ret<0){
 			// error polling - is the socket closed?
 			send_ok = -3;
+		} else if(ret==0){
+			// 'resource temporarily unavailable'...? no connections on this socket?
+			send_ok = -4;
 		} else if(poll.revents & ZMQ_POLLOUT){
 			bool success = Send(sock, false, std::forward<T>(message));
 			send_ok = success ? 0 : -1;
@@ -234,6 +239,9 @@ class ServicesBackend {
 		if(ret<0){
 			// error polling - is the socket closed?
 			send_ok = -3;
+		} else if(ret==0){
+			// 'resource temporarily unavailable'...? no connections on this socket?
+			send_ok = -4;
 		} else if(poll.revents & ZMQ_POLLOUT){
 			bool success = Send(sock, false, std::forward<T>(message), std::forward<Rest>(rest)...);
 			send_ok = success ? 0 : -1;