Présentation, description et utilisation des variables d'environnement sous Windows.

Date de publication : 8/11/2003

Par Pierre Castelain
 

Présentation, description et utilisation des variables d'environnement sous Windows. A l'article est associée une unité Delphi permettant une manipulation aisée de celles-ci.

1. Remerciements

• Nono40 : http://nono40.developpez.com,
• hachesse : http://hachesse.developpez.com.

2. Préambule

3. Présentation

4. Variables d'environnement fournies par Windows

• TMP et TEMP : répertoire temporaire de Windows.
• PROMPT : Invite affichée par l'invite de commandes.
• Winbootdir : répertoire de démarrage de Windows.
• COMSPEC : nom du programme d'invite de commande.
• PATH : chemins de recherche des programmes et DLL (séparés par des points virgules).
• Windir : répertoire de Windows.

• COMPUTERNAME : nom de l'ordinateur.
• HOMEDRIVE : disque local primaire (partition système).
• HOMEPATH : dossier par défaut pour les utilisateurs.
• LOGONSERVER : nom du serveur de domaine.
• NUMBER_OF_PROCESSORS : nombre de processeurs installés.
• OS : nom du système d'exploitation.
• Os2LibPath : chemin de la bibliothèque Microsoft OS/2.
• PATHEXT : liste des extensions de fichier reconnus comme des exécutables.
• PROCESSOR_ARCHITECTURE : type de processeur installé.
• PROCESSOR_IDENTIFIER : identification du processeur installé (type, modèle, etc.).
• PROCESSOR_LEVEL : niveau du processeur.
• PROCESSOR_REVISION : révision du processeur.
• SystemDrive : disque local sur lequel le système réside.
• SystemRoot : chemin du système (égal à Windir).
• USERDOMAIN : nom du domaine sous lequel l'utilisateur s'est connecté.
• USERNAME : nom de l'utilisateur courant.
• USERPROFILE : chemin du profil de l'utilisateur courant.

• ALLUSERSPROFILE : chemin du profil commun à tous les utilisateurs.
• APPDATA : chemin des données applicatives de l'utilisateur courant.
• CommonProgramFiles : chemin des programmes communs.
• ProgramFiles : chemin des programmes.

5. Implémentation

TEMP=%USERPROFILE%\Local Settings\Temp#0
TMP=%USERPROFILE%\Local Settings\Temp#0
#0

