Networking in C++

Introduction to Networking in C++

Networking is a crucial aspect of many software applications, and being able to implement networking functionality in C++ is a valuable skill for any programmer. In this lesson, we will provide an overview of networking concepts in C++ and cover the basics of creating networked applications.

C++ provides a rich set of libraries and functions for networking, allowing developers to build robust and efficient networked applications. Whether you are working on a client-server application, a distributed system, or any other networked software, understanding the fundamentals of networking in C++ is essential.

Topics Covered in this Lesson

• TCP/IP and UDP protocols
• Sockets and socket programming
• Client-server architecture
• Sending and receiving data over a network
• Error handling and exception handling in networking

To start exploring networking in C++, let's take a look at a simple example to create a basic networking application:

#include <iostream>

int main() {
  // Networking code here
  std::cout << "Networking in C++" << std::endl;
  return 0;
}

In this example, we include the necessary header files and create a simple main function. Inside the main function, we can write the networking code specific to our application.

Before we dive deeper into networking concepts and implementation in C++, it is important to have a basic understanding of C++ programming and concepts such as functions, variables, and control flow. If you are new to C++, make sure to familiarize yourself with these fundamental concepts before diving into networking.

```c++
#include <iostream>

int main() {
  // Networking code here
  std::cout << "Networking in C++" << std::endl;
  return 0;
}
```

Networking in C++ is the process of _______________ between two or more computers over a network connection. In C++, this can be accomplished using ______ and ____. A _______ is a communication endpoint that allows computers to send and receive data over the network. And a ___________ is a unique identifier that helps identify a specific machine on the network. Networking in C++ enables the development of distributed applications, client-server architectures, and many other networked software solutions.

In networking, a socket is an endpoint for sending or receiving data across a computer network. It provides a connection-oriented and reliable communication channel between two applications running on different machines.

To create a socket in C++, you will need to use the socket() function from the <sys/socket.h> header. Here's an example of how to create a socket:

#include <iostream>
#include <sys/socket.h>

int main() {
  int sockfd;

  // Create a socket
  sockfd = socket(AF_INET, SOCK_STREAM, 0);

  if (sockfd == -1) {
    std::cout << "Failed to create socket" << std::endl;
    return 1;
  }

  std::cout << "Socket created successfully" << std::endl;

  return 0;
}

In this example, we include the necessary header file <sys/socket.h> and define an integer variable sockfd to hold the socket descriptor. We then call the socket() function, passing in the address family (AF_INET) for IPv4, the socket type (SOCK_STREAM) for TCP, and the protocol value (0) to let the system choose the appropriate protocol.

If the socket() function returns a value of -1, it indicates that an error occurred during socket creation. Otherwise, the socket is created successfully, and we can proceed with further network operations.

Creating a socket is the first step in building networked applications. Understanding the fundamentals of socket creation in C++ is crucial for implementing various networking functionalities.

```c++
#include <iostream>
#include <sys/socket.h>

int main() {
  int sockfd;

  // Create a socket
  sockfd = socket(AF_INET, SOCK_STREAM, 0);

  if (sockfd == -1) {
    std::cout << "Failed to create socket" << std::endl;
    return 1;
  }

  std::cout << "Socket created successfully" << std::endl;

  return 0;
}
```

To create a socket in C++, you will need to use the ___________() function from the <sys/socket.h> header. Here's an example of how to create a socket:

#include <iostream>
#include <sys/socket.h>

int main() {
  int sockfd;

  // Create a socket
  sockfd = _______;

  if (sockfd == -1) {
    std::cout << "Failed to create socket" << std::endl;
    return 1;
  }

  std::cout << "Socket created successfully" << std::endl;

  return 0;
}

When creating a network application, you often need to bind a socket to a specific address and port. Binding a socket means associating a network address and port with the socket so that it can listen for incoming connections or send data to a specific destination.

