Write two programs in C: hello_client and hello_server With using I/O multiplexing

// Server program

#include <arpa/inet.h>

#include <errno.h>

#include <netinet/in.h>

#include <signal.h>

#include <stdio.h>

#include <stdlib.h>

#include <strings.h>

#include <sys/socket.h>

#include <sys/types.h>

#include <unistd.h>

#define PORT 5000

#define MAXLINE 1024

int max(int x, int y)

{

            if (x > y)

                        return x;

            else

                        return y;

}

int main()

{

            int listenfd, connfd, udpfd, nready, maxfdp1;

            char buffer[MAXLINE];

            pid_t childpid;

            fd_set rset;

            ssize_t n;

            socklen_t len;

            const int on = 1;

            struct sockaddr_in cliaddr, servaddr;

            char* message = "Hello Client";

            void sig_chld(int);

            /* create listening TCP socket */

            listenfd = socket(AF_INET, SOCK_STREAM, 0);

            bzero(&servaddr, sizeof(servaddr));

            servaddr.sin_family = AF_INET;

            servaddr.sin_addr.s_addr = htonl(INADDR_ANY);

            servaddr.sin_port = htons(PORT);

            // binding server addr structure to listenfd

            bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr));

            listen(listenfd, 10);

            /* create UDP socket */

            udpfd = socket(AF_INET, SOCK_DGRAM, 0);

            // binding server addr structure to udp sockfd

            bind(udpfd, (struct sockaddr*)&servaddr, sizeof(servaddr));

            // clear the descriptor set

            FD_ZERO(&rset);

            // get maxfd

            maxfdp1 = max(listenfd, udpfd) + 1;

            for (;;) {

                        // set listenfd and udpfd in readset

                        FD_SET(listenfd, &rset);

                        FD_SET(udpfd, &rset);

                        // select the ready descriptor

                        nready = select(maxfdp1, &rset, NULL, NULL, NULL);

                        // if tcp socket is readable then handle

                        // it by accepting the connection

                        if (FD_ISSET(listenfd, &rset)) {

                                    len = sizeof(cliaddr);

                                    connfd = accept(listenfd, (struct sockaddr*)&cliaddr, &len);

                                    if ((childpid = fork()) == 0) {

                                                close(listenfd);

                                                bzero(buffer, sizeof(buffer));

                                                printf("Message From TCP client: ");

                                                read(connfd, buffer, sizeof(buffer));

                                                puts(buffer);

                                                write(connfd, (const char*)message, sizeof(buffer));

                                                close(connfd);

                                                exit(0);

                                    }

                                    close(connfd);

                        }

                        // if udp socket is readable receive the message.

                        if (FD_ISSET(udpfd, &rset)) {

                                    len = sizeof(cliaddr);

                                    bzero(buffer, sizeof(buffer));

                                    printf("\nMessage from UDP client: ");

                                    n = recvfrom(udpfd, buffer, sizeof(buffer), 0,

                                                                        (struct sockaddr*)&cliaddr, &len);

                                    puts(buffer);

                                    sendto(udpfd, (const char*)message, sizeof(buffer), 0,

                                                (struct sockaddr*)&cliaddr, sizeof(cliaddr));

                        }

            }

}

// TCP Client program

#include <netinet/in.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <sys/socket.h>

#include <sys/types.h>

#define PORT 5000

#define MAXLINE 1024

int main()

{

            int sockfd;

            char buffer[MAXLINE];

            char* message = "Hello Server";

            struct sockaddr_in servaddr;

            int n, len;

            // Creating socket file descriptor

            if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {

                        printf("socket creation failed");

                        exit(0);

            }

            memset(&servaddr, 0, sizeof(servaddr));

            // Filling server information

            servaddr.sin_family = AF_INET;

            servaddr.sin_port = htons(PORT);

            servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");

            if (connect(sockfd, (struct sockaddr*)&servaddr,

                                                                                    sizeof(servaddr)) < 0) {

                        printf("\n Error : Connect Failed \n");

            }

            memset(buffer, 0, sizeof(buffer));

            strcpy(buffer, "Hello Server");

            write(sockfd, buffer, sizeof(buffer));

            printf("Message from server: ");

            read(sockfd, buffer, sizeof(buffer));

            puts(buffer);

            close(sockfd);

}

