Transfert d'information

[invite849f6457]

Bonjour,
je me présente charléne, je suis étudiante en licence.
Lors de cette licence j'ai un projet a réaliser.
Se projet consiste a réaliser un programme qui permet de transférer d'un pc A a un pc B des informations en temp réel via le réseau internet.
pour notre application nous pouvons considérer que nous connaissons l'adresse IP du pc A ainsi que celui du pc B.
Alors voila ma question, comment puis je m'y prendre?
en sachant que je maitrisse un peut le c++, mais je ne sais pas si cela est possible si juste avec l'adresse IP on peut communiquer avec le pc.
J'ai donc penser faire une page php qui permettrais la communication avec le pc B qui vient scruter cette page.
Bref je ne sais pas trop comment m'y prendre si vous aviez deux trois idées, ou mieux si vous saviez que c'est possible en m'expliquant comment faire je vous serais trés reconnaisant.

Amicalement
charléne
-----

[invite89303051]

Bonjour,

C'est plus un problème de développement que d'électronique. Mais un simple programme Client/Serveur utilisant des sockets (avec éventuellement translation NAT sur les ports pour router les messages sur les bonnes machines) ne doit pas prendre plus d'une heure de développement.
Il suffit de voir la foultitude d'exemple sur le net.
Après, s'il faut récupérer les informations d'une interface spéciale, c'est une autre affaire, mais il faut plus d'informations.

Cordialement

[invite849f6457]

Bonjour RicounetZat et merci de prendre quelques instants pour mon probléme.
il te faut plus d'information a quel sujet?
donc mon projet et d'avoir un capteur ( de pression température ou autres ) par exemple a lyon, je vais faire un boitier pour numériser le signal récupérer les infos de se capteur sur le port paralléle de mon pc a lyon ( je compte ensuite améliorer le systéme pour passer par usb mais ceci est une autre histoire ).
Ensuite j'envoi les infos sur un autre pc ( exemple paris ).
Donc comment envoyé les infos de se capteur en temp réel a mon pc qui est a paris.
"Mais un simple programme Client/Serveur utilisant des sockets (avec éventuellement translation NAT sur les ports pour router les messages sur les bonnes machines) ne doit pas prendre plus d'une heure de développement.
Il suffit de voir la foultitude d'exemple sur le net."
Bon donc visiblement sa m'a l'air plutot trés simple vue comme ceci.
je ne connais pas trés bien le fonctionnement client/serveur, "sockets" j'i déja entendu se mot mais sa signification ...
il y a apparement full exemple sur le net, comment a tu trouver les exemples?
qu'a tu écrit sur google pour les trouver? et quel language est utiliser ( au pire j'achéterais le livre "se language pour les nuls" ^^

Amicalement
Charléne

[invite89303051]

Bonjour,

Cela se complique un peu.
Il faut donc :

• 1 capteur
• 1 interface de lecture pour mettre en forme les informations du capteurs et les envoyer au PC.
• 1 PC pour envoyer l'information sur un autre PC (ou mac ou tout autre ensemble permettant de se connecter au net)
• 1 PC pour recevoir les données et afficher les informations

Concernant le développement, regardes sur le site http://www.developpez.com ou tu trouveras surement des exemples en C, C++, C#, Java, PHP.

Pour Java : http://gfx.developpez.com/tutoriel/java/network/

Après, il y a pleins de solutions, tu peux faire ta propre carte intégrant un stack ip, ou utiliser une mini carte style Arduino, tout cela dépendant également du capteur.
Tu peux utiliser un PC pour mémoriser les données horodatées pour une consultation ultérieure, implémenter un serveur Web avec graphes de variation etc...

Je pense qu'il faut préciser ton projet : faire la carte d'acquisition et/ou la carte d'interface et/ou les logiciels sur le PC ou juste faire un schéma de principe et tout cela en fonction de tes capacités, du temps et des moyens mis en œuvre pour accomplir cette tache.

Cordialement

[A voir en vidéo sur Futura]

[invite849f6457]

