wip

src/resolver/Server.cpp

@@ -1,53 +1,26 @@
 #include "Server.hpp"
 #include "Message.hpp"
-#include <fstream>
 
 #include <memory>
 #include <utility>
 #include <vector>
 #include <ctime>
 
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <unistd.h>
+
+//Testing:
+#include <iostream>
+#include <fstream>
+
 
 namespace Plains {
 namespace Resolver {
 
-using asio::ip::udp;
+//using asio::ip::udp;
-using asio::ip::tcp;
+//using asio::ip::tcp;
-
-static char* byteToHex(char c) {
-    static char* out = new char[3];
-    out[2] = 0x0; //Terminate string
-    const char* dict = "0123456789ABCDEF";
-    char left  = c & 0xF; //Mask upper 4 bits on the right
-    char right = c >> 4;
-    out[0] = dict[right];
-    out[1] = dict[left];
-    return out;
-}
-
-static char* intToHex(unsigned byteCount, int c) {
-    //static char* out = new char[byteCount*3+1];
-    static char* out = new char[32];
-    const char* byte = (char*)&c;
-
-    //printf("%x\n", c);
-    //printf("%x\n", byte[0] & 0xFF);
-    //printf("%x\n", byte[1] & 0xFF);
-    
-
-    out[byteCount*3] = 0x0; //Terminate string
-    //out[4] = 0xE; //Terminate string
-    for (unsigned i = 0; i < byteCount; i++) {
-        //std::cout << "i(" << i << ") ";
-        //char byte = (c >> (i*8)) & 0xFF;
-        const char* nibble = byteToHex(byte[i]);
-        out[i*3]     = nibble[0];
-        out[i*3+1]   = nibble[1];
-        out[i*3+2]   = ' ';
-        //std::cout <<  "Char1(" << out[0] << ") Char2(" << out[1] << ") Char3(" << out[2] << ")" << std::endl;
-    }
-    return out;
-}
 
 Server::Server(Logger& logger, EventBus& eventBus)
   : _logger(logger),
@@ -55,11 +28,13 @@ Server::Server(Logger& logger, EventBus& eventBus)
 {
     _logger.debug.ln ("Starting Resolver...");
     //throw Exception("Testi");
-/*
+    /*
     _logger.debug << "Testing some stuff..." << Logger::commit;
     _logger.debug << "Message header overall size: " << sizeof(Message::Header) << Logger::commit;
-//    _logger.debug << "Message::Header size:" << sizeof(Message::Header) << endl;
+    _logger.debug << "Message::Header size:" << sizeof(Message::Header) << endl;
-//    _logger.debug << "Message::QR:RESPONSE Enum:" << Message::QR::RESPONSE << endl;
+    _logger.debug << "Message::QR:RESPONSE Enum:" << Message::QR::RESPONSE << endl;
+
+    std::cerr << std::hex << 0xABCDEF
 
     std::fstream myfile;
     std::streampos beg,end;
@@ -90,24 +65,65 @@ Server::Server(Logger& logger, EventBus& eventBus)
     myfile.close();
     //Testing over
     _logger.debug << "Done testing" << Logger::commit;
-*/
+
     _udpSocket = new udp::socket(_ioContext, udp::endpoint(udp::v4(), 8853));
     _ioContext.run();
     doReceive();
+    */
+    _thread = thread(&Server::run, this);
     _logger.debug.ln ("Resolver started");
 }
 
 Server::~Server() {
     _logger.debug.ln ("Stopping Resolver...");
-    _udpSocket->close();
+    //_udpSocket->close();
+   _thread.join();
     _logger.debug.ln ("Resolver stopped");
 }
 
-//void Server::run() {
+void Server::run() {
 //    _ioContext.run();
 //    doReceive();
-//}
+    _logger.warn.ln ("Hi From resolver thread!");
+    char msg[] = "Hello to you too!!!\n";
 
+    //creating a new server socket
+    if ((_serSockDes = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
+        perror("socket creation error...\n");
+        exit(-1);
+    }
+
+    //binding the port to ip and port
+    _serAddr.sin_family = AF_INET;
+    _serAddr.sin_port = htons(PORT);
+    _serAddr.sin_addr.s_addr = INADDR_ANY;
+
+    if ((bind(_serSockDes, (struct sockaddr*)&_serAddr, sizeof(_serAddr))) < 0) {
+        perror("binding error...\n");
+        close(_serSockDes);
+        exit(-1);
+    }
+
+    _cliAddrLen = sizeof(_cliAddr);
+    _readStatus = recvfrom(_serSockDes, _buff, 1024, 0, (struct sockaddr*)&_cliAddr, &_cliAddrLen);
+    if (_readStatus < 0) { 
+        perror("reading error...\n");
+        close(_serSockDes);
+        exit(-1);
+    }
+
+    std::cout.write(_buff, _readStatus);
+
+    if ( sendto(_serSockDes, msg, strlen(msg), 0, (struct sockaddr*)&_cliAddr, _cliAddrLen) < 0 ) { 
+        _logger.debug.ln("sending error...\n");
+        close(_serSockDes);
+        exit(-1);
+    }
+
+    close(_serSockDes);
+}
+
+/*
 void Server::doReceive()
 {
     _udpSocket->async_receive_from(
@@ -127,12 +143,12 @@ void Server::doSend(std::size_t length)
 {
     _udpSocket->async_send_to (
         asio::buffer(_data, length), _sender_endpoint,
-        [this](std::error_code /*ec*/, std::size_t /*_bytessent*/)
+        [this](std::error_code, std::size_t)
     {
         doReceive();
     });
 }
-
+*/
 
 
 

src/resolver/include/Server.hpp

@@ -2,6 +2,7 @@
 #define SERVER_HPP
 #include "asio.hpp"
 #include "Core.hpp"
+#include <thread>
 //#include <cstdlib>
 
 
@@ -11,25 +12,35 @@ namespace Resolver {
 using Core::EventBus;
 using Core::Logger;
 using Core::Exception;
+using std::thread;
+
+#define PORT 5353
+
 
 
 class Server
 {
-    private:
-    EventBus& _eventBus;
-    Logger& _logger;
-    asio::io_context _ioContext;
-    asio::ip::udp::socket* _udpSocket;
-    asio::ip::udp::endpoint _sender_endpoint;
-    char _data[1024];
-
-    void doReceive();
-    void doSend(std::size_t length);
-
     public:
     Server(Logger& logger, EventBus& eventBus);
     ~Server();
-    //void run();
+
+    private:
+    EventBus& _eventBus;
+    Logger& _logger;
+    //asio::io_context _ioContext;
+    //asio::ip::udp::socket* _udpSocket;
+    //asio::ip::udp::endpoint _sender_endpoint;
+    //char _data[1024];
+    char _buff[1024] = {0};
+    int _serSockDes, _readStatus;
+    struct sockaddr_in _serAddr, _cliAddr;
+    socklen_t _cliAddrLen;
+    thread _thread;
+
+    private:
+    //void doReceive();
+    //void doSend(std::size_t length);
+    void run();
 };