WRITING A C++ SERVER AND CLIENT SOCKET

-

 

Setting Up the Server

Step 1: Initialize Winsock

In the server, the first step is to initialize the Winsock library. This involves loading the DLL and setting up the necessary variables. The following code demonstrates how to achieve this:

#include <iostream>
#include <winsock2.h>
int main() {
    // Initialize WSA variables
    WSADATA wsaData;
    int wsaerr;
    WORD wVersionRequested = MAKEWORD(2, 2);
    wsaerr = WSAStartup(wVersionRequested, &wsaData);
    // Check for initialization success
    if (wsaerr != 0) {
        std::cout << "The Winsock dll not found!" << std::endl;
        return 0;
    } else {
        std::cout << "The Winsock dll found" << std::endl;
        std::cout << "The status: " << wsaData.szSystemStatus << std::endl;
    }
        
    return 0;
}

Step 2: Create a Socket

Next, we create a socket to handle communication. The socket() function is used for this purpose. It allows us to specify the address family, socket type, and protocol. In our case, we are creating a TCP socket:

// Create a socket
SOCKET serverSocket;
serverSocket = INVALID_SOCKET;
serverSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
// Check for socket creation success
if (serverSocket == INVALID_SOCKET) {
    std::cout << "Error at socket(): " << WSAGetLastError() << std::endl;
    WSACleanup();
    return 0;
} else {
    std::cout << "Socket is OK!" << std::endl;
}

Step 3: Bind the Socket

Now, we bind the socket to a specific IP address and port number. This is crucial for the server to listen for incoming connections:

// Bind the socket to an IP address and port number
sockaddr_in service;
service.sin_family = AF_INET;
service.sin_addr.s_addr = inet_addr("127.0.0.1");  // Replace with your desired IP address
service.sin_port = htons(55555);  // Choose a port number
// Use the bind function
if (bind(serverSocket, reinterpret_cast<SOCKADDR*>(&service), sizeof(service)) == SOCKET_ERROR) {
    std::cout << "bind() failed: " << WSAGetLastError() << std::endl;
    closesocket(serverSocket);
    WSACleanup();
    return 0;
} else {
    std::cout << "bind() is OK!" << std::endl;
}

Step 4: Listen for Connections

Now, we make the server listen for incoming connections using the listen() function:

// Listen for incoming connections
if (listen(serverSocket, 1) == SOCKET_ERROR) {
    std::cout << "listen(): Error listening on socket: " << WSAGetLastError() << std::endl;
} else {
    std::cout << "listen() is OK! I'm waiting for new connections..." << std::endl;
}

Step 5: Accept Connections

When a client attempts to connect, the server uses the accept() function to accept the incoming connection:

// Accept incoming connections
SOCKET acceptSocket;
acceptSocket = accept(serverSocket, nullptr, nullptr);
// Check for successful connection
if (acceptSocket == INVALID_SOCKET) {
    std::cout << "accept failed: " << WSAGetLastError() << std::endl;
    WSACleanup();
    return -1;
} else {
    std::cout << "accept() is OK!" << std::endl;
}

Step 6: Receive and Send Data

Now that the server is set up and connected to a client, it can send and receive data. The following code demonstrates receiving data and sending a response:

// Receive data from the client
char receiveBuffer[200];
int rbyteCount = recv(acceptSocket, receiveBuffer, 200, 0);
if (rbyteCount < 0) {
    std::cout << "Server recv error: " << WSAGetLastError() << std::endl;
    return 0;
} else {
    std::cout << "Received data: " << receiveBuffer << std::endl;
}
// Send a response to the client
char buffer[200];
std::cout << "Enter the message: ";
std::cin.getline(buffer, 200);
int sbyteCount = send(acceptSocket, buffer, 200, 0);
if (sbyteCount == SOCKET_ERROR) {
    std::cout << "Server send error: " << WSAGetLastError() << std::endl;
    return -1;
} else {
    std::cout << "Server: Sent " << sbyteCount << " bytes" << std::endl;
}

Creating the Client

Now that we have our server code, let’s set up a simple client to connect to the server and exchange messages.

Step 1: Initialize Winsock and Create a Socket

This step is similar to what we did in the server. Initialize Winsock and create a socket:

#include <iostream>
#include <winsock2.h>
int main() {
    // Initialize WSA variables
    WSADATA wsaData;
    int wserr;
    WORD wVersionRequested = MAKEWORD(2, 2);
    wserr = WSAStartup(wVersionRequested, &wsaData);
    // Check for initialization success
    if (wsaerr != 0) {
        std::cout << "The winsock dll not found" << std::endl;
        return 0;
    } else {
        std::cout << "The Winsock dll found" << std::endl;
        std::cout << "The status: " << wsaData.szSystemStatus << std::endl;
    }
    // Create a socket
    SOCKET clientSocket;
    clientSocket = INVALID_SOCKET;
    clientSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    // Check for socket creation success
    if (clientSocket == INVALID_SOCKET) {
        std::cout << "Error at socket(): " << WSAGetLastError() << std::endl;
        WSACleanup();
        return 0;
    } else {
        std::cout << "Socket is OK!" << std::endl;
    }
    // Continue with the client setup...
    // (See the full code here: https://github.com/Tharun8951/cpp-tcp-server/")
    return 0;
}

Step 2: Connect to the Server

Connect the client to the server using the connect() function:

// Connect to the server
sockaddr_in clientService;
clientService.sin_family = AF_INET;
clientService.sin_addr.s_addr = inet_addr("127.0.0.1");  // Replace with the server's IP address
clientService.sin_port = htons(55555);  // Use the same port as the server
// Use the connect function
if (connect(clientSocket, reinterpret_cast<SOCKADDR*>(&clientService), sizeof(clientService)) == SOCKET_ERROR) {
    std::cout << "Client: connect() - Failed to connect: " << WSAGetLastError() << std::endl;
    WSACleanup();
    return 0;
} else {
    std::cout << "Client: Connect() is OK!" << std::endl;
    std::cout << "Client: Can start sending and receiving data..." << std::endl;
}

Step 3: Send and Receive Data

Similar to the server, the client can now send and receive data:

// Sending data to the server
char buffer[200];
std::cout << "Enter the message: ";
std::cin.getline(buffer, 200);
int sbyteCount = send(clientSocket, buffer, 200, 0);
if (sbyteCount == SOCKET_ERROR) {
    std::cout << "Client send error: " << WSAGetLastError() << std::endl;
    return -1;
} else {
    std::cout << "Client: Sent " << sbyteCount << " bytes" << std::endl;
}
// Receiving data from the server
char receiveBuffer[200];
int rbyteCount = recv(clientSocket, receiveBuffer, 200, 0);
if (rbyteCount < 0) {
    std::cout << "Client recv error: " << WSAGetLastError() << std::endl;
    return 0;
} else {
    std::cout << "Client: Received data: " << receiveBuffer << std::endl;
}
// Continue with the client setup...


Ever thought about the security breaches that go unnoticed, those the happen and the lowest level in the computer world(rootkits with enhanced virus abilities), those the happen within the architectural realms of a machine, welcome aboard. On this channel you will learn everything about that from rootkits/ anti-rootkit technologies,viruses/ anti-viruses technologies,spyware/anti-spyware technologies, Architecture-assembly programming, Architecture-OS internals, kernel and driver programming, firmware security and many more.

Comments

Post a Comment

Check out our works

WINDOWS SYSTEM PROGRAMMING WITH C/C++

-
  Windows System Architecture History Windows was originally a 16-bit graphical layer for MS-DOS that was written by Microsoft.As it grew, it gained the ability to handle 32-bit programs and eventually became totally 32-bit when Windows NT and 2000 came out. After Windows 95, Microsoft began to remove dependencies on DOS and finally fully implemented the separation in Windows 2000. Windows has many advanced features as well as many platform specific problems. It possesses an Application Programming Interface that consists of thousands of mostly undocumented GUI functions as well as having varying degrees of MS-DOS compatibility. Additionally, with the advent of NT (New Technology), Windows relies completely on the NT kernel instead of its MS-DOS subsystem, the NT kernel is capable of emulating the necessary DOS functionality. In addition to the NT kernel, Microsoft has also introduced many API wrappers, such as the MFCs (Microsoft Foundation Classes), COM (Component Object Model), an...
Read more

PYTHON PROGRAMMING IN AND OUT

-
Image
PYTHON FOR ALL   Python is a high-level, interpreted, interactive and object-oriented scripting language. Python is designed to be highly readable. It uses English keywords frequently where as other languages use punctuation, and it has fewer syntactical constructions than other languages. Python is Interpreted − Python is processed at runtime by the interpreter. You do not need to compile your program before executing it. This is similar to PERL and PHP. Python is Interactive − You can actually sit at a Python prompt and interact with the interpreter directly to write your programs. Python is Object-Oriented − Python supports Object-Oriented style or technique of programming that encapsulates code within objects. Python is a Beginner's Language − Python is a great language for the beginner-level programmers and supports the development of a wide range of applications from simple text processing to WWW browsers to games. Python is an open-source and cross-platform pro...
Read more

Creating a Reverse Shell in Python

-
lntroduction There are many ways to gain control over a compromised system. A common practice is to gain interactive shell access, which enables you to try to gain complete control of the operating system. However, most basic firewalls block direct remote connections. One of the methods to bypass this is to use reverse shells. A reverse shell is a program that executes local cmd.exe (for Windows) or bash/zsh (for Unix-like) commands and sends the output to a remote machine. With a reverse shell, the target machine initiates the connection to the attacker machine, and the attacker's machine listens for incoming connections on a specified port; this will bypass firewalls. The basic idea of the code we will implement is that the attacker's machine will keep listening for connections. Once a client (or target machine) connects, the server will send shell commands to the target machine and expect output results.  full code on github:https://github.com/theKlaytonLabs...
Read more

Network programming in python with examples

-
GETING A HOST NAME >>> import socket >>> host_name = socket.gethostname() >>> print ("Host name: %s" %host_name) >>> print ("IP address: %s",host_name) GETTING A HOST NAME WITH A FUNCTION DEFINITION import socket def print_machine_info():      host_name = socket.gethostname()      ip_address = socket.gethostbyname(host_name)      print ("Host name: " ,host_name)      print ("IP address: " ,ip_address) if __name__ == '__main__':      print_machine_info() The hostname is what you assigned to your computer when you configured your operating system. This output will be different on your machine depending on the system's host configuration. Here hostname indicates where the Python interpreter is currently executing. Retrieving a remote machine's IP address If you need to know the IP address of a remote machine, you can use a built-in library function, gethostbyname(). In this c...
Read more