To bind a socket in C++, you will use the bind() function from the <sys/socket.h> header. Here's an example of how to bind a socket:

#include <iostream>
#include <sys/socket.h>
#include <netinet/in.h>

int main() {
  int sockfd;
  struct sockaddr_in serverAddr;

  // Create a socket
  sockfd = socket(AF_INET, SOCK_STREAM, 0);

  if (sockfd == -1) {
    std::cout << "Failed to create socket" << std::endl;
    return 1;
  }

  // Set up the server address
  serverAddr.sin_family = AF_INET;
  serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);
  serverAddr.sin_port = htons(8080);

  // Bind the socket
  int bindResult = bind(sockfd, (struct sockaddr*)&serverAddr, sizeof(serverAddr));

  if (bindResult == -1) {
    std::cout << "Failed to bind socket" << std::endl;
    return 1;
  }

  std::cout << "Socket bound successfully" << std::endl;

  return 0;
}

In this example, we include the necessary header files <sys/socket.h> and <netinet/in.h>. We define an integer variable sockfd to hold the socket descriptor and a sockaddr_in struct variable serverAddr to hold the server address information.

We then call the socket() function to create a socket, specifying the address family (AF_INET) for IPv4 and the socket type (SOCK_STREAM) for TCP.

Next, we set up the server address by setting the sin_family field to AF_INET, the sin_addr.s_addr field to htonl(INADDR_ANY) to bind the socket to any available network interface, and the sin_port field to the desired port number.

Finally, we call the bind() function to bind the socket to the specified address and port. If the bind() function returns a value of -1, it indicates that an error occurred during socket binding.

Binding a socket is a crucial step in creating a networked application. It allows the application to listen for incoming connections or send data to a specific destination. Understanding how to bind a socket in C++ is essential for building networking functionalities for your applications.

Which function is used to bind a socket in C++?

To make a socket listen for incoming connections, you need to perform a few steps:

1. Create a socket using the socket() function from the <sys/socket.h> header. You specify the address family as AF_INET, the socket type as SOCK_STREAM for TCP, and set the protocol as 0.

   int sockfd;
   sockfd = socket(AF_INET, SOCK_STREAM, 0);

1. Set up the server address using the sockaddr_in structure. This structure contains fields such as sin_family for the address family, sin_addr.s_addr for the IP address, and sin_port for the port number. In this example, we set the sin_addr.s_addr to htonl(INADDR_ANY) to bind the socket to any available network interface, and we set the sin_port to the desired port number.

   struct sockaddr_in serverAddr;
   serverAddr.sin_family = AF_INET;
   serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);
   serverAddr.sin_port = htons(8080);

1. Bind the socket to the server address using the bind() function. This associates the socket with the specified address and port.

   int bindResult = bind(sockfd, (struct sockaddr*)&serverAddr, sizeof(serverAddr));

1. Finally, you can make the socket listen for incoming connections using the listen() function. You pass the socket descriptor and specify the maximum number of connections that can be queued using the second parameter. In this example, we set the maximum queue size to 10.

   int listenResult = listen(sockfd, 10);

If any errors occur during these steps, you can check the return values of the relevant functions to handle them accordingly.

Once the socket is listening for connections, you can then accept incoming connections using the accept() function. This allows you to establish a connection with a client and start sending and receiving data.

Remember to close the socket when you're done with it by calling the close() function!

Here's an example code that demonstrates how to make a socket listen for connections:

#include <iostream>
#include <sys/socket.h>
#include <netinet/in.h>

