Completely rewrote Server class, and split the class into header and implementation

server.cpp

@@ -0,0 +1,69 @@
+#include <sys/socket.h>
+#include <fcntl.h>
+#include "includes/sock.hpp"
+#include "includes/server.hpp"
+#include "includes/exception_consts.hpp"
+#include "includes/easysock.hpp"
+
+/* Destructor - closes any open sockets */
+Server::~Server() {
+	close(this->other_socket);
+	close(this->sock_fd);
+}
+
+/* Sends given data through the peer socket - This method is overriden from the
+base method, because a different socket must be used. In the server's case, the
+'peer' socket i.e. the socket returned after calling 'accept', must be used. */
+
+void Server::sendAll(std::string to_send) {
+	Sock::sendAll(to_send, this->other_socket);
+}
+
+/* Receives data from socket, and returns it. This function works differently
+based on the Transport layer protocol used. For TCP, it calls the parent method
+with the peer socket. As mentioned above, this is the socket returned after
+calling the accept function. With UDP, there is no concept of a peer socket, and
+so the regular server socket (the one created in create_socket() ) is used
+instead. */
+
+std::string Server::recvAll() {
+	if (this->protocol == 'T') {
+		return Sock::recvAll(this->other_socket);
+	} else {
+		return Sock::recvAll(this->sock_fd);
+	}
+}
+
+/* FOR TCP ONLY - Waits for a peer to connect to the server socket. It stores
+the return value of the accept() function i.e. the peer socket. This method does
+nothing if your server socket is a UDP socket. If the accept function fails, the errno
+is thrown as an exception. */
+
+void Server::wait_for_peer() {
+	if (this->protocol == 'T') {
+		this->other_socket = accept(this->sock_fd, NULL, NULL);
+		if (this->other_socket < 0) {
+			throw errno;
+		}
+	}
+}
+
+/* Creates a server socket. This method extends the parent method, and should be
+called immediately after the constructor. If the socket is TCP, it also sets the
+socket to listen for incoming connections. This function throws an exception if
+the socket could not be created. The excpetion is an integer corresponding to the errno
+of the failing function, and enables the caller to print a corresponding error message by
+'catching' the thrown exception and using strerror(). */
+
+void Server::create_socket() {
+	Sock::create_socket();
+        this->sock_fd = create_local(this->ip_ver, this->protocol, this->address.data(), this->port, dest);
+	if (this->sock_fd < 0) {
+		throw (this->sock_fd * -1);
+	}
+	if (protocol == 'T') {
+		listen(sock_fd, 10);
+	}
+}
+
+