diff --git a/socket_channel.cpp b/socket_channel.cpp
new file mode 100644
index 0000000..4a6d827
--- /dev/null
+++ b/socket_channel.cpp
@@ -0,0 +1,156 @@
+#include "socket_channel.hpp"
+
+#include <errno.h>
+#include <netinet/in.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <unistd.h>
+
+#include <iostream>
+#include <string>
+
+namespace udpsocket
+{
+
+std::string Channel::getRemoteAddress() const
+{
+    char tmp[INET_ADDRSTRLEN] = { 0 };
+    inet_ntop(AF_INET, &address.inAddr.sin_addr, tmp, sizeof(tmp));
+    return std::string(tmp);
+}
+
+std::tuple<int, buffer> Channel::read()
+{
+    int rc = 0;
+    int readSize = 0;
+    ssize_t readDataLen = 0;
+    buffer outBuffer(0);
+
+    if (ioctl(sockfd, FIONREAD, &readSize) < 0)
+    {
+        std::cerr << "E> Channel::Read : ioctl failed with errno = " << errno;
+        rc = -errno;
+        return std::make_tuple(rc, std::move(outBuffer));
+    }
+
+    outBuffer.resize(readSize);
+    auto bufferSize = outBuffer.size();
+    auto outputPtr = outBuffer.data();
+
+    address.addrSize = sizeof(address.inAddr);
+
+    do
+    {
+        readDataLen = recvfrom(sockfd,               // File Descriptor
+                               outputPtr ,           // Buffer
+                               bufferSize,           // Bytes requested
+                               0,                    // Flags
+                               &address.sockAddr,    // Address
+                               &address.addrSize);   // Address Length
+
+        if (readDataLen > 0) // Data read from the socket
+        {
+            std::cout << "I> Channel::Read : DataIn Fd[" << sockfd << "] Req["
+                      << bufferSize << "] Recv[" << readDataLen << "]\n";
+        }
+        else if (readDataLen == 0) // Peer has performed an orderly shutdown
+        {
+            std::cerr << "E> Channel::Read : Connection Closed Fd[" << sockfd
+                      << "]\n";
+            outBuffer.resize(0);
+            rc = -1;
+        }
+        else if (readDataLen < 0) // Error
+        {
+            rc = -errno;
+            std::cerr << "E> Channel::Read : Receive Error Fd[" << sockfd << "]"
+                      << "errno = " << rc << "\n";
+            outBuffer.resize(0);
+        }
+    }
+    while ((readDataLen < 0) && (-(rc) == EINTR));
+
+    // Resize the vector to the actual data read from the socket
+    outBuffer.resize(readDataLen);
+    return std::make_tuple(rc, std::move(outBuffer));
+}
+
+int Channel::write(buffer& inBuffer)
+{
+    int rc = 0;
+    auto outputPtr = inBuffer.data();
+    auto bufferSize = inBuffer.size();
+    auto spuriousWakeup = false;
+    ssize_t writeDataLen = 0;
+    timeval varTimeout = timeout;
+
+    fd_set writeSet;
+    FD_ZERO(&writeSet);
+    FD_SET(sockfd, &writeSet);
+
+    do
+    {
+        spuriousWakeup = false;
+
+        rc = select((sockfd + 1), nullptr, &writeSet, NULL, &varTimeout);
+
+        if (rc > 0)
+        {
+            if (FD_ISSET(sockfd, &writeSet))
+            {
+                address.addrSize = sizeof(address.inAddr);
+                do
+                {
+                    writeDataLen = sendto(sockfd,           // File Descriptor
+                                          outputPtr,        // Message
+                                          bufferSize,       // Length
+                                          MSG_NOSIGNAL,     // Flags
+                                          &address.sockAddr,// Destination Address
+                                          address.addrSize);// Address Length
+
+                    if (writeDataLen < 0)
+                    {
+                        rc = -errno;
+                        std::cerr << "Channel::Write: Write failed with errno:"
+                                  << rc << "\n";
+                    }
+                    else if (static_cast<size_t>(writeDataLen) < bufferSize)
+                    {
+                        rc = -1;
+                        std::cerr << "Channel::Write: Complete data not written"
+                                  " to the socket\n";
+                    }
+                }
+                while ((writeDataLen < 0) && (-(rc) == EINTR));
+            }
+            else
+            {
+                // Spurious wake up
+                std::cerr << "E> Spurious wake up on select (writeset)\n";
+                spuriousWakeup = true;
+            }
+        }
+        else
+        {
+            if (rc == 0)
+            {
+                // Timed out
+                rc = -1;
+                std::cerr << "E> We timed out on select call (writeset)\n";
+            }
+            else
+            {
+                // Error
+                rc  = -errno;
+                std::cerr << "E> select call (writeset) had an error : "
+                          << rc << "\n";
+            }
+
+        }
+    }
+    while (spuriousWakeup);
+
+    return rc;
+}
+
+} // namespace udpsocket
diff --git a/socket_channel.hpp b/socket_channel.hpp
new file mode 100644
index 0000000..de95bfd
--- /dev/null
+++ b/socket_channel.hpp
@@ -0,0 +1,124 @@
+#pragma once
+
+#include <arpa/inet.h>
+#include <unistd.h>
+
+#include <string>
+#include <tuple>
+#include <vector>
+
+namespace udpsocket
+{
+
+using buffer = std::vector<uint8_t>;
+/** @class Channel
+ *
+ *  @brief Provides encapsulation for UDP socket operations like Read, Peek,
+ *         Write, Remote peer's IP Address and Port.
+ */
+class Channel
+{
+    public:
+        struct SockAddr_t
+        {
+            union
+            {
+                sockaddr sockAddr;
+                sockaddr_in inAddr;
+            };
+            size_t addrSize;
+        };
+
+        /**
+         * @brief Constructor
+         *
+         * Initialize the IPMI socket object with the socket descriptor
+         *
+         * @param [in] File Descriptor for the socket
+         * @param [in] Timeout parameter for the select call
+         *
+         * @return None
+         */
+        Channel(int insockfd, timeval& inTimeout)
+        {
+            sockfd = insockfd;
+            timeout = inTimeout;
+        }
+
+        /**
+         * @brief Fetch the IP address of the remote peer
+         *
+         * Returns the IP address of the remote peer which is connected to this
+         * socket
+         *
+         * @return IP address of the remote peer
+         */
+        std::string getRemoteAddress() const;
+
+        /**
+         * @brief Fetch the port number of the remote peer
+         *
+         * Returns the port number of the remote peer
+         *
+         * @return Port number
+         *
+         */
+        auto getPort() const
+        {
+            return address.inAddr.sin_port;
+        }
+
+        /**
+         * @brief Read the incoming packet
+         *
+         * Reads the data available on the socket
+         *
+         * @return A tuple with return code and vector with the buffer
+         *         In case of success, the vector is populated with the data
+         *         available on the socket and return code is 0.
+         *         In case of error, the return code is < 0 and vector is set
+         *         to size 0.
+         */
+        std::tuple<int, buffer> read();
+
+        /**
+         *  @brief Write the outgoing packet
+         *
+         *  Writes the data in the vector to the socket
+         *
+         *  @param [in] inBuffer
+         *      The vector would be the buffer of data to write to the socket.
+         *
+         *  @return In case of success the return code is 0 and return code is
+         *          < 0 in case of failure.
+         */
+        int write(buffer& inBuffer);
+
+        /**
+         * @brief Returns file descriptor for the socket
+         */
+        auto getHandle(void) const
+        {
+            return sockfd;
+        }
+
+        ~Channel() = default;
+        Channel(const Channel& right) = delete;
+        Channel& operator=(const Channel& right) = delete;
+        Channel(Channel&&) = default;
+        Channel& operator=(Channel&&) = default;
+
+    private:
+        /*
+         * The socket descriptor is the UDP server socket for the IPMI port.
+         * The same socket descriptor is used for multiple ipmi clients and the
+         * life of the descriptor is lifetime of the net-ipmid server. So we
+         * do not need to close the socket descriptor in the cleanup of the
+         * udpsocket class.
+         */
+        int sockfd;
+        SockAddr_t address;
+        timeval timeout;
+};
+
+} // namespace udpsocket