/// <summary>
        /// This call waits until all the shadowcopy preparation is done on the file server.
        /// It is used to avoid the long preparation time on file server break the
        /// 60 seconds freeze/thaw window on the application server
        /// It must be called between the last AddToShadowCopySet and CommitShadowCopySet
        /// </summary>
        /// <param name="ShadowCopySetId">The GUID of shadow copy set</param>
        /// <param name="TimeOutInMilliseconds">The maximum total time in milliseconds for which the server MUST wait for the expose operation.</param>
        /// <returns></returns>
        public int PrepareShadowCopySet(
            Guid ShadowCopySetId,
            uint TimeOutInMilliseconds
            )
        {
            Int3264[] paramList;
            int       retVal = 0;

            SafeIntPtr pShadowCopySetId = TypeMarshal.ToIntPtr(ShadowCopySetId);

            paramList = new Int3264[] {
                pShadowCopySetId,
                TimeOutInMilliseconds,
                IntPtr.Zero
            };

            try
            {
                using (RpceInt3264Collection outParamList = RpceCall(paramList, (ushort)FSRVP_OPNUM.PrepareShadowCopySet))
                {
                    retVal = outParamList[2].ToInt32();
                }
            }
            finally
            {
                pShadowCopySetId.Dispose();
            }

            return(retVal);
        }
Example #2
0
        /// <summary>
        /// The common method of all the SWN calls
        /// </summary>
        /// <param name="callId">The identifier of async call.</param>
        /// <returns>The decoded paramlist</returns>
        /// <exception cref="ArgumentException">
        /// Thrown when the call id is invalid.
        /// </exception>
        private RpceInt3264Collection RpceAsyncCallExpect(uint callId)
        {
            RpceInt3264Collection outParamList = null;

            byte[]             responseStub;
            RpceResponseFormat format;

            lock (responseLock)
            {
                if (!responseFormat.TryGetValue(callId, out format))
                {
                    throw new ArgumentException("Invalid call id.");
                }
            }

            rpceClientTransport.RecvResponse(callId, rpceTimeout, out responseStub);

            outParamList = RpceStubDecoder.ToParamList(
                RpceStubHelper.GetPlatform(),
                SwnStubFormatString.TypeFormatString,
                null,
                SwnStubFormatString.ProcFormatString,
                SwnStubFormatString.ProcFormatStringOffsetTable[format.opnum],
                true,
                responseStub,
                rpceClientTransport.Context.PackedDataRepresentationFormat,
                format.paramList);

            lock (responseLock)
            {
                responseFormat.Remove(callId);
            }

            return(outParamList);
        }
