Click here to Skip to main content
11,488,877 members (77,832 online)
Click here to Skip to main content
Add your own
alternative version

Network Shares and UNC paths

, 11 Nov 2003 CPOL 332.7K 4.8K 109
Classes to enumerate network shares on local and remote machines, and convert local file paths to UNC paths.
networkshares_src.zip
testShares.exe
using System;
using System.IO;
using System.Collections;
using System.Runtime.InteropServices;

namespace Trinet.Networking
{
	#region Share Type
	
	/// <summary>
	/// Type of share
	/// </summary>
	[Flags]
	public enum ShareType
	{
		/// <summary>Disk share</summary>
		Disk		= 0,
		/// <summary>Printer share</summary>
		Printer		= 1,
		/// <summary>Device share</summary>
		Device		= 2,
		/// <summary>IPC share</summary>
		IPC			= 3,
		/// <summary>Special share</summary>
		Special		= -2147483648, // 0x80000000,
	}
	
	#endregion
	
	#region Share
	
	/// <summary>
	/// Information about a local share
	/// </summary>
	public class Share
	{
		#region Private data
		
		private string _server;
		private string _netName;
		private string _path;
		private ShareType _shareType;
		private string _remark;
		
		#endregion
		
		#region Constructor

		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="Server"></param>
		/// <param name="shi"></param>
		public Share(string server, string netName, string path, ShareType shareType, string remark) 
		{
			if (ShareType.Special == shareType && "IPC$" == netName)
			{
				shareType |= ShareType.IPC;
			}
			
			_server = server;
			_netName = netName;
			_path = path;
			_shareType = shareType;
			_remark = remark;
		}
		
		#endregion
		
		#region Properties

		/// <summary>
		/// The name of the computer that this share belongs to
		/// </summary>
		public string Server 
		{
			get { return _server; }
		}

		/// <summary>
		/// Share name
		/// </summary>
		public string NetName 
		{
			get { return _netName; }
		}

		/// <summary>
		/// Local path
		/// </summary>
		public string Path 
		{
			get { return _path; }
		}

		/// <summary>
		/// Share type
		/// </summary>
		public ShareType ShareType 
		{
			get { return _shareType; }
		}

		/// <summary>
		/// Comment
		/// </summary>
		public string Remark 
		{
			get { return _remark; }
		}

		/// <summary>
		/// Returns true if this is a file system share
		/// </summary>
		public bool IsFileSystem 
		{
			get 
			{
				// Shared device
				if (0 != (_shareType & ShareType.Device)) return false;
				// IPC share
				if (0 != (_shareType & ShareType.IPC)) return false;
				// Shared printer
				if (0 != (_shareType & ShareType.Printer)) return false;
				
				// Standard disk share
				if (0 == (_shareType & ShareType.Special)) return true;
				
				// Special disk share (e.g. C$)
				if (ShareType.Special == _shareType && null != _netName && 0 != _netName.Length)
					return true;
				else
					return false;
			}
		}

		/// <summary>
		/// Get the root of a disk-based share
		/// </summary>
		public DirectoryInfo Root 
		{
			get 
			{
				if (IsFileSystem) 
				{
					if (null == _server || 0 == _server.Length)
						if (null == _path || 0 == _path.Length)
							return new DirectoryInfo(ToString());
						else
							return new DirectoryInfo(_path);
					else
						return new DirectoryInfo(ToString());
				}
				else 
					return null;
			}
		}
		
		#endregion

		/// <summary>
		/// Returns the path to this share
		/// </summary>
		/// <returns></returns>
		public override string ToString() 
		{
			if (null == _server || 0 == _server.Length)
			{
				return string.Format(@"\\{0}\{1}", Environment.MachineName, _netName);
			}
			else
				return string.Format(@"\\{0}\{1}", _server, _netName);
		}

		/// <summary>
		/// Returns true if this share matches the local path
		/// </summary>
		/// <param name="path"></param>
		/// <returns></returns>
		public bool MatchesPath(string path) 
		{
			if (!IsFileSystem) return false;
			if (null == path || 0 == path.Length) return true;
			
			return path.ToLower().StartsWith(_path.ToLower());
		}
	}
	
	#endregion
	
	#region Share Collection
	
	/// <summary>
	/// A collection of shares
	/// </summary>
	public class ShareCollection : ReadOnlyCollectionBase
	{
		#region Platform
		