int main() {
  int sockfd;
  struct sockaddr_in serverAddr;

  // Create a socket
  sockfd = socket(AF_INET, SOCK_STREAM, 0);

  if (sockfd == -1) {
    std::cout << "Failed to create socket" << std::endl;
    return 1;
  }

  // Set up the server address
  serverAddr.sin_family = AF_INET;
  serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);
  serverAddr.sin_port = htons(8080);

  // Bind the socket
  int bindResult = bind(sockfd, (struct sockaddr*)&serverAddr, sizeof(serverAddr));

  if (bindResult == -1) {
    std::cout << "Failed to bind socket" << std::endl;
    return 1;
  }

  // Listen for connections
  int listenResult = listen(sockfd, 10);

  if (listenResult == -1) {
    std::cout << "Failed to listen for connections" << std::endl;
    return 1;
  }

  std::cout << "Socket is now listening for connections" << std::endl;

  return 0;
}

```c++
#include <iostream>
#include <sys/socket.h>
#include <netinet/in.h>

int main() {
  int sockfd;
  struct sockaddr_in serverAddr;

  // Create a socket
  sockfd = socket(AF_INET, SOCK_STREAM, 0);

  if (sockfd == -1) {
    std::cout << "Failed to create socket" << std::endl;
    return 1;
  }

  // Set up the server address
  serverAddr.sin_family = AF_INET;
  serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);
  serverAddr.sin_port = htons(8080);

  // Bind the socket
  int bindResult = bind(sockfd, (struct sockaddr*)&serverAddr, sizeof(serverAddr));

  if (bindResult == -1) {
    std::cout << "Failed to bind socket" << std::endl;
    return 1;
  }

  // Listen for connections
  int listenResult = listen(sockfd, 10);

  if (listenResult == -1) {
    std::cout << "Failed to listen for connections" << std::endl;
    return 1;
  }

  std::cout << "Socket is now listening for connections" << std::endl;

  return 0;
}
```

To make a socket listen for incoming connections, you need to call the listen() function after binding the socket.

To accept an incoming connection on a socket, you need to perform the following steps:

1. Create a new socket using the socket() function, just like in the previous step.

   int sockfd, newSockfd;
   sockfd = socket(AF_INET, SOCK_STREAM, 0);

1. Set up the server address, as mentioned before.

2. Bind the socket to the server address, as mentioned before.

3. Make the socket listen for connections, as mentioned before.

4. Call the accept() function to accept an incoming connection. This function blocks until a connection is made. You pass the listening socket descriptor, the client address structure, and the length of the client address structure as parameters.

   socklen_t clientAddrLen;
   newSockfd = accept(sockfd, (struct sockaddr*)&clientAddr, &clientAddrLen);

1. If the accept() function returns a valid socket descriptor, it means a connection has been successfully established.

   if (newSockfd == -1) {
     std::cout << "Failed to accept connection" << std::endl;
     return 1;
   }

   std::cout << "Accepted connection from client" << std::endl;

Remember to handle any errors that might occur during the accept process and close both the listening socket and the new socket when you're done.

Here's an example code that demonstrates how to accept an incoming connection on a socket:

#include <iostream>
#include <sys/socket.h>
#include <netinet/in.h>

int main() {
  // ... code from previous steps ...

  // Accept incoming connections
  clientAddrLen = sizeof(clientAddr);
  newSockfd = accept(sockfd, (struct sockaddr*)&clientAddr, &clientAddrLen);

  if (newSockfd == -1) {
    std::cout << "Failed to accept connection" << std::endl;
    return 1;
  }

  std::cout << "Accepted connection from client" << std::endl;

  return 0;
}