Example #3
0
        /// <summary>
        /// SWN client invoke WitnessrGetInterfaceList method to retrieve information about the interfaces to which witness client connections can be made.
        /// </summary>
        /// <param name="InterfaceList">A pointer to a PWITNESS_INTERFACE_LIST, as specified in section 2.2.1.9.</param>
        /// <returns>Return zero if success, otherwise return nonzero.</returns>
        public int WitnessrGetInterfaceList(out WITNESS_INTERFACE_LIST InterfaceList)
        {
            Int3264[] paramList;
            int       retVal = 0;

            paramList = new Int3264[] {
                IntPtr.Zero, //out param
                IntPtr.Zero  //return value
            };

            using (RpceInt3264Collection outParamList = RpceCall(paramList, (ushort)SWN_OPNUM.WitnessrGetInterfaceList))
            {
                WITNESS_INTERFACE_LIST_RPC rpcList  = TypeMarshal.ToStruct <WITNESS_INTERFACE_LIST_RPC>(Marshal.ReadIntPtr(outParamList[0]));
                WITNESS_INTERFACE_INFO[]   infoList = new WITNESS_INTERFACE_INFO[rpcList.NumberOfInterfaces];
                int sizeInByte = Marshal.SizeOf(typeof(WITNESS_INTERFACE_INFO));
                for (int i = 0; i < rpcList.NumberOfInterfaces; i++)
                {
                    IntPtr pInfo = IntPtrUtility.Add(rpcList.InterfaceInfo, i * sizeInByte);
                    infoList[i] = (WITNESS_INTERFACE_INFO)Marshal.PtrToStructure(pInfo, typeof(WITNESS_INTERFACE_INFO));
                }

                InterfaceList = new WITNESS_INTERFACE_LIST();
                InterfaceList.NumberOfInterfaces = rpcList.NumberOfInterfaces;
                InterfaceList.InterfaceInfo      = infoList;

                retVal = outParamList[paramList.Length - 1].ToInt32();
            }
            return(retVal);
        }
        /// <summary>
        /// The StartShadowCopySet method is called by the client to initiate a new shadow copy set for shadow copy creation.
        /// </summary>
        /// <param name="pShadowCopySetId">On output, the GUID of the shadow copy set that must be created by server.</param>
        /// <returns></returns>
        public int StartShadowCopySet(
            Guid clientShadowCopySetId,
            out Guid pShadowCopySetId)
        {
            Int3264[] paramList;
            int       retVal = 0;

            SafeIntPtr pClientShadowCopySetId = TypeMarshal.ToIntPtr(clientShadowCopySetId);

            paramList = new Int3264[] {
                pClientShadowCopySetId,
                IntPtr.Zero,
                IntPtr.Zero
            };

            try
            {
                using (RpceInt3264Collection outParamList = RpceCall(paramList, (ushort)FSRVP_OPNUM.StartShadowCopySet))
                {
                    pShadowCopySetId = TypeMarshal.ToStruct <Guid>(outParamList[1]);
                    retVal           = outParamList[2].ToInt32();
                }
            }
            finally
            {
                pClientShadowCopySetId.Dispose();
            }

            return(retVal);
        }
        /// <summary>
        /// The NetrShareGetInfo method retrieves information about a particular shared resource on the server from the ShareList.
        /// </summary>
        /// <param name="ServerName">A string that identifies the server. If this parameter is NULL, the local computer is used.</param>
        /// <param name="NetName">The name of the share to return information for.</param>
        /// <param name="Level">Specifies the information level of the data. This parameter MUST be one of the following values.</param>
        /// <param name="InfoStruct">Its contents are determined by the value of the Level parameter, as shown in the preceding table.</param>
        /// <returns>The method returns 0x00000000 (NERR_Success) to indicate success; otherwise, it returns a nonzero error code.</returns>
        public uint NetrShareGetInfo(string ServerName, string NetName, SHARE_ENUM_STRUCT_LEVEL Level, out SHARE_INFO?InfoStruct)
        {
            /*
             * NET_API_STATUS NetrShareGetInfo(
             * [in, string, unique] SRVSVC_HANDLE ServerName,
             * [in, string] WCHAR* NetName,
             * [in] DWORD Level,
             * [out, switch_is(Level)] LPSHARE_INFO InfoStruct
             * );
             */
            Int3264[] paramList;
            uint      retVal = 0;

            InfoStruct = null;
            using (SafeIntPtr pServerName = Marshal.StringToHGlobalUni(ServerName), pNetName = Marshal.StringToHGlobalUni(NetName))
            {
                paramList = new Int3264[] {
                    pServerName,
                    pNetName,
                    (uint)Level,
                    IntPtr.Zero, // out value
                    IntPtr.Zero  // return value
                };
                using (RpceInt3264Collection outParamList = RpceCall(paramList, (ushort)SRVS_OPNUM.NetrShareGetInfo))
                {
                    retVal = outParamList[paramList.Length - 1].ToUInt32();
                    if (retVal == (uint)Win32ErrorCode_32.ERROR_SUCCESS)
                    {
                        InfoStruct = TypeMarshal.ToStruct <SHARE_INFO>(outParamList[3], Level, null, null);
                    }
                }
            }
            return(retVal);
        }
        /// <summary>
        /// The DeleteShareMapping method deletes the mapping of a share’s shadow copy from a shadow copy set.
        /// </summary>
        /// <param name="ShadowCopySetId">The GUID of the shadow copy set.</param>
        /// <param name="ShadowCopyId">The GUID of the shadow copy associated with the share.</param>
        /// <param name="ShareName">The name of the share for which the share mapping is to be deleted.</param>
        /// <returns></returns>
        public int DeleteShareMapping(
            Guid ShadowCopySetId,
            Guid ShadowCopyId,
            string ShareName)
        {
            Int3264[] paramList;
            int       retVal = 0;

            SafeIntPtr pShadowCopySetId = TypeMarshal.ToIntPtr(ShadowCopySetId);
            SafeIntPtr pShadowCopyId    = TypeMarshal.ToIntPtr(ShadowCopyId);
            SafeIntPtr pShareName       = Marshal.StringToHGlobalUni(ShareName);

            paramList = new Int3264[] {
                pShadowCopySetId,
                pShadowCopyId,
                pShareName,
                IntPtr.Zero
            };

            try
            {
                using (RpceInt3264Collection outParamList = RpceCall(paramList, (ushort)FSRVP_OPNUM.DeleteShareMapping))
                {
                    retVal = outParamList[3].ToInt32();
                }
            }
            finally
            {
                pShadowCopySetId.Dispose();
                pShadowCopyId.Dispose();
                pShareName.Dispose();
            }

            return(retVal);
        }
