How to create a file share using .NET framework

Introduction

Title of this article says how to create a file share using .NET framework. But if you really get down to bottom of it, there is no class or method in .NET framework that accomplishes this task. This is the time when we take help from PInvoke to call unmanaged Win32 API. The NetApi in Win32 platform provides a rich set of functions that allows us to do network management.

Details

Network Management API provides following functions to manage file shares.

• NetShareAdd
• NetShareDel
• NetShareCheck
• NetShareGetInfo
• NetShareSetInfo

The names of these APIs are very self explanatory. They do what their names suggest. In this article we will show how you can use NetShareAdd API to create a new file share on an existing folder in a machine. Following code is a complete example of how you can use this API with PInvoke in .NET framework to create a share.

There are couple of important points in this code that we would like to highlight.

• SHARE_INFO_502 structure that contains the share information requires that all strings should be Wide Character strings. Therefore it is important that when you define the structure, use MarshalAs attribute to specify that string should be marshalled appropriately as Wide Character type. You can specify the value foe the attribute as UnmanagedType.LPWStr.
• In SHARE_INFO_502 structure you can specify the permissions by specifying a Security Descriptor that has the required ACL. If you set the value of shi502_security_descriptor variable to 0, then a null DACL is set on the file share meaning that Everybody has full access to this share.

Code

using System;
using System.Diagnostics;
using System.Collections;
using System.Runtime.InteropServices;
using ActiveDs;

namespace ADSI_Net
{
    class NetApi32
    {
        public enum NetError
        {
            NERR_Success = 0,
            NERR_BASE = 2100,
            NERR_UnknownDevDir = (NERR_BASE + 16),
            NERR_DuplicateShare = (NERR_BASE + 18),
            NERR_BufTooSmall = (NERR_BASE + 23),
        }

        public enum SHARE_TYPE : ulong
        {
            STYPE_DISKTREE = 0,
            STYPE_PRINTQ = 1,
            STYPE_DEVICE = 2,
            STYPE_IPC = 3,
            STYPE_SPECIAL = 0x80000000,
        }

        [ StructLayout( LayoutKind.Sequential )]
        public struct SHARE_INFO_502
        {
            [MarshalAs(UnmanagedType.LPWStr)]
            public string shi502_netname;
            public uint shi502_type;
            [MarshalAs(UnmanagedType.LPWStr)]
            public string shi502_remark;
            public Int32 shi502_permissions;
            public Int32 shi502_max_uses;
            public Int32 shi502_current_uses;
            [MarshalAs(UnmanagedType.LPWStr)]
            public string shi502_path;
            public IntPtr shi502_passwd;
            public Int32 shi502_reserved;
            public IntPtr shi502_security_descriptor;
        }

        [DllImport("Netapi32.dll")]
        public static extern int NetShareAdd(
                [MarshalAs(UnmanagedType.LPWStr)]
        string strServer, Int32 dwLevel, IntPtr buf, IntPtr parm_err);


    }
    
    class AD_ShareUtil
    {
        [STAThread]
        static void Main(string[] args)
        {
            string strServer = @"HellRaiser";
            string strShareFolder = @"G:\Mp3folder";
            string strShareName = @"MyMP3Share";
            string strShareDesc = @"Share to store MP3 files";
            NetApi32.NetError nRetVal = 0;
            AD_ShareUtil shUtil = new AD_ShareUtil();
            nRetVal = shUtil.CreateShare(strServer, 
              strShareFolder, strShareName, strShareDesc, false);
            if (nRetVal == NetApi32.NetError.NERR_Success)
            {
                Console.WriteLine("Share {0} created", strShareName);
            }
            else if (nRetVal == NetApi32.NetError.NERR_DuplicateShare)
            {
                Console.WriteLine("Share {0} already exists", 
                          strShareName);
            }
        }

        NetApi32.NetError CreateShare(string strServer,
                                      string strPath,
                                      string strShareName,
                                      string strShareDesc,
                                      bool bAdmin)
        {
            NetApi32.SHARE_INFO_502 shInfo = 
                  new ADSI_Net.NetApi32.SHARE_INFO_502();
            shInfo.shi502_netname = strShareName;
            shInfo.shi502_type = 
                (uint)NetApi32.SHARE_TYPE.STYPE_DISKTREE;
            if (bAdmin)
            {
                shInfo.shi502_type = 
                    (uint)NetApi32.SHARE_TYPE.STYPE_SPECIAL;
                shInfo.shi502_netname += "$";
            }
            shInfo.shi502_permissions = 0;
            shInfo.shi502_path = strPath;
            shInfo.shi502_passwd = IntPtr.Zero;
            shInfo.shi502_remark = strShareDesc;
            shInfo.shi502_max_uses = -1;
            shInfo.shi502_security_descriptor = IntPtr.Zero;

            string strTargetServer = strServer;
            if (strServer.Length != 0)
            {
                strTargetServer = strServer;
                if (strServer[0] != '\\')
                {
                    strTargetServer = "\\\\" + strServer;
                }
            }
            int nRetValue = 0;
            // Call Net API to add the share..
            int nStSize = Marshal.SizeOf(shInfo);
            IntPtr buffer = Marshal.AllocCoTaskMem(nStSize);
            Marshal.StructureToPtr(shInfo, buffer, false);
            nRetValue = NetApi32.NetShareAdd(strTargetServer, 502, 
                    buffer, IntPtr.Zero);
            Marshal.FreeCoTaskMem( buffer );

            return (NetApi32.NetError)nRetValue;
        }
    }
}                       
                            

This article has no explicit license attached to it but may contain usage terms in the article text or the download files themselves. If in doubt please contact the author via the discussion board below.

A list of licenses authors might use can be found here