		/// <summary>
		/// Is this an NT platform?
		/// </summary>
		protected static bool IsNT
		{
			get { return (PlatformID.Win32NT == Environment.OSVersion.Platform); }
		}

		/// <summary>
		/// Returns true if this is Windows 2000 or higher
		/// </summary>
		protected static bool IsW2KUp
		{
			get 
			{
				OperatingSystem os = Environment.OSVersion;
				if (PlatformID.Win32NT == os.Platform && os.Version.Major >= 5) 
					return true;
				else 
					return false;
			}
		}
		
		#endregion

		#region Interop
		
		#region Constants
		
		/// <summary>Maximum path length</summary>
		protected const int MAX_PATH = 260;
		/// <summary>No error</summary>
		protected const int NO_ERROR = 0;
		/// <summary>Access denied</summary>
		protected const int ERROR_ACCESS_DENIED = 5;
		/// <summary>Access denied</summary>
		protected const int ERROR_WRONG_LEVEL = 124;
		/// <summary>More data available</summary>
		protected const int ERROR_MORE_DATA = 234;
		/// <summary>Not connected</summary>
		protected const int ERROR_NOT_CONNECTED = 2250;
		/// <summary>Level 1</summary>
		protected const int UNIVERSAL_NAME_INFO_LEVEL = 1;
		/// <summary>Max extries (9x)</summary>
		protected const int MAX_SI50_ENTRIES = 20;
		
		#endregion
		
		#region Structures
		
		/// <summary>Unc name</summary>
		[StructLayout(LayoutKind.Sequential, CharSet=CharSet.Auto)]
		protected struct UNIVERSAL_NAME_INFO 
		{
			[MarshalAs(UnmanagedType.LPTStr)]
			public string lpUniversalName;
		}

		/// <summary>Share information, NT, level 2</summary>
		/// <remarks>
		/// Requires admin rights to work. 
		/// </remarks>
		[StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)]
		protected struct SHARE_INFO_2 
		{
			[MarshalAs(UnmanagedType.LPWStr)]
			public string NetName;
			public ShareType ShareType;
			[MarshalAs(UnmanagedType.LPWStr)]
			public string Remark;
			public int Permissions;
			public int MaxUsers;
			public int CurrentUsers;
			[MarshalAs(UnmanagedType.LPWStr)]
			public string Path;
			[MarshalAs(UnmanagedType.LPWStr)]
			public string Password;
		}
		
