### interp Commandes Internes Tcl

NOM
interp - Crée et manipule des interpréteurs Tcl
SYNTAXE
interp option ?arg arg ...?
DESCRIPTION
Cette commande permet la création d'un ou plusieurs nouveaux interpréteurs Tcl qui coexistent avec l'interpréteur créateur dans la même application. L'interpréteur créateur est appelé le maître et le nouvel interpréteur est appelé l'esclave. Un maître peut créer n'importe quel nombre d'esclaves, et chaque esclave peut lui-même créer des esclaves supplémentaires pour lequel il est maître, créant ainsi une hiérarchie d'interpréteurs.
Chaque interpréteur est indépendant des autres: il a son propre namespace pour les commandes, fonctions, et variables globales. Un maître interpréteur peut créer des connections entre ses esclaves et lui-même en utilisant un mécanisme appelé un alias Un alias est une commande dans un interpréteur esclave qui, quand elle est appelée, provoque l'appel d'une commande dans son interpréteur maître ou dans un autre interpréteur esclave Les seules autres connections entre interpréteurs sont au travers de variable d'environnements (la variable env), qui sont normalement partagées entre tous les interpréteurs dans l'application. Notez que le namespace pour les fichiers (tel que les noms renvoyé par la commande open) n'est pas partagé entre interpréteurs. Des commandes explicites sont fournies pour partager les fichiers et transférer les références à un fichier ouvert d'un interpréteur à un autre.
La commande interp fournit aussi le support des interpréteurs safe Un interpréteur sùr est un esclave dont les fonctions ont été grandement restreintes, ainsi il est plus sùr d'exécuter un script étranger sans risque pour les autres interpréteurs ou l'environnement d'application. Par exemple, toutes commandes de création de canal IO et les commandes de création de sous-process sont rendues inaccessible aux interpréteurs sùrs. Voir INTERPRETEURS SURS ci-dessous pour plus d'information sur les fonctionnalités présentes dans un interpréteur sùr. Les fonctionalités dangereuses ne sont pas enlevées de l'interpréteur sùr; par contre, elle sont cachées, ainsi seul les interpréteurs de confiance peuvent y acceder. Pour une explication détaillée des commandes cachées, voir COMMANDES CACHEES, ci-dessous. Le mécanisme d'alias peut être utilisé pour une communication protégée (analogue à un appel kernel) entre un interpréteur esclave et son maître. Voir INVOCATION D'ALIAS, ci-dessous, pour plus de détails sur comment le mécanisme d'alias fonctionne.
Un nom d'interpréteur qualifié est une liste Tcl correcte contenant une sous ensemble de ses ancêtres dans la hiérarchie de l'interpréteur, terminée par les chaîne désignant l'interpréteur dans son maître immédiat. Les noms d'interpréteur sont relatif à l'interpréteur dans lequel ils sont utilisés. Par exemple, si a est un esclave de l'interpréteur courant et qu'il a un esclave a1, qui à son tour a un esclave a11, le nom qualifié de a11 dans a est la liste a1 a11.
La commande interp, décrite ci-dessous, accepte des noms d'interpréteur qualifiés comme arguments; l'interpréteur dans lequel la commande est évaluée peut toujours être référencé comme {} (la liste ou chaîne vide). Notez qu'il est impossible de se referer à un maître (ancestor) interpréteur par son nom dans un interpréteur esclave excepté au travers d'alias. Egalement, il n'y a pas de nom global par lequel se referer au premier interpréteur créé dans une application. L'ensemble de ces restrictions sont motivées par des raisons de sécurité
LA COMMANDE INTERP
La commande interp est utilisée pour créer, effacer, et manipuler des interpréteurs esclaves, et pour partager ou transferer des canaux entre interpréteurs Elle peut avoir une parmi plusieurs formes, dépendantes de l'argument option:

interp alias srcPath srcCmd
  Renvoie une liste Tcl dont les éléments sont les targetCmd et args associés à l'alias nommé srcCmd (ce sont toutes les valeurs spécifiées quand l'alias a été créé; il est possible que la commande source actuelle dans l'esclave soit différente de srcCmd si elle a été renommée).