Re,
pour le capteur et l'acquisition des données sur le port paralléle je ne m'inquiéte pas trop je converti et mets en forme les données du capteur, relativement facile.
ensuite reception sur le port ( j'ai déja utiliser le port paralléle dans un autre projet en c++ et c'est trés facile a utiliser donc je considére cela comme régler ).
le seul sujet que je n'est jamais aborder et qui de se fait m'inquiéte un peu c'est vraiment l'envoie de ces donnée je vais regarder, le lien que tu m'a donné pour le java, il me semble pas mal, je vais creser la dessus.
Encore merci

amicalement
charléne

[invite849f6457]

Désoler pour le double post mais du coup je me suis pencher sur les sockets, et j'ai trouver quelque truck interrésant.
étant donné que j'ai quelques notion en c++ et que pour la réception des données du capteur sur le pc je vais utiliser le c++ autant utiliser se méme language pour l'envoi des données.
http://c.developpez.com/cours/socket...p-demystifies/

SOCKET sock;
SOCKADDR_IN sin;
sin.sin_addr.s_addr = inet_addr("127.0.0.1");
sin.sin_family = AF_INET;
sin.sin_port = htons(4148);
sock = socket(AF_INET,SOCK_STREAM,0);
bind(sock, (SOCKADDR *)&sin, sizeof(sin));

Donc si j'ai bien comprit dans "sin_addr.s_addr" il me suffit de mettre l'adresse IP du PC B (celui qui va recevoir les infos envoyé par le PC A) qui va recevoir les infos.
Et dans "sin_port" htons(23) pour utiliser le réseau internet ( en admettant que internet soit relier par la prise Ethernet et pas par Wifi ).
J'espére avoir bien comprit.
quand pense tu RicounetZap?

Amicalement
charléne

[invite89303051]

Bonjour

Le morceau de code que tu présentes permet juste d'ouvrir un socket sur la loopback de ta carte (adresse 127.0.0.1) sur le port 4148
En général, si tu veux travailler en mode connecté (SOCK_STREAM) il faut avoir une partie serveur, utilisant l'instruction listen(); et une partie cliente utilisant la fonction connect();
Le serveur est en attente de connection du client.
Pour la partie serveur, le code en fin de page de ton lien est simple à comprendre, il suffit juste de modifier la partie cliente juste au dessus pour se connecter à l'adresse du serveur sur le port 23 .

Après, tu fait passer ce que tu veux dans le message, du texte, du binaire etc...

Cordialement

[invite849f6457]

Pas encore couché ^^
moi non plus j'ai tester deux trois truck pas trés concluant...
si je prend deux de mes pc relier ensemble par un cable eternet celui qui emet devient il "l'hebegeur"? qu'elle est le code que je doit mettre sur celui qui emets et le code sur celui qui reçoi?
car j'ai pas tous comprit.

cordialement
charléne

[invite849f6457]

Me revoila

alors voila se que j'ai fait
Client

void __fastcall TForm1::Button1Click(TObject *Sender)
{
WSADATA WSAData; //initialisation WSADATA utilisée pour le démarrage de WSAStartup()
WSAStartup(MAKEWORD(2,0), &WSAData); // permet de dire à l'ordinateur que vous allez utiliser des sockets
//Création du socket
SOCKET sock; // init de la variable sock type socket
SOCKADDR_IN sin; //SOCKADDR contient les informations techniques du socket
sin.sin_addr.s_addr = inet_addr("adresse de mon pc A"); //adresse du serveur
sin.sin_family = AF_INET; //type de socket
sin.sin_port = htons(23); //utilisation du port telnet
sock = socket(AF_INET,SOCK_STREAM,0); //création su socket ( STREAM aprés il faut faire accept() ou de connect() et pas DGRAM)
bind(sock, (SOCKADDR *)&sin, sizeof(sin)); //attache le socket directement au port et à l'adresse
//connection avec le serveur
connect(sock, (SOCKADDR *)&sin, sizeof(sin)); //permet de se connecter
send(sock, "Ceci est un test!\r\n", 19, 0); //envoi d'un string de 19 caracteres
closesocket(sock); // ferme le socket

WSACleanup(); //nettoyage WSA
}

