Ciao a tutti,
ho scritto una mini classe che mi gestisce la comunicazione in udp.

socket.h
codice:
#ifndef SOCKET_H_INCLUDED
#define SOCKET_H_INCLUDED

#include <stdio.h>

#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>

#include <string.h>
#include <stdlib.h>
#include <unistd.h>

#include <errno.h>

//class for udp connections
class connection{

    private:
        int ip;
        int port;

        int udp_socket;
        int sockaddr_in_size;
        struct sockaddr_in server_address;
        struct timeval tv;

    public:
        connection();   //constructor
        ~connection();  //destructor

        int start(char *in_ip, int in_port, int timeout);    //get ip and port

        //send data to server
        //RETURN: number of bytes sent
        //or 0 in case of error
        int send(char *data, long size);

        //recive data from server
        //RETURN: number of bytes recived
        //or 0 in case of error
        int recv(char *data, long size);

};


#endif // SOCKET_H_INCLUDED
socket.cpp
codice:
#include "socket.h"

connection::connection(){

    sockaddr_in_size = sizeof(server_address);

    udp_socket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);

    if(udp_socket < 0)
        printf("socket() error\n");

}

connection::~connection(){

    int err = 0;
    err = shutdown(udp_socket, SHUT_RDWR);

    if(err < 0)
        printf("shutdown() error: %s\n", strerror(errno));

}

int connection::start(char *in_ip, int in_port, int timeout){

    int err;

    //here i should implement some kind of control for ip address!!!!
    //and maybe some timeout bounds...

    tv.tv_sec = timeout;
    tv.tv_usec = 0;

	server_address.sin_family = AF_INET;
	server_address.sin_port = htons(in_port);
	server_address.sin_addr.s_addr = inet_addr(in_ip);

	err = setsockopt(udp_socket, SOL_SOCKET, SO_RCVTIMEO, (char *)&tv, sizeof(tv));

    if(err < 0){
        printf("setsockopt() error: %s\n", strerror(errno));
        return 0;
    }

    return 1;
}

int connection::send(char *data, long size){

    int err = 0;
    err = sendto(udp_socket, data, size, 0, (sockaddr *) &server_address, sockaddr_in_size);

    if(err<0){
        printf("sendto() error: %s\n", strerror(errno));
        return 0;
    }

    return err;
}

int connection::recv(char *data, long size){

    int err = 0;
    err = recvfrom(udp_socket, data, size, 0, (sockaddr *) &server_address, (socklen_t *) &sockaddr_in_size);

    if(err<0){
        printf("recvfrom() error: %s\n", strerror(errno));
        return 0;
    }

    return err;
}
Funziona per cio che ho bisogno di fare, ma essendo la prima volta che ho a che fare con udp un dubbio mi assilla:

la grandezza del pacchetto che devo ricevere con connection::recv è fissa e decisa da chi me lo manda, ma io come faccio a sapere se ho ricevuto tutti i dati oppure manca ancora qualcosa? Se devo ricevere molti dati infatti saranno spezzettati in piu tranche da ricevere con recvfrom()... però io non so quante volte devo eseguire tale comando per essere sicuro di aver ricevuto tutta la risposta.
Lo saprei fare in TCP con recv(), ma qui non sono sicuro di come risolvere.

Grazie a tutti,
Marco