Émulateur de terminal

Un émulateur de terminal , ou application de terminal , est un programme informatique qui émule un terminal vidéo dans une autre architecture d'affichage. Bien que généralement synonyme de terminal shell ou texte , le terme terminal couvre tous les terminaux distants, y compris les interfaces graphiques. Un émulateur de terminal dans une interface utilisateur graphique est souvent appelé fenêtre de terminal .

Une fenêtre de terminal permet à l'utilisateur d'accéder à un terminal texte et à toutes ses applications telles que les interfaces de ligne de commande (CLI) et les applications d' interface utilisateur texte (TUI). Celles-ci peuvent être exécutées sur la même machine ou sur une autre via telnet , ssh , dial-up ou via une connexion série directe . Sur les systèmes d'exploitation de type Unix , il est courant d'avoir une ou plusieurs fenêtres de terminal connectées à la machine locale.

Les terminaux prennent généralement en charge un ensemble de séquences d'échappement pour contrôler la couleur, la position du curseur , etc. Les exemples incluent la famille de normes de séquences de contrôle de terminal qui comprend ECMA-48 , ANSI X3.64 et ISO/IEC 6429 .

Aux débuts de l'informatique, avec l'avènement de l'informatique interactive, le modèle dominant impliquait un ordinateur central connecté à plusieurs terminaux. Cette configuration, connue sous le nom de modèle centralisé ou mainframe, comprenait un ordinateur central puissant qui effectuait toutes les tâches de traitement, tandis que les terminaux servaient de périphériques d'entrée/sortie pour permettre aux utilisateurs d'interagir avec le système. Ces systèmes étaient initialement basés sur des caractères.

Un terminal orienté caractères est un type de terminal informatique qui communique avec son hôte un caractère à la fois, par opposition à un terminal orienté blocs qui communique par blocs de données. Il s'agit du type de terminal de données le plus courant, car il est facile à mettre en œuvre et à programmer. La connexion à l'ordinateur central ou au serveur de terminaux s'effectue via des liaisons série RS-232, Ethernet ou d'autres protocoles propriétaires .

Les terminaux orientés caractères peuvent être « muets » ou « intelligents ». Les terminaux muets sont ceux qui peuvent interpréter un nombre limité de codes de contrôle (CR, LF, etc.) mais n'ont pas la capacité de traiter des séquences d'échappement spéciales qui exécutent des fonctions telles que l'effacement d'une ligne, l'effacement de l'écran ou le contrôle de la position du curseur. Dans ce contexte, les terminaux muets sont parfois surnommés télétypes en verre , car ils ont essentiellement les mêmes fonctionnalités limitées qu'un télétype mécanique. Ce type de terminal muet est toujours pris en charge sur les systèmes modernes de type Unix en définissant la variable d'environnement TERM sur dumb. Les terminaux intelligents ou intelligents sont ceux qui ont également la capacité de traiter des séquences d'échappement, en particulier les séquences d'échappement VT52, VT100 ou ANSI.

Lorsque les ordinateurs personnels sont devenus omniprésents dans les années 1980, ils ont offert la possibilité d'exécuter des logiciels sur l'ordinateur personnel de l'utilisateur, offrant ainsi la possibilité de remplacer les terminaux matériels coûteux et encombrants par quelque chose qui avait des fonctions supplémentaires. Des logiciels sont immédiatement devenus disponibles, capables d'émuler les fonctions des terminaux matériels d'un PC. Des exemples de tels logiciels pour DOS étaient Telix ou Telemate, qui a été publié en 1988 et pouvait émuler un terminal DEC VT102.

Les stations de travail , qui exécutaient généralement des versions d' Unix , sont également devenues courantes dans les années 1980. Les systèmes Unix permettaient généralement d'accéder à la ligne de commande via des terminaux connectés localement ou par accès commuté. Les stations de travail Unix étaient conçues pour être utilisées principalement via une interface utilisateur graphique (GUI) ; pour fournir l'accès à la ligne de commande, l'interface graphique comprenait des applications d'émulation de terminal qui se comportaient comme des terminaux connectés localement.