serveur

void __fastcall TForm1::Button1Click(TObject *Sender)
{
WSADATA WSAData; //initialisation WSADATA utilisée pour le démarrage de WSAStartup()
WSAStartup(MAKEWORD(2,0), &WSAData); // permet de dire à l'ordinateur que vous allez utiliser des sockets

SOCKET sock; // init de la variable sock type socket
SOCKADDR_IN sin; //SOCKADDR contient les informations techniques du socket
sin.sin_addr.s_addr = inet_addr("adresse de mon pc A"); //adresse du serveur
sin.sin_family = AF_INET; //type de socket
sin.sin_port = htons(23); //utilisation du port telnet
sock = socket(AF_INET,SOCK_STREAM,0); //création su socket ( STREAM aprés il faut faire accept() ou de connect() et pas DGRAM)
bind(sock, (SOCKADDR *)&sin, sizeof(sin)); //attache le socket directement au port et à l'adresse

listen(sock, 0); //scrutation du port du socket, Le 1er paramètre, sock, est le socket sur lequel le listen() écoutera. Le 2ème paramètre s'appelle le BACKLOG. C'est le nombre maximum de connexions qui seront écoutées en même temps.
int val = 0; //déclaration d'une variable, utiliser pour le retour de accept, vérification du socket
while(CheckBox1->Checked==FALSE )
{
int sizeof_sin = sizeof(sin); //définition de la taille du socket
val = accept(sock, (SOCKADDR *)&sin, &sizeof_sin); //permet d'accepter une connexion
if(val != INVALID_SOCKET) //vérification de "validité" du socket
{
Label1->Caption="reçu";
}
}

closesocket(sock);
WSACleanup(); //nettoyage WSA

}

[invite849f6457]

désoler pour le double poste je n'ai pas pu éditer mon message
donc je pense que je n'arrive pas a me connecter a mon pc A.
J'ai fait du pas a pas et lors de la commande connect() il me faut bien 10 secondes pour passer a la ligne suivante et mon label de change jamais.
Il y a donc un élément qui m'échappe, mais quoi ??

[Jack]

Cette discussion a plus sa place dans le forum informatique vers lequel je la déplace.

[invite89303051]

Bonjour,

Pour la partie serveur, tu peux choisir IN_ADDR_ANY comme adresse de réception, à moins que tu aies plusieurs interfaces réseaux sur ta machine.
Pour le code, c'est presque ça. En gros, le serveur ouvre un socket, bind sur un port spécifique et passe en attente.
Pour le client, il ouvre un socket, bind sur n'importe quel port, rempli les infomations pour accéder à l'emetteur (Adresse et port du serveur) et fait une tentative de connexion.
Pour ton code, la partie cliente est un peu à revoir, tu ne peux pas te binder avec l'adresse du destinataire.
C'est un peu comme du téléphone, tu peux appeler quelqu'un de n'importe ou, il faut juste que le numéro soit correct, une fois mis en relation, la communication peut s'établir.
Cordialement

[invite849f6457]

Bonjour RicounetZap,
Merci de suivre le sujet
j'ai remplacer dans le programme du serveur l'adresse par IN_ADDR_ANY.
Je n'arrive pas a me connecter car mon serveur reste en attente, ma fonction connect() a éffectivement un probléme .
Donc pour le code du serveur je ne vois pas d'erreur tout a l'air de se passer correctement.
Maintenant pour le code du client, il faudrait ajouter
SOCKADDR_IN csin;
csin.sin_addr.s_addr = inet_addr("adresse de se PC et non du serveur");
csin.sin_family = AF_INET;
csin.sin_port = htons(23);
et pour mon bind je fais:
bind(sock, (SOCKADDR *)&csin, sizeof(csin));
et je ne change pas mon connecte, comme cela j'attache le socket au port de se PC avec le bind et ensuite je me connecte a l'adresse du serveur.
je vais test ceci encore merci.
Amicalement
Charléne

[invite89303051]

Bonjour,

