Not Getting the output at the client side (UDP socket in C)

Question

Here is my code for the server and the client side of the UDP socket.

The issue is, when I am running this in the terminal, the server execution stops as soon as the client reaches the server, but on the client side I did not receive any data.

Client.c

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <fcntl.h>
#include <unistd.h>

int main() {
    int network_socket;

    network_socket = socket(AF_INET, SOCK_DGRAM, 0);

    struct sockaddr_in server_address;

    server_address.sin_family = AF_INET;
    server_address.sin_port = htons(9002);
    server_address.sin_addr.s_addr = INADDR_ANY;

    sendto(network_socket, 0, 0, MSG_CONFIRM, (const struct sockaddr *) &server_address, sizeof(server_address));
    char server_response[256];
    int len = sizeof(network_socket);
    int = recvfrom(network_socket, &server_response, sizeof(server_response), 0,(struct sockaddr*) &network_socket, (socklen_t*)&len);

    printf("The server sent the data : %s\n", server_response);

    close(network_socket);
    return 0;
}

Server.c

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <fcntl.h>
#include <unistd.h>

int main() {
    char server_message[256] = "you have reached the UDP server";

    int server_socket,client_address;
    server_socket = socket(AF_INET, SOCK_DGRAM,0);

    struct sockaddr_in server_address;
    server_address.sin_family = AF_INET;
    server_address.sin_port = htons(9002);
    server_address.sin_addr.s_addr = INADDR_ANY;

    bind(server_socket, (struct sockaddr *) &server_address, sizeof(server_address));

    int n,len;
    len = sizeof(client_address);
    n = recvfrom(server_socket, server_message, sizeof(server_message), 0, (struct sockaddr *) &client_address, (socklen_t*)&len);

    sendto(server_socket, server_message, sizeof(server_message), 0, (struct sockaddr *) &client_address, len);
    close(server_socket);
    return 0;
}

Answer 1

sendto(network_socket, 0, 0, MSG_CONFIRM, (const struct sockaddr *) &server_address, sizeof(server_address));

You aren't sending any data.

int = recvfrom(network_socket, &server_response, sizeof(server_response), 0,(struct sockaddr*) &network_socket, (socklen_t*)&len);

printf("The server sent the data : %s\n", server_response);

You didn't keep the number of bytes you received, that's what recvfrom returns. So you have no idea how much data you received. You then try to print this data through %s, which is only for C-style strings. You can't use it to print arbitrary data. At a minimum, you have to tell it how much data to print (otherwise, how could it possibly know?) and you threw that information away.

Answer 2

On both sides, you are not doing any error handling at all.

On the client side, you can't send datagrams to INADDR_ANY, you need to send to an actual IP address. And when calling recvfrom(), you are using the network_socket file descriptor as a sockaddr_in struct to receive the sender's address/port, which is just wrong.

On the server side, you are declaring client_address as an int when it needs to be a sockaddr_in struct instead. And you are using the same char[] buffer to receive the client's data that you use to store your server's greeting message, so you are effectively echoing back what the client sends (which is nothing), but you are not taking the size of the client's data into account. And you are misusing printf() after recvfrom() exits, since the client is not sending a null-terminated string, but %s expects one.

Try this instead:

Client.c

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>

int main()
{
    int network_socket = socket(AF_INET, SOCK_DGRAM, 0);
    if (network_socket < 0)
    {
        perror("socket() failed");
        return -1;
    }

    struct sockaddr_in server_address;

    bzero(&server_address, sizeof(server_address));
    server_address.sin_family = AF_INET;
    server_address.sin_port = htons(9002);
    server_address.sin_addr.s_addr = inet_addr("Server IP Address Here"); // or "127.0.0.1" for localhost

    if (sendto(network_socket, 0, 0, MSG_CONFIRM, (struct sockaddr *) &server_address, sizeof(server_address)))
    {
        perror("sendto() failed");
        close(network_socket);
        return -1;
    }

    char server_response[256];

    struct sockaddr_in sender_address;
    socklen_t addrlen = sizeof(sender_address);

    int n = recvfrom(network_socket, server_response, sizeof(server_response), 0, (struct sockaddr*) &sender_address, &addrlen);
    // or, since you are not using the sender's sockaddr_in for anything:
    // int n = recvfrom(network_socket, server_response, sizeof(server_response), 0, NULL, NULL);
    if (n < 0)
    {
        perror("recvfrom() failed");
        close(network_socket);
        return -1;
    }

    printf("The server sent the data : %.*s\n", n, server_response);

    close(network_socket);
    return 0;
}

Server.c

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>

int main()
{
    char server_message[] = "you have reached the UDP server";

    int server_socket = socket(AF_INET, SOCK_DGRAM, 0);
    if (server_socket < 0)
    {
        perror("socket() failed");
        return -1;
    }

    struct sockaddr_in server_address;

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

    if (bind(server_socket, (struct sockaddr *) &server_address, sizeof(server_address)) < 0)
    {
        perror("bind() failed");
        close(server_socket);
        return -1;
    }

    char client_message[256];

    struct sockaddr_in client_address;
    socklen_t addrlen = sizeof(client_address);

    int n = recvfrom(server_socket, client_message, sizeof(client_message), 0, (struct sockaddr *) &client_address, &addrlen);
    if (n < 0)
    {
        perror("recvfrom() failed");
        close(server_socket);
        return -1;
    }

    printf("The client sent the data : %.*s\n", n, client_message);

    if (sendto(server_socket, /*client_message*/server_message, /*n*/strlen(server_message), 0, (struct sockaddr *) &client_address, addrlen) < 0)
    {
        perror("sendto() failed");
        close(server_socket);
        return -1;
    }

    close(server_socket);
    return 0;
}