interp

 

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 (espace de nom) 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 inaccessibles aux interpréteurs sûrs. Voir INTERPRÉTEURS SURS ci-dessous pour plus d'information sur les fonctionnalités présentes dans un interpréteur sùr. Les fonctionnalité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 accéder. Pour une explication détaillée des commandes cachées, voir COMMANDES CACHÉES, 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 référer à un maître (ancestor) interpréteur par son nom dans un interpréteur esclave excepté au travers d'alias. Également, il n'y a pas de nom global par lequel se référer 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 transférer 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’argument 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à ; 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 interpx, 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 fonctionnalité limitées ; autrement l'esclave inclura 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 commandeconcat, et évalue alors la chaîne résultante comme script Tcl dans l'interpréteur esclave identifié par path. Le résultat de cette évaluation (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 CACHÉES , 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 quantificateurs 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 CACHÉES , 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 accéder aux variables locales dans ce cadre et appeler des cadres externes. Les commandes cachées sont expliquées plus en détail dans COMMANDES CACHÉES , 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 déterminent 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 CACHÉES , 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 quantificateurs 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 de détails sur les commande cachées, voir COMMANDES CACHÉES , 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 accéder à ses variables locales ou appeler des cadres externes. Pour plus de détails sur les commande cachées, voir COMMANDES CACHÉES, 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 fonctionnalités 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ées 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égâts à 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 spécifiant 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 recommande 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 restreindre leur propre fonctionnalité 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 safe dans 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ître sùr. La chose 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 appellerait 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 étaient "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 CACHÉES

Les interpréteurs sûrs restreignent grandement les fonctionnalités disponibles pour les programmes Tcl qui seraient exécutés. Permettre à du code Tcl non fiable un accès direct à ces fonctionnalités est dangereux, parce que il peut être utilisé pour un grand nombre d'attaques sur l'environnement. Néanmoins, il y a parfois un besoin légitime d'utiliser les fonctionnalité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 définir 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.

Parce qu’un interpréteur maître peut appeler une commande cachée comme partie de la gestion d'un appel d'alias, grand soin doit être pris d'éviter l'évaluation 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 topique. 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’accéder aux fonctionnalité 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 quantificateurs 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.

CRÉDITS

Ce mécanisme est basé sur le prototype Safe-Tcl implémenté par Nathaniel Borenstein et Marshall Rose

VOIR ÉGALEMENT

load


Catégorie Manuel Tcl/Tk