Donc, si le bind s'est bien passé en utilisant la SOCKADDR_IN sSockAddrLocal, il faut maintenant définir à qui tu veux l'envoyer.
Il faut donc remplir une SOCKADDR_IN sSockAddrDistant en indiquant l'adresse du serveur, le port du serveur et faire le connect du style connect(sock, (SOCKADDR *)&sSockAddrDistant, sizeof(SOCKADDR_IN));

Si tu utilises inet_addr pour indiquer l'adresse du serveur, il faut prendre la notation aaa.bbb.ccc.ddd et pas mamachine.domaine.net

Et normalement, cela devrait fonctionner.

Cordialement

[invite849f6457]

WSADATA WSAData; //initialisation WSADATA utilisée pour le démarrage de WSAStartup()
WSAStartup(MAKEWORD(2,0), &WSAData); // permet de dire à l'ordinateur que vous allez utiliser des sockets
//Création du socket
SOCKET sock; // init de la variable sock type socket
SOCKADDR_IN csin;
csin.sin_addr.s_addr = inet_addr("aa.bb.cc.ddd"); //adresse de se PC
csin.sin_family = AF_INET;
csin.sin_port = htons(23);
SOCKADDR_IN sin; //SOCKADDR contient les informations techniques du socket
sin.sin_addr.s_addr = inet_addr("aa.bb.ccc.ddd"); //adresse du serveur
sin.sin_family = AF_INET; //type de socket
sin.sin_port = htons(23); //utilisation du port telnet
sock = socket(AF_INET,SOCK_STREAM,0); //création su socket ( STREAM aprés il faut faire accept() ou de connect() et pas DGRAM)
bind(sock, (SOCKADDR *)&csin, sizeof(csin));
//connection avec le serveur
connect(sock, (SOCKADDR *)&sin, sizeof(sin)); //permet de se connecter
send(sock, "Ceci est un test!\r\n", 19, 0); //envoi d'un string de 19 caracteres
closesocket(sock); // ferme le socket

WSACleanup(); //nettoyage WSA

voila se que j'ai fait mais pas concluant si mon adresse IP est par exemple 45.96.23.186 dois je mettre inet_addr("045.096.023.186) ou inet_addr("45.96.23.186) il n'y a pas de différence?

[invite89303051]

Bonjour,

Normalement, c'est la même chose, mais ces adresses ne sont pas des adresses privées. Pour les tests, peux tu mettre les 2 machines sur le même réseau local.
Il faut également vérifier les codes retour de tes fonctions réseau. Il peut y avoir des erreurs sur le bind si le service telnet est en cours de fonctionnement ou sur la fonction socket.
Peux tu décrire plus précisement la topologie de ton réseau ?

Cordialement

[invite849f6457]

Bonjour,
Alors aprés quelques recherche j'ai trouver des inforation assez étrange e la je suis complétement larger.
http://fr.wikipedia.org/wiki/Telnet#...a_et_Windows_7

Telnet est un protocole de type client-serveur basé sur TCP. Les clients se connectent généralement sur le port 23 du serveur.

je suis daccord avec sa

Depuis Windows Vista, le protocole réseau Telnet n'est plus activé par défaut. Microsoft explique son choix de le désactiver pour des raisons de sécurité, mais aussi car de moins en moins d'utilisateur y feraient appel. Il reste malgré tout possible de l'activer, que ce soit sous Vista ou Windows 7 : il faut exécuter la commande pkgmgr /iu:TelnetClient en tant qu'administrateur.

Donc la je ne cromprend plus rien...
Donc chez moi les deux pc sont connecter a internet par wifi, telnet étant un protocole nous pouvons l'utiliser quelque soit le support physique, cable ethernet ou wifi.
j'ai regarder la norme RFC 1010 telnet et bien le port 23 http://www.faqs.org/rfcs/rfc1010.html
mais es ce le port que je doit utiliser ?

Il peut y avoir des erreurs sur le bind si le service telnet est en cours de fonctionnement ou sur la fonction socket.

je ne comprend pas se que tu veut dire par la.
amicalement
charléne

[invite89303051]

Bonjour,