```c++
#include <iostream>
#include <sys/socket.h>
#include <netinet/in.h>

int main() {
  int sockfd, newSockfd;
  struct sockaddr_in serverAddr, clientAddr;
  socklen_t clientAddrLen;

  // Create a socket
  sockfd = socket(AF_INET, SOCK_STREAM, 0);

  if (sockfd == -1) {
    std::cout << "Failed to create socket" << std::endl;
    return 1;
  }

  // Set up the server address
  serverAddr.sin_family = AF_INET;
  serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);
  serverAddr.sin_port = htons(8080);

  // Bind the socket
  int bindResult = bind(sockfd, (struct sockaddr*)&serverAddr, sizeof(serverAddr));

  if (bindResult == -1) {
    std::cout << "Failed to bind socket" << std::endl;
    return 1;
  }

  // Listen for connections
  int listenResult = listen(sockfd, 10);

  if (listenResult == -1) {
    std::cout << "Failed to listen for connections" << std::endl;
    return 1;
  }

  std::cout << "Socket is now listening for connections" << std::endl;

  // Accept incoming connections
  clientAddrLen = sizeof(clientAddr);
  newSockfd = accept(sockfd, (struct sockaddr*)&clientAddr, &clientAddrLen);

  if (newSockfd == -1) {
    std::cout << "Failed to accept connection" << std::endl;
    return 1;
  }

  std::cout << "Accepted connection from client" << std::endl;

  return 0;
}

```

To accept an incoming connection on a socket, you need to call the _____________() function. This function blocks until a connection is made and returns a valid socket descriptor if a connection is successfully established.

To send data over a socket in C++, you need to perform the following steps:

1. Create a socket using the socket() function. Specify the address family (usually AF_INET for IPv4), the socket type (usually SOCK_STREAM for TCP), and the protocol (usually 0 to let the system choose).

   #include <sys/socket.h>
   int sockfd = socket(AF_INET, SOCK_STREAM, 0);

1. Set up the server address by creating a sockaddr_in structure and filling in the necessary details. This includes the address family (AF_INET), port number (converted to network byte order using htons()), and IP address (converted to binary form using inet_addr()).

   #include <netinet/in.h>
   struct sockaddr_in serverAddr;
   serverAddr.sin_family = AF_INET;
   serverAddr.sin_port = htons(8080); // change port number if needed
   serverAddr.sin_addr.s_addr = inet_addr("127.0.0.1"); // change IP address if needed

1. Connect to the server using the connect() function. Pass the socket descriptor, server address structure, and the size of the server address structure as parameters.

   int status = connect(sockfd, (struct sockaddr*)&serverAddr, sizeof(serverAddr));

1. Send data over the socket using the send() function. Pass the socket descriptor, the data to send (converted to a C-style string using c_str()), the length of the data, and any additional flags (usually 0).

   std::string data = "Hello, server!";
   status = send(sockfd, data.c_str(), data.size(), 0);

1. Check the return value of send() to ensure the data was sent successfully.

   if (status == -1) {
     std::cout << "Failed to send data" << std::endl;
     return 1;
   }

1. Close the socket using the close() function.

   close(sockfd);

Here's an example code that demonstrates how to send data over a socket in C++: ```cpp

include

include

include

int main() { // Create a socket int sockfd = socket(AF_INET, SOCK_STREAM, 0); if (sockfd == -1) { std::cout << "Failed to create socket" << std::endl; return 1; }

// Set up the server address struct sockaddr_in serverAddr; serverAddr.sin_family = AF_INET; serverAddr.sin_port = htons(8080); // change port number if needed serverAddr.sin_addr.s_addr = inet_addr("127.0.0.1"); // change IP address if needed

// Connect to the server int status = connect(sockfd, (struct sockaddr*)&serverAddr, sizeof(serverAddr)); if (status == -1) { std::cout << "Failed to connect to server" << std::endl; return 1; }

// Send data std::string data = "Hello, server!"; status = send(sockfd, data.c_str(), data.size(), 0); if (status == -1) { std::cout << "Failed to send data" << std::endl; return 1; }

std::cout << "Data sent successfully" << std::endl;

// Close the socket close(sockfd);

return 0; } ```

```c++
#include <iostream>
#include <sys/socket.h>
#include <netinet/in.h>

