Scribd
Upload
10 views8 pages

CLient Server TCP UDP

The document provides code examples for TCP and UDP client-server models in C. The TCP model includes a server that listens for client connections and responds to messages, while the UDP model demonstrates a server that receives messages from clients and echoes them back. Both models include client implementations that connect to the server, send messages, and receive responses.

Uploaded by

harshvardhanj88
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
10 views8 pages

CLient Server TCP UDP

The document provides code examples for TCP and UDP client-server models in C. The TCP model includes a server that listens for client connections and responds to messages, while the UDP model demonstrates a server that receives messages from clients and echoes them back. Both models include client implementations that connect to the server, send messages, and receive responses.

Uploaded by

harshvardhanj88
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 8

//Tcp Client Server Model

Server
#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h> // For close()

int main(void)
{
int socket_desc, client_sock, client_size;
struct sockaddr_in server_addr, client_addr;
char server_message[2000], client_message[2000];

// Clean buffers:
memset(server_message, '\0', sizeof(server_message));
memset(client_message, '\0', sizeof(client_message));

// Create socket:
socket_desc = socket(AF_INET, SOCK_STREAM, 0);
if(socket_desc < 0){
printf("Error while creating socket\n");
return -1;
}
printf("Socket created successfully\n");

// Set port and IP:


server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(2000);
server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");

// Bind to the set port and IP:


if(bind(socket_desc, (struct sockaddr*)&server_addr,
sizeof(server_addr)) < 0){
printf("Couldn't bind to the port\n");
return -1;
}
printf("Done with binding\n");

// Listen for clients:


if(listen(socket_desc, 1) < 0){
printf("Error while listening\n");
return -1;
}
printf("\nListening for incoming connections.....\n");

// Accept an incoming connection:


client_size = sizeof(client_addr);
client_sock = accept(socket_desc, (struct sockaddr*)&client_addr,
(socklen_t*)&client_size);
if (client_sock < 0){
printf("Can't accept\n");
return -1;
}
printf("Client connected at IP: %s and port: %d\n",
inet_ntoa(client_addr.sin_addr),
ntohs(client_addr.sin_port));

// Receive client's message:


if (recv(client_sock, client_message, sizeof(client_message), 0) <
0){
printf("Couldn't receive\n");
return -1;
}
printf("Msg from client: %s\n", client_message);

// Respond to client:
strcpy(server_message, "This is the server's message.");
if (send(client_sock, server_message, strlen(server_message), 0) <
0){
printf("Can't send\n");
return -1;
}

// Closing the socket:


close(client_sock);
close(socket_desc);

return 0;
}

Client
#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h> // For close()

int main(void)
{
int socket_desc;
struct sockaddr_in server_addr;
char server_message[2000], client_message[2000];

// Clean buffers:
memset(server_message, '\0', sizeof(server_message));
memset(client_message, '\0', sizeof(client_message));

// Create socket:
socket_desc = socket(AF_INET, SOCK_STREAM, 0);
if(socket_desc < 0){
printf("Unable to create socket\n");
return -1;
}
printf("Socket created successfully\n");

// Set port and IP the same as server-side:


server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(2000);
server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
// Send connection request to server:
if(connect(socket_desc, (struct sockaddr*)&server_addr,
sizeof(server_addr)) < 0){
printf("Unable to connect\n");
return -1;
}
printf("Connected with server successfully\n");

// Get input from the user:


printf("Enter message: ");
fgets(client_message, sizeof(client_message), stdin);

// Remove newline character (if any) from input


client_message[strcspn(client_message, "\n")] = '\0';

// Send the message to server:


if(send(socket_desc, client_message, strlen(client_message), 0) <
0)
{
printf("Unable to send message\n");
return -1;
}

// Receive the server's response:


if(recv(socket_desc, server_message, sizeof(server_message), 0) <
0)
{
printf("Error while receiving server's message\n");
return -1;
}
printf("Server's response: %s\n", server_message);

// Close the socket:


close(socket_desc);

return 0;
}

Output

ClientSide:
ServerSide:
UDP Client Server Model
Server
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <netdb.h>
#include <stdio.h>
#include <string.h>
#include <arpa/inet.h>

#define MAXLINE 1024

int main(int argc, char **argv)


{
int sockfd;
int n;
socklen_t len;
char msg[MAXLINE];
struct sockaddr_in servaddr, cliaddr;

// Create socket:
sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (sockfd < 0) {
perror("Socket creation failed");
return -1;
}

// Initialize server address structure:


bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = INADDR_ANY;
servaddr.sin_port = htons(5035);

printf("\n\n Binded");

// Bind socket:
if (bind(sockfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) <
0) {
perror("Bind failed");
return -1;
}

printf("\n\n Listening...");

for (;;) {
printf("\n ");
len = sizeof(cliaddr);

// Receive message from client:


n = recvfrom(sockfd, msg, MAXLINE, 0, (struct
sockaddr*)&cliaddr, &len);
if (n < 0) {
perror("Receive error");
continue;
}
// Null-terminate the received message:
msg[n] = '\0';

printf("\n Client's Message: %s\n", msg);

// Send message back to client:


if (sendto(sockfd, msg, n, 0, (struct sockaddr*)&cliaddr, len)
< 0) {
perror("Send error");
}
}

return 0;
}

Client
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <string.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <stdlib.h>

#define MAXLINE 1024

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


{
int sockfd, n;
socklen_t len;
char sendline[MAXLINE], recvline[MAXLINE];
struct sockaddr_in servaddr;

// Clear the send buffer


memset(sendline, 0, sizeof(sendline));

printf("\nEnter the message: ");


fgets(sendline, sizeof(sendline), stdin);

// Remove newline character if present


sendline[strcspn(sendline, "\n")] = '\0';

// Create UDP socket


sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (sockfd < 0) {
perror("Socket creation failed");
return -1;
}

// Initialize server address structure


memset(&servaddr, 0, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
servaddr.sin_port = htons(5035);
len = sizeof(servaddr);

// Send message to server


if (sendto(sockfd, sendline, strlen(sendline), 0, (struct
sockaddr*)&servaddr, len) < 0) {
perror("Send failed");
return -1;
}

// Receive response from server


n = recvfrom(sockfd, recvline, MAXLINE, 0, (struct
sockaddr*)&servaddr, &len);
if (n < 0) {
perror("Receive failed");
return -1;
}

// Null-terminate the received message


recvline[n] = '\0';

printf("\nServer's Echo: %s\n\n", recvline);

// Close socket
close(sockfd);

return 0;
}

Output
ClientSide:
ServerSide:

You might also like