[..] Envoi/Réception d'un message sur un réseau

[rougipa]

Bonjour,

J'ai connecté deux PC (un Windows XP et un Windows Seven) avec un cable croisé pour établir un réseau.

J'aimerais savoir comment envoyer un message du premier au second ordinateur en AutoIt et que le second ordinateur sache l'interpréter.

Par exemple, comment envoyer de PC1 à PC2 le message "Hello World" et que le second PC, une fois le message reçu affiche une message box contenant "Hello World" ?

Je suis assez débutant en AutoIt, et je ne me suis encore jamais interessé à ce qui touche à un réseau.

Si vous pourriez ne serait-ce que m'indiquer le nom de fonctions qui pourraient m'aider (afin que je comprenne leur fonctionnement dans l'aide de Scite), je vous en serais reconnaissant

Merci !

[TT22]

Salut, j'avais déjà fais ça pour un autre membre du forum (il faut faire plus de recherches) :
Il y a un receveur et un expéditeur, le receveur est lancé en permanence (il recherche si un message a été reçu) et l'expéditeur est à lancer seulement quand vous voulez envoyer un message.
Il fonctionne simplement en créant un fichier dans les documents partagé

receveur :

► Afficher le texte

Code : Tout sélectionner

$adresse = @ScriptDir[color=#00BF00]; Adresse du dossier des fichiers partagés (sans contre-slash à la fin). Exemple : "\\NOM-DU-PC\Public"[/color]
While 1
    $exist = FileExists($adresse&"\message")
    If $exist = 1 Then
        $message=FileRead($adresse&"\message")
        MsgBox(64,"Message","Vous avez reçu un message :"&@CRLF&$message)
        FileDelete($adresse&"\message")
    EndIf
    Sleep(1000)
WEnd

expéditeur

► Afficher le texte

Code : Tout sélectionner

$adresse = @ScriptDir[color=#00BF00]; Adresse du dossier des fichiers partagés (sans contre-slash à la fin). Exemple : "\\NOM-DU-PC\Public"[/color]
$message=InputBox("Envoie","Veuillez entrer le messge à envoyer :")
FileWrite($adresse&"\message",$message)

[DimVar]

[Reflexe systeme ON]
CHMODer le dossier de partage
[Reflexe systeme OFF]

[ZDS]

Bonjour,

Passer par des fichiers temporaires pour faire discuter deux ordis me semble être un peu... Bref, autre solution que je trouve plus logique, l'envoi de messages par TCP Send/Recv. Voici les fonctions en question :
- TCPStartup pour lancer le système de communication
- TCPShutdown pour l'éteindre
- TCPListen pour créer une "boîte de reception", un tunnel de communication appelé socket
- TCPAccept pour ouvrir la connexion (entrante) sur la socket (en gros, accepte les receptions)
- TCPConnect pour établir une connexion (sortante) sur une socket (en gros, accepte les envois)
- TCPRecv pour écouter les messages présent dans la socket
- TCPSend pour envoyer des messages sur une socket

Je te prépare un exemple d'ici qq minutes.

A bientôt.

PS: TT22 et DimVar, votre solution ressemble un peu à deux gars qui discutent en face l'un de l'autre, mais au lieu de parler, ils s’envoient des post-its... Aberrant, non? ^^

[DimVar]

Désolé, je ne vois rien d'aberrant là-dedans.
C'est certes, simpliste et basique, mais compréhensible.
Il s'agit d'un utilisateur qui débute en Autoit et en réseau. (voir son post)
Je ne pense donc pas qu'il faille le noyer dans des notions TCP dés le début (au risque de passer 2 jours à lui expliquer les fondamentaux), mais le laisser découvrir les limites de ce script et lui donner envie d'aller plus loin si besoin.
Ce n'est que mon humble avis.

[ZDS]

Sans être non plus un puriste, je suis en train de créer 2 fonctions : une qui s'appelle sendMsg() pour envoyer un message, l'autre recvMsg pour recevoir un message. Deux fonctions qui auront un code certes un petit peu complexe (même si je considère que ça ne l'est pas, même pour un débutant, car des commentaires suffisent à comprendre comment ça fonctionne), mais qui auront une utilisation très simple.

TCP n'a de compliqué que la théorie. Sans aller dans les détails, c'est quand même simple :
- Celui qui veut recevoir un message, ouvre un tunnel, et regarde ce qui apparaît dedans.
- Celui qui veut envoyer un message, se branche sur le tunnel, et y envoye son blabla.
- Voila.

Scruter un dossier partagé est très lourd et compliqué en comparaison. M'enfin, idem que pour ton choix que je respecte, ce n'est que mon avis personnel.

Sinon, voici un petit fichier, pas encore testé (je le fais dans l'heure de midi, depuis le boulot j'ai rien de fonctionnel). Les trois quarts sont des commentaires pour faire comprendre le code; Le PC d'envoi utilise la fonction sendMsg, le PC de destination utilise la fonction recvMsg (les fonctions avec un _ devant sont là pour aérer et éviter d'avoir des pavés de 4 km de long ^^).

► Afficher le texteEnvoi-Réception.au3

Code : Tout sélectionner

; On choisi un port de communication, un nombre au pif, commun pour l'envoi et la réception (perso, j'aime bien 12345 ^^)
Global $_PORT = 12345

; Fonction qui envoye un message à une cible
; Paramètres =
; - $_target  [chaine] : nom du PC de destination, exemple "PORTABLE_ACER"
; - $_message [chaine] : message à envoyer, exemple "Hello World !"
; - $_timeout [nombre] : temps maximum en millisecondes que doit mettre l'envoi, exemple 10000 (si plus de 10000, on arrete d'envoyer)
; Retourne =
; - Succès : retourne la chaine vide
; - Echec  : met le flag @error à 1, et retourne une chaine non vide qui correspond à l'erreur rencontrée
Func sendMsg($_target, $_message, $_timeout)
    TCPStartup() ; On lance le système de com'
    Local $timer = TimerInit()
    Do
        Local $resultat = _sendMsg($_target, $_message) ; On envoie le message
        Local $erreur = @error
    Until $erreur <> 0 Or TimerDiff($timer) > $_timeout ; Tant qu'on a une erreur ($erreur <> 0) ou qu'on a pas encore dépassé le temps maximum (TimerDiff et $_timeout), on recommence à envoyer le message
    TCPShutdown() ; On arrete le système de com'
    If $erreur <> 0 Then ; Si on a une erreur, on retourne un code d'erreur à 1, et on affiche l'erreur dans le resultat
        SetError(1)
        Return $resultat
    Else
        Return "" ; Si pas d'erreur on retourne une chaine vide, tout s'est bien passé, rien à signaler
    EndIf
EndFunc

; Fonction qui envoye un message
; Paramètres =
; - $_target : nom du PC de destination, exemple "PORTABLE_ACER"
; - $_message : message à envoyer, exemple "Hello World !"
; Retourne =
; - Succès : retourne la chaine vide
; - Echec  : met le flag @error à 1, et retourne une chaine non vide qui correspond à l'erreur rencontrée
Func _sendMsg($_target, $_message)
    ; On récupère l'IP du PC qui doit recevoir le message
    $_address = TCPNameToIP($_target)
    If @error Then
        SetError(1)
        Return "Adresse introuvable"
    EndIf
    ; On se connecte au PC de destination
    Local $_socket = TCPConnect($_address, $_PORT)
    If @error Then
        SetError(1)
        Return "Connexion impossible"
    EndIf
    ; On envoye le message
    TCPSend($_socket, $_message)
    If @error Then
        SetError(1)
        Return "Envoi impossible"
    EndIf
    ; Si on a rencontré aucune erreur, rien à signaler, on retourne la chaine vide
    Return ""
EndFunc

; Fonction qui reçoit un message
; Paramètres =
; - $_timeout : temps maximum en millisecondes que l'on attendre la réception, exemple 10000 (si plus de 10000, on arrete de recevoir)
; Retourne =
; - Succès : retourne le message reçu
; - Echec  : met le flag @error à 1, et retourne une chaine non vide qui correspond à l'erreur rencontrée
Func recvMsg($_timeout)
    ; On lance le système de com'
    TCPStartup()
    ; On récupère l'IP du PC qui doit recevoir le message, c'est à dire soi-même
    $_address = TCPNameToIP(@ComputerName)
    If @error Then
        SetError(1)
        Return "Adresse introuvable"
    EndIf
    ; On ouvre une connexion pour que le PC d'envoi puisse envoyer son message
    Local $_socket = TCPListen($_address, $_PORT)
    If @error Then
        SetError(1)
        Return "Connexion impossible"
    EndIf
    ; On attend que le PC d'envoi se connecte (mais pas plus longtemps que le timeout
    Local $timer = TimerInit()
    Do
        Local $resultat = _recvMsg($_socket) ; On reçoie le message
        Local $erreur = @error
    Until $erreur <> 0 Or TimerDiff($timer) > $_timeout ; Tant qu'on a une erreur ($erreur <> 0) ou qu'on a pas encore dépassé le temps maximum (TimerDiff et $_timeout), on continue de recevoir le message
    ; On coupe la connexion pour tout le monde
    TCPCloseSocket($_socket)
    ; On arrete le système de com'
    TCPShutdown()
    ; On retourne le message reçu
    If $resultat <> "" Then ; Si on a une erreur, on retourne un code d'erreur, et on affiche l'erreur dans le resultat
        SetError(1)
        Return $resultat
    Else
        Return $resultat ; Si pas d'erreur on retourne une chaine vide, tout s'est bien passé, on retourne le message reçu
    EndIf
EndFunc

; Fonction qui reçoit un message sur une socket (tunnel de communication
; Paramètres =
; - $socket : tunnel de communication, pour que le PC d'envoi puisse envoyer un message
; Retourne =
; - Succès : retourne le message reçu
; - Echec  : met le flag @error à 1, et retourne une chaine non vide qui correspond à l'erreur rencontrée
Func _recvMsg($socket)
    ; On attend que le PC d'envoi se connecte dessus
    Local $_socket_connectee = TCPAccept($_socket)
    If @error Then
        SetError(1)
        Return "Connexion non établie"
    EndIf
    ; On reçoie le message, tant que la connexion est ouverte
    Local $resultat = ""
    Do
        $resultat = $resultat & TCPRecv($_socket_connectee, 2048)
        Local $resultat = TCPRecv($_socket_connectee, 2048) ; On reçoie le message par morceau (2048 bits)
        Local $erreur = @error
    Until $erreur ; Jusqu'à ce que la connexion soit coupée
    ; On coupe la connexion du coté du PC de destination
    TCPCloseSocket($_socket_connectee)
    ; On retourne le message reçu
    Return $resultat
EndFunc

Dans l'absolu, il suffira de mettre #include "Envoi-Réception.au3" dans ton code pour pouvoir faire appel à sendMsg("PC_DESTINATION", "Hello World !", 15000) ; le 15000 correspond à 15 secondes, si le temps est écoulé il stoppe (évitons d'avoir un script qui ne s'arrete plus ^^). Et de faire appel de l'autre coté à recvMsg(15000) ; idem pour le 15000

Je te prépare ça en début d'aprèm après mangé et testé ^^

EDIT: No problem Dimvar. Ce que j'entends par lourd, c'est faire un FileExists en permanence sur un fichier en partage réseau; utiliser le protocole samba pour récupérer les infos d'un dossier partagé, dont 99% d'informations qui ne nous intéressent pas, comme le nom du fichier, sa description, la liste des droits d'utilisateurs, sa date de modification... alors que son contenu de quelques mots reste la donnée que l'on souhaite. Tu déployes et tu mobilises des ressources de façon inutile, que ce soit
- en espace disque (là où la donnée représente une fraction de la taille que prend un fichier)
- ou en réseau (Samba est un protocole sur un modèle client serveur, dans la couche Présentation, qui s'appuye sur ... TCP/IP ! Bah dis donc, deux couches de travail (Présentation et Session) en trop ^^).
- ou en ram/cpu/célensamèrlipopette (fais le test) : Bah oui, mobiliser au moins 3 ports (le 139 et je sais plus les autres), faire tourner un serveur SMB pour traiter les demandes, regénérer la liste des fichiers disponibles à chaque demande (sauf peut-être depuis la version 2, mais sous XP et avant c'est pas génial), etc... ALORS QUE le système que je propose utilise un port et c'est tout...

Je ne dis pas que votre système ne marche pas, je dis seulement que c'est complètement inadapté au besoin en question. C'est comme de discuter avec ton voisin de bureau en passant par un système de chat ou par un forum informatique, c'est quand même plus simple de remuer les lèvres (scène excellente de la série Dead Like Me). Sinon, si tu veux pousser la chose au paroxysme, tu as aussi le protocole IPoAC de la RFC 1149. Ca a beau être un poisson d'avril, ça n'en démontre pas moins l'absurdité de certains moyens pour effectuer des tâches simples comme un ping.

[DimVar]

...Scruter un dossier partagé est très lourd et compliqué en comparaison...

Peux tu développer stp ? (pour ma culture personnelle)

[matwachich]

Sinon, il y a aussi ça, je sais que ça fonctionne en réseau, mais je ne l'ai jamais fait.
Je me pencherai sur leurs (MailSlots) utilisation en réseau dès que j'aurai le temps.

[ZDS]

Voila, je pense que tu vas apprécier la simplicité du bidule ^^

Voici le code du celui qui envoie :

Code : Tout sélectionner

#Include "Envoi-Réception.au3"
Local $resultat = sendMsg("[color=#BF0000][b]DESTINATAIRE[/b][/color]", "Hello World !")
MsgBox(0, "ENVOI", "Error code : " & @error)

Et maintenant, voici le code de celui qui reçoit :

Code : Tout sélectionner

#Include "Envoi-Réception.au3"
Local $resultat = recvMsg()
MsgBox(0, "RECEPTION", "Error code : " & @error & @CRLF & "'"&$resultat&"'")

Comme quoi, c'est simplissime dans l'utilisation Juste à ajouter le script suivant "Envoi-Réception.au3" dans le même répertoire que chaque script (sur les deux pcs).

► Afficher le texteEnvoi-Réception.au3

Code : Tout sélectionner

; On choisi un port de communication, un nombre au pif, commun pour l'envoi et la réception (perso, j'aime bien 12345 ^^)
Global $_PORT = 12345

; Fonction qui envoye un message à une cible
; Paramètres =
; - $_target  [chaine] : nom du PC de destination, exemple "PORTABLE_ACER"
; - $_message [chaine] : message à envoyer, exemple "Hello World !"
; - $_timeout [nombre] : temps maximum en millisecondes que doit mettre l'envoi, exemple 10000 (si plus de 10000, on arrete d'envoyer)
;                        /!\ Paramètre optionnel, équivalent à 10 secondes par défaut
; Retourne =
; - Succès : retourne la chaine vide
; - Echec  : met le flag @error à 1, et retourne une chaine non vide qui correspond à l'erreur rencontrée
Func sendMsg($_target, $_message, $_timeout = 10000)
    TCPStartup() ; On lance le système de com'
    Local $timer = TimerInit()
    Do
        Local $resultat = _sendMsg($_target, $_message) ; On envoie le message
        Local $erreur = @error
    Until $erreur = 0 Or TimerDiff($timer) > $_timeout ; Tant qu'on a une erreur ($erreur <> 0) ou qu'on a pas encore dépassé le temps maximum (TimerDiff et $_timeout), on recommence à envoyer le message
    TCPShutdown() ; On arrete le système de com'
    If $erreur <> 0 Then ; Si on a une erreur, on retourne un code d'erreur à 1, et on affiche l'erreur dans le resultat
        SetError(1)
        Return $resultat
    Else
        Return "" ; Si pas d'erreur on retourne une chaine vide, tout s'est bien passé, rien à signaler
    EndIf
EndFunc

; Fonction qui envoye un message
; Paramètres =
; - $_target  [chaine] : nom du PC de destination, exemple "PORTABLE_ACER"
; - $_message [chaine] : message à envoyer, exemple "Hello World !"
; Retourne =
; - Succès : retourne la chaine vide
; - Echec  : met le flag @error à 1, et retourne une chaine non vide qui correspond à l'erreur rencontrée
Func _sendMsg($_target, $_message)
    ; On récupère l'IP du PC qui doit recevoir le message
    $_address = TCPNameToIP($_target)
    If @error Then
        SetError(1)
        Return "Adresse introuvable"
    EndIf
    ; On se connecte au PC de destination
    Local $_socket = TCPConnect($_address, $_PORT)
    If @error Then
        SetError(1)
        Return "Connexion impossible"
    EndIf
    ; On envoye le message
    TCPSend($_socket, $_message)
    If @error Then
        SetError(1)
        Return "Envoi impossible"
    EndIf
[b][color=#4080FF]    ; On coupe la connexion proprement
    TCPCloseSocket($_socket)[/color][/b]
    ; Si on a rencontré aucune erreur, rien à signaler, on retourne la chaine vide
    Return ""
EndFunc

; Fonction qui reçoit un message
; Paramètres =
; - $_timeout [nombre] : temps maximum en millisecondes que l'on attendre la réception, exemple 10000 (si plus de 10000, on arrete de recevoir)
;                        /!\ Paramètre optionnel, équivalent à 10 secondes par défaut
; Retourne =
; - Succès : retourne le message reçu
; - Echec  : met le flag @error à 1, et retourne une chaine non vide qui correspond à l'erreur rencontrée
Func recvMsg($_timeout = 10000)
    ; On lance le système de com'
    TCPStartup()
    ; On récupère l'IP du PC qui doit recevoir le message, c'est à dire soi-même
    $_address = TCPNameToIP(@ComputerName)
    If @error Then
        SetError(1)
        Return "Adresse introuvable"
    EndIf
    ; On ouvre une connexion pour que le PC d'envoi puisse envoyer son message
    Local $_socket = TCPListen($_address, $_PORT)
    If @error Then
        SetError(1)
        Return "Connexion impossible"
    EndIf
    ; On attend que le PC d'envoi se connecte (mais pas plus longtemps que le timeout
    Local $timer = TimerInit()
    Do
        Local $resultat = _recvMsg($_socket) ; On reçoie le message
        Local $erreur = @error
    Until $erreur = 0 Or TimerDiff($timer) > $_timeout ; Tant qu'on a une erreur ($erreur <> 0) ou qu'on a pas encore dépassé le temps maximum (TimerDiff et $_timeout), on continue de recevoir le message
    ; On coupe la connexion pour tout le monde
    TCPCloseSocket($_socket)
    ; On arrete le système de com'
    TCPShutdown()
    ; On retourne le message reçu
    If $erreur Then ; Si on a une erreur, on retourne un code d'erreur, et on affiche l'erreur dans le resultat
        SetError(1)
        Return $resultat
    Else
        Return $resultat ; Si pas d'erreur on retourne une chaine vide, tout s'est bien passé, on retourne le message reçu
    EndIf
EndFunc

; Fonction qui reçoit un message sur une socket (tunnel de communication)
; Paramètres =
; - $_socket [identifiant-nombre] : tunnel de communication, pour que le PC d'envoi puisse envoyer un message
; Retourne =
; - Succès : retourne le message reçu
; - Echec  : met le flag @error à 1, et retourne une chaine non vide qui correspond à l'erreur rencontrée
Func _recvMsg($_socket)
    ; On attend que le PC d'envoi se connecte dessus
    Local $_socket_connectee = TCPAccept($_socket)
    If @error Or $_socket_connectee = -1 Then
        SetError(1)
        Return "Connexion non établie"
    EndIf
    ConsoleWrite("Connexion établie"&@CRLF)
    ; On reçoie le message, tant que la connexion est ouverte
    Local $resultat = ""
    Do
        $resultat = $resultat & TCPRecv($_socket_connectee, 1024) ; On reçoie le message par morceau (2048 bits)
        Local $erreur = @error
    Until $erreur ; Jusqu'à ce que la connexion soit coupée
    ; On coupe la connexion du coté du PC de destination
    TCPCloseSocket($_socket_connectee)
    ; On retourne le message reçu
    Return $resultat
EndFunc

Contrairement aux scripts de l'aide fournie avec AutoIt, il n'y a pas forcément besoin de lancer le destinataire (serveur) avant l'expéditeur (client).

Tiens moi au courant, à bientôt !

EDIT : Méa Culpa, j'avais oublié un morceau pour fermer proprement la connexion après avoir envoyé le message. Je fais la gu**le quand les gens font du code pas beau ou quand ce n'est pas un minimum fonctionnel, je ferai bien de suivre mes propres conseils ^^
PJ: Archive ZIP comprenant les différents fichiers présentés ici

Envoi-Réception.zip

(1.96 Kio) Téléchargé 65 fois

[jchd]

Oui Mat, MailSlots !

[TT22]

Passer par des fichiers temporaires pour faire discuter deux ordis me semble être un peu...

Peut-être, mais 1 : C'est un script que j'avais fait il y a déjà quelques temps, 2 : quoi qu'on en dise, cette méthode fonctionne , 3 : Comme l'as dit DimVar : "Je ne pense donc pas qu'il faille le noyer dans des notions TCP dés le début"

deux gars qui discutent en face l'un de l'autre, mais au lieu de parler, ils s’envoient des post-its...

J'adore cette comparaison !!!