first version of InternalUDPService

src/WHISPER/InternalUDPService.cpp

@@ -0,0 +1,167 @@
+
+
+#include "WHISPER/InternalUDPService.hpp"
+#include "WHISPER/Messages/Message.hpp"
+#include "WHISPER/whisper.hpp"
+#include "zmq.hpp"
+#include <chrono>
+#include <memory>
+#include <string>
+#include <string_view>
+#include <unistd.h>
+#include <utility>
+#include <sys/socket.h>
+#include <netinet/in.h>
+
+
+namespace WHISPER {
+
+   
+    InternalUDPService::InternalUDPService(std::uint32_t id, SourceType owndevicetype,std::uint16_t port, std::string address):
+    whispercomm(id, owndevicetype),port_(port),address_(address)
+    {
+        ctx = zmq::context_t(2);
+        sender = zmq::socket_t(ctx,zmq::socket_type::radio);
+        receiver = std::make_shared<zmq::socket_t>(ctx,zmq::socket_type::dish);
+        // receiver = zmq::socket_t(ctx,zmq::socket_type::dish);
+        LOG_S(INFO)<< "sockets are created";
+    }
+
+    void InternalUDPService::derivedConnect()
+    {
+        ownReceivingPort_ = checkPort(port_);
+        LOG_S(INFO)<< "could bind to port:" << ownReceivingPort_;
+
+       
+        if(ownReceivingPort_ == port_){
+            std::string portAsString = std::to_string(ownReceivingPort_);
+            receiver->bind("udp://*:"+portAsString);
+        }else if (ownReceivingPort_ == 0) {
+            throw std::invalid_argument( " receiver cant bind to port " );            
+        }else {
+            std::string portAsString = std::to_string(ownReceivingPort_);
+            receiver->bind("udp://*:"+portAsString);
+        }
+        
+        receiver->join("management");
+
+
+        std::string sendingPort = std::to_string(port_);
+        LOG_S(INFO)<< sendingPort;
+
+        sender.connect("udp://"+address_+":"+sendingPort);
+    }
+    
+
+    void InternalUDPService::derivedDisconnect() 
+    {
+        sender.close();
+        receiver->close();
+    }
+    void InternalUDPService::derivedPublish(std::string msg,std::string topic) 
+    {
+        zmq::message_t tmpmsg(msg.size());
+        memcpy (tmpmsg.data (), msg.data(), msg.size());
+         const char *tmp = topic.c_str();    
+        tmpmsg.set_group(topic.c_str());
+        sender.send(tmpmsg,zmq::send_flags::none);
+
+    }
+    void InternalUDPService::derivedReceive() 
+    {
+        
+        LOG_S(INFO)<<"zmq receiving funk";
+        zmq::message_t msg;
+
+        
+        receiver->recv(msg,zmq::recv_flags::none);
+        // LOG_S(INFO)<<result.value();
+        std::string data;
+        memcpy (data.data (), msg.data(), msg.size());          
+        addMsgToReceiverQueue(WHISPER::Message(data));
+
+        
+    }
+
+    void InternalUDPService::derivedSubscribe(std::string topic)
+    {
+        // receiver.join(topic.c_str());
+    }
+    void InternalUDPService::derivedUnsubscribe(std::string topic)
+    {
+        // receiver.leave(topic.c_str());
+    }
+
+    std::uint16_t InternalUDPService::checkPort(std::uint16_t port)
+    {
+        std::uint16_t localPort = port;
+
+        struct sockaddr_in local;
+        socklen_t localLen;
+        int sockfd; 
+        // Creating socket file descriptor 
+        if ( (sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0 ) { 
+            perror("socket creation failed"); 
+            exit(EXIT_FAILURE); 
+        } 
+
+        local.sin_family    = AF_INET; // IPv4 
+        local.sin_addr.s_addr = INADDR_ANY; 
+        local.sin_port = htons(port); 
+        int err = bind(sockfd, (const struct sockaddr *)&local, sizeof(local));
+        
+    
+
+        if (err == -1 && errno == EADDRINUSE)
+        {
+        // no we are not a gateway
+        setGateway(false);
+
+        // set port to auto on binding
+        local.sin_port = 0;
+        err = bind(sockfd, (const struct sockaddr *) &local, sizeof(local));
+
+    
+        if(err == -1)
+        {
+            throw std::runtime_error(std::string(__PRETTY_FUNCTION__) + std::string("could not bind port to socket "));
+        }
+
+        // if we could bind to a port we have to get the port value from the socket
+        memset((char *) &local, 0, sizeof(local));
+        localLen=sizeof(local);
+        err=getsockname(sockfd, (struct sockaddr *) &local, &localLen);
+        if(err == -1)
+        {
+            throw std::runtime_error(std::string(__PRETTY_FUNCTION__) + std::string("could not get port nr errno=") + std::to_string(errno));
+        }
+
+        //sometime getsock return port 0, i do not know why yet (dmeyer)
+        //therefore i check for port 0 and try again
+        localPort=ntohs(local.sin_port);
+        if (localPort==0)
+        {
+            err=getsockname(sockfd, (struct sockaddr *) &local, &localLen);
+            if(err == -1)
+            {
+            throw std::runtime_error(std::string(__PRETTY_FUNCTION__) + std::string("could not get port nr "));
+            }
+            localPort=ntohs(local.sin_port);
+        }
+        }
+        else if(err == -1)
+        {
+        throw std::runtime_error(std::string(__PRETTY_FUNCTION__) + std::string("could not bind port to socket"));
+        }
+
+
+        close(sockfd); 
+        
+        
+        return localPort;
+    }
+
+
+
+
+}