/// <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; }
private RpceInt3264Collection RpceCall(Int3264[] paramList, ushort opnum) { byte[] requestStub; byte[] responseStub; RpceInt3264Collection outParamList = null; requestStub = RpceStubEncoder.ToBytes( RpceStubHelper.GetPlatform(), SrvsStubFormatString.TypeFormatString, null, SrvsStubFormatString.ProcFormatString, SrvsStubFormatString.ProcFormatStringOffsetTable[opnum], true, paramList); RpceClientTransport.Call(opnum, requestStub, RpceTimeout, out responseStub); outParamList = RpceStubDecoder.ToParamList( RpceStubHelper.GetPlatform(), SrvsStubFormatString.TypeFormatString, null, SrvsStubFormatString.ProcFormatString, SrvsStubFormatString.ProcFormatStringOffsetTable[opnum], true, responseStub, paramList); return outParamList; }
/// <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 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 common method of all the SWN async calls /// </summary> /// <param name="paramList">input param list to decode</param> /// <param name="opnum">opnum of the current SWN calls</param> /// <returns>The identifier of this async call.</returns> private uint RpceAsyncCall(Int3264[] paramList, ushort opnum) { byte[] requestStub; uint callId; requestStub = RpceStubEncoder.ToBytes( RpceStubHelper.GetPlatform(), SwnStubFormatString.TypeFormatString, null, SwnStubFormatString.ProcFormatString, SwnStubFormatString.ProcFormatStringOffsetTable[opnum], true, paramList); rpceClientTransport.SendRequest(opnum, requestStub, out callId); RpceResponseFormat format = new RpceResponseFormat(); format.opnum = opnum; format.paramList = paramList; lock (responseLock) { responseFormat.Add(callId, format); } return callId; }
/// <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; }
/// <summary> /// SWN client invoke WitnessrRegisterEx 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="ShareName">Specifies a null-terminated string that specifies the name of the share 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="Flags">Specifies the type of Witness registration.</param> /// <param name="KeepAliveTimout">Specifies the maximum number of milliseconds for any notification response from the server.</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 WitnessrRegisterEx(SwnVersion Version, string NetName, string ShareName, string IpAddr, string ClientName, WitnessrRegisterExFlagsValue Flags, uint KeepAliveTimout, out IntPtr pContext) { Int3264[] paramList; int retVal = 0; SafeIntPtr pNetName = Marshal.StringToHGlobalUni(NetName); SafeIntPtr pShareName = Marshal.StringToHGlobalUni(ShareName); SafeIntPtr pIpAddr = Marshal.StringToHGlobalUni(IpAddr); SafeIntPtr pClientName = Marshal.StringToHGlobalUni(ClientName); paramList = new Int3264[] { IntPtr.Zero,//out param (uint)Version, pNetName, pShareName, pIpAddr, pClientName, (uint)Flags, KeepAliveTimout, IntPtr.Zero //return value }; try { using (RpceInt3264Collection outParamList = RpceCall(paramList, (ushort)SWN_OPNUM.WitnessrRegisterEx)) { pContext = Marshal.ReadIntPtr(outParamList[0]); retVal = outParamList[paramList.Length - 1].ToInt32(); } } finally { pNetName.Dispose(); pShareName.Dispose(); pIpAddr.Dispose(); pClientName.Dispose(); } return retVal; }
/// <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> /// 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="pContext">A context handle to identifies the client on the server.</param> /// <returns>The identifier of this async call.</returns> public uint WitnessrAsyncNotify(IntPtr pContext) { Int3264[] paramList; paramList = new Int3264[] { pContext, IntPtr.Zero, //out param IntPtr.Zero //return value }; return RpceAsyncCall(paramList, (ushort)SWN_OPNUM.WitnessrAsyncNotify); }