salut,
mon probleme est le suivant :
je veut faire un tunnel vpn entre deux pc (client et serveur) en programmation en language c sous windows;  
je dispose au depart de deux cartes reseaux virtuels une est installé coté client et l'autre coté serveur  
les deux sont nommées "TAP01" les instructions à réaliser est les suivantes:
1- ouvrir une socket de connexion entre le client et le serveur en mode connecté
2-coté client:
 2.1-lire les données du TAP01 (ReadFile)
 2.2-envoyer ces données via la socket vers le serveur (send)
 2.3-recevoir les données venant du serveur via sa socket (recv)
 2.4-ecrire les données reçus sur le TAP01 (WriteFile)
tous ces instructions sont dans un boucle while
 
while (1) {
 
 //*************************lecture*************************
    if(ReadFile(hTap, Buf, sizeof(Buf), &dwLen, &ovl))
   {  
 //**************** send ***************************
   nombre_de_caractere=send(id_de_la_socket,Buf,dwLen,0);
   }
   
// Reception des données
      // ********************************************************
     nombre_de_caractere=recv(id_de_la_socket,Buf,sizeof(Buf),0);
   
  if (nombre_de_caractere==SOCKET_ERROR)
            printf("\nDesole, je n'ai pas recu de donnee" );
        else    
    {  
  //*****************************ecriture*************************************
    WriteFile(hTap, Buf,nombre_de_caractere, &dwLen, &ovl)  
    }
 
}//fin while
 
3-coté serveur:
 3.1-recevoir les données venant du client via sa socket (recv)
 3.2-ecrire les données reçus sur son TAP01 (WriteFile)
 3.3lire les données du son TAP01 (ReadFile)
 3.4-envoyer les données lus via sa socket vers le client (send)
de meme ces instructions sont dans un boucle while
 
while (1) {
 
// Reception des données
      // ********************************************************
     nombre_de_caractere=recv(id_de_la_socket,Buf,sizeof(Buf),0);
   
  if (nombre_de_caractere==SOCKET_ERROR)
            printf("\nDesole, je n'ai pas recu de donnee" );
        else    
    {  
  //*****************************ecriture*************************************
    WriteFile(hTap, Buf,nombre_de_caractere, &dwLen, &ovl)  
    }
 //*************************lecture*************************
    if(ReadFile(hTap, Buf, sizeof(Buf), &dwLen, &ovl))
   {  
 //**************** send ***************************
   nombre_de_caractere=send(id_de_la_socket,Buf,dwLen,0);
   }
   
 
}//fin while
 
tous marche bien sans erreur lors du test le ping du client vers le serveur marche bien  
mais dans l'autre sens (serveur vers client)ne marche pas sauf lorsque je ping coté client et simultanement coté serveur.
j'arrive à constater que le probleme est que le recv du serveur est bloqué.
j'ai essayé avec les socket non bloquante mais cela ne resoud pas le probleme (probleme de synchronization)
je n'arrive pas à resoudre ce probleme qui m'ennuie
je serais heureuse si quelqu'un peut m'aider

Je suppose que tu veux dire que la fonction recv() du serveur renvoie toujours SOCKET_ERROR. dans ce cas il faut appeler WSAGetLastError() qui retourne le code erreur. Généralement c'est un pb d'initialisation qui fait que le truc marche a moitié.

merci de me répondre mais ce n'est pas le cas la fonction recv du serveur marche bien le serveur est en attente de la réception de données c'est pour cela il ne passe pas à exécuter les instructions suivantes (donc la valeur de retour de la fonction recv est different de SOCKET_ERROR) viola ce que j'ai fait

le serveur affiche "receive:             ok"
 

J'ai pas compris où est ton pb. A l'emission a la reception ? sur le serveur ou sur le client ?
Mais je pense que se doit etre un pb d'initialisation. la fonction send() retourne aussi une erreur SOCKET_ERROR dont tu trouves le code avec WSAGetLastError(). donc teste. C'est aussi le cas lors de la création par socket().
 
ReadFile() et WriteFile() quand ils sont utilisé en asynchrone doivent etre over en OVERLAPPED avec avec une structure ovl (ce que tu semble faire). dans ce cas la valeur que tu trouveras dans ton dwLen sera nulle. Faut lire la structure de ovl.
sinon essaie d'ouvrir en synchro et mets  NULL a la place de &ovl  pour forcer ReadFile() a utiliser dwLen.
 
Tout ca dépend de comment est ouvert le socket.
 

merci pour votre temps à me repondre mon probleme est à la reception des données coté serveur le serveur se bloque en attendent les données venant de client alors que je veut qu'il passe à excuter les instructions suivantes ( ReadFile() et send()) donc je doit debloquer le recv tanqu'il n'y a pas de données à recevoir, passer à executer les instructions suivantes.

si recv() attend sans rien recevoir, c'est :
soit parce que le socket est mal ouvert (a t'il ete testé ?)  
soit que le send() en face de marche pas (idem).
soit les 2.

salut,
A propos de mon problème est ce que je peut la résoudre en créant deux threads l'un destiné pour le ReadFile et le send et l'autre destiné pour la recv et le WriteFile ces deux threads partages la même socket et la même tap.est ce que c'est faisable ou non, sinon comment je doit les suggestionnées(les threads)?
merci d'avance.

Si du point de vu communication parler et entendre sont deux fonctions complémentaires de meme nature, ce n'est pas le cas du point de vu des programmes qui utilisent la communication.  
Parler est une action volontaire de la part du prog envoyant le message (comme n'importe quelle fonction executé par un algo).  
Par conte Entendre est passive, car independante de la volonté du prog qui recoit le message. Il nécessite un prog qui passe son temps a attendre(écouter) la bonne volonté de quelque chose qui lui est extérieur.
Ce concept est général en info dans la communication avec les périphériques, a commencer par le clavier et la souris. Pour répondre a ca, on a inventé la programmation événementielle. Basée sur un processus qui gere l'attente des événements extérieurs qui quand il en trouve un, envoie une notification au procesus principal du prog qui lui ne s'arrete jamais pour attendre l'extérieur.
 
En clair, il est tout a fait indiqué de mettre la boucle de reception qui passe son temps attendre, dans un thread différent de celui du prog. Seulement que tu vas te retrouver avec un nouveau défit de programmation : gerer la communication entre thread.