int main() {
  // Create a socket
  int sockfd = socket(AF_INET, SOCK_STREAM, 0);
  if (sockfd == -1) {
    std::cout << "Failed to create socket" << std::endl;
    return 1;
  }

  // Set up the server address
  struct sockaddr_in serverAddr;
  serverAddr.sin_family = AF_INET;
  serverAddr.sin_port = htons(8080); // change port number if needed
  serverAddr.sin_addr.s_addr = inet_addr("127.0.0.1"); // change IP address if needed

  // Connect to the server
  int status = connect(sockfd, (struct sockaddr*)&serverAddr, sizeof(serverAddr));
  if (status == -1) {
    std::cout << "Failed to connect to server" << std::endl;
    return 1;
  }

  // Send data
  std::string data = "Hello, server!";
  status = send(sockfd, data.c_str(), data.size(), 0);
  if (status == -1) {
    std::cout << "Failed to send data" << std::endl;
    return 1;
  }

  std::cout << "Data sent successfully" << std::endl;

  // Close the socket
  close(sockfd);

  return 0;
}
```

True or false swipe question for Sending Data

To receive data over a socket in C++, you need to perform the following steps:

1. Create a buffer to store the received data. The buffer can be a character array or a string.

   #include <iostream>
   const int bufferSize = 1024;
   char buffer[bufferSize];

1. Use the recv() function to receive data. Pass the socket descriptor, the buffer, the size of the buffer, any additional flags (usually 0), and any necessary error handling.

   int bytesReceived = recv(sockfd, buffer, bufferSize, 0);
   if (bytesReceived == -1) {
     std::cout << "Error receiving data" << std::endl;
     return 1;
   }

1. Check the value of bytesReceived to determine if data was successfully received. If bytesReceived is 0, it means the connection has been closed by the other side.

   if (bytesReceived == 0) {
     std::cout << "Connection closed" << std::endl;
   }

1. Process the received data stored in the buffer as needed.

   std::cout << "Received data: " << buffer << std::endl;

1. Repeat the receive process as necessary to receive additional data.

   bytesReceived = recv(sockfd, buffer, bufferSize, 0);
   // Process additional received data

Here's an example code that demonstrates how to receive data over a socket in C++:

#include <iostream>
#include <sys/socket.h>

int main() {
  // Create a socket
  int sockfd = socket(AF_INET, SOCK_STREAM, 0);
  if (sockfd == -1) {
    std::cout << "Failed to create socket" << std::endl;
    return 1;
  }

  // ... Set up server address and connect to server ...

  // Receive data
  const int bufferSize = 1024;
  char buffer[bufferSize];
  int bytesReceived = recv(sockfd, buffer, bufferSize, 0);
  if (bytesReceived == -1) {
    std::cout << "Error receiving data" << std::endl;
    return 1;
  }

  if (bytesReceived == 0) {
    std::cout << "Connection closed" << std::endl;
  }

  std::cout << "Received data: " << buffer << std::endl;

  // Close the socket
  close(sockfd);

  return 0;
}

To properly close a socket in C++, you need to follow these steps:

1. Use the close() function to close the socket. Pass the socket descriptor as the argument.

   close(sockfd);

1. Handle any necessary error checking after closing the socket.

   if (close(sockfd) == -1) {
     std::cout << "Error closing socket" << std::endl;
     return 1;
   }

Closing a socket is important to free up system resources and maintain proper network communication. Failure to close a socket can lead to resource leaks and potentially impact the network performance.

Here's an example code that demonstrates how to properly close a socket in C++:

#include <iostream>
#include <sys/socket.h>

int main() {
  // Create a socket
  int sockfd = socket(AF_INET, SOCK_STREAM, 0);
  if (sockfd == -1) {
    std::cout << "Failed to create socket" << std::endl;
    return 1;
  }

  // ... Set up server address and connect to server ...

  // Close the socket
  if (close(sockfd) == -1) {
    std::cout << "Error closing socket" << std::endl;
    return 1;
  }

  return 0;
}

```c++
#include <iostream>
#include <sys/socket.h>