Telnet est un protocole qui s'appuie sur de la communication TCP, le serveur étant en écoute sur le port normalisé pour telnet, c'est à dire 23.
Un serveur apache ou IIS est en écoute sur le port 80, un serveur SSH sur le port 22.
Comme tu développes ton propre protocole, tu peux utiliser le port d'écoute que tu veux pour le serveur, il faut juste que ce port soit disponible.
En effet, si tu utilises le port 23 pour l'écoute et que tu as un serveur telnet en fonction sur la même machine, tu ne pourras pas binder/ouvrir la socket. D'ou l'interet de vérifier les code retours de ces fonctions.
Par contre, le port du client n'a pas d'importance, le serveur récupérant toutes les informations lors de la connexion.
Ensuite, selon tes machines, tu peux avoir les firewalls activés, donc empécher l'écoute et/ou l'émission des messages.
Si tu passes par le net, ton serveur est logiquement derrière un routeur. Ton client doit donc se connecter sur l'adresse IP de ton routeur et ton routeur doit être configuré pour faire de la redirection de port, c'est à dire que pour toute demande de connexion sur le port XX, il faut envoyer le message sur le port XX de la machine du réseau local à l'adresse aaa.bbb.ccc.ddd
Donc, pour les premiers tests, utilises le réseau local en vérifiant bien les firewalls.
Vérifie les codes d'erreur des fonctions (j'avais appris dans mon jeune temps que le traitement des erreurs étaient environ 80% d'un programme).
Lance d'abord le serveur, puis le client.

Cordialement

[inviteb9f49292]

2 conseils:
Absorbe ce cocument, c'est une très bonne référence pour la programmation d'application réseau...
Utilise Qt pour coder, ton code pourra alors être compilé sur une foultitude d'OS différents, et de plus je pense qu'il y a des classes qui doivent te faciliter la vie pour gérer l'aspect client / serveur

[invite849f6457]

Bonjour,
Donc j'ai relier mes deux pc par un cable réseau, j'ai accès au dossier de chaque ordinateur, pour étre sur j'ai lancer un jeu pour jouer en réseau et je peut rejoindre la parti créer donc mon réseau et OK.
Pour étre sur que le port telnet ne soit pas utilisé j'ai déconnecter mes deux pc d'internet, la seul connection qu'ils ont et le reseau local créer via le cable ethernet.
J'ai vérifier les pare-feu il sont bien débloquer pour mon appli.
ensuite je retest, donc en mode pas a pas le connect() se fait immédiatement pas comme au début ou il fallai une dizaine de secondes,je ne sais pas si c'est un avancement car du coté serveur je reste toujour bloqué sur accept() ...
Holalala pour un programme qui devais étre réaliser en une heure j'en suis a 3 jours Mais bon je ne me démoralise pas, je vais réussir
Je vais ajouter a mon code la gestion des codes erreurs et je vous tient au courant.

Amicalement
Charléne

[invite849f6457]

