Bonjour,

j'ai une classe qui me permet de lire les données UDP d'un PC client :
Code c++ : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
 
#include <iostream>
#include <cstring>
#include "SocketClass.h"
 
 
using namespace std;
 
SocketClass::SocketClass(int port)
{
    this->port = port;
    this->socketError = NO_ERROR;
	this->sec = 5;
	this->usec = 0;
}
 
SocketClass::~SocketClass()
{
	if (socketError == NO_ERROR)
	{
		socketError = shutdown(socketServer, SD_BOTH);
		socketError = closesocket(socketServer);
	}
 
	WSACleanup();
}
 
/**
Initialisation du socket
**/
int SocketClass::initSocket()
{
    WSADATA WSAData;
 
    socketError = WSAStartup(MAKEWORD(2,2), &WSAData);    // initialisation du socket, utilisation de la verions 2.0 de winsock
    if (socketError!=NO_ERROR)
    {
        return socketError;
    }
 
    // initialisation du socket
    sin.sin_addr.s_addr	= htonl(INADDR_ANY);    // pas d'adresse, mode serveur
    sin.sin_family		= AF_INET;              // protocole IPv4
    sin.sin_port		= htons(port);          // port
 
 
    // création du socket
    socketServer = socket(AF_INET, SOCK_DGRAM, 0);
 
    if (socketServer == INVALID_SOCKET)
    {
        socketError = INVALID_SOCKET;
        //WSACleanup();
        return INVALID_SOCKET;
    }
 
 
	// bind
    socketError = bind(socketServer, (SOCKADDR *)&sin, sizeof(sin));
    if (socketError == SOCKET_ERROR)
    {
        //WSACleanup();
        return SOCKET_ERROR;
    }
 
	// taille du buffer de lecture
    socketError = setsockopt(socketServer, SOL_SOCKET, SO_RCVBUF, (char*)&data, sizeof(data));
    if (socketError == SOCKET_ERROR)
    {
       // WSACleanup();
        return SOCKET_ERROR;
    }
 
	socketError = NO_ERROR;
    return NO_ERROR;
}
 
/**
Fermeture du socket
**/
int SocketClass::closeSocket()
{
	if (socketError == NO_ERROR)
	{
		socketError = shutdown(socketServer, SD_BOTH);
		socketError = closesocket(socketServer);
	}
 
	WSACleanup();
 
    return socketError;
}
 
/**
Time out sur le socket
**/
void SocketClass::setTimeOut(int sec, int usec)
{
	this->sec = sec;
	this->usec = usec;
}
 
 
/**
Lecture des données
**/
int SocketClass::readData()
{
    int sinSize;
    int len;
 
    fd_set fd;
    timeval tv;
 
    sinSize = sizeof(sin);
    len = NO_ERROR;
 
	if (socketError == NO_ERROR)
	{
		//while(1)
		{
			FD_ZERO(&fd);
			FD_SET(socketServer, &fd);
 
			tv.tv_sec = sec;		// timeout sur la méthode accept
			tv.tv_usec = usec;
 
			if (select(0, &fd, NULL, NULL, &tv) > 0)
			{
				len = recvfrom(socketServer, (char*)&data, sizeof(data), 0, (SOCKADDR *)&sin, &sinSize);
 
				/*if (len > 0)
					break;*/
			   /* if (len == SOCKET_ERROR)
					break;*/
			}
		}
	}
 
	//Sleep(20);
 
    return len;
}

Le client m'envoie les données en continue. Et mon serveur, lui ne lit les données avec la fonction readData() qui est appelée 1 fois par seconde. Je reçois donc plus de données que je n'en lis.

Or il semblerait que les données soient stockées dans une pile FIFO et lors de la lecture du buffer je ne lis que la 1ère donnée reçue (la plus ancienne), or moi ce qui m'intéresse c'est la dernière donnée (la plus récente).
J'ai pourtant précisé que la taille du buffer de lecture était de la taille de ma variable data.

Comment je dois modifier mon code pour ne récupérer que la dernière donnée reçue et jeter le reste ?