Aspx.net, C# et accès à des partages réseau

[KewlCat]

Bonjour.

 

Une fois de plus j'ai un problème tordu, mais pour une fois je viens poser des questions avant d'être à court d'idées sur la chose

Je dispose d'un serveur d'applications { Windows 2k/XP + IIS + Aspx.net } sur lequel j'ai un client NFS (un produit Hummingbird, "Maestro NFS Solo").

 

J'ai besoin d'accéder à un fichier sur un partage NFS, mais je n'ai pas l'assurance que le disque en question soit accessible localement (donc je dois le "mounter").

Pour l'instant j'ai réussi à exécuter un System.Diagnostics.Process pour qu'il me fasse le "nfs link g: \\serveur\/repertoire/partage" (la ligne de commande qui permet de mapper g: sur le partage NFS) mais le truc drôle c'est que, bien qu'un autre System.Diagnostics.Process me permettrait d'accéder à "G:" jusqu'à ce que je lui fasse exécuter un "nfs unlink" (cette méthode d'accès à mon lecteur réseau ne m'interesse pas), n'importe quel Directory.Exists("G:") me renvoie false ! Le "lecteur réseau" n'est donc pas accessible depuis mon programme (*) !

 

Comment accède-t-on à un partage réseau en C# ?

 

A toutes fins utiles, je signale que ce fameux client nfs semble me permettre de mapper localement des partages NFS en partages SMB (vu que la syntaxe "\\serveur\/repertoire/du/partageNFS" est interchangeable avec "\\serveur\nom_du_partage" et qu'une extension de ce produit semble être une gateway NFS <-> SMB).

 

En espérant que vous aurez plus d'idées que moi...

 

(*) ni accessible au programme, ni à un autre utilisateur local sur le serveur. Il n'apparait pas dans la listes des lecteurs dans l'explorateur ! Apparemment seuls les System.Diagnostics.Process ont accès à ce lecteur g:\. (je HAIS la logique Microsoft)

[KewlCat]

Visual Studio me conseille d'aller voir un médecin...

[Greywolf]

j'adore les messages d'erreur toujours utiles des outils microsoft (bon j'utilise pas visual studio mais la suite office me suffit pour en trouver )

 

Pardon de cette intrusion, je compatis néanmoins à ton problème... au moins tu te sentiras peut être moins seul

 

A toutes fins utiles, quelques idées d'un profane totalement ignare dans le domaine:

• NFS et windows je pensais que c'était que pour les réseaux unix.
  y'a pas une histoire de droits d'accès à gérer avec LSASS?
  

Modifié le 5 octobre 2004 par Greywolf

[KewlCat]

Oui, je sais, je sais... NFS et Windows c'est une aberration (pourtant il existe quelques éditeurs qui font des clients et même des serveurs NFS pour win32).

Ca doit être pour les gens qui n'ont pas confiance en Samba (et Dieu sait que Samba sous Unix c'est tout aussi aberrant que NFS sous Windows).

 

L'ennui c'est que c'est imposé, je n'ai donc pas le choix.

 

Un point positif, c'est que l'authentification n'a pas à se faire par NDIS, NDIS+ ou Active-Directory-chaipukoi, je peux donc mettre en place un serveur de test sous Linux (le portable de ma boite) et m'authentifier grâce à rpc.pcnfsd (parce que le daemon hclnfsd fourni par Hummingbird ne fonctionne pas... le comble).

 

Bref. Je tiens une piste avec WindowsIdentity.Impersonate() mais pour récupérer les infos me permettant de changer le user possédant le thread qui fait les requêtes sur les partages réseau, il faut passer par (roulements de tambour) des fonctions Win32 !

(C'est incroyable la facilité avec laquelle on est obligé, dans n'importe quel projet .Net, d'avoir recours à des fonctions non-managées... c'est hallucinant !)

[tangui]

tiens, je dois avoir des cours, et des bonnes adresses pour du C#... je jetterai un coup d'oeil pour voir si j'ai klke chose qui puisse t'aider...mais ca m'etonnerait...

[KewlCat]

Tu demanderas à ton formateur ("prof" ?) comment on peut, en aspx, accéder à des partages réseau (commence par demander pour "un fichier sur un lecteur réseau qui a été connecté" puis vas-y carrément avec "un chemin du type \\serveur\partage\chemin\vers\le\fichier.txt")

S'il arrive à répondre à ces questions, il est doué. Y'a un sacré paquet de gens qui ont posé ces questions sur des forums techniques, fréquentés par la crème des codeurs C# / aspx et y'en a un seul qui a eu une réponse.

 

J'ai trouvé les sources sur le Net, je copie/colle :

using System;
using System.Runtime.InteropServices;
using System.Security.Principal;
using System.Security.Permissions;

namespace MonNameSpace
{
       public enum LogonType : int {
               LOGON32_LOGON_INTERACTIVE =     2,
               LOGON32_LOGON_NETWORK = 3,
               LOGON32_LOGON_BATCH = 4,
               LOGON32_LOGON_SERVICE = 5,
               LOGON32_LOGON_UNLOCK = 7,
               LOGON32_LOGON_NETWORK_CLEARTEXT = 8,    // Only for Win2K or higher
               LOGON32_LOGON_NEW_CREDENTIALS = 9               // Only for Win2K or higher
       };

       public enum LogonProvider : int {
               LOGON32_PROVIDER_DEFAULT = 0,
               LOGON32_PROVIDER_WINNT35 = 1,
               LOGON32_PROVIDER_WINNT40 = 2,
               LOGON32_PROVIDER_WINNT50 = 3
       };

       class SecuUtil32 {
               [DllImport("advapi32.dll", SetLastError=true)]
               public static extern bool LogonUser(String lpszUsername, String lpszDomain, String lpszPassword,
                       int dwLogonType, int dwLogonProvider, ref IntPtr TokenHandle);

               [DllImport("kernel32.dll", CharSet=CharSet.Auto)]
               public extern static bool CloseHandle(IntPtr handle);

               [DllImport("advapi32.dll", CharSet=CharSet.Auto, SetLastError=true)]
               public extern static bool DuplicateToken(IntPtr ExistingTokenHandle,
                       int SECURITY_IMPERSONATION_LEVEL, ref IntPtr DuplicateTokenHandle);
       }

       /// <summary>
       /// Summary description for NetworkSecurity.
       /// </summary>
       public class NetworkSecurity {

               public NetworkSecurity() {
                       // TODO: Add constructor logic here
               }
      
               public static WindowsImpersonationContext ImpersonateUser(string strDomain,
                                                                                        string strLogin,
                                                                                        string strPwd,
                                                                                        LogonType logonType,
                                                                                        LogonProvider logonProvider) {
                       IntPtr tokenHandle = new IntPtr(0);
                       IntPtr dupeTokenHandle = new IntPtr(0);
                       try {
                               const int SecurityImpersonation = 2;
      
                               tokenHandle = IntPtr.Zero;
                               dupeTokenHandle = IntPtr.Zero;

                               // Call LogonUser to obtain a handle to an access token.
                               bool returnValue = SecuUtil32.LogonUser(
                                       strLogin,
                                       strDomain,
                                       strPwd,
                                       (int)logonType,
                                       (int)logonProvider,
                                       ref tokenHandle);
                               if (returnValue == false)  {
                                       int ret = Marshal.GetLastWin32Error();
                                       string strErr = String.Format("LogonUser failed with error code : {0}", ret);
                                       throw new ApplicationException(strErr, null);
                               }

                               bool retVal = SecuUtil32.DuplicateToken(tokenHandle, SecurityImpersonation, ref dupeTokenHandle);
                               if (false == retVal == false) {
                                       SecuUtil32.CloseHandle(tokenHandle);
                                       throw new ApplicationException("Failed to duplicate token", null);
                               }

                               // The token that is passed to the following constructor must
                               // be a primary token in order to use it for impersonation.
                               WindowsIdentity newId = new WindowsIdentity(dupeTokenHandle);
                               WindowsImpersonationContext impersonatedUser = newId.Impersonate();

                               return impersonatedUser;
                       } catch (Exception ex) {
                               throw new ApplicationException(ex.Message, ex);
                       }
               }
       }
}

Ca s'utilise comme ça :

                        impContext = null;
                       try {
                               // Changement d'identite courante afin d'obtenir les droits d'acces
                               //            aux ressources partagees en reseau.
                               impContext = NetworkSecurity.ImpersonateUser(
                                       TextBoxDomain.Text,     TextBoxLogin.Text, TextBoxPassword.Text,
                                       LogonType.LOGON32_LOGON_NETWORK, LogonProvider.LOGON32_PROVIDER_DEFAULT);
                       } catch (ApplicationException ex) {
                               // Exception
                       }
                       if (impContext != null)
                       {
                               try {
                                       // Tout ce qu'on veut. Par exemple, Directory a accès à "\\192.168.0.12\partage\mon_repertoire"
                               } catch (Exception ex) {
                                       // Exception
                               }
                               // Finally we have to revert the impersonation.
                               impContext.Undo();
                       }