Au cours des années 1990, de nouveaux systèmes d'exploitation comme Windows et OS/2 sont arrivés, fournissant le contexte technique pour davantage d'émulateurs de terminaux comme Telix pour Windows, ZOC pour OS/2 ou PuTTY , initialement publié pour Windows en 1998 et qui (avec ses dérivés) est toujours un choix très populaire à ce jour.

Grâce au succès de Linux , notamment dans les centres de données et les serveurs cloud, la nécessité d'accéder à des ordinateurs distants via des terminaux basés sur des caractères demeure. Cela est évident dans le fait qu'aujourd'hui, les listes d'émulateurs de terminaux qui pourraient servir d'alternative au PuTTY susmentionné proposent plus de 100 alternatives.

De nombreux émulateurs de terminaux ont été développés pour les terminaux matériels physiques tels que VT52 , VT100 , VT220 , VT320 , IBM 3270/8/9/E , IBM 5250 , IBM 3179G , Data General D211, Hewlett-Packard HP700/92, Sperry/Unisys 2000-series UTS60 , Burroughs/Unisys A-series T27/TD830/ET1100, ADDS ViewPoint, AT386, Siemens Nixdorf (SNI) 97801, Televideo 925 et Wyse 50/60.

Certains émulateurs de terminaux, tels que xterm , implémentent des fonctionnalités supplémentaires non présentes dans le terminal émulé.

De plus, des programmes ont été développés pour émuler divers « terminaux » de console système tels que la console de station de travail Sun et la console Linux .

Enfin, certains émulateurs font simplement référence à un ensemble de normes, telles que les normes pour les codes d'échappement ANSI .

Ces programmes sont disponibles sur de nombreuses plateformes, notamment DOS , les systèmes de type Unix, notamment Linux et macOS , Windows et les systèmes d'exploitation embarqués présents dans les téléphones portables et le matériel industriel.

