Bonjour, je voudrais écrire une petite application en C (un mini client PPP
qui à terme fonctionnera sur un OS tout à fait différent mais là n'est pas
le problème), application qui doit lire et écrire sur un port série alors
que sur l'autre c'est un serveur PPP qui tourne.
Je voudrais éviter de mettre en place un "vrai" loopback (un nullmodem du
port 1 vers le port 2).
Donc je résume : PPPd tourne sur un port série "virtuel" et ce même port
série est relié en loopback sur un second port série tout aussi virtuel...
Je suis presque sûr que linux permet de faire se genre de chose mais je ne
sais pas comment.
A moins qu'il y ait une autre solution plus propre ?
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Julien Salgado
Zouplaz a écrit :
Bonjour, je voudrais écrire une petite application en C (un mini client PPP qui à terme fonctionnera sur un OS tout à fait différent mais là n'est pas le problème), application qui doit lire et écrire sur un port série alors que sur l'autre c'est un serveur PPP qui tourne.
Je voudrais éviter de mettre en place un "vrai" loopback (un nullmodem du port 1 vers le port 2).
C'est franchmement la solution la plus rapide, si on a la connectique.
Donc je résume : PPPd tourne sur un port série "virtuel" et ce même port série est relié en loopback sur un second port série tout aussi virtuel...
Je suis presque sûr que linux permet de faire se genre de chose mais je ne sais pas comment.
A moins qu'il y ait une autre solution plus propre ?
Si c'est pour faire du PPP il suffir d'utiliser comme port de communication un pseudo-terminal ou lien d'un port série. Bien sûr on a pas les controles de flux.
Sinon on peut aussi jouer avec user mode linux pour faire tourner un linux virtuel qui gérera comme un grand des lignes séries (virtuelles toujours sans contrôle de flux).
Auriez-vous quelques pistes ?
-- Julien
Zouplaz a écrit :
Bonjour, je voudrais écrire une petite application en C (un mini client PPP
qui à terme fonctionnera sur un OS tout à fait différent mais là n'est pas
le problème), application qui doit lire et écrire sur un port série alors
que sur l'autre c'est un serveur PPP qui tourne.
Je voudrais éviter de mettre en place un "vrai" loopback (un nullmodem du
port 1 vers le port 2).
C'est franchmement la solution la plus rapide, si on a la connectique.
Donc je résume : PPPd tourne sur un port série "virtuel" et ce même port
série est relié en loopback sur un second port série tout aussi virtuel...
Je suis presque sûr que linux permet de faire se genre de chose mais je ne
sais pas comment.
A moins qu'il y ait une autre solution plus propre ?
Si c'est pour faire du PPP il suffir d'utiliser comme port de
communication un pseudo-terminal ou lien d'un port série. Bien sûr on a
pas les controles de flux.
Sinon on peut aussi jouer avec user mode linux pour faire tourner un
linux virtuel qui gérera comme un grand des lignes séries (virtuelles
toujours sans contrôle de flux).
Bonjour, je voudrais écrire une petite application en C (un mini client PPP qui à terme fonctionnera sur un OS tout à fait différent mais là n'est pas le problème), application qui doit lire et écrire sur un port série alors que sur l'autre c'est un serveur PPP qui tourne.
Je voudrais éviter de mettre en place un "vrai" loopback (un nullmodem du port 1 vers le port 2).
C'est franchmement la solution la plus rapide, si on a la connectique.
Donc je résume : PPPd tourne sur un port série "virtuel" et ce même port série est relié en loopback sur un second port série tout aussi virtuel...
Je suis presque sûr que linux permet de faire se genre de chose mais je ne sais pas comment.
A moins qu'il y ait une autre solution plus propre ?
Si c'est pour faire du PPP il suffir d'utiliser comme port de communication un pseudo-terminal ou lien d'un port série. Bien sûr on a pas les controles de flux.
Sinon on peut aussi jouer avec user mode linux pour faire tourner un linux virtuel qui gérera comme un grand des lignes séries (virtuelles toujours sans contrôle de flux).
Auriez-vous quelques pistes ?
-- Julien
Nicolas George
Zouplaz wrote in message :
Donc je résume : PPPd tourne sur un port série "virtuel" et ce même port série est relié en loopback sur un second port série tout aussi virtuel...
C'est assez facile, à condition de faire un dessin. Classiquement, on a ceci :
| ligne RTC | pppd |>port série -- modem ---------- modem -- port série<| pppd | |
| Ce que je représente par |>, c'est ce qu'on appelle un tty, c'est | l'interface que donne le noyau pour des périphériques comme les ports série ou les consoles. Le côté plat représente l'interface assez développée (cf. termios) fournie par le noyau, le côté pointu représente la connexion bas niveau avec le matériel, qu'on appelle côté maître.
Première bonne nouvelle : le noyau est capable de gérer des pseudo-tty, avec le schéma suivant :
| |>processus quelconque |
Le tty apparaît alors dans /dev/pts/<numéro> (ou /dev/tty[p-za-e][0-9a-f] pour les OS obsolètes (Linux jusqu'à 2.0 inclus et BSD). Du point de vue du « processus quelconque », le côté maître du pseudo-tty apparaît comme un file-descriptor à peu près comme les autres). Cf. posix_openpt(3) pour plus de détails (ces gros nuls l'ont oublié dans le man standard, mais c'est lisible dans Single Unix)
Deuxième bonne nouvelle : pppd (au moins une version assez récente), est capable, au lieu de bêtement ouvrir un tty préexistant, de créer lui-même un pseudo-tty et d'exécuter le programme qu'on veut cu côté maître. L'option s'utilise typiquement ainsi :
Mais il est tout à fait loisible de choisir un autre programme que pppoe.
Il te reste donc à trouve un programme qui crée un pseudo-tty, y lance le programme de ton choix, ainsi :
--> | E/S standard ===== programme cherché<| programme de ton choix <-- |
et qui ensuite recopie scrupuleusement son entrée standard vers le pseudo-tty maître, et le pseudo-tty maître vers sa sortie standard.
Ce n'est pas très difficile à écrire, mais un peu fastidieux. Voici deux solutions faciles toutes faites :
- <URL: http://www.skarnet.org/software/conn-tools/ioconnect.html > est un programme bien sympa qui recopie entre son entrée/sortie standard et une paire de file-descriptors. En utilisant la méthode obsolète, il est relativement facile d'allouer un pseudo-tty en shell : /dev/ptyp0 est le maître correspondant à /dev/ttyp0, idem pour ptyq7 et ttyq7, etc. Donc un script shell de la forme :
#!/bin/sh exec 2>pseudo-tty.log exec 3<>/dev/ptyp0 stty [ce que tu veux] <&3 exec ioconnect 0 3 3
devrait faire l'affaire. Mais ça cafouille de temps en temps. Le pseudo-tty à utiliser pour ton programme est alors /dev/ttyp0.
- une paire ssh/sshd fait très bien le boulot. On se retrouve avec :
connexion réseau | E/S standard == ssh -------------------- sshd<| programme lancé par ssh |
Il faut donc utiliser une commande de la forme, au choix :
Le deuxième cas permet de lancer soi-même le programme à tester (on peut utiliser la commande w pour savoir le nom du pseudo-tty, ou alors remplacer le sleep par « "tty > nom_dy_tty; sleep 1000000 ».
Le -t à ssh sert à l'obliger à allouer un pseudo-tty alors même qu'on a spécifié une commande ; l'exec évite de garder le shell qui a servi entre pppd et ssh.
Il faut faire très attention, avec cette méthode, que la connexion se fasse sans mot de passe, car ssh le demanderait dans le pseudo-tty alloué par pppd, et ça risque de mal se passer. Donc absolument utiliser une clef sans mot de passe ou chargée dans un agent.
Je dirais que la méthode avec ssh est plus fiable que la première, mais elle est également un peu plus coûteuse.
Pour finir, *la* référence pour en savoir plus est, il me semble, le chapitre 19 de _Advanced Programming in the Unix Environment_, de W. Richard Stevens, mais je ne peux pas l'affirmer de première main, car ça fait des mois que je n'ai pas avancé du chapitre 8 (mais dans un autre registre de la culture geek, j'en suis arrivé à l'invention du cinéma par la Guilde des Alchimistes).
Zouplaz wrote in message <Xns954F7A4AA4C3DZoupla@212.27.42.70>:
Donc je résume : PPPd tourne sur un port série "virtuel" et ce même port
série est relié en loopback sur un second port série tout aussi virtuel...
C'est assez facile, à condition de faire un dessin. Classiquement, on a
ceci :
| ligne RTC |
pppd |>port série -- modem ---------- modem -- port série<| pppd
| |
|
Ce que je représente par |>, c'est ce qu'on appelle un tty, c'est
|
l'interface que donne le noyau pour des périphériques comme les ports série
ou les consoles. Le côté plat représente l'interface assez développée (cf.
termios) fournie par le noyau, le côté pointu représente la connexion bas
niveau avec le matériel, qu'on appelle côté maître.
Première bonne nouvelle : le noyau est capable de gérer des pseudo-tty, avec
le schéma suivant :
|
|>processus quelconque
|
Le tty apparaît alors dans /dev/pts/<numéro> (ou
/dev/tty[p-za-e][0-9a-f] pour les OS obsolètes (Linux jusqu'à 2.0 inclus et
BSD). Du point de vue du « processus quelconque », le côté maître du
pseudo-tty apparaît comme un file-descriptor à peu près comme les autres).
Cf. posix_openpt(3) pour plus de détails (ces gros nuls l'ont oublié dans le
man standard, mais c'est lisible dans Single Unix)
Deuxième bonne nouvelle : pppd (au moins une version assez récente), est
capable, au lieu de bêtement ouvrir un tty préexistant, de créer lui-même un
pseudo-tty et d'exécuter le programme qu'on veut cu côté maître. L'option
s'utilise typiquement ainsi :
Mais il est tout à fait loisible de choisir un autre programme que pppoe.
Il te reste donc à trouve un programme qui crée un pseudo-tty, y lance le
programme de ton choix, ainsi :
--> |
E/S standard ===== programme cherché<| programme de ton choix
<-- |
et qui ensuite recopie scrupuleusement son entrée standard vers le
pseudo-tty maître, et le pseudo-tty maître vers sa sortie standard.
Ce n'est pas très difficile à écrire, mais un peu fastidieux. Voici deux
solutions faciles toutes faites :
- <URL: http://www.skarnet.org/software/conn-tools/ioconnect.html > est un
programme bien sympa qui recopie entre son entrée/sortie standard et une
paire de file-descriptors. En utilisant la méthode obsolète, il est
relativement facile d'allouer un pseudo-tty en shell : /dev/ptyp0 est le
maître correspondant à /dev/ttyp0, idem pour ptyq7 et ttyq7, etc. Donc un
script shell de la forme :
#!/bin/sh
exec 2>pseudo-tty.log
exec 3<>/dev/ptyp0
stty [ce que tu veux] <&3
exec ioconnect 0 3 3
devrait faire l'affaire. Mais ça cafouille de temps en temps. Le
pseudo-tty à utiliser pour ton programme est alors /dev/ttyp0.
- une paire ssh/sshd fait très bien le boulot. On se retrouve avec :
connexion réseau |
E/S standard == ssh -------------------- sshd<| programme lancé par ssh
|
Il faut donc utiliser une commande de la forme, au choix :
Le deuxième cas permet de lancer soi-même le programme à tester (on peut
utiliser la commande w pour savoir le nom du pseudo-tty, ou alors
remplacer le sleep par « "tty > nom_dy_tty; sleep 1000000 ».
Le -t à ssh sert à l'obliger à allouer un pseudo-tty alors même qu'on a
spécifié une commande ; l'exec évite de garder le shell qui a servi entre
pppd et ssh.
Il faut faire très attention, avec cette méthode, que la connexion se
fasse sans mot de passe, car ssh le demanderait dans le pseudo-tty alloué
par pppd, et ça risque de mal se passer. Donc absolument utiliser une clef
sans mot de passe ou chargée dans un agent.
Je dirais que la méthode avec ssh est plus fiable que la première, mais elle
est également un peu plus coûteuse.
Pour finir, *la* référence pour en savoir plus est, il me semble, le
chapitre 19 de _Advanced Programming in the Unix Environment_, de W. Richard
Stevens, mais je ne peux pas l'affirmer de première main, car ça fait des
mois que je n'ai pas avancé du chapitre 8 (mais dans un autre registre de la
culture geek, j'en suis arrivé à l'invention du cinéma par la Guilde des
Alchimistes).
Donc je résume : PPPd tourne sur un port série "virtuel" et ce même port série est relié en loopback sur un second port série tout aussi virtuel...
C'est assez facile, à condition de faire un dessin. Classiquement, on a ceci :
| ligne RTC | pppd |>port série -- modem ---------- modem -- port série<| pppd | |
| Ce que je représente par |>, c'est ce qu'on appelle un tty, c'est | l'interface que donne le noyau pour des périphériques comme les ports série ou les consoles. Le côté plat représente l'interface assez développée (cf. termios) fournie par le noyau, le côté pointu représente la connexion bas niveau avec le matériel, qu'on appelle côté maître.
Première bonne nouvelle : le noyau est capable de gérer des pseudo-tty, avec le schéma suivant :
| |>processus quelconque |
Le tty apparaît alors dans /dev/pts/<numéro> (ou /dev/tty[p-za-e][0-9a-f] pour les OS obsolètes (Linux jusqu'à 2.0 inclus et BSD). Du point de vue du « processus quelconque », le côté maître du pseudo-tty apparaît comme un file-descriptor à peu près comme les autres). Cf. posix_openpt(3) pour plus de détails (ces gros nuls l'ont oublié dans le man standard, mais c'est lisible dans Single Unix)
Deuxième bonne nouvelle : pppd (au moins une version assez récente), est capable, au lieu de bêtement ouvrir un tty préexistant, de créer lui-même un pseudo-tty et d'exécuter le programme qu'on veut cu côté maître. L'option s'utilise typiquement ainsi :
Mais il est tout à fait loisible de choisir un autre programme que pppoe.
Il te reste donc à trouve un programme qui crée un pseudo-tty, y lance le programme de ton choix, ainsi :
--> | E/S standard ===== programme cherché<| programme de ton choix <-- |
et qui ensuite recopie scrupuleusement son entrée standard vers le pseudo-tty maître, et le pseudo-tty maître vers sa sortie standard.
Ce n'est pas très difficile à écrire, mais un peu fastidieux. Voici deux solutions faciles toutes faites :
- <URL: http://www.skarnet.org/software/conn-tools/ioconnect.html > est un programme bien sympa qui recopie entre son entrée/sortie standard et une paire de file-descriptors. En utilisant la méthode obsolète, il est relativement facile d'allouer un pseudo-tty en shell : /dev/ptyp0 est le maître correspondant à /dev/ttyp0, idem pour ptyq7 et ttyq7, etc. Donc un script shell de la forme :
#!/bin/sh exec 2>pseudo-tty.log exec 3<>/dev/ptyp0 stty [ce que tu veux] <&3 exec ioconnect 0 3 3
devrait faire l'affaire. Mais ça cafouille de temps en temps. Le pseudo-tty à utiliser pour ton programme est alors /dev/ttyp0.
- une paire ssh/sshd fait très bien le boulot. On se retrouve avec :
connexion réseau | E/S standard == ssh -------------------- sshd<| programme lancé par ssh |
Il faut donc utiliser une commande de la forme, au choix :
Le deuxième cas permet de lancer soi-même le programme à tester (on peut utiliser la commande w pour savoir le nom du pseudo-tty, ou alors remplacer le sleep par « "tty > nom_dy_tty; sleep 1000000 ».
Le -t à ssh sert à l'obliger à allouer un pseudo-tty alors même qu'on a spécifié une commande ; l'exec évite de garder le shell qui a servi entre pppd et ssh.
Il faut faire très attention, avec cette méthode, que la connexion se fasse sans mot de passe, car ssh le demanderait dans le pseudo-tty alloué par pppd, et ça risque de mal se passer. Donc absolument utiliser une clef sans mot de passe ou chargée dans un agent.
Je dirais que la méthode avec ssh est plus fiable que la première, mais elle est également un peu plus coûteuse.
Pour finir, *la* référence pour en savoir plus est, il me semble, le chapitre 19 de _Advanced Programming in the Unix Environment_, de W. Richard Stevens, mais je ne peux pas l'affirmer de première main, car ça fait des mois que je n'ai pas avancé du chapitre 8 (mais dans un autre registre de la culture geek, j'en suis arrivé à l'invention du cinéma par la Guilde des Alchimistes).
Zouplaz
Merci beaucoup pour cette longue et intéressante réponse !
Merci beaucoup pour cette longue et intéressante réponse !