int main() {
  // Create a socket
  int sockfd = socket(AF_INET, SOCK_STREAM, 0);
  if (sockfd == -1) {
    std::cout << "Failed to create socket" << std::endl;
    return 1;
  }

  // ... Set up server address and connect to server ...

  // Close the socket
  close(sockfd);

  return 0;
}
```

What is the proper function to close a socket in C++?

To build a TCP server in C++, you can follow these steps:

1. Create a socket using the socket() function. Specify the address family, socket type, and protocol.

   int sockfd = socket(AF_INET, SOCK_STREAM, 0);
   if (sockfd == -1) {
     std::cout << "Failed to create socket" << std::endl;
     return 1;
   }

1. Bind the socket to an address and port using the bind() function. Specify the server address and port in a sockaddr_in structure.

   struct sockaddr_in serverAddr;
   serverAddr.sin_family = AF_INET;
   serverAddr.sin_port = htons(8080);
   serverAddr.sin_addr.s_addr = INADDR_ANY;

   if (bind(sockfd, (struct sockaddr*)&serverAddr, sizeof(serverAddr)) == -1) {
     std::cout << "Failed to bind socket" << std::endl;
     return 1;
   }

1. Listen for incoming connections using the listen() function. Specify the maximum number of queued connections.

   if (listen(sockfd, 5) == -1) {
     std::cout << "Failed to listen for connections" << std::endl;
     return 1;
   }

1. Accept incoming connections using the accept() function. Specify a sockaddr_in structure to store the client address.

   struct sockaddr_in clientAddr;
   unsigned int clientAddrSize = sizeof(clientAddr);
   int clientSock = accept(sockfd, (struct sockaddr*)&clientAddr, &clientAddrSize);
   if (clientSock == -1) {
     std::cout << "Failed to accept connection" << std::endl;
     return 1;
   }

1. Send and receive data on the client socket using the read() and write() functions.

   char buffer[1024] = {0};
   read(clientSock, buffer, 1024);
   std::cout << "Received message: " << buffer << std::endl;

   const char* response = "Hello from the server!";
   write(clientSock, response, strlen(response));

1. Close the client socket and server socket using the close() function.

   close(clientSock);
   close(sockfd);

Here's an example code that demonstrates how to build a TCP server in C++:

#include <iostream>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>

int main() {
  // Create a socket
  int sockfd = socket(AF_INET, SOCK_STREAM, 0);
  if (sockfd == -1) {
    std::cout << "Failed to create socket" << std::endl;
    return 1;
  }

  // Bind the socket to an address and port
  struct sockaddr_in serverAddr;
  serverAddr.sin_family = AF_INET;
  serverAddr.sin_port = htons(8080);
  serverAddr.sin_addr.s_addr = INADDR_ANY;

  if (bind(sockfd, (struct sockaddr*)&serverAddr, sizeof(serverAddr)) == -1) {
    std::cout << "Failed to bind socket" << std::endl;
    return 1;
  }

  // Listen for incoming connections
  if (listen(sockfd, 5) == -1) {
    std::cout << "Failed to listen for connections" << std::endl;
    return 1;
  }

  // Accept incoming connections
  struct sockaddr_in clientAddr;
  unsigned int clientAddrSize = sizeof(clientAddr);
  int clientSock = accept(sockfd, (struct sockaddr*)&clientAddr, &clientAddrSize);
  if (clientSock == -1) {
    std::cout << "Failed to accept connection" << std::endl;
    return 1;
  }

  // Send and receive data on the client socket
  char buffer[1024] = {0};
  read(clientSock, buffer, 1024);
  std::cout << "Received message: " << buffer << std::endl;

  const char* response = "Hello from the server!";
  write(clientSock, response, strlen(response));

  // Close the client socket
  close(clientSock);

  // Close the server socket
  close(sockfd);

  return 0;
}

```c++
#include <iostream>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>

double calculate_interest(double principal, double rate, int years) {
  return principal * rate * years;
}