Dans le passé, les systèmes Unix et similaires utilisaient des périphériques de port série tels que les ports RS-232 et fournissaient /dev/* des fichiers de périphériques pour eux.

Avec les émulateurs de terminaux, ces fichiers de périphériques sont eux-mêmes émulés par une paire de périphériques pseudo-terminaux . Ceux-ci émulent à leur tour un port/une connexion physique au point de terminaison informatique hôte – le matériel fourni par les API du système d'exploitation ou des logiciels tels que rlogin , telnet ou SSH , entre autres. Dans les systèmes Linux, par exemple, il s'agirait respectivement /dev/ptyp0(pour le côté maître) et /dev/ttyp0(pour le côté esclave) de périphériques pseudo-terminaux.

Il existe également des fichiers de console virtuelle spéciaux comme /dev/console. En mode texte, l'écriture dans le fichier affiche le texte sur la console virtuelle et la lecture à partir du fichier renvoie le texte que l'utilisateur écrit sur la console virtuelle. Comme avec d'autres terminaux texte , il existe également des séquences d'échappement spéciales , des caractères de contrôle et des fonctions qu'un programme peut utiliser, le plus facilement via une bibliothèque telle que ncurses . Pour des opérations plus complexes, les programmes peuvent utiliser des appels système ioctl spéciaux de console et de terminal . On peut comparer les périphériques en utilisant les modèles vcs ("écran de console virtuelle") et vcsa ("écran de console virtuelle avec attributs") tels que /dev/vcs1et /dev/vcsa1.

Certains émulateurs de terminaux incluent également des séquences d'échappement pour configurer le comportement du terminal afin de faciliter une bonne interopérabilité entre le terminal et les programmes exécutés à l'intérieur de celui-ci, par exemple pour configurer le collage entre crochets .

Les consoles virtuelles peuvent être configurées dans le fichier /etc/inittablu par init — en général, il démarre le processus de connexion en mode texte getty pour plusieurs consoles virtuelles. Le système X Window peut être configuré dans /etc/inittabou par un gestionnaire d'affichage X. Un certain nombre de distributions Linux utilisent systemd au lieu de init , ce qui permet également la configuration de la console virtuelle.

Les programmes système Linux typiques utilisés pour accéder aux consoles virtuelles incluent :

• chvtpour changer la console virtuelle actuelle
• openvtpour exécuter un programme sur une nouvelle console virtuelle
• deallocvtpour fermer une console virtuelle actuellement inutilisée

Les émulateurs de terminaux peuvent implémenter une fonction d'écho locale , qui peut être nommée à tort « half-duplex », ou encore légèrement incorrectement « echoplex » (qui est formellement un mécanisme de détection d'erreur plutôt qu'une option d'affichage d'entrée).

Les émulateurs de terminaux peuvent implémenter l'édition locale, également connue sous le nom de « mode ligne à la fois ». On l'appelle également à tort « semi-duplex ». Dans ce mode, l'émulateur de terminal envoie uniquement des lignes complètes d'entrée au système hôte. L'utilisateur entre et édite une ligne, mais elle est conservée localement dans l'émulateur de terminal pendant qu'elle est éditée. Elle n'est pas transmise tant que l'utilisateur ne signale pas sa fin, généralement avec la ↵ Entertouche du clavier ou un bouton « envoyer » quelconque dans l'interface utilisateur. À ce stade, la ligne entière est transmise. Le mode ligne à la fois implique un écho local, car sinon l'utilisateur ne pourra pas voir la ligne pendant qu'elle est éditée et construite. Cependant, le mode ligne à la fois est indépendant du mode écho et ne nécessite pas d'écho local. Lors de la saisie d'un mot de passe, par exemple, la saisie ligne à la fois avec édition locale est possible, mais l'écho local est désactivé (sinon le mot de passe serait affiché).

La complexité du mode ligne par ligne est illustrée par l'option mode ligne par ligne du protocole telnet. Pour l'implémenter correctement, l' implémentation du terminal virtuel réseau fournie par le programme d'émulation de terminal doit être capable de reconnaître et de gérer correctement les événements « d'interruption » et « d'abandon » qui surviennent au milieu de l'édition locale d'une ligne.

Dans les terminaux asynchrones, les données peuvent circuler dans n'importe quelle direction à tout moment. Dans les terminaux synchrones, un protocole contrôle qui peut envoyer des données et à quel moment. Les terminaux basés sur IBM 3270 utilisés avec les ordinateurs centraux IBM sont un exemple de terminaux synchrones . Ils fonctionnent essentiellement en mode « écran par écran » (également appelé mode bloc ). Les utilisateurs peuvent apporter de nombreuses modifications à une page, avant de soumettre l'écran mis à jour à la machine distante en une seule action.

Des émulateurs de terminaux qui simulent le protocole 3270 sont disponibles pour la plupart des systèmes d'exploitation, pour être utilisés à la fois par ceux qui administrent des systèmes tels que le z9 , ainsi que par ceux qui utilisent les applications correspondantes telles que CICS .

D'autres exemples de terminaux synchrones incluent l' IBM 5250 , l'ICL 7561, le Honeywell Bull VIP7800 et le Hewlett-Packard 700/92.

Les consoles virtuelles , également appelées terminaux virtuels, sont des terminaux texte émulés , utilisant le clavier et l'écran d'un ordinateur personnel ou d'un poste de travail. Le mot « texte » est essentiel car les consoles virtuelles ne sont pas des terminaux GUI et ne s'exécutent pas dans une interface graphique. Les consoles virtuelles se trouvent sur la plupart des systèmes de type Unix . Elles sont principalement utilisées pour accéder aux serveurs et interagir avec eux, sans utiliser d'environnement de bureau graphique.