Example #7
0
        /// <summary>
        /// SWN client invoke WitnessrRegister to register for resource state change notifications of a NetName and IPAddress.
        /// </summary>
        /// <param name="Version">The version of the Witness protocol currently in use by the client.</param>
        /// <param name="NetName">Specifies a null-terminated string that specifies the name of the resource for which the client requires notifications.</param>
        /// <param name="IpAddr">Specifies a null-terminated string that specifies the IP address to which the client application connection is established.</param>
        /// <param name="ClientName">Specifies a null-terminated string that is used to identify the Witness client.</param>
        /// <param name="pContext">A context handle to identifies the client on the server. </param>
        /// <returns>Return zero if success, otherwise return nonzero.</returns>
        public int WitnessrRegister(SwnVersion Version, string NetName, string IpAddr, string ClientName, out IntPtr pContext)
        {
            Int3264[] paramList;
            int       retVal = 0;

            SafeIntPtr pNetName    = Marshal.StringToHGlobalUni(NetName);
            SafeIntPtr pIpAddr     = Marshal.StringToHGlobalUni(IpAddr);
            SafeIntPtr pClientName = Marshal.StringToHGlobalUni(ClientName);

            paramList = new Int3264[] {
                IntPtr.Zero,//out param
                (uint)Version,
                pNetName,
                pIpAddr,
                pClientName,
                IntPtr.Zero //return value
            };

            try
            {
                using (RpceInt3264Collection outParamList = RpceCall(paramList, (ushort)SWN_OPNUM.WitnessrRegister))
                {
                    pContext = Marshal.ReadIntPtr(outParamList[0]);
                    retVal   = outParamList[paramList.Length - 1].ToInt32();
                }
            }
            finally
            {
                pNetName.Dispose();
                pIpAddr.Dispose();
                pClientName.Dispose();
            }

            return(retVal);
        }
        /// <summary>
        /// The IsPathShadowCopied method is invoked by the client to query if any shadow copy for a share already exists.
        /// </summary>
        /// <param name="ShareName">The full path of the share in UNC format.</param>
        /// <param name="ShadowCopyPresent">On output, a Boolean, when set to TRUE, indicates that shadow
        /// copies of this share are supported by the server.</param>
        /// <param name="ShadowCopyCompatibility">On output, this indicates whether certain I/O operations on the object
        /// store containing the shadow copy are disabled. This MUST be zero or a combination of the values
        /// as specified in section 2.2.2.2.</param>
        /// <returns></returns>
        public int IsPathShadowCopied(
            string ShareName,
            out bool ShadowCopyPresent,
            out long ShadowCopyCompatibility)
        {
            Int3264[] paramList;
            int       retVal = 0;

            SafeIntPtr pShareName = Marshal.StringToHGlobalUni(ShareName);

            paramList = new Int3264[] {
                pShareName,
                IntPtr.Zero,
                IntPtr.Zero,
                IntPtr.Zero
            };

            try
            {
                using (RpceInt3264Collection outParamList = RpceCall(paramList, (ushort)FSRVP_OPNUM.IsPathShadowCopied))
                {
                    retVal                  = outParamList[paramList.Length - 1].ToInt32();
                    ShadowCopyPresent       = TypeMarshal.ToStruct <bool>(outParamList[1]);
                    ShadowCopyCompatibility = Marshal.ReadInt32(outParamList[2]);
                    retVal                  = outParamList[3].ToInt32();
                }
            }
            finally
            {
                pShareName.Dispose();
            }

            return(retVal);
        }
        /// <summary>
        /// The IsPathSupported method is invoked by client to query if a given share is supported by the server
        /// for shadow copy operations.
        /// </summary>
        /// <param name="ShareName">The full path of the share in UNC format.</param>
        /// <param name="SupportedByThisProvider">On output, a Boolean, when set to TRUE, indicates that shadow
        /// copies of this share are supported by the server.</param>
        /// <param name="OwnerMachineName">On output, the name of the server machine to which the client MUST
        /// connect to create shadow copies of the specified ShareName.</param>
        /// <returns></returns>
        public int IsPathSupported(
            string ShareName,
            out bool SupportedByThisProvider,
            out string OwnerMachineName)
        {
            Int3264[] paramList;
            int       retVal = 0;

            SafeIntPtr pShareName = Marshal.StringToHGlobalUni(ShareName);

            paramList = new Int3264[] {
                pShareName,
                IntPtr.Zero,
                IntPtr.Zero,
                IntPtr.Zero
            };

            try
            {
                using (RpceInt3264Collection outParamList = RpceCall(paramList, (ushort)FSRVP_OPNUM.IsPathSupported))
                {
                    SupportedByThisProvider = TypeMarshal.ToStruct <bool>(outParamList[1]);//(Marshal.ReadInt32(outParamList[1]) == 1);
                    OwnerMachineName        = Marshal.PtrToStringUni(Marshal.ReadIntPtr(outParamList[2]));
                    retVal = outParamList[3].ToInt32();
                }
            }
            finally
            {
                pShareName.Dispose();
            }

            return(retVal);
        }
        /// <summary>
        /// The AbortShadowCopySet method is invoked by the client to delete a given shadow copy set on the server.
        /// </summary>
        /// <param name="ShadowCopySetId">The GUID of the shadow copy set to which ShareName is to be added.</param>
        /// <returns></returns>
        public int AbortShadowCopySet(Guid ShadowCopySetId)
        {
            Int3264[] paramList;
            int       retVal = 0;

            SafeIntPtr pShadowCopySetId = TypeMarshal.ToIntPtr(ShadowCopySetId);

            paramList = new Int3264[] {
                pShadowCopySetId,
                IntPtr.Zero
            };

            try
            {
                using (RpceInt3264Collection outParamList = RpceCall(paramList, (ushort)FSRVP_OPNUM.AbortShadowCopySet))
                {
                    retVal = outParamList[1].ToInt32();
                }
            }
            finally
            {
                pShadowCopySetId.Dispose();
            }

            return(retVal);
        }
