Question

Write technical report about the socket programming which should include the followng:

Introduction about the socket programming

Advantages of socket programming

Create TCP/IP Client (the source code in any language) socket program that performs the following steps:

a. Initializes Winsock.

b. Creates a socket.

c. Connects to the server.

d. Sends and receives data.

e. Disconnects.

create TCP/IP Server socket program that performs the following steps:

a. Initializes Winsock.

b. Creates a socket.

c. Listen for client.

d. Receives and sends data.

e. Disconnects.

Answer 1

When writing programs that communicate across a computer network, one must first invent a protocol, an agreement on how those programs will communicate. High level decisions must be made about which program is expected to initiate communication and when responses are expected.
For example, a Web server is typically thought of as a long-running program that sends network messages only in response to requests coming in from the network.
The other side of the protocol is a Web client, such as a browser, which always initiates communication with the server.
This organization into client and server is used by most network aware applications.
Deciding that the client always initiates requests tends to simplify the protocol as well as the programs themselves.
The client application and the server application may be thought of as communicating via a implementations network protocol, but actually, multiple layers of network protocols are typically involved.

Advantages :
1) Complete control over information sent/received on a network.
2) Best for implementing new protocols for application layer.
3) Writing network monitoring and troubleshooting tools.
4) Used to provide security to higher layer such as SSL/TLS.
5) Best for performance network related applications such as what's app, games etc.
6) Cloud management.
7) Internet.

Client.c

#include<stdio.h>
#include<sys/socket.h>
#include<arpa/inet.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<sys/types.h>

#define RCVBUFSIZE 32   // size of receive buffer

int main(int argc, char*argv[])
{
int sock;               // socket descriptor
struct sockaddr_in echoServAddr;   // echo server address
unsigned short echoServPort;       // echo server port
char* servIP;               // server IP address (dotted quad)
char* echoString;           // string to send to echo server
char echoBuffer[RCVBUFSIZE];       // buffer for echo string
unsigned int echoStringLen;       // length of string to echo
int bytesRcvd, totalBytesRcvd;       // bytes read in single recv()
                       // and total bytes read
if((argc < 3) || (argc > 4)){
    fprintf(stderr, "Usage: %s <Server IP> <Echo Word> [<Echo Port>]\n", argv[0]);
    exit(1);
}

servIP = argv[1];       // first arg: server IP address
echoString = argv[2];       // second arg: string to echo

if(argc == 4)
    echoServPort = atoi(argv[3]);   // use given port, if any
else
    echoServPort = 7;

// create a reliable, stream socket using TCP
if((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0){
    perror("socket failed");
    exit(1);
}

// construct the server address structure
memset(&echoServAddr, 0, sizeof(echoServAddr));   // zero out structure
echoServAddr.sin_family = AF_INET;       // server address family
echoServAddr.sin_addr.s_addr = inet_addr(servIP);   // server IP address
echoServAddr.sin_port = htons(echoServPort);   // server port

// establish the connection to echo server
if(connect(sock, (struct sockaddr*)&echoServAddr, sizeof(echoServAddr)) < 0){
    perror("connect failed");
    exit(1);
}

echoStringLen = strlen(echoString);   // determine input length
// send the string to the server
if(send(sock, echoString, echoStringLen, 0) != echoStringLen){
    perror("send() sent a different number of bytes than expected");
    exit(1);
}

// receive the same string back from server
totalBytesRcvd = 0;
printf("Received: ");

while(totalBytesRcvd < echoStringLen){
    // receive up to the buffer size (minus 1 to leave space for a null terminator)
    // bytes from the sender
    if((bytesRcvd = recv(sock, echoBuffer, RCVBUFSIZE - 1, 0)) <= 0){
      perror("recv() failed or connection closed prematurely");
      exit(1);
    }
    totalBytesRcvd += bytesRcvd;
    echoBuffer[bytesRcvd] = '\0';
    printf("%s\n", echoBuffer);
}
printf("\n");

close(sock);
return 0;
}

Server.c

#include<stdio.h>
#include<sys/socket.h>
#include<arpa/inet.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<sys/types.h>

#define MAXPENDING 5   // maximum connection requets
#define RCVBUFSIZE 32

void HandleTCPClient(int clntSocket);   // TCP client handling function

int main(int argc, char*argv[])
{
int servSock;           // socket descriptor for server
int clntSock;           // socket descriptor for client
struct sockaddr_in echoServAddr;   // local address
struct sockaddr_in echoClntAddr;   // client address
unsigned short echoServPort;       // server port
unsigned int clntLen;           // length of client address data structure

if(argc != 2){
    fprintf(stderr, "Usage: %s <Server Port>\n", argv[0]);
    exit(1);
}

echoServPort = atoi(argv[1]);   // first arg: local port

// create socket for incoming connections
if((servSock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0){
    perror("socket() failed");
    exit(1);
}

// construct local address structure
memset(&echoServAddr, 0, sizeof(echoServAddr));   // zero out structure
echoServAddr.sin_family = AF_INET;       // internet address family
echoServAddr.sin_addr.s_addr = htonl(INADDR_ANY);   // any incoming interface
echoServAddr.sin_port = htons(echoServPort);   // local port

// bind to the local address
if(bind(servSock, (struct sockaddr*)&echoServAddr, sizeof(echoServAddr)) < 0){
    perror("bind() failed");
    exit(1);
}

// mark the socket so it will listen for incoming connections
if(listen(servSock, MAXPENDING) < 0){
    perror("listen() failed");
    exit(1);
}

for(;;)   // run forever
{
    // set the size of the in-out parameter
    clntLen = sizeof(echoClntAddr);
    // wait for a client to connect
    if((clntSock = accept(servSock, (struct sockaddr*)&echoClntAddr, &clntLen)) < 0){
      perror("accept() failed");
      exit(1);
    }

    printf("Handling client %s\n", inet_ntoa(echoClntAddr.sin_addr));
    HandleTCPClient(clntSock);
}

return 0;
}

void HandleTCPClient(int clntSocket)
{
char echoBuffer[RCVBUFSIZE];   // buffer for echo string
int recvMsgSize;       // size of received message

// receive message from client
if((recvMsgSize = recv(clntSocket, echoBuffer, RCVBUFSIZE, 0)) < 0){
    perror("recv() failed");
    exit(1);
}

printf("msg = %s\n", echoBuffer);
// send received string and receive again until end of transmission
while(recvMsgSize > 0){
    // echo message back to client
    if(send(clntSocket, echoBuffer, recvMsgSize, 0) != recvMsgSize){  
      perror("send() failed");
      exit(1);
    }

    // see if there is more data to receive
    if((recvMsgSize = recv(clntSocket, echoBuffer, RCVBUFSIZE, 0)) < 0){  
      perror("recv() failed");
      exit(1);
    }
}
}