int main() {
  // Create a socket
  int sockfd = socket(AF_INET, SOCK_STREAM, 0);
  if (sockfd == -1) {
    std::cout << "Failed to create socket" << std::endl;
    return 1;
  }

  // Bind the socket to an address and port
  struct sockaddr_in serverAddr;
  serverAddr.sin_family = AF_INET;
  serverAddr.sin_port = htons(8080);
  serverAddr.sin_addr.s_addr = INADDR_ANY;

  if (bind(sockfd, (struct sockaddr*)&serverAddr, sizeof(serverAddr)) == -1) {
    std::cout << "Failed to bind socket" << std::endl;
    return 1;
  }

  // Listen for incoming connections
  if (listen(sockfd, 5) == -1) {
    std::cout << "Failed to listen for connections" << std::endl;
    return 1;
  }

  // Accept incoming connections
  struct sockaddr_in clientAddr;
  unsigned int clientAddrSize = sizeof(clientAddr);
  int clientSock = accept(sockfd, (struct sockaddr*)&clientAddr, &clientAddrSize);
  if (clientSock == -1) {
    std::cout << "Failed to accept connection" << std::endl;
    return 1;
  }

  // Send and receive data on the client socket
  char buffer[1024] = {0};
  read(clientSock, buffer, 1024);
  std::cout << "Received message: " << buffer << std::endl;

  const char* response = "Hello from the server!";
  write(clientSock, response, strlen(response));

  // Close the client socket
  close(clientSock);

  // Close the server socket
  close(sockfd);

  return 0;
}
```

What is the purpose of the bind() function in building a TCP server?

To build a TCP client in C++, you can follow these steps:

1. Create a socket using the socket() function. Specify the address family, socket type, and protocol.

   int sockfd = socket(AF_INET, SOCK_STREAM, 0);
   if (sockfd == -1) {
     std::cout << "Failed to create socket" << std::endl;
     return 1;
   }

1. Connect to the server using the connect() function. Specify the server address and port in a sockaddr_in structure.

   struct sockaddr_in serverAddr;
   serverAddr.sin_family = AF_INET;
   serverAddr.sin_port = htons(8080);
   serverAddr.sin_addr.s_addr = inet_addr("127.0.0.1");

   if (connect(sockfd, (struct sockaddr*)&serverAddr, sizeof(serverAddr)) == -1) {
     std::cout << "Failed to connect to server" << std::endl;
     return 1;
   }

1. Send and receive data on the client socket using the write() and read() functions.

   const char* message = "Hello from the client!";
   write(sockfd, message, strlen(message));

   char buffer[1024] = {0};
   read(sockfd, buffer, 1024);
   std::cout << "Received message: " << buffer << std::endl;

1. Close the socket using the close() function.

   close(sockfd);

Here's an example code that demonstrates how to build a TCP client in C++:

#include <iostream>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <cstring>

int main() {
  // Create a socket
  int sockfd = socket(AF_INET, SOCK_STREAM, 0);
  if (sockfd == -1) {
    std::cout << "Failed to create socket" << std::endl;
    return 1;
  }

  // Connect to the server
  struct sockaddr_in serverAddr;
  serverAddr.sin_family = AF_INET;
  serverAddr.sin_port = htons(8080);
  serverAddr.sin_addr.s_addr = inet_addr("127.0.0.1");

  if (connect(sockfd, (struct sockaddr*)&serverAddr, sizeof(serverAddr)) == -1) {
    std::cout << "Failed to connect to server" << std::endl;
    return 1;
  }

  // Send and receive data
  const char* message = "Hello from the client!";
  write(sockfd, message, strlen(message));

  char buffer[1024] = {0};
  read(sockfd, buffer, 1024);
  std::cout << "Received message: " << buffer << std::endl;

  // Close the socket
  close(sockfd);

  return 0;
}

Building a TCP Client involves creating a socket, binding it to an address and port, and accepting incoming connections.

Generating complete for this lesson!