		/// <summary>Share information, NT, level 1</summary>
		/// <remarks>
		/// Fallback when no admin rights.
		/// </remarks>
		[StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)]
		protected struct SHARE_INFO_1 
		{
			[MarshalAs(UnmanagedType.LPWStr)]
			public string NetName;
			public ShareType ShareType;
			[MarshalAs(UnmanagedType.LPWStr)]
			public string Remark;
		}
		
		/// <summary>Share information, Win9x</summary>
		[StructLayout(LayoutKind.Sequential, CharSet=CharSet.Ansi, Pack=1)]
		protected struct SHARE_INFO_50 
		{
			[MarshalAs(UnmanagedType.ByValTStr, SizeConst=13)]
			public string NetName;

			public byte bShareType;
			public ushort Flags;
			
			[MarshalAs(UnmanagedType.LPTStr)]
			public string Remark;
			[MarshalAs(UnmanagedType.LPTStr)]
			public string Path;

			[MarshalAs(UnmanagedType.ByValTStr, SizeConst=9)]
			public string PasswordRW;
			[MarshalAs(UnmanagedType.ByValTStr, SizeConst=9)]
			public string PasswordRO;
			
			public ShareType ShareType
			{
				get { return (ShareType)((int)bShareType & 0x7F); }
			}
		}
		
		/// <summary>Share information level 1, Win9x</summary>
		[StructLayout(LayoutKind.Sequential, CharSet=CharSet.Ansi, Pack=1)]
		protected struct SHARE_INFO_1_9x 
		{
			[MarshalAs(UnmanagedType.ByValTStr, SizeConst=13)]
			public string NetName;
			public byte Padding;

			public ushort bShareType;
			
			[MarshalAs(UnmanagedType.LPTStr)]
			public string Remark;
			
			public ShareType ShareType
			{
				get { return (ShareType)((int)bShareType & 0x7FFF); }
			}
		}

		#endregion
		
		#region Functions
		
		/// <summary>Get a UNC name</summary>
		[DllImport("mpr", CharSet=CharSet.Auto)]
		protected static extern int WNetGetUniversalName (string lpLocalPath,
			int dwInfoLevel, ref UNIVERSAL_NAME_INFO lpBuffer, ref int lpBufferSize);

		/// <summary>Get a UNC name</summary>
		[DllImport("mpr", CharSet=CharSet.Auto)]
		protected static extern int WNetGetUniversalName (string lpLocalPath,
			int dwInfoLevel, IntPtr lpBuffer, ref int lpBufferSize);

		/// <summary>Enumerate shares (NT)</summary>
		[DllImport("netapi32", CharSet=CharSet.Unicode)]
		protected static extern int NetShareEnum (string lpServerName, int dwLevel,
			out IntPtr lpBuffer, int dwPrefMaxLen, out int entriesRead,
			out int totalEntries, ref int hResume);

		/// <summary>Enumerate shares (9x)</summary>
		[DllImport("svrapi", CharSet=CharSet.Ansi)]
		protected static extern int NetShareEnum(
			[MarshalAs(UnmanagedType.LPTStr)] string lpServerName, int dwLevel,
			IntPtr lpBuffer, ushort cbBuffer, out ushort entriesRead,
			out ushort totalEntries);

		/// <summary>Free the buffer (NT)</summary>
		[DllImport("netapi32")]
		protected static extern int NetApiBufferFree(IntPtr lpBuffer);
		
		#endregion
		
		#region Enumerate shares
		
		/// <summary>
		/// Enumerates the shares on Windows NT
		/// </summary>
		/// <param name="server">The server name</param>
		/// <param name="shares">The ShareCollection</param>
		protected static void EnumerateSharesNT(string server, ShareCollection shares)
		{
			int level = 2;
			int entriesRead, totalEntries, nRet, hResume = 0;
			IntPtr pBuffer = IntPtr.Zero;

			try 
			{
				nRet = NetShareEnum(server, level, out pBuffer, -1, 
					out entriesRead, out totalEntries, ref hResume);

				if (ERROR_ACCESS_DENIED == nRet) 
				{
					//Need admin for level 2, drop to level 1
					level = 1;
					nRet = NetShareEnum(server, level, out pBuffer, -1, 
						out entriesRead, out totalEntries, ref hResume);
				}

				if (NO_ERROR == nRet && entriesRead > 0) 
				{
					Type t = (2 == level) ? typeof(SHARE_INFO_2) : typeof(SHARE_INFO_1);
					int offset = Marshal.SizeOf(t);

					for (int i=0, lpItem=pBuffer.ToInt32(); i<entriesRead; i++, lpItem+=offset) 
					{
						IntPtr pItem = new IntPtr(lpItem);
						if (1 == level) 
						{
							SHARE_INFO_1 si = (SHARE_INFO_1)Marshal.PtrToStructure(pItem, t);
							shares.Add(si.NetName, string.Empty, si.ShareType, si.Remark);
						}
						else 
						{
							SHARE_INFO_2 si = (SHARE_INFO_2)Marshal.PtrToStructure(pItem, t);
							shares.Add(si.NetName, si.Path, si.ShareType, si.Remark);
						}
					}
				}
				
			}
			finally 
			{
				// Clean up buffer allocated by system
				if (IntPtr.Zero != pBuffer) 
					NetApiBufferFree(pBuffer);
			}
		}
		
		/// <summary>
		/// Enumerates the shares on Windows 9x
		/// </summary>
		/// <param name="server">The server name</param>
		/// <param name="shares">The ShareCollection</param>
		protected static void EnumerateShares9x(string server, ShareCollection shares)
		{
			int level = 50;
			int nRet = 0;
			ushort entriesRead, totalEntries;
			
			Type t = typeof(SHARE_INFO_50);
			int size = Marshal.SizeOf(t);
			ushort cbBuffer = (ushort)(MAX_SI50_ENTRIES * size);
			//On Win9x, must allocate buffer before calling API
			IntPtr pBuffer = Marshal.AllocHGlobal(cbBuffer);

			try 
			{
				nRet = NetShareEnum(server, level, pBuffer, cbBuffer, 
					out entriesRead, out totalEntries);
				
				if (ERROR_WRONG_LEVEL == nRet)
				{
					level = 1;
					t = typeof(SHARE_INFO_1_9x);
					size = Marshal.SizeOf(t);
					
					nRet = NetShareEnum(server, level, pBuffer, cbBuffer, 
						out entriesRead, out totalEntries);
				}

				if (NO_ERROR == nRet || ERROR_MORE_DATA == nRet) 
				{
					for (int i=0, lpItem=pBuffer.ToInt32(); i<entriesRead; i++, lpItem+=size) 
					{
						IntPtr pItem = new IntPtr(lpItem);
						
						if (1 == level)
						{
							SHARE_INFO_1_9x si = (SHARE_INFO_1_9x)Marshal.PtrToStructure(pItem, t);
							shares.Add(si.NetName, string.Empty, si.ShareType, si.Remark);
						}
						else
						{
							SHARE_INFO_50 si = (SHARE_INFO_50)Marshal.PtrToStructure(pItem, t);
							shares.Add(si.NetName, si.Path, si.ShareType, si.Remark);
						}
					}
				}
				else
					Console.WriteLine(nRet);
				
			}
			finally 
			{
				//Clean up buffer
				Marshal.FreeHGlobal(pBuffer);
			}
		}
		
		/// <summary>
		/// Enumerates the shares
		/// </summary>
		/// <param name="server">The server name</param>
		/// <param name="shares">The ShareCollection</param>
		protected static void EnumerateShares(string server, ShareCollection shares)
		{
			if (null != server && 0 != server.Length && !IsW2KUp) 
			{
				server = server.ToUpper();
				
				// On NT4, 9x and Me, server has to start with "\\"
				if (!('\\' == server[0] && '\\' == server[1])) 
					server = @"\\" + server;
			}
		
			if (IsNT)
				EnumerateSharesNT(server, shares);
			else
				EnumerateShares9x(server, shares);
		}
		
		#endregion
		
		#endregion
		
		#region Static methods

		/// <summary>
		/// Returns true if fileName is a valid local file-name of the form:
		/// X:\, where X is a drive letter from A-Z
		/// </summary>
		/// <param name="fileName">The filename to check</param>
		/// <returns></returns>
		public static bool IsValidFilePath(string fileName) 
		{
			if (null == fileName || 0 == fileName.Length) return false;

			char drive = char.ToUpper(fileName[0]);
			if ('A' > drive || drive > 'Z') 
				return false;
			
			else if (Path.VolumeSeparatorChar != fileName[1]) 
				return false;
			else if (Path.DirectorySeparatorChar != fileName[2]) 
				return false;
			else 
				return true;
		}

		/// <summary>
		/// Returns the UNC path for a mapped drive or local share.
		/// </summary>
		/// <param name="fileName">The path to map</param>
		/// <returns>The UNC path (if available)</returns>
		public static string PathToUnc(string fileName) 
		{
			if (null == fileName || 0 == fileName.Length) return string.Empty;
			
			fileName = Path.GetFullPath(fileName);
			if (!IsValidFilePath(fileName)) return fileName;
			
			int nRet = 0;
			UNIVERSAL_NAME_INFO rni = new UNIVERSAL_NAME_INFO();
			int bufferSize = Marshal.SizeOf(rni);

			nRet = WNetGetUniversalName(
				fileName, UNIVERSAL_NAME_INFO_LEVEL, 
				ref rni, ref bufferSize);
			
			if (ERROR_MORE_DATA == nRet) 
			{
				IntPtr pBuffer = Marshal.AllocHGlobal(bufferSize);;
				try 
				{
					nRet = WNetGetUniversalName(
						fileName, UNIVERSAL_NAME_INFO_LEVEL, 
						pBuffer, ref bufferSize);

					if (NO_ERROR == nRet) 
					{
						rni = (UNIVERSAL_NAME_INFO)Marshal.PtrToStructure(pBuffer,
							typeof(UNIVERSAL_NAME_INFO));
					}
				}
				finally 
				{
					Marshal.FreeHGlobal(pBuffer);
				}
			}

			switch (nRet) 
			{
				case NO_ERROR:
					return rni.lpUniversalName;

				case ERROR_NOT_CONNECTED:
					//Local file-name
					ShareCollection shi = LocalShares;
					if (null != shi)
					{
						Share share = shi[fileName];
						if (null != share)
						{
							string path = share.Path;
							if (null != path && 0 != path.Length)
							{
								int index = path.Length;
								if (Path.DirectorySeparatorChar != path[path.Length - 1])
									index++;
								
								if (index < fileName.Length)
									fileName = fileName.Substring(index);
								else
									fileName = string.Empty;
								
								fileName = Path.Combine(share.ToString(), fileName);
							}
						}
					}
					
					return fileName;

				default:
					Console.WriteLine("Unknown return value: {0}", nRet);
					return string.Empty;
			}
		}

		/// <summary>
		/// Returns the local <see cref="Share"/> object with the best match
		/// to the specified path.
		/// </summary>
		/// <param name="fileName"></param>
		/// <returns></returns>
		public static Share PathToShare(string fileName) 
		{
			if (null == fileName || 0 == fileName.Length) return null;

			fileName = Path.GetFullPath(fileName);
			if (!IsValidFilePath(fileName)) return null;

			ShareCollection shi = LocalShares;
			if (null == shi) 
				return null;
			else 
				return shi[fileName];
		}
		
		#endregion
		
		#region Local shares
		
		/// <summary>The local shares</summary>
		private static ShareCollection _local = null;

		/// <summary>
		/// Return the local shares
		/// </summary>
		public static ShareCollection LocalShares 
		{
			get 
			{
				if (null == _local) 
					_local = new ShareCollection();
				
				return _local;
			}
		}
		
		/// <summary>
		/// Return the shares for a specified machine
		/// </summary>
		/// <param name="server"></param>
		/// <returns></returns>
		public static ShareCollection GetShares(string server)
		{
			return new ShareCollection(server);
		}

		#endregion
		
		#region Private Data

		/// <summary>The name of the server this collection represents</summary>
		private string _server;
		
		#endregion
		
		#region Constructor

		/// <summary>
		/// Default constructor - local machine
		/// </summary>
		public ShareCollection() 
		{
			_server = string.Empty;
			EnumerateShares(_server, this);
		}

		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="Server"></param>
		public ShareCollection(string server) 
		{
			_server = server;
			EnumerateShares(_server, this);
		}
		
		#endregion
		
		#region Add
		
		protected void Add(Share share)
		{
			InnerList.Add(share);
		}
		
		protected void Add(string netName, string path, ShareType shareType, string remark)
		{
			InnerList.Add(new Share(_server, netName, path, shareType, remark));
		}
		
		#endregion
		
		#region Properties

		/// <summary>
		/// Returns the name of the server this collection represents
		/// </summary>
		public string Server 
		{
			get { return _server; }
		}

		/// <summary>
		/// Returns the <see cref="Share"/> at the specified index.
		/// </summary>
		public Share this[int index] 
		{
			get { return (Share)InnerList[index]; }
		}

		/// <summary>
		/// Returns the <see cref="Share"/> which matches a given local path
		/// </summary>
		/// <param name="path">The path to match</param>
		public Share this[string path] 
		{
			get 
			{
				if (null == path || 0 == path.Length) return null;
				
				path = Path.GetFullPath(path);
				if (!IsValidFilePath(path)) return null;

				Share match = null;
				
				for(int i=0; i<InnerList.Count; i++) 
				{
					Share s = (Share)InnerList[i];
					
					if (s.IsFileSystem && s.MatchesPath(path)) 
					{
						//Store first match
						if (null == match) 
							match = s;

						// If this has a longer path,
						// and this is a disk share or match is a special share, 
						// then this is a better match
						else if (match.Path.Length < s.Path.Length) 
						{
							if (ShareType.Disk == s.ShareType || ShareType.Disk != match.ShareType)
								match = s;
						}
					}
				}

				return match;
			}
		}
		
		#endregion

		#region Implementation of ICollection

		/// <summary>
		/// Copy this collection to an array
		/// </summary>
		/// <param name="array"></param>
		/// <param name="index"></param>
		public void CopyTo(Share[] array, int index) 
		{
			InnerList.CopyTo(array, index);
		}

		#endregion
	}
	
	#endregion
}

By viewing downloads associated with this article you agree to the Terms of Service and the article's licence.

If a file you wish to view isn't highlighted, and is a text file (not binary), please let us know and we'll add colourisation support for it.

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Share

About the Author

Richard Deeming
Software Developer Nevalee Business Solutions
United Kingdom United Kingdom
No Biography provided
Follow on   Twitter   Google+

| Advertise | Privacy | Terms of Use | Mobile
Web04 | 2.8.150520.1 | Last Updated 12 Nov 2003
Article Copyright 2002 by Richard Deeming
Everything else Copyright © CodeProject, 1999-2015
Layout: fixed | fluid