Example #11
0
        /// <summary>
        /// The common method of all the SWN calls
        /// </summary>
        /// <param name="paramList">input param list to decode</param>
        /// <param name="opnum">opnum of the current SWN calls</param>
        /// <returns>the decoded paramlist</returns>
        private RpceInt3264Collection RpceCall(Int3264[] paramList, ushort opnum)
        {
            RpceInt3264Collection outParamList = null;

            byte[] requestStub;
            byte[] responseStub;

            requestStub = RpceStubEncoder.ToBytes(
                RpceStubHelper.GetPlatform(),
                SwnStubFormatString.TypeFormatString,
                null,
                SwnStubFormatString.ProcFormatString,
                SwnStubFormatString.ProcFormatStringOffsetTable[opnum],
                true,
                paramList);

            rpceClientTransport.Call(opnum, requestStub, rpceTimeout, out responseStub);

            outParamList = RpceStubDecoder.ToParamList(
                RpceStubHelper.GetPlatform(),
                SwnStubFormatString.TypeFormatString,
                null,
                SwnStubFormatString.ProcFormatString,
                SwnStubFormatString.ProcFormatStringOffsetTable[opnum],
                true,
                responseStub,
                rpceClientTransport.Context.PackedDataRepresentationFormat,
                paramList);

            return(outParamList);
        }
        /// <summary>
        /// The common part of all the FSRVP methods
        /// </summary>
        /// <param name="paramList">input param list to decode</param>
        /// <param name="opnum">opnum of the current FSRVP method</param>
        /// <returns>the decoded paramlist</returns>
        public RpceInt3264Collection RpceCall(Int3264[] paramList, ushort opnum)
        {
            byte[] requestStub;
            byte[] responseStub;
            RpceInt3264Collection outParamList = null;

            requestStub = RpceStubEncoder.ToBytes(
                RpceStubHelper.GetPlatform(),
                FsrvpStubFormatString.TypeFormatString,
                null,
                FsrvpStubFormatString.ProcFormatString,
                FsrvpStubFormatString.ProcFormatStringOffsetTable[opnum],
                true,
                paramList);

            rpceClientTransport.Call(opnum, requestStub, rpceTimeout, out responseStub);

            outParamList = RpceStubDecoder.ToParamList(
                RpceStubHelper.GetPlatform(),
                FsrvpStubFormatString.TypeFormatString,
                null,
                FsrvpStubFormatString.ProcFormatString,
                FsrvpStubFormatString.ProcFormatStringOffsetTable[opnum],
                true,
                responseStub,
                paramList);


            return(outParamList);
        }
        /// <summary>
        ///  The IDL_DSAExecuteScript method executes a maintenance script.
        ///  Opnum: 1
        /// </summary>
        /// <param name="hRpc">
        ///  The RPC binding handle, as specified in [C706].
        /// </param>
        /// <param name="dwInVersion">
        ///  The version of the request message.
        /// </param>
        /// <param name="pmsgIn">
        ///  A pointer to the request message.
        /// </param>
        /// <param name="pdwOutVersion">
        ///  A pointer to the version of the response message.
        /// </param>
        /// <param name="pmsgOut">
        ///  A pointer to the response message.
        /// </param>
        public uint IDL_DSAExecuteScript(
            IntPtr hRpc,
            uint dwInVersion,
            //[Switch("dwInVersion")]
            DSA_MSG_EXECUTE_SCRIPT_REQ?pmsgIn,
            out uint?pdwOutVersion,
            //[Switch("*pdwOutVersion")]
            out DSA_MSG_EXECUTE_SCRIPT_REPLY?pmsgOut)
        {
            const ushort opnum = 1;

            byte[]    requestStub;
            byte[]    responseStub;
            Int3264[] paramList;

            SafeIntPtr ptrMsgIn = TypeMarshal.ToIntPtr(pmsgIn, dwInVersion, null, null);

            paramList = new Int3264[]
            {
                dwInVersion,
                ptrMsgIn,
                IntPtr.Zero,
                IntPtr.Zero,
                0//retVal
            };

            requestStub = RpceStubEncoder.ToBytes(
                RpceStubHelper.GetPlatform(),
                DrsrRpcStubFormatString.TypeFormatString,
                null,
                DrsrRpcStubFormatString.ProcFormatString,
                DrsrRpcStubFormatString.Dsaop_ProcFormatStringOffsetTable[opnum],
                true,
                paramList);

            rpceClientTransport.Call(opnum, requestStub, rpceTimeout, out responseStub);

            using (RpceInt3264Collection outParamList = RpceStubDecoder.ToParamList(
                       RpceStubHelper.GetPlatform(),
                       DrsrRpcStubFormatString.TypeFormatString,
                       null,
                       DrsrRpcStubFormatString.ProcFormatString,
                       DrsrRpcStubFormatString.Dsaop_ProcFormatStringOffsetTable[opnum],
                       true,
                       responseStub,
                       rpceClientTransport.Context.PackedDataRepresentationFormat,
                       paramList))
            {
                pdwOutVersion = TypeMarshal.ToNullableStruct <uint>(outParamList[2]);
                pmsgOut       = TypeMarshal.ToNullableStruct <DSA_MSG_EXECUTE_SCRIPT_REPLY>(
                    outParamList[3], pdwOutVersion, null, null);
                retVal = outParamList[4].ToUInt32();
            }

            ptrMsgIn.Dispose();

            return(retVal);
        }
        /// <summary>
        /// The GetShareMapping method is invoked by the client to get the shadow copy information on a given
        /// file share on the server.
        /// </summary>
        /// <param name="ShadowCopyId">The GUID of the shadow copy associated with the share.</param>
        /// <param name="ShadowCopySetId">The GUID of the shadow copy set.</param>
        /// <param name="ShareName">The name of the share in UNC format.</param>
        /// <param name="Level">The format of this data depends on the value of the level parameter.</param>
        /// <param name="ShareMapping">On output, a FSSAGENT_SHARE_MAPPING structure, as specified in section 2.2.3.1.</param>
        /// <returns></returns>
        public int GetShareMapping(
            Guid ShadowCopyId,
            Guid ShadowCopySetId,
            string ShareName,
            uint Level,
            out FSSAGENT_SHARE_MAPPING ShareMapping)
        {
            Int3264[] paramList;
            int       retVal = 0;

            SafeIntPtr pShadowCopyId    = TypeMarshal.ToIntPtr(ShadowCopyId);
            SafeIntPtr pShadowCopySetId = TypeMarshal.ToIntPtr(ShadowCopySetId);
            SafeIntPtr pShareName       = Marshal.StringToHGlobalUni(ShareName);

            paramList = new Int3264[] {
                pShadowCopyId,
                pShadowCopySetId,
                pShareName,
                Level,
                IntPtr.Zero,
                IntPtr.Zero
            };

            try
            {
                using (RpceInt3264Collection outParamList = RpceCall(paramList, (ushort)FSRVP_OPNUM.GetShareMapping))
                {
                    retVal       = outParamList[5].ToInt32();
                    ShareMapping = new FSSAGENT_SHARE_MAPPING();
                    if ((FsrvpErrorCode)retVal == FsrvpErrorCode.FSRVP_SUCCESS)
                    {
                        ShareMapping.ShareMapping1       = TypeMarshal.ToStruct <FSSAGENT_SHARE_MAPPING_1>(Marshal.ReadIntPtr(outParamList[4]));
                        ShareMapping.ShareMapping1IsNull = false;
                    }
                    else
                    {
                        ShareMapping.ShareMapping1IsNull = true;
                    }
                }
            }
            finally
            {
                pShadowCopyId.Dispose();
                pShadowCopySetId.Dispose();
                pShareName.Dispose();
            }

            return(retVal);
        }
        /// <summary>
        /// The NetrShareEnum method retrieves information about each shared resource on a server.
        /// </summary>
        /// <param name="serverName">A string that identifies the server. If this parameter is NULL, the local computer is used.</param>
        /// <param name="infoStruct">A SHARE_ENUM_STRUCT structure. The SHARE_ENUM_STRUCT structure has a Level member
        /// that specifies the type of structure to return in the ShareInfo member.</param>
        /// <param name="PreferedMaximumLength">Specifies the preferred maximum length, in bytes, of the returned data.
        /// If the specified value is MAX_PREFERRED_LENGTH, the method MUST attempt to return all entries.</param>
        /// <param name="TotalEntries">The total number of entries that could have been enumerated if the buffer had been big enough to hold all the entries.</param>
        /// <param name="ResumeHandle">A pointer to a value that contains a handle, which is used to continue an existing share search in ShareList.
        /// handle MUST be zero on the first call and remain unchanged for subsequent calls. If the ResumeHandle parameter is NULL, no resume handle MUST be stored.
        /// If this parameter is not NULL and the method returns ERROR_MORE_DATA, this parameter receives a nonzero value that can be passed in subsequent
        /// calls to this method to continue with the enumeration in ShareList. If this parameter is NULL or points to 0x00000000, the enumeration starts from the beginning of the ShareList.
        /// </param>
        /// <returns>The method returns 0x00000000 (NERR_Success) to indicate success; otherwise, it returns a nonzero error code.</returns>
        public uint NetrShareEnum(
            string serverName,
            ref SHARE_ENUM_STRUCT infoStruct,
            uint PreferedMaximumLength,
            out uint?TotalEntries,
            ref uint?ResumeHandle)
        {
            /*  NET_API_STATUS NetrShareEnum(
             *    [in, string, unique] SRVSVC_HANDLE ServerName,
             *    [in, out] LPSHARE_ENUM_STRUCT InfoStruct,
             *    [in] DWORD PreferedMaximumLength,
             *    [out] DWORD* TotalEntries,
             *    [in, out, unique] DWORD* ResumeHandle
             *  );
             */

            Int3264[] paramList;
            TotalEntries = 0;
            uint retVal = 0;

            using (SafeIntPtr pServerName = Marshal.StringToHGlobalUni(serverName),
                   pInfoStruct = TypeMarshal.ToIntPtr(infoStruct),
                   pResumeHandle = TypeMarshal.ToIntPtr(ResumeHandle))
            {
                paramList = new Int3264[] {
                    pServerName,
                    pInfoStruct,
                    PreferedMaximumLength,
                    IntPtr.Zero, // out value
                    pResumeHandle,
                    IntPtr.Zero  // return value
                };

                using (RpceInt3264Collection outParamList = RpceCall(paramList, (ushort)SRVS_OPNUM.NetrShareEnum))
                {
                    retVal = outParamList[paramList.Length - 1].ToUInt32();
                    if (retVal == (uint)Win32ErrorCode_32.ERROR_SUCCESS)
                    {
                        infoStruct   = TypeMarshal.ToStruct <SHARE_ENUM_STRUCT>(outParamList[1].ToIntPtr());
                        TotalEntries = TypeMarshal.ToNullableStruct <uint>(outParamList[3]);
                        ResumeHandle = TypeMarshal.ToNullableStruct <uint>(outParamList[4]);
                    }
                }
            }
            return(retVal);
        }
        /// <summary>
        /// The SetContext method sets the context for subsequent shadow copy-related operations.
        /// </summary>
        /// <param name="Context">The context to be used for the shadow copy operations.</param>
        /// <returns>It MUST be zero or a combination of the CONTEXT_VALUES as specified in section 2.2.2.2.</returns>
        public int SetContext(ulong Context)
        {
            Int3264[] paramList;
            int       retVal = 0;

            paramList = new Int3264[] {
                Context,
                IntPtr.Zero
            };

            using (RpceInt3264Collection outParamList = RpceCall(paramList, (ushort)FSRVP_OPNUM.SetContext))
            {
                retVal = outParamList[1].ToInt32();
            }

            return(retVal);
        }