• Ouvrez une invite de commandes (Menu Démarrer, Exécuter, tapez "CMD" sous Windows NT ou "COMMAND" sous 9x).
• Nous allons utiliser la commande SET qui permet d'afficher et de modifier la valeur de chaque variable.
• Tapez la commande "SET DV=DEVELOPPEZ.COM"
• Nous venons de créer une nouvelle variable nommée DV dont la valeur est "DEVELOPPEZ.COM".
• Tapez la commande "SET" pour afficher la liste des variables ainsi que leurs valeurs respectives.
• Vous pouvez également taper la commande "ECHO %DV%" pour afficher la valeur de la variable DV (les caractères % permettent de spécifier à l'invite de commandes qu'il s'agit d'une variable d'environnement dont nous voulons obtenir la valeur).
• Ne fermez pas l'invite de commande actuelle et ouvrez-en une seconde.
• Tapez la commande "SET" pour obtenir la liste des variables.
• Vous pouvez constater que la variable DV n'existe pas dans cet environnement, celui-ci étant directement hérité de l'environnement principal de Windows et non de l'environnement de la première invite de commandes.
• Fermez cette invite de commande et retournez sur la première.
• Tapez la commande "CMD" (ou "COMMAND" si vous êtes sous Windows 9x) pour créer une nouvelle invite de commande (attention, celle-ci n'ouvre pas de nouvelle fenêtre).
• Utilisez la commande "SET" pour vérifier la présence de la variable DV.
• Vous pouvez donc constater que cette nouvelle invite a hérité de l'environnement de la première. Ce processus à bien hérité l'environnement du processus parent.
• Utilisez deux fois la commande "EXIT" pour fermer les deux invites.

6. Modifier les variables d'environnement

[NonWindowsApp]
CommandEnvSize=4096

7. Variables système et utilisateur

8. Emplacements dans la base de registre (Windows NT uniquement)

• Les variables utilisateur sont stockées sous la clé :
  HKEY_CURRENT_USER\Environment
• Les variables système sont stockées sous la clé :
  HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\Environment
• Il existe un troisième emplacement qui est généralement très mal compris. Il s'agit de la clé :
  HKEY_USERS\.DEFAULT\Environment
  Cet emplacement ne définit pas les variables d'environnement par défaut fournies à chaque nouvel utilisateur mais plutôt les variables disponibles quand aucun utilisateur n'est connecté, c'est à dire quand Windows présente l'invite de connexion. Si vous voulez spécifier des variables utilisateur qui seront définies à chaque création d'utilisateur, il vous faut créer un profil et le copier dans le profil par défaut. Cette manipulation dépasse le cadre de cet article, vous trouverez facilement la marche à suivre sur de nombreux sites et forums.

9. Manipuler les variables d'environnement par programme

• GetEnvironmentVariable : Cette fonction permet d'obtenir la valeur d'une variable de l'environnement du processus courant si elle existe. Dans le cas contraire, la fonction retourne zéro et la fonction GetLastError retourne ERROR_ENVVAR_NOT_FOUND.
• SetEnvironmentVariable : Cette fonction permet d'ajouter, de modifier ou de supprimer une variable de l'environnement du processus courant. Si la valeur passée est nulle, la variable est supprimée, sinon la variable est modifiée dans le cas où elle existe déjà et créée dans le cas où elle n'existe pas.
  Attention, comme nous l'avons déjà vu, ces modifications ne sont valables que pour l'environnement du processus courant (en général l'application) et par héritage pour l'environnement des processus enfants du processus courant.
• GetEnvironmentStrings : Cette fonction permet d'obtenir la liste complète des variables de l'environnement du processus courant. Cette liste est fournie sous la forme d'un vecteur de chaînes de caractères à zéro terminal (chaînes C), lui-même terminé par un zéro. La fonction retourne l'adresse du bloc de mémoire contenant ces informations. Il est strictement interdit de modifier ce bloc de mémoire. Pour modifier les variables, utilisez la fonction SetEnvironmentVariable.
  Une fois que vous n'avez plus besoin de ce bloc de mémoire, utilisez la fonction FreeEnvironmentStrings pour le libérer.
• FreeEnvironmentStrings : Cette fonction libère un bloc d'environnement fourni par GetEnvironmentStrings.
• CreateProcess : Il est possible de modifier le bloc d'environnement d'un processus lancé par la fonction CreateProcess. Le paramètre lpEnvironment permet de spécifier l'adresse d'un bloc d'environnement que vous aurez préalablement créé et rempli. Si cette adresse n'est pas fournie, la fonction CreateProcess utilise l'environnement du processus courant.
• WM_SETTINGCHANGE : Ce message permet d'informer les processus en cours d'exécution de la modification des variables d'environnement (entre autres). Il doit être envoyé à l'aide des fonctions SendMessageTimeOut ou BroadcastSystemMessage et le paramètre LParam doit contenir la chaîne 'Environment'. L'utilisation d'un temps mort (time out) permet d'attendre l'acquittement des applications traitant ce message tout en évitant de bloquer le système lorsque certaines applications ne traitent pas celui-ci.

10. Code Delphi

unit Environment;

interface
uses
  Classes;
        
{ GetCurrentProcessEnvVar retourne la valeur de la variable d'environnement }
{ VariableName du processus courant ou une chaîne vide si cette variable    }
{ n'existe pas.                                                             }
function GetCurrentProcessEnvVar(const VariableName: string): string;

{ SetCurrentProcessEnvVar créé ou change la valeur de la variable     }
{ d'environnement VariableName du processus courant en VariableValue. }
procedure SetCurrentProcessEnvVar(const VariableName, VariableValue: string);

{ DeleteCurrentProcessEnvVar supprime la variable d'environnement VariableName }
{ de l'environnement du processus courant.                                     }
procedure DeleteCurrentProcessEnvVar(const VariableName: string);

{ ReadCurrentProcessEnvVars rempli la liste Vars avec l'ensemble des variables }
{  d'environnement du processus courant. Chaque ligne est de la forme          }
{  variable=valeur                                                             }
procedure ReadCurrentProcessEnvVars(Vars: TStrings);

{ BuildEnvironmentBlock construit un bloc d'environnement en utilisant une    }
{ liste de variables d'environnement fournie par Vars. Le bloc est copié dans }
{ Buffer et le nombre de caractères copiés est retourné comme résultat.       }
{ L'argument Len est utilisé à l'appel pour spécifier la taille du buffer en  }
{ nombre de caratères et contient après l'appel la taille minimale du buffer  }
{ pour contenir le bloc en entier.                                            }
{ Cette fonction est utilisée en 2 appels: le premier permet d'obtenir la     }
{ taille du buffer à allouer et le deuxième appel rempli le buffer.           }
function BuildEnvironmentBlock(Vars: TStrings; Buffer: PAnsiChar;
  var Len: Longword): LongWord;

{ ReadSystemVars rempli la liste Vars avec l'ensemble des variables système. }
procedure ReadSystemEnvVars(Vars: TStrings);

{ ReadSystemVars rempli la liste Vars avec l'ensemble des variables utilisateur. }
procedure ReadUserEnvVars(Vars: TStrings);

{ ReadSystemVars rempli la liste Vars avec l'ensemble des variables par défaut. }
procedure ReadDefaultEnvVars(Vars: TStrings);

{ SetSystemEnvVar modifie la valeur d'une variable système et informe          }
{ l'ensemble des applications que l'environnement a changé si BroadcastChange  }
{ vaut vrai.                                                                   }
procedure SetSystemEnvVar(const VariableName, VariableValue: string;
  const BroadcastChange: boolean);

{ DeleteSystemEnvVar supprime une variable système et informe l'ensemble des }
{ applications que l'environnement a changé si BroadcastChange vaut vrai.    }
procedure DeleteSystemEnvVar(const VariableName: string;
  const BroadCastChange: boolean);

{ SetUserEnvVar modifie la valeur d'une variable utilisateur et informe       }
{ l'ensemble des applications que l'environnement a changé si BroadcastChange }
{ vaut vrai.                                                                  }
procedure SetUserEnvVar(const VariableName, VariableValue: string;
  const BroadcastChange: boolean);

{ DeleteUserEnvVar supprime une variable utilisateur et informe l'ensemble des }
{ applications que l'environnement a changé si BroadcastChange vaut vrai.      }
procedure DeleteUserEnvVar(const VariableName: string;
  const BroadcastChange: boolean);

{ SetDefaultEnvVar modifie la valeur d'une variable par défaut et informe     }
{ l'ensemble des applications que l'environnement a changé si BroadcastChange }
{  vaut vrai.                                                                 }
procedure SetDefaultEnvVar(const VariableName, VariableValue: string;
  const BroadcastChange: boolean);

{ DeleteDefaultEnvVar supprime une variable par défaut et informe l'ensemble  }
{ des applications que l'environnement a changé si BroadcastChange vaut vrai. }
procedure DeleteDefaultEnvVar(const VariableName: string;
  const BroadcastChange: boolean);

{ BroadcastEnvironmentChange informe l'ensemble des applications que }
{ l'environnement a changé.                                          }
procedure BroadcastEnvironmentChange(TimeOut: Cardinal = 2000);


implementation
uses
  Windows, SysUtils, Registry, Messages;


function GetCurrentProcessEnvVar(const VariableName: string): string;
var
  nSize: DWord;
begin
  nSize:= 0;
  nSize:= GetEnvironmentVariable(PChar(VariableName), nil, nSize);
  if nSize = 0 then
    result:= ''
  else
  begin
    SetLength(result, nSize - 1);
    if GetEnvironmentVariable(PChar(VariableName), PChar(result), nSize) <> nSize - 1 then
      raise Exception.Create(SysErrorMessage(GetlastError))
  end;
end;

procedure SetCurrentProcessEnvVar(const VariableName, VariableValue: string);
begin
  SetEnvironmentVariable(PChar(VariableName), PChar(VariableValue));
end;

procedure DeleteCurrentProcessEnvVar(const VariableName: string);
begin
  SetCurrentProcessEnvVar(VariableName, '');
end;

procedure ReadEnvironmentBlock(const Block: PAnsiChar; Vars: TStrings);
var
  i: Integer;
  s: string;
begin
  Vars.Clear;
  i:= 0;
  while Block[i] <> #0 do
  begin
    s:= '';
    while Block[i] <> #0 do
    begin
      s:= s + Block[i];
      Inc(i);
    end;
    Vars.Add(s);
    Inc(i);
  end;
end;
        
procedure ReadCurrentProcessEnvVars(Vars: TStrings);
var
  block: PAnsiChar;
begin
  block:= GetEnvironmentStrings;
  try
    ReadEnvironmentBlock(block, Vars);
  finally
    FreeEnvironmentStrings(block);
  end;
end;
        
function BuildEnvironmentBlock(Vars: TStrings; Buffer: PAnsiChar;
  var Len: Longword): LongWord;
var
  line, i: Integer;
  p, l: LongWord;
begin
  p:= 0;
  l:= p;
  for line:= 0 to Vars.Count - 1 do
  begin
    for i:= 1 to Length(Vars[line]) do
    begin
      if p < Len then
      begin
        Buffer[p]:= Vars[line][i];
        Inc(l);
      end;
      Inc(p);
    end;
    if p < Len then
    begin
      Buffer[p]:= #0;
      Inc(l);
    end;
    Inc(p);
  end;
  if p < Len then
  begin
    Buffer[p]:= #0;
    Inc(l);
  end;
  result:= l;
  Len:= p;
end;
        
procedure ReadSystemEnvVars(Vars: TStrings);
var
  i: Integer;
begin
  Vars.Clear;
  with TRegistry.Create do
  try
    Access:= KEY_READ;
    RootKey:= HKEY_LOCAL_MACHINE;
    if OpenKey('SYSTEM\CurrentControlSet\Control\Session Manager\Environment',
      false) then
    begin
      GetValueNames(Vars);
      for i:= Vars.Count - 1 downto 0 do
        try
          Vars[i]:= Vars[i] + '=' + ReadString(Vars[i]);
        except
          Vars.Delete(i);
        end;
      CloseKey;
    end
    else
      raise Exception.Create('Impossible d''ouvrir la clé.');
  finally
    Free;
  end;
end;

procedure ReadUserEnvVars(Vars: TStrings);
var
  i: Integer;
begin
  Vars.Clear;
  with TRegistry.Create do
  try
    Access:= KEY_READ;
    RootKey:= HKEY_CURRENT_USER;
    if OpenKey('Environment', false) then
    begin
      GetValueNames(Vars);
      for i:= Vars.Count - 1 downto 0 do
        try
          Vars[i]:= Vars[i] + '=' + ReadString(Vars[i]);
        except
          Vars.Delete(i);
        end;
      CloseKey;
    end
    else
      raise Exception.Create('Impossible d''ouvrir la clé.');
  finally
    Free;
  end;
end;
        
procedure ReadDefaultEnvVars(Vars: TStrings);
var
  i: Integer;
begin
  Vars.Clear;
  with TRegistry.Create do
  try
    Access:= KEY_READ;
    RootKey:= HKEY_USERS;
    if OpenKey('.DEFAULT\Environment', false) then
    begin
      GetValueNames(Vars);
      for i:= Vars.Count - 1 downto 0 do
        try
          Vars[i]:= Vars[i] + '=' + ReadString(Vars[i]);
        except
          Vars.Delete(i);
        end;
      CloseKey;
    end
    else
      raise Exception.Create('Impossible d''ouvrir la clé.');
  finally
    Free;
  end;
end;
        
procedure SetSystemEnvVar(const VariableName, VariableValue: string;
  const BroadcastChange: boolean);
begin
  with TRegistry.Create do
  try
    Access:= KEY_WRITE;
    RootKey:= HKEY_LOCAL_MACHINE;
    if OpenKey('SYSTEM\CurrentControlSet\Control\Session Manager\Environment',
      false) then
    begin
      if (VariableValue = '') then
        DeleteValue(VariableName)
      else
        WriteString(VariableName, VariableValue);
      if BroadcastChange then
        BroadcastEnvironmentChange;
    end;
  finally
    Free;
  end;
end;
        
procedure SetUserEnvVar(const VariableName, VariableValue: string;
  const BroadcastChange: boolean);
begin
  with TRegistry.Create do
  try
    Access:= KEY_WRITE;
    RootKey:= HKEY_CURRENT_USER;
    if OpenKey('Environment', false) then
    begin
      if (VariableValue = '') then
        DeleteValue(VariableName)
      else
        WriteString(VariableName, VariableValue);
      if BroadcastChange then
        BroadcastEnvironmentChange;
    end;
  finally
    Free;
  end;
end;
        
procedure SetDefaultEnvVar(const VariableName, VariableValue: string;
  const BroadcastChange: boolean);
begin
  with TRegistry.Create do
  try
    Access:= KEY_WRITE;
    RootKey:= HKEY_USERS;
    if OpenKey('.DEFAULT\Environment', false) then
    begin
      if (VariableValue = '') then
        DeleteValue(VariableName)
      else
        WriteString(VariableName, VariableValue);
      if BroadcastChange then
        BroadcastEnvironmentChange;
    end;
  finally
    Free;
  end;
end;

procedure BroadcastEnvironmentChange(TimeOut: Cardinal = 2000);
var
  lParam: PChar;
  dwResult: Cardinal;
begin
  lParam:= 'Environment';
  SendMessageTimeOut(HWND_BROADCAST, WM_SETTINGCHANGE, 0,
    Integer(lParam), SMTO_NORMAL	, TimeOut, dwResult);
  if dwResult <> 0 then
    raise Exception.Create(SysErrorMessage(dwResult));
end;

procedure DeleteSystemEnvVar(const VariableName: string;
  const BroadCastChange: boolean);
begin
  SetSystemEnvVar(VariableName, '', BroadCastChange);
end;

procedure DeleteUserEnvVar(const VariableName: string;
  const BroadCastChange: boolean);
begin
  SetUserEnvVar(VariableName, '', BroadCastChange);
end;

procedure DeleteDefaultEnvVar(const VariableName: string;
  const BroadCastChange: boolean);
begin
  SetDefaultEnvVar(VariableName, '', BroadCastChange);
end;

end.