Me revoila
Avec une mauvaise nouvelle ;(
donc je complétement refait mon programme pour vérifier chaque étape de mon programme, j'ai mis beaucoup de commentaire pour mis retrouver cela donne un bien mais est un peut long.
Client

void __fastcall TForm1::Button1Click(TObject *Sender)
{
// ****************************** **************************
// Déclaration des variables
// ****************************** **************************

WSADATA initialisation_win32; // Variable permettant de récupérer la structure d'information sur l'initialisation
int erreur; // Variable permettant de récupérer la valeur de retour des fonctions utilisées
SOCKET sock; // init de la variable sock type socket
int tempo; // Variable temporaire de type int
SOCKADDR_IN information_sur_la_source; // Déclaration de la structure des informations lié à l'écoute
SOCKADDR_IN information_sur_la_destination ; // Déclaration de la structure des informations lié au serveur
int nombre_de_caractere; // Indique le nombre de caractères qui a été reçu ou envoyé
char buffer[65535]; // Tampon contenant les données reçues ou envoyées
char adresse_serveur [13];
strcpy(adresse_serveur,"aa.bb. cc.ddd");

// ****************************** **************************
// Initialisation de Winsock
// ****************************** **************************

erreur=WSAStartup(MAKEWORD(2,2 ),&initialisation_win32);
Memo1->Clear();
if (erreur!=0)
{
Memo1->Lines->Add("Desole, je ne peux pas initialiser Winsock");
}
else
{
Memo1->Lines->Add("\nInitialisation de Winsock OK");
}

// ****************************** **************************
// Ouverture d'une Socket
// ****************************** **************************

sock = socket(AF_INET,SOCK_STREAM,0); //création su socket ( STREAM aprés il faut faire accept() ou de connect() et pas DGRAM)
if (sock==INVALID_SOCKET) //test de la validité de la socket
{
Memo1->Lines->Add("\nDesole, je ne peux pas creer la socket");
}
else
{
Memo1->Lines->Add("\nCréation de la socket OK");
}

// ****************************** **************************
// Activation de l'option permettant d'activer l'algorithme de Nagle
// ****************************** **************************

tempo=1;
erreur=setsockopt(sock,IPPROTO _TCP,TCP_NODELAY,(char *)&tempo,sizeof(tempo));
if (erreur!=0)
{
Memo1->Lines->Add("\nDesole, je ne peux pas configurer cette option");
}
else
{
Memo1->Lines->Add("\nConfiguration des options OK");
}

// ****************************** **************************
// Ouverture de la session TCP sur destination de l'adresse IP aa.bb.cc.dd et du port xx
// ****************************** **************************

information_sur_la_destination .sin_family=AF_INET;
information_sur_la_destination .sin_addr.s_addr=inet_addr(buf fer); // Indiquez l'adresse IP de votre serveur
information_sur_la_destination .sin_port=htons(23); // Port écouté du serveur (23)
erreur=connect(sock,(struct sockaddr*)&information_sur_la_ destination,sizeof(information _sur_la_destination));
if (erreur!=0)
{
Memo1->Lines->Add("\nDesole, je n'ai pas pu ouvrir la session TCP" );
}
else
{
Memo1->Lines->Add("\nOuverture de session TCP OK");
}

// ****************************** **************************
// Envoi des données
// ****************************** **************************

strcpy(buffer,"Ceci est un test, pourvu que cela fonctionne je commence a en avoir ..."); // Copie la chaine de caractère dans buffer
nombre_de_caractere=send(sock, buffer,strlen(buffer),0);
if (nombre_de_caractere==SOCKET_E RROR)
{
Memo1->Lines->Add("\nDesole, je n'ai pas envoyer les données");
}
else
{
Memo1->Lines->Add("\nEnvoi des données OK");
}

// ****************************** **************************
// Fermeture de la session TCP Correspondant à la commande connect()
// ****************************** **************************

erreur=shutdown(sock,2); // 2 signifie socket d'émission et d'écoute
if (erreur!=0)
{
Memo1->Lines->Add("\nDesole, je ne peux pas fermer la session TCP");
}
else
{
Memo1->Lines->Add("\nFermeture de session TCP");
}

// ****************************** **************************
// Fermeture de la socket correspondant à la commande socket()
// ****************************** **************************

erreur=closesocket(sock);
if (erreur!=0)
{
Memo1->Lines->Add("\nDesole, je ne peux pas liberer la socket");
}
else
{
Memo1->Lines->Add("\nFermeture de la socket OK");
}

// ****************************** **************************
// Quitte proprement le winsock ouvert avec la commande WSAStartup
// ****************************** **************************

erreur=WSACleanup(); // A appeler autant de fois qu'il a été ouvert.
if (erreur!=0)
{
Memo1->Lines->Add("\nDesole, je ne peux pas liberer winsock");
}
else
{
Memo1->Lines->Add("\nQuitte winsock OK");
}

serveur

void __fastcall TForm1::Button1Click(TObject *Sender)
{

// ****************************** **************************
// Déclaration des variables
// ****************************** **************************

WSADATA initialisation_win32; // Variable permettant de récupérer la structure d'information sur l'initialisation
int erreur; // Variable permettant de récupérer la valeur de retour des fonctions utilisées
SOCKET sock; // init de la variable sock type socket
int tempo; // Variable temporaire de type int
SOCKADDR_IN information_sur_la_source; // Déclaration de la structure des informations lié à l'écoute
SOCKET id_de_la_nouvelle_socket; // Identifiant de la nouvelle socket
int nombre_de_caractere; // Indique le nombre de caractères qui a été reçu ou envoyé
char buffer[65535]; // Tampon contenant les données reçues ou envoyées

// ****************************** **************************
// Initialisation de Winsock
// ****************************** **************************

erreur=WSAStartup(MAKEWORD(2,2 ),&initialisation_win32);
Memo1->Clear();
if (erreur!=0)
{
Memo1->Lines->Add("Desole, je ne peux pas initialiser Winsock");
}
else
{
Memo1->Lines->Add("\nInitialisation de Winsock OK");
}

// ****************************** **************************
// Ouverture d'une Socket
// ****************************** **************************

sock = socket(AF_INET,SOCK_STREAM,0); //création su socket ( STREAM aprés il faut faire accept() ou de connect() et pas DGRAM)
if (sock==INVALID_SOCKET) //test de la validité de la socket
{
Memo1->Lines->Add("\nDesole, je ne peux pas creer la socket");
}
else
{
Memo1->Lines->Add("\nCréation de la socket OK");
}

// ****************************** **************************
// Activation de l'option permettant d'activer l'algorithme de Nagle
// ****************************** **************************

tempo=1;
erreur=setsockopt(sock,IPPROTO _TCP,TCP_NODELAY,(char *)&tempo,sizeof(tempo));
if (erreur!=0)
{
Memo1->Lines->Add("\nDesole, je ne peux pas configurer cette option");
}
else
{
Memo1->Lines->Add("\nConfiguration des options OK");
}

// ****************************** **************************
// Lie la socket à une ip et un port d'écoute
// ****************************** **************************

information_sur_la_source.sin_ family=AF_INET;
information_sur_la_source.sin_ addr.s_addr=INADDR_ANY; // Ecoute sur toutes les IP locales
information_sur_la_source.sin_ port=htons(23); // Ecoute sur le port 23
erreur=bind(sock,(struct sockaddr*)&information_sur_la_ source,sizeof(information_sur_ la_source));
if (erreur!=0)
{
Memo1->Lines->Add("\nDesole, je ne peux pas ecouter ce port");
}
else
{
Memo1->Lines->Add("\nEcoute du port OK");
}

// ****************************** **************************
// Attente d'ouverture de session
// ****************************** **************************

erreur=99; // Initiation de erreur pour être sur que l'on va rentrer dans la boucle
while(erreur!=0) // Boucle tant qu'une demande de session (SYN) tcp n'a pas été reçu
{
erreur=listen(sock,1);
Memo1->Lines->Add("\nattente d'établicement de session TCP");
}
Memo1->Lines->Add("Une session TCP a été établie");

// ****************************** **************************
// Acceptation de la demande d'ouverture de session
// ****************************** **************************

tempo=sizeof(information_sur_l a_source); // Passe par une variable afin d'utiliser un pointeur
id_de_la_nouvelle_socket=accep t(sock,(struct sockaddr*)&information_sur_la_ source,&tempo);
if(id_de_la_nouvelle_socket==I NVALID_SOCKET)
{
Memo1->Lines->Add("\nDesole, je ne peux pas accepter la session TCP");
}
else
{
Memo1->Lines->Add("\nsession TCP OK");
}

// ****************************** **************************
// Reception des données
// ****************************** **************************

nombre_de_caractere=recv(id_de _la_nouvelle_socket,buffer,151 5,0);
if (nombre_de_caractere==SOCKET_E RROR)
{
Memo1->Lines->Add("\nDesole, je n'ai pas recu de donnee");
}
else
{
buffer[nombre_de_caractere]=0; // Permet de fermer le tableau après le contenu des data, car la fonction recv ne le fait pas
Memo1->Lines->Add("\nVoici les donnees : ");
Memo1->Lines->Add(buffer);
}

// ****************************** **************************
// Fermeture de la session TCP Correspondant à la commande connect()
// ****************************** **************************

erreur=shutdown(sock,2); // 2 signifie socket d'émission et d'écoute
if (erreur!=0)
{
Memo1->Lines->Add("\nDesole, je ne peux pas fermer la session TCP");
}
else
{
Memo1->Lines->Add("\nFermeture de session TCP");
}

// ****************************** **************************
// Fermeture de la socket correspondant à la commande socket()
// ****************************** **************************

erreur=closesocket(sock);
if (erreur!=0)
{
Memo1->Lines->Add("\nDesole, je ne peux pas liberer la socket");
}
else
{
Memo1->Lines->Add("\nFermeture de la socket OK");
}

// ****************************** **************************
// Quitte proprement le winsock ouvert avec la commande WSAStartup
// ****************************** **************************

erreur=WSACleanup(); // A appeler autant de fois qu'il a été ouvert.
if (erreur!=0)
{
Memo1->Lines->Add("\nDesole, je ne peux pas liberer winsock");
}
else
{
Memo1->Lines->Add("\nLiberation de winsock OK");
}

donc coté serveur sur le memo on a : Une session TCP a été établie, je suis donc bloqué a accept().
coté client je n'ai pas réussi a ouvrir une session TCP
voila le memo

Initialisation de Winsock OK
Création de la socket OK
Configuration des options OK
Desole, je n'ai pas pu ouvrir la session TCP
Desole, je n'ai pas envoyer les données
Desole, je ne peux pas fermer la session TCP
Fermeture de la socket OK
Quitte winsock OK

J'ai donc un probléme avec mon connect()
Es ce un probléme de code, de matériel, de port enfin je ne sais pas aider moi svp

Amicalement
Charléne

[invite89303051]

Bonsoir,
Il n'y a pas de bind sur la socket cliente. Je pense que l'erreur vient de la.
Cordialement

[invite849f6457]

J'ai ajouter WSAGetLastError() lors d'une erreur, cette fonction me renvoi 5, génial je connais le code erreur mais je n'arrive pas a trouver a quoi il correspond

[invite89303051]

5 -> Accès refusé
Cordialement

[invite849f6457]

donc j'ai ajouter un bind sur le code client aprés activation de l'option.

// ****************************** **************************
// Lie la socket à une ip et un port d'écoute
// ****************************** **************************

information_sur_la_source.sin_ family=AF_INET;
information_sur_la_source.sin_ addr.s_addr=inet_addr(adresse de se PC); // Ecoute sur toutes les IP locales
information_sur_la_source.sin_ port=htons(23); // Ecoute sur le port 23
erreur=bind(sock,(struct sockaddr*)&information_sur_la_ source,sizeof(information_sur_ la_source));
if (erreur!=0)
{
Memo1->Lines->Add("\nDesole, je ne peux pas ecouter ce port");
Memo1->Lines->Add(WSAGetLastError());
}
else
{
Memo1->Lines->Add("\nEcoute du port OK");
}

je vous laisse devinez se qu'il me dit ^^ erreur 5
que fait on maintenant?

amicalement
charléne

[invite849f6457]

HEY SALUT LES AMIS
j'ai une bonne et une mauvaise nouvelles, je commence par la mauvaise, je suis une vrai blonde les adresses ip que j'utilisais n'étais pas les bonnes donc si vous voulez connaitre votre adresse IP dans la commande faite ipconfig/all .
LA BONNE NOUVELLE bah c'est qu'avec les bonnes IP cela fonctionne a merveille pas besoin de mettre de bind dans l'appli client donc les softs que j'ai mis au dessus fonctionnent trés bien.
UN GRAND MERCI A TOI RicounetZap tu m'a beaucoup aider dans le dévellopement mais aussi mentalement, j'étais a deux doigt de tout arréter et tu venais me donner un éclaircissement et hop c'étais reparti, donc merci beaucoup.
Maintenant il faut que je passe par internet et non par un réseau local, mais pour se soir se sera tout ^^

Amicalement
Charléne