Example #17
0
        /// <summary>
        /// SWN client invoke WitnessrUnRegister to unregister for notifications from the server.
        /// </summary>
        /// <param name="pContext">A context handle to identifies the client on the server.</param>
        /// <returns>Return zero if success, otherwise return nonzero.</returns>
        public int WitnessrUnRegister(IntPtr pContext)
        {
            Int3264[] paramList;
            int       retVal = 0;

            paramList = new Int3264[] {
                pContext,
                IntPtr.Zero //return value
            };

            using (RpceInt3264Collection outParamList = RpceCall(paramList, (ushort)SWN_OPNUM.WitnessrUnRegister))
            {
                retVal = outParamList[paramList.Length - 1].ToInt32();
            }

            return(retVal);
        }
Example #18
0
        /// <summary>
        /// SWN client invoke WitnessrAsyncNotify method to post a message on the server; this message is completed when there are no longer any notifications which are required to be communicated with the client.
        /// </summary>
        /// <param name="callId">The identifier of this async call.</param>
        /// <param name="NotifyResp">Structure contains the resource change notification from server.</param>
        /// <returns>Return zero if success, otherwise return nonzero.</returns>
        public int ExpectWitnessrAsyncNotify(uint callId, out RESP_ASYNC_NOTIFY NotifyResp)
        {
            int retVal = 0;

            using (RpceInt3264Collection outParamList = RpceAsyncCallExpect(callId))
            {
                retVal = outParamList[2].ToInt32();
                if (retVal == (int)SwnErrorCode.ERROR_SUCCESS)
                {
                    NotifyResp = TypeMarshal.ToStruct <RESP_ASYNC_NOTIFY>(Marshal.ReadIntPtr(outParamList[1]));
                }
                else
                {
                    NotifyResp = new RESP_ASYNC_NOTIFY();
                }
            }

            return(retVal);
        }
        /// <summary>
        /// Get the Server supported version range.
        /// Windows Server 8 compatiable Agent should return both
        /// as FSSAGENT_RPC_VERSION_1
        /// </summary>
        /// <param name="MinVersion">The minor version.</param>
        /// <param name="MaxVersion">The maximum version.</param>
        /// <returns></returns>
        public int GetSupportedVersion(out uint MinVersion, out uint MaxVersion)
        {
            Int3264[] paramList;
            int       retVal = 0;

            paramList = new Int3264[] {
                IntPtr.Zero,
                IntPtr.Zero,
                IntPtr.Zero
            };

            using (RpceInt3264Collection outParamList = RpceCall(paramList, (ushort)FSRVP_OPNUM.GetSupportedVersion))
            {
                MinVersion = (uint)Marshal.ReadInt32(outParamList[0]);
                MaxVersion = (uint)Marshal.ReadInt32(outParamList[1]);
                retVal     = outParamList[2].ToInt32();
            }

            return(retVal);
        }
        /// <summary>
        /// The NetrShareSetInfo method sets the parameters of a shared resource in a ShareList.
        /// </summary>
        /// <param name="ServerName">A string that identifies the server. If this parameter is NULL, the local computer is used.</param>
        /// <param name="NetName">The name of the share to return information for.</param>
        /// <param name="Level">Specifies the information level of the data. This parameter MUST be one of the following values.</param>
        /// <param name="InfoStruct">Its contents are determined by the value of the Level parameter, as shown in the preceding table.
        /// This parameter MUST NOT contain a null value. </param>
        /// <param name="ParmErr">An integer value that receives the index of the first member of the share information
        /// structure that caused the ERROR_INVALID_PARAMETER error, if it occurs</param>
        /// <returns>The method returns 0x00000000 (NERR_Success) to indicate success; otherwise, it returns a nonzero error code.</returns>
        public uint NetrShareSetInfo(string ServerName, string NetName, SHARE_ENUM_STRUCT_LEVEL Level, SHARE_INFO InfoStruct, ref uint?ParmErr)
        {
            /*
             * NET_API_STATUS NetrShareSetInfo(
             *  [in, string, unique] SRVSVC_HANDLE ServerName,
             *  [in, string] WCHAR* NetName,
             *  [in] DWORD Level,
             *  [in, switch_is(Level)] LPSHARE_INFO ShareInfo,
             *  [in, out, unique] DWORD* ParmErr
             * );
             */

            Int3264[] paramList;
            uint      retVal = 0;

            using (SafeIntPtr pServerName = Marshal.StringToHGlobalUni(ServerName),
                   pNetName = Marshal.StringToHGlobalUni(NetName),
                   pShareInfo = TypeMarshal.ToIntPtr(InfoStruct, Level, null, null),
                   pParmErr = TypeMarshal.ToIntPtr(ParmErr))
            {
                paramList = new Int3264[] {
                    pServerName,
                    pNetName,
                    (uint)Level,
                    pShareInfo, // out value
                    pParmErr,
                    IntPtr.Zero // return value
                };
                using (RpceInt3264Collection outParamList = RpceCall(paramList, (ushort)SRVS_OPNUM.NetrShareSetInfo))
                {
                    retVal = outParamList[paramList.Length - 1].ToUInt32();
                    if (retVal == (uint)Win32ErrorCode_32.ERROR_INVALID_PARAMETER)
                    {
                        ParmErr = TypeMarshal.ToNullableStruct <uint>(outParamList[4]);
                    }
                }
            }
            return(retVal);
        }
        /// <summary>
        /// The AddToShadowCopySet method adds a share to an existing shadow copy set.
        /// </summary>
        /// <param name="ClientShadowCopyId">The GUID of the client. This MUST be set to NULL.</param>
        /// <param name="ShadowCopySetId">The GUID of the shadow copy set to which ShareName is to be added.</param>
        /// <param name="ShareName">The name of the share in UNC format for which a shadow copy is required.</param>
        /// <param name="pShadowCopyId">On output, the GUID of the shadow copy associated to the share.</param>
        /// <returns></returns>
        public int AddToShadowCopySet(
            Guid ClientShadowCopyId,
            Guid ShadowCopySetId,
            string ShareName,
            out Guid pShadowCopyId)
        {
            Int3264[] paramList;
            int       retVal = 0;

            SafeIntPtr pClientShadowCopyId = TypeMarshal.ToIntPtr(ClientShadowCopyId);
            SafeIntPtr pShadowCopySetId    = TypeMarshal.ToIntPtr(ShadowCopySetId);
            SafeIntPtr pShareName          = Marshal.StringToHGlobalUni(ShareName);

            paramList = new Int3264[] {
                pClientShadowCopyId,
                pShadowCopySetId,
                pShareName,
                IntPtr.Zero,
                IntPtr.Zero
            };

            try
            {
                using (RpceInt3264Collection outParamList = RpceCall(paramList, (ushort)FSRVP_OPNUM.AddToShadowCopySet))
                {
                    pShadowCopyId = TypeMarshal.ToStruct <Guid>(outParamList[3]);
                    retVal        = outParamList[4].ToInt32();
                }
            }
            finally
            {
                pClientShadowCopyId.Dispose();
                pShadowCopySetId.Dispose();
                pShareName.Dispose();
            }

            return(retVal);
        }