interp alias srcPath srcCmd {}
  Efface l'alias de srcCmd dans l'interpréteur esclave identifié par srcPath. srcCmd se réfère au nom sous lequel l'alias a été créé si la commande source a été renommée, la commande renommée sera effacée.
interp alias srcPath srcCmd targetPath targetCmd ?arg arg ...?
  Cette commande crée un alias entre un esclave et un autre (voyez la commande alias esclave ci-dessous pour la création d'alias entre un esclave et son maître) Dans cette commande, chacun des interpréteurs esclave peut être n'importe où dans la hiérarchie des interpréteurs sous l'interpréteur qui appelle la commande. SrcPath et srcCmd identifient le source de l'alias. SrcPath est une liste Tcl dont les éléments désignent un interpréteur particulier Par exemple, "a b" identifie un interpréteur b, qui est une esclave de l'interpréteur a, qui est un esclave de l'interpréteur appelant Une liste vide spécifie l'interpréteur appelant la commande srcCmd donne le nom d'une nouvelle commande, qui sera créée dans l'interpréteur source. TargetPath et targetCmd spécifient une cible interpréteur et commande, et l'arguments arg, s'il existe, Spécifie les arguments supplémentaires à targetCmd qui sont ajoutés à tout argument spécifié dans l'appel de srcCmd. TargetCmd peut être indéfini à l'instant de cet appel, ou il peut existe déjàr; il n'est pas créé par cette commande. L'alias prépare la commande cible à être appelée dans l'interpréteur cible chaque fois que la commande source est appelée dans l'interpréteur source Voir APPEL D'ALIAS ci-dessous pour plus de détails.
interp aliases ?path?
  Cette commande retourne une liste Tcl de noms de toutes les commandes source des alias définis dans l'interpréteur identifié par path. interp create ?-safe? ?--? ?path?
  Crée un interpréteur esclave identifié par path et une nouvelle commande, appelé une slave command. Le nom de la commande esclave est le dernier composant de path. Le nouvel interpréteur esclave et la commande esclave sont créée dans l'interpréteur identifié par le chemin obtenu en enlevant le dernier composant de path. Par exemple, si path est a bc alors un nouvel interpréteur et commande esclave nommés c sont créés dans l'interpréteur identifié par les chemin a b. La commande esclave peut être employée pour manipuler le nouvel interpréteur comme décrit ci-dessous. Si path est omis, Tcl crée un nom unique de la forme interp x, où x est un entier, et l'utilise pour l'interpréteur et la commande esclave. Si le switch -safe est spécifié (ou si le maître interpréteur est un interpréteur sùr), le nouvel interpréteur esclave sera créé comme un interpréteur sùr avec des fonctionalité limitées; autrement l'esclave inclutra le jeu complet des commandes et variables Tcl internes. Le -- switch peut être utilisé pour marquer la fin des commutateurs; il peut être nécessaires si path est une valeur inhabituelle telle que -safe. Le résultat de la commande est le nom du nouvel interpréteur. Le nom d'un interpréteur esclave doit être unique parmi tout les esclaves; une erreur se produit si le nom d'un interpréteur esclave existe déjà pour ce maître.
interp delete ?path ...?
  Efface zéro ou plus interpréteurs donnés par les arguments optionnels path, et pour chaque interpréteur, efface aussi ses esclaves. La commande efface aussi la commande esclave de chaque interpréteur effacé. Pour chaque argument path, si aucun interpréteur de ce nom existe, la commande lève une erreur.
interp eval path arg ?arg ...?
  Cette commande concatène tous les arguments arg de la même façon que la commande concat, et évalue alors la chaîne résultante comme script Tcl dans l'interpréteur esclave identifié par path. Le résultat de cette evaluation (incluant l'information d'erreur telle que les variables errorInfo et errorCode, si une erreur se produit) est renvoyé à l'interpréteur appelant .
interp exists path
  Renvoie 1 si un interpréteur esclave du path spécifié existe dans ce maître, 0 autrement. Si path est omis, l'interpréteur appelant est utilisé.
interp expose path hiddenName ?exposedCmdName?
  Rend la commande cachée hiddenName visible, en lui donnant éventuellement un nouveau nom exposedCmdName (ce nom est couramment accepté seulement si c'est un nom global valide sans quelconque ::), dans l'interpréteur désigné par path. Si une commande visible avec le nom cible existe déjà, cette commande échoue. Les commandes cachées sont expliquées plus en détail dans COMMANDES CACHEES , ci-dessous.
interp hide path exposedCmdName ?hiddenCmdName?
  Cache la commande visible exposedCmdName, en la renommant en commande cachée hiddenCmdName, ou conservant le même nom si hiddenCmdName n'est pas donné, dans l'interpréteur désigné par path. Si une commande cachée avec le nom ciblé existe déjà, cette commande échoue. exposedCmdName et hiddenCmdNamene peuvent pas contenir en même temps de qualificateurs namespace, ou une erreur est levée. Les commandes à cacher par interp hide sont recherchées dans le namespace global même si le namespace courant n'est pas le global. Ceci empêche les esclaves d'abuser un maître interpréteur en cachant les mauvaises commandes, en rendant le namespace courant différent du global. Les commandes cachées sont expliquées plus en détail dans COMMANDES CACHEES , ci-dessous.
interp hidden path
  Renvoie une liste des noms de toutes les commandes cachées dans l'interpréteur identifié par path.
interp invokehidden path ?-global? hiddenCmdName ?arg ...?
  Appelle la commande cachée hiddenCmdName avec les arguments fournis dans l'interpréteur désigné par path. Aucune substitution ou évaluation ne sont appliquées aux arguments. Si le flag -global est présent, la commande cachée est appelée au niveau global dans l'interpréteur cible; autrement elle est appelée dans le cadre d'appel courant et peut acceder aux variables locales dans ce cadre et appeler des cadres externes. Les commandes cachées sont expliquées plus en détail dans COMMANDES CACHEES , ci-dessous.
interp issafe ?path?
  Renvoie 1 si l'interpréteur identifié par le path spécifié est sùr, 0 autrement.
interp marktrusted path
  Marque l'interpréteur identifié par path comme fiable. Ne montre pas les commande cachées. Cette commande peut seulement être appelée à partir d'un interpréteur de confiance. La commande n'a pas d'effet si l'interpréteur identifié par path est déjà fiable.
interp share srcPath channelId destPath
  Met en place le partage du canal IO identifié par channelId entre l'interpréteur identifié par srcPath et l'interpréteur identifié par destPath. Les deux interpréteurs ont les même permissions sur le canal IO. Les deux interpréteurs doivent le fermer pour fermer le IO canal sous-jacent; les canaux IO accessibles dans un interpréteur sont automatiquement fermés quand un interpréteur est détruit.
interp slaves ?path?
  Renvoie une liste Tcl des noms de tous les interpréteurs esclaves associés à l'interpréteur identifié par path. Si path est omis, l'interpréteur appelant est utilisé.
interp target path alias
  Renvoie une liste Tcl décrivant l'interpréteur cible d'un alias. L'alias est spécifié avec un chemin d'interpréteur et le nom de la commande source, juste comme dans interp alias plus haut. Le nom de l'interpréteur cible est renvoyé comme un chemin d'interpréteur, relatif à l'interpréteur appelant . Si l'interpréteur cible de l'alias est l'interpréteur appelant alors une liste vide est renvoyée. Si l'interpréteur cible de l'alias n'est pas l'interpréteur appelant ou un de ses descendants alors une erreur est générée. La commande cible n'a pas a être définie à l'instant de cet appel.
interp transfer srcPath channelId destPath
  Rends le canal IO identifié par channelId disponible dans l'interpréteur identifié par destPath et indisponible dans l'interpréteur identifié par srcPath

LA COMMANDE SLAVE
Pour chaque interpréteur esclave créé avec lA commande interp, une nouvelle commande Tcl est créée dans le maître interpréteur avec le même nom que le nouvel interpréteur. Cette commande peut être employée pour faire des opérations variées sur l'interpréteur Elle a la forme générale suivante: slave command ?arg arg ...?
Slave est le nom de l'interpréteur, et command et args determinent le comportement exact de la commande. Les formes valides de cette commande sont:

slave aliases
  Renvoie une liste Tcl dont les éléments sont les noms de tous les alias dans slave Les noms renvoyés sont les valeurs srcCmd utilisées quand les alias ont été créés (qui ne peuvent pas être les même que les noms des commandes courantes, si elles ont été renommées).
slave alias srcCmd
  Renvoie une liste Tcl dont les éléments sont les targetCmd et args associés à l'alias nommé srcCmd (toutes sont les valeurs spécifiées quand l'alias a été créée; il est possible que la commande source actuelle dans l'esclave soit différente de srcCmd si elle a été renommée).
slave alias srcCmd {}
  Efface l'alias de srcCmd dans l'interpréteur esclave. srcCmd se réfère au nom sous lequel l'alias a été créé si la commande source a été renommée, la commande renommée sera effacé.
slave alias srcCmd targetCmd ?arg ..?
  Crée un alias tel que chaque fois que srcCmd est appelée dans slave, targetCmd est appelée dans le maître. Les arguments arg seront transmis à targetCmd comme arguments supplémentaires, ajoutés avant tout argument transmis dans l'appel de srcCmd. Voir APPEL D'ALIAS ci-dessous pour les détails.
slave eval arg ?arg ..?
  Cette commande concatène tous les arguments arg de la même façon que la commande concat, et évalue la chaîne résultante comme un script Tcl dans slave. Le résultat de cette évaluation (incluant information erreur telle que les variables errorInfo et errorCode, si une erreur se produit) est renvoyé à l'interpréteur appelant .
slave expose hiddenName ?exposedCmdName?
  Cette commande expose la commande cachéehiddenName, lui donnant éventuellement un nouveau nom exposedCmdName (ce nom est couramment accepté seulement si c'est une nom global valide sans quelconque ::), dans slave. Si une commande visible avec le nom ciblé existe déjà, cette commande échoue. Pour plus details sur les commande cachées, voir COMMANDES CACHEES , ci-dessous.
slave hide exposedCmdName ?hiddenCmdName?
  Cette commande cache la commande visible exposedCmdName, en la renommant en la commande cachée hiddenCmdName, ou gardant le même nom si l'argument n'est pas donné, dans l'interpréteur slave. Si une commande cachée avec le nom ciblé existe déjà, cette commande échoue. Autant exposedCmdName que hiddenCmdName ne peuvent contenir de qualificateurs namespace, ou une erreur est levée. Les commandes a cacher sont recherchée dans le namespace global même si le namespace courant n'est pas le global un . Ceci empêche les esclaves d'abuser un maître interpréteur en cachant les mauvaises commandes, en rendant le namespace courant différent du global. Pour plus details sur les commande cachées, voir COMMANDES CACHEES , ci-dessous.
slave hidden
  Renvoie une liste des noms de toutes les commande cachées dans slave. slave invokehidden ?-global hiddenName ?arg ..?
  Cette commande appelle la commande cachée hiddenName avec les arguments fournis, dans slave. Aucune substitutions ou évaluations ne sont appliquées aux arguments. Si le flag -global est donné, la commande est appelée au niveau global dans l'esclave; autrement elle est appelée dans le cadre d'appel courant et peut acceder à ses variables locales ou appeler des cadres externes. Pour plus details sur les commande cachées, voir COMMANDES CACHEES , ci-dessous.
slave issafe
  Renvoie 1 si l'interpréteur esclave est sùr, 0 autrement.
slave marktrusted
  Marque l'interpréteur esclave comme fiable. Peut seulement être appelée par un interpréteur de confiance. Cette commande ne rend visible aucune commande cachée dans l'interpréteur esclave. La commande n'a pas d'effet si l'esclave est déjà fiable

SAFE INTERPRETERS
Un interpréteur sùr a des fonctionalité restreintes, ainsi il est sùr d'exécuter un script arbitraire donné par votre pire ennemi sans s'inquiéter pour l'application hôte ou le reste de votre environnement de travail De manière à rendre un interpréteur sùr, certaines commandes et variables sont enlevése de l'interpréteur. Par exemple, les commandes pour créer fichiers sur disque sont enlevées, et la commande exec est enlevée, car elle pourrait être utilisée pour faire des dégats à l'aide de sous-processus. Un accès limité à ces facilités peut être fourni, par création d'alias du maître interpréteur pour vérifier leurs arguments soigneusement et fournir un accès restreint à une sous ensemble sùr de facilités. Par exemple, la création de fichier pourra être autorisé dans un sous répertoire particulier et l'appel de sous-processus pourra être autorisé pour un ensemble soigneusement choisi de programmes.
Un interpréteur sùr est créée en specifiant le switch -safe à la commande interp create Néanmoins, tout esclave créé par un interpréteur sùr sera aussi sùr.
Un interpréteur sùr est créée avec exactement ce jeu de commandes internes:

after | append | array | binary
break | case | catch | clock
close | concat | continue | eof
error | eval | expr | fblocked
fcopy | fileevent | flush | for
foreach | format | gets | global
history | if | incr | info
interp | join | lappend | lindex
linsert | list | llength | lrange
lreplace | lsearch | lsort | namespace
package | pid | proc | puts
read | regexp | regsub | rename
return | scan | seek | set
split | string | subst | switch
tell | trace | unset | update
uplevel | upvar | variable | vwait
while |  |  |

Les commandes suivantes sont cachées par interp create quand il crée un interpréteur sùr:

cd | exec | exit | fconfigure
file | glob | load | open
pwd | socket | source | vwait

Ces commandes peuvent être recréées plus tard comme fonctions ou alias Tcl, ou réexposées avec interp expose.
De plus, la variable env n'est pas présente dans un interpréteur sùr, donc il ne peut partager des variables d'environnement avec les autres interpréteurs. La variable env pose un problème de sécurité, parce que les utilisateurs peuvent stocker de l'information sensible dans une variable d'environnement. Par exemple, le manuel PGP recommende de stocker le mot de passe de protection de la clé PGP privée dans la variable d'environnement PGPPASS. Rendre cette variable disponible à l'exécution de code étranger dans un interpréteur sùr induirait une faille de sécurité.
Si les extensions sont chargées dans un interpréteur sùr, elles peuvent aussi restraindre leur propre fonctionalité pour éliminer les commandes sensibles. Pour une discussion sur la getion des extensions pour la sécurité voyez l 'entrée de manuel des commandes Tcl Safe-Tcl et load
APPEL D'ALIAS
Le mécanisme alias a été soigneusement conçu ainsi il peut être utilisé sùrement quand un script non fiable est exécuté dans un esclave sùr et que le cible de l'alias est une maîtresùr Lachose la plus importante pour garantir la sécurité est de s'assurer qui l'information transmise de l'esclave au maître n'est jamais évaluée ou substituée dans le maître; si ceci se produisait, cela pourrait activer un script de la mort dans l'esclave qui appelerait des fonctions arbitraires dans le maître, pour compromettre la sécurité.
Quand la source d'un alias est appelée dans l'interpréteur esclave, les substitutions Tcl usuelles sont effectuées à l'analyse de la commande. Ces substitutions sont effectuées dans l'interpréteur source juste comme elles seraient faites pour tout autre commande appelée dans cet interpréteur. La fonction de commande de la commande source prend ses arguments et les mélange avec les targetCmd et args de l'alias pour créer un nouveau tableau d'arguments Si les mots de srcCmd etaient "srcCmd arg1 arg2 ... argN", le nouvel ensemble de mots sera "targetCmd arg arg ... arg arg1 arg2 ... argN", où targetCmd et args sont les valeurs fournies quand l'alias a été créé. TargetCmd est alors utilisée pour localiser une fonction de commande dans l'interpréteur cible, et cette fonction de commande est appelée avec le nouveau jeu d'aguments Un erreur se produit s'il n'y a pas commande nommée targetCmd dans l'interpréteur cible. Aucunes substitutions supplémentaires ne sont effectuées sur les mots, la fonction de commande cible est appelée directement, sans passer au travers du mécanisme evaluation Tcl normal. Les substitutions sont ainsi effectuées sur chaque mot exactement une seule fois: targetCmd et args ont été substituées pendant l'analyse de la commande qui créée l'alias, et arg1 - argN sont substituées quand la commande source de l'alias est analysée dans l'interpréteur source.
A l'écriture de targetCmds pour des alias dans des interpréteurs sùrs, il est très important que les arguments de cette commande ne soient jamais évalués ou substitués, car ceci fournirait un mécanisme d'échappement par lequel les interpréteurs esclaves pourraient exécuter du code arbitraire dans le maître Par conséquent, ceci pourrait compromettre la sécurité du système
COMMANDES CACHEES
Les interpréteurs sùrs restreignent grandement les fonctionalités disponibles pour les programmes Tcl qui seraient éxecutés. Permettre à du code Tcl non fiable un accès direct à ces fonctionalités est dangeureux, parce que il peut être utilisé pour un grand nombre d'attaques sur l'environnement. Néanmoins, il y a parfois un besoin legitime d'utiliser les fonctionalités dangereuses dans le contexte de l'interpréteur sùr. Par exemple, parfois un programme doit être sourced dans l'interpréteur. Un autre exemple est Tk, ou des fenêtres sont attachées à une hiérarchie de fenêtres pour un interpréteur spécifique; quelque potentiellement dangereuse fonctions, ex. gestion de fenêtres, doit être effectuée sur ces fenêtres dans le contexte de l'interpréteur.
La commande interp fournit une solution à ce problème sous la forme des hidden commands. Au lieu d'enlever entièrement les commandes dangereuses d'un interpréteur sùr, ces commandes sont cachées donc elles deviennent indisponibles pour les l'exécution de scripts Tcl dans l'interpréteur. Néanmoins, ces commande cachées peuvent être appelée par ancêtre fiable de l'interpréteur sùr, dans le contexte de l'interpréteur sùr, en utilisant interpinvoke. Les commandes cachées et commandes visibles résident dans des namespaces séparés. Il est possible de definir une commande cachée et un commande visible portant les même nom dans un interpréteur.
Les commandes cachées dans un interpréteur esclave peuvent être appelées dans le corps des fonctions appelées dans le maître pendant l'appel d'alias. Par exemple, un alias de source pourrait être créé dans un interpréteur esclave. Quand elle est appelée dans l'interpréteur esclave, une fonction est appelée dans le maître interpréteur pour vérifier si l'opération est autorisée (ex. il demande de sourcer un fichier que l'interpréteur esclave est autorisé à accéder). La fonction alors appelle la commande source cachée dans l'interpréteur esclave pour sourcer le contenu du fichier. Notez que deux commandes nommées source existent dans l'interpréteur esclave: l'alias, et la commande cachée.
Parcequ'un interpréteur maître peut appeller une commande cachée comme partie de la gestion d'un appel d'alias, grans soin doit être pris d'éviter l'évalualuation de tout arguments transmis au travers de l'appel de l'alias. Autrement, un interpréteur esclave malin pourrait faire exécuter à l'interpréteur maître de confiance des commandes dangereuses. Voir la section sur l' APPEL D'ALIAS pour une discussion plus complète de ce topic. Pour aider à éviter ce problème, aucune substitutions ou évaluations ne sont appliquées aux arguments de interp invokehidden.
Les interpréteurs sùrs ne sont pas autorisés à appeler des commande cachées dans eux-mêmes ou dans leurs descendants. Ceci empêche les esclaves sùr d'acceder aux fonctionalité cachées dans eux-mêmes ou leurs descendants.
L'ensemble des commandes cachées dans un interpréteur peut être manipulé par un interpréteur de confiance en utilisant interp expose et interp hide. La commande interp expose déplace une commande cachée dans le jeu de commande visibles dans l'interpréteur identifié par path, potentiellement renommant la commande dans le processus. Si une commande visible du nom ciblé existe déjà, l'opération échoue. Pareillement, interp hide déplace une commande visible dans le jeu de commande cachées dans cet interpréteur. Les interpréteurs sùrs ne sont pas autorisés à déplacer les commandes entre l'ensemble des commandes cachées et visibles, dans soit eux-même ou leurs descendants.
Actuellement, les noms des commande cachées ne peuvent pas contenir de qualificateurs namespace, et vous devez en premier renommer une commande d'un namespace dans le namespace global avant de pouvoir la cacher. Les commandes cachées par interp hide sont recherchée dans le namespace global même si le namespace courant n'est pas le global. Ceci empêche les esclaves d'abuser un maître interpréteur en cachant les mauvaises commandes, en rendant le namespace courant différent du global.
CREDITS
Ce mécanisme est basé sur le prototype Safe-Tcl implémenté par Nathaniel Borenstein et Marshall Rose
VOIR EGALEMENT
load(n), safe(n), Tcl_CreateSlave(3)
Dernière révision: 7.6
Index Précédent Suivant