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
| /*******************************************************************************
Système d'exploitation : Ubuntu Intrepid Ibex
*******************************************************************************/
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <time.h>
/*******************************************************************************
Point d'entrée de la fonction
*******************************************************************************/
int main (int argc, char **argv, char **env)
{
int pt_maitre ; // descripteur de fichier pseudo-terminal maître
int pt_esclave ; // descripteur de fichier pseudo-terminal esclave
int pid ; // id du processus fork
unsigned char buffer[2048], ligne[512], auxligne[512] ;
int i, ier, ip, necho ;
//******************************************************************************
pid = forkpty(&pt_maitre, &pt_esclave, NULL, NULL);
printf ("exec forkpty\n") ; // clonage du processus
//******************************************************************************
switch(pid)
{ case -1 :
goto ERR_01 ;
//******************************************************************************
//*************************** processus-fils ***********************************
//******************************************************************************
case 0 :
execl("mon_programme", "mon_programme", NULL);
goto ERR_02 ;
//******************************************************************************
//*************************** processus-père ***********************************
//******************************************************************************
default :
//*** Le programme encapsulé envoie des lignes de compte-rendu et
// un prompt pour aquérir une commande. Mais toutes les lignes sont
// bufferisées :
ip = -1 ; // au départ, il faut lire l'esclave
auxligne[0] = '\0' ; // pas de buffer en echo à priori (**echo**)
while(1) //****** protocole de dialogue avec le programme encapsulé ******
{ if (ip < 0)
{
ENCORE : // (**echo**)
sleep(1) ; //============= !!!!!!!....... pour voir==================
ier = read(pt_maitre, buffer, sizeof(ligne)) ;
if (ier == -1) goto ERR_03 ;
if (ier == 0 ) return (0) ; // terminé
buffer[ier] = '\0' ; // pour fermer la chaîne
ip = 0 ; // on positionne le pointeur au début du buffer
if (auxligne[0] != '\0') // (**echo**)
{ auxligne[0] = '\0' ; // (**echo**)
goto ENCORE ; // (**echo**)
}
}
// - On transfère la ligne jusqu'à un "\r\n" ;
for (i=0 ; i<sizeof(ligne) ; i++)
{ if (buffer[ip] == '\0') break ;
if (strncmp(&buffer[ip],"\r\n",2) != 0) // "\r\n" trouvé ?
{ // non : // on alimente la ligne
ligne[i] = buffer[ip] ;
ip++ ; // on incrémente pour le caractère suivant
}
else
{ // oui : On prépare la ligne pour le traitement :
ligne[i] = '\0' ; // on ferme la ligne
ip +=2 ; // on ajuste l'index dans le buffer
goto TRAITEMENT ;
}
}
// - Ici on a épuisé le buffer reçu :
ligne[i] = '\0' ; // on ferme la ligne
ip = -1 ; // on marque qu'il faudra lire un buffer
TRAITEMENT :
printf ("=R=> %s\n",ligne) ; // impression ligne reçue de l'esclave
// - A-t-on reçu un prompt du programme encapsulé ?
if (strncmp(ligne , "mpgm=>" , 6) == 0)
{ printf ( "???? :" ) ; // affichage du prompt-maitre
scanf ( "%s" , ligne) ; // récuperation de la commande
printf ("=L=> %s\n",ligne) ;
strcpy(auxligne,ligne) ; // préserve la ligne pour l'echo (**echo**)
// - L'utilisateur a-t-il entré une commande de sortie du programme ?
// On teste aprés conversion en minuscule :
if (ligne[0] == 'q') return (0) ;
if(write(pt_maitre, ligne, strlen(ligne)) == -1) goto ERR_04 ;
fsync(pt_maitre) ;
}
}
}
return 0 ;
//==============================================================================
ERR_01 : printf ("ERR_01 forkpty() : création processus-esclave\n") ;
return (1) ;
ERR_02 : printf ("ERR_02 execl() : lancement du programme encapsulé\n") ;
return (2) ;
ERR_03 : printf ("ERR_03 read() : peut pas recevoir de l'esclave\n") ;
return (3) ;
ERR_04 : printf ("ERR_04 write() : peut pas envoyer vers l'esclave\n") ;
return (4) ;
} |
Les pseudo-terminaux sous *nix
Répondre avec citation
Partager