// UDP client program

#include <arpa/inet.h>

#include <netinet/in.h>

#include <stdio.h>

#include <stdlib.h>

#include <strings.h>

#include <sys/socket.h>

#include <sys/types.h>

#define PORT 5000

#define MAXLINE 1024

int main()

{

            int sockfd;

            char buffer[MAXLINE];

            char* message = "Hello Server";

            struct sockaddr_in servaddr;

            int n, len;

            // Creating socket file descriptor

            if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {

                        printf("socket creation failed");

                        exit(0);

            }

            memset(&servaddr, 0, sizeof(servaddr));

            // Filling server information

            servaddr.sin_family = AF_INET;

            servaddr.sin_port = htons(PORT);

            servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");

            // send hello message to server

            sendto(sockfd, (const char*)message, strlen(message),

                        0, (const struct sockaddr*)&servaddr,

                        sizeof(servaddr));

            // receive server's response

            printf("Message from server: ");

            n = recvfrom(sockfd, (char*)buffer, MAXLINE,

                                                0, (struct sockaddr*)&servaddr,

                                                &len);

            puts(buffer);

            close(sockfd);

            return 0;

}

Write two programs in C: hello_client and hello_server a. The server listens for, and accepts, a single TCP connection; it reads all the data it can from that connection, and prints it to the screen; then it closes the connection

// TCP Server

#include <unistd.h>

#include <stdio.h>

#include <sys/socket.h>

#include <stdlib.h>

#include <netinet/in.h>

#include <string.h>

#define PORT 8080

int main(int argc, char const *argv[])

{

    int server_fd, new_socket, valread;

    struct sockaddr_in address;

    int opt = 1;

    int addrlen = sizeof(address);

    char buffer[1024] = {0};

    char *hello = "Hello from server";  

    // Creating socket file descriptor

    if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0)

    {  perror("socket failed");

       exit(EXIT_FAILURE);

    }

      

    // Forcefully attaching socket to the port 8080

    if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT,&opt, sizeof(opt)))

    {   perror("setsockopt");

        exit(EXIT_FAILURE);

    }

    address.sin_family = AF_INET;

    address.sin_addr.s_addr = INADDR_ANY;

    address.sin_port = htons( PORT );

      

    // Forcefully attaching socket to the port 8080

    if (bind(server_fd, (struct sockaddr *)&address, sizeof(address))<0)

    {

        perror("bind failed");

        exit(EXIT_FAILURE);

    }

    if (listen(server_fd, 3) < 0)

    {

        perror("listen");

        exit(EXIT_FAILURE);

    }

    if ((new_socket = accept(server_fd, (struct sockaddr *)&address, (socklen_t*)&addrlen))<0)

    { perror("accept");

        exit(EXIT_FAILURE);

    }

    valread = read( new_socket , buffer, 1024);

    printf("%s\n",buffer );

    send(new_socket , hello , strlen(hello) , 0 );

    printf("Hello message sent\n");

    return 0;

}

// Tcp Client  

#include <stdio.h>

#include <sys/socket.h>

#include <stdlib.h>

#include <netinet/in.h>

#include <string.h>

#define PORT 8080

  

int main(int argc, char const *argv[])

{

    struct sockaddr_in address;

    int sock = 0, valread;

    struct sockaddr_in serv_addr;

    char *hello = "Hello from client";

    char buffer[1024] = {0};

    if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0)

    {

        printf("\n Socket creation error \n");

        return -1;

    }

  

    memset(&serv_addr, '0', sizeof(serv_addr));

  

    serv_addr.sin_family = AF_INET;

    serv_addr.sin_port = htons(PORT);

      

    // Convert IPv4 and IPv6 addresses from text to binary form

    if(inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr)<=0) 

    {

        printf("\nInvalid address/ Address not supported \n");

        return -1;

    }

  

    if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0)

    {

        printf("\nConnection Failed \n");

        return -1;

    }

    send(sock , hello , strlen(hello) , 0 );

    printf("Hello message sent\n");

    valread = read( sock , buffer, 1024);

    printf("%s\n",buffer );

    return 0;

}

Steps to compile and Run

Open one Terminal in Linux and compile and run TCP server program    

1. Compile the server program

gcc tcpserver.c -o tcpser)

2. Run server using

./tcpser

Output 

[root@localhost TCP]# gcc tcpserver.c -o tcpser

[root@localhost TCP]# ./tcpser

Client : Hello from client

Hello message sent.

Open one Terminal in Linux and compile and run TCP client program    

1.       compile tcp client program

gcc tcpclient.c -o tcpcli)

2.       Run tcp client

./tcpcli)

Output 

[root@localhost TCP# gcc tcpclient.c -o tcpcli

[root@localhost TCP]# ./tcpcli

Hello message sent.

Write an C program for Echo_Client and Echo_server using UDP

Write two programs in C: hello_client and hello_server
a. The server listens for, and accepts, a single UDP connection; it reads all the data it can from that connection, and prints it to the screen; then it closes the connection
b. The UDP client connects to the server, sends the string “Hello, world!”, then closes the connection

// Server side implementation using UDP
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>

#define PORT 8080
#define MAXLINE 1024

// Driver code
int main() {
int sockfd;
char buffer[MAXLINE];
char *hello = "Hello from server";
struct sockaddr_in servaddr, cliaddr;

// Creating socket file descriptor
if ( (sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0 ) {
perror("socket creation failed");
exit(EXIT_FAILURE);
}

memset(&servaddr, 0, sizeof(servaddr));
memset(&cliaddr, 0, sizeof(cliaddr));

// Filling server data
servaddr.sin_family = AF_INET; // IPv4
servaddr.sin_addr.s_addr = INADDR_ANY;
servaddr.sin_port = htons(PORT);

// Binding of socket with the server address
if ( bind(sockfd, (const struct sockaddr *)&servaddr,
sizeof(servaddr)) < 0 )
{
perror("bind failed");
exit(EXIT_FAILURE);
}

int len, n;
n = recvfrom(sockfd, (char *)buffer, MAXLINE,
MSG_WAITALL, ( struct sockaddr *) &cliaddr,
&len);
buffer[n] = '\0';
printf("Client : %s\n", buffer);
sendto(sockfd, (const char *)hello, strlen(hello),
MSG_CONFIRM, (const struct sockaddr *) &cliaddr,
len);
printf("Hello message sent.\n");

return 0;
}



// Client side implementation using UDP
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>

#define PORT 8080
#define MAXLINE 1024

// Driver code
int main() {
int sockfd;
char buffer[MAXLINE];
char *hello = "Hello from client";
struct sockaddr_in servaddr;

// Creating socket file descriptor
if ( (sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0 ) {
perror("socket creation failed");
exit(EXIT_FAILURE);
}

memset(&servaddr, 0, sizeof(servaddr));

// Filling server data
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(PORT);
servaddr.sin_addr.s_addr = INADDR_ANY;

int n, len;

sendto(sockfd, (const char *)hello, strlen(hello),
MSG_CONFIRM, (const struct sockaddr *) &servaddr,
sizeof(servaddr));
printf("Hello message sent.\n");

n = recvfrom(sockfd, (char *)buffer, MAXLINE,
MSG_WAITALL, (struct sockaddr *) &servaddr,
&len);
buffer[n] = '\0';
printf("Server : %s\n", buffer);

close(sockfd);
return 0;
}

Steps to compile and Run

Open one Terminal in Linux and compile and run UDP server program    

1. Compile the server program

gcc udpserver.c -o udpser)

2. Run server using

./udpser

Output 

[root@localhost udp]# gcc udpserver.c -o udpser

[root@localhost udp]# ./udpser

Client : Hello from client

Hello message sent.

Open one Terminal in Linux and compile and run UDP client program    

1.       compile tcp client program

gcc udpclient.c -o udpcli)

2.       Run tcp client

./udpcli)

Output 

[root@localhost udp]# gcc udpclient.c -o udpcli

[root@localhost udp]# ./udpcli

Hello message sent.