public static HttpConfigUrlAcl GetHttpReservations() { HttpConfigUrlAcl result = new HttpConfigUrlAcl(); int size; for (int count = 0;; count++) { HTTP_SERVICE_CONFIG_URLACL_QUERY query = new HTTP_SERVICE_CONFIG_URLACL_QUERY(HTTP_SERVICE_CONFIG_QUERY_TYPE.HttpServiceConfigQueryNext, new HTTP_SERVICE_CONFIG_URLACL_KEY(null), count); ErrorCode errorCode = HttpQueryServiceConfiguration(IntPtr.Zero, HTTP_SERVICE_CONFIG_ID.HttpServiceConfigUrlAclInfo, ref query, Marshal.SizeOf(query), null, 0, out size, IntPtr.Zero); if (errorCode != ErrorCode.ERROR_SUCCESS) { if (errorCode == ErrorCode.ERROR_NO_MORE_ITEMS) { break; } if (errorCode != ErrorCode.ERROR_INSUFFICIENT_BUFFER) { throw new Win32Exception((int)errorCode); } byte[] buffer = new byte[size]; fixed(byte *b = buffer) { errorCode = HttpQueryServiceConfiguration(IntPtr.Zero, HTTP_SERVICE_CONFIG_ID.HttpServiceConfigUrlAclInfo, ref query, Marshal.SizeOf(query), b, size, out size, IntPtr.Zero); if (errorCode != ErrorCode.ERROR_SUCCESS) { throw new Win32Exception((int)errorCode); } HTTP_SERVICE_CONFIG_URLACL_SET output = (HTTP_SERVICE_CONFIG_URLACL_SET)Marshal.PtrToStructure((IntPtr)b, typeof(HTTP_SERVICE_CONFIG_URLACL_SET)); result.Add(output.KeyDesc.pUrlPrefix, output.ParamDesc.pStringSecurityDescriptor); } } } return(result); }
private static void freeURL(string networkURL, string securityDescriptor) { uint retVal = (uint)ErrorCodes.NOERROR; retVal = NativeMethods.HttpInitialize(HttpApiConstants.HTTPAPI_VERSION_1, HttpApiConstants.HTTP_INITIALIZE_CONFIG, IntPtr.Zero); if ((uint)ErrorCodes.NOERROR == retVal) { HTTP_SERVICE_CONFIG_URLACL_KEY urlAclKey = new HTTP_SERVICE_CONFIG_URLACL_KEY(networkURL); HTTP_SERVICE_CONFIG_URLACL_PARAM urlAclParam = new HTTP_SERVICE_CONFIG_URLACL_PARAM(securityDescriptor); HTTP_SERVICE_CONFIG_URLACL_SET urlAclSet = new HTTP_SERVICE_CONFIG_URLACL_SET(); urlAclSet.KeyDesc = urlAclKey; urlAclSet.ParamDesc = urlAclParam; IntPtr configInformation = Marshal.AllocCoTaskMem(Marshal.SizeOf(typeof(HTTP_SERVICE_CONFIG_URLACL_SET))); Marshal.StructureToPtr(urlAclSet, configInformation, false); int configInformationSize = Marshal.SizeOf(urlAclSet); retVal = NativeMethods.HttpDeleteServiceConfiguration(IntPtr.Zero, HTTP_SERVICE_CONFIG_ID.HttpServiceConfigUrlAclInfo, configInformation, configInformationSize, IntPtr.Zero); Marshal.FreeCoTaskMem(configInformation); NativeMethods.HttpTerminate(HttpApiConstants.HTTP_INITIALIZE_CONFIG, IntPtr.Zero); } if ((uint)ErrorCodes.NOERROR != retVal) { throw new Win32Exception(Convert.ToInt32(retVal)); } }
public UrlAcl(HTTP_SERVICE_CONFIG_URLACL_SET urlacl) { this.UrlPrefix = urlacl.KeyDesc.pUrlPrefix; var match = Regex.Match(this.UrlPrefix, ":([0-9]+?)/"); var port = match.Groups[1].Value; this.Port = port; }
private static HTTP_SERVICE_CONFIG_URLACL_SET CreateUrlAclSet(string key, string param) { HTTP_SERVICE_CONFIG_URLACL_SET ReturnValue; ReturnValue = new HTTP_SERVICE_CONFIG_URLACL_SET() { KeyDesc = new HTTP_SERVICE_CONFIG_URLACL_KEY(key), ParamDesc = new HTTP_SERVICE_CONFIG_URLACL_PARAM(param) }; return(ReturnValue); }
public static void ReserveURL(string networkURL, string securityDescriptor) { uint retVal = (uint)ErrorCodes.NOERROR; // NOERROR = 0 HttpApi.HTTPAPI_VERSION HttpApiVersion = new HttpApi.HTTPAPI_VERSION(1, 0); retVal = HttpApi.HttpInitialize(HttpApiVersion, HttpApi.HTTP_INITIALIZE_CONFIG, IntPtr.Zero); if ((uint)ErrorCodes.NOERROR == retVal) { HTTP_SERVICE_CONFIG_URLACL_KEY keyDesc = new HTTP_SERVICE_CONFIG_URLACL_KEY(networkURL); HTTP_SERVICE_CONFIG_URLACL_PARAM paramDesc = new HTTP_SERVICE_CONFIG_URLACL_PARAM(securityDescriptor); HTTP_SERVICE_CONFIG_URLACL_SET inputConfigInfoSet = new HTTP_SERVICE_CONFIG_URLACL_SET(); inputConfigInfoSet.KeyDesc = keyDesc; inputConfigInfoSet.ParamDesc = paramDesc; IntPtr pInputConfigInfo = Marshal.AllocCoTaskMem(Marshal.SizeOf(typeof(HTTP_SERVICE_CONFIG_URLACL_SET))); Marshal.StructureToPtr(inputConfigInfoSet, pInputConfigInfo, false); retVal = HttpApi.HttpSetServiceConfiguration(IntPtr.Zero, HttpApi.HTTP_SERVICE_CONFIG_ID.HttpServiceConfigUrlAclInfo, pInputConfigInfo, Marshal.SizeOf(inputConfigInfoSet), IntPtr.Zero); if ((uint)ErrorCodes.ERROR_ALREADY_EXISTS == retVal) // ERROR_ALREADY_EXISTS = 183 { retVal = HttpApi.HttpDeleteServiceConfiguration(IntPtr.Zero, HttpApi.HTTP_SERVICE_CONFIG_ID.HttpServiceConfigUrlAclInfo, pInputConfigInfo, Marshal.SizeOf(inputConfigInfoSet), IntPtr.Zero); if ((uint)ErrorCodes.NOERROR == retVal) { retVal = HttpApi.HttpSetServiceConfiguration(IntPtr.Zero, HttpApi.HTTP_SERVICE_CONFIG_ID.HttpServiceConfigUrlAclInfo, pInputConfigInfo, Marshal.SizeOf(inputConfigInfoSet), IntPtr.Zero); } } Marshal.FreeCoTaskMem(pInputConfigInfo); HttpApi.HttpTerminate(HttpApi.HTTP_INITIALIZE_CONFIG, IntPtr.Zero); } if ((uint)ErrorCodes.NOERROR != retVal) { throw new Win32Exception(Convert.ToInt32(retVal)); } }
private static void reserveURL(string networkURL, string securityDescriptor, bool deleteIfExists) { uint retVal = NativeMethods.HttpInitialize(HTTPAPI_VERSION.VERSION_1, Flags.HTTP_INITIALIZE_CONFIG, IntPtr.Zero); if (retVal == ReturnCodes.NO_ERROR) { var keyDesc = new HTTP_SERVICE_CONFIG_URLACL_KEY(networkURL); var paramDesc = new HTTP_SERVICE_CONFIG_URLACL_PARAM(securityDescriptor); var inputConfigInfoSet = new HTTP_SERVICE_CONFIG_URLACL_SET() { KeyDesc = keyDesc, ParamDesc = paramDesc }; IntPtr pInputConfigInfo = Marshal.AllocCoTaskMem(Marshal.SizeOf(typeof(HTTP_SERVICE_CONFIG_URLACL_SET))); Marshal.StructureToPtr(inputConfigInfoSet, pInputConfigInfo, false); retVal = NativeMethods.HttpSetServiceConfiguration(IntPtr.Zero, HTTP_SERVICE_CONFIG_ID.HttpServiceConfigUrlAclInfo, pInputConfigInfo, Marshal.SizeOf(inputConfigInfoSet), IntPtr.Zero); if (ReturnCodes.ERROR_ALREADY_EXISTS == retVal && deleteIfExists) { retVal = NativeMethods.HttpDeleteServiceConfiguration(IntPtr.Zero, HTTP_SERVICE_CONFIG_ID.HttpServiceConfigUrlAclInfo, pInputConfigInfo, Marshal.SizeOf(inputConfigInfoSet), IntPtr.Zero); if (retVal == ReturnCodes.NO_ERROR) { retVal = NativeMethods.HttpSetServiceConfiguration(IntPtr.Zero, HTTP_SERVICE_CONFIG_ID.HttpServiceConfigUrlAclInfo, pInputConfigInfo, Marshal.SizeOf(inputConfigInfoSet), IntPtr.Zero); } } Marshal.FreeCoTaskMem(pInputConfigInfo); NativeMethods.HttpTerminate(Flags.HTTP_INITIALIZE_CONFIG, IntPtr.Zero); } if (retVal != ReturnCodes.NO_ERROR) { throw new Win32Exception(Convert.ToInt32(retVal)); } }
public static void CreateUrlAcl(HttpConfigUrlAclEntry entry) { if (entry == null) { return; } HTTP_SERVICE_CONFIG_URLACL_SET configInformation = new HTTP_SERVICE_CONFIG_URLACL_SET(); configInformation.KeyDesc = new HTTP_SERVICE_CONFIG_URLACL_KEY(entry.UriPrefix); configInformation.ParamDesc = new HTTP_SERVICE_CONFIG_URLACL_PARAM(entry.SecurityDescriptor.GetSddlForm(AccessControlSections.All)); ErrorCode errorCode = HttpSetServiceConfiguration(IntPtr.Zero, HTTP_SERVICE_CONFIG_ID.HttpServiceConfigUrlAclInfo, ref configInformation, Marshal.SizeOf(configInformation), IntPtr.Zero); if (errorCode != ErrorCode.ERROR_SUCCESS) { throw new Win32Exception((int)errorCode); } }
public static void DeleteUrlAcl(string uriPrefix) { if (uriPrefix == null) { return; } HTTP_SERVICE_CONFIG_URLACL_SET configInformation = new HTTP_SERVICE_CONFIG_URLACL_SET(); configInformation.KeyDesc = new HTTP_SERVICE_CONFIG_URLACL_KEY(uriPrefix); int configInformationSize = Marshal.SizeOf(configInformation); ErrorCode errorCode = HttpDeleteServiceConfiguration(IntPtr.Zero, HTTP_SERVICE_CONFIG_ID.HttpServiceConfigUrlAclInfo, ref configInformation, configInformationSize, IntPtr.Zero); if (errorCode != ErrorCode.ERROR_FILE_NOT_FOUND && errorCode != ErrorCode.ERROR_SUCCESS) { throw new Win32Exception((int)errorCode); } }
private void SetUrlAcl() { var retVal = PInvoke.HttpInitialize(new HTTPAPI_VERSION(2, 0), PInvoke.HTTP_INITIALIZE_CONFIG, IntPtr.Zero); if ((uint)PInvoke.NO_ERROR != retVal) { throw new Exception(string.Format("Could not set the initialize the HTTP API. Code {0}", retVal)); } var url = string.Format("http://{0}.ngrok.com:{1}/", this.Subdomain, this.LocalhostPort); HTTP_SERVICE_CONFIG_URLACL_KEY keyDesc = new HTTP_SERVICE_CONFIG_URLACL_KEY(url); HTTP_SERVICE_CONFIG_URLACL_PARAM paramDesc = new HTTP_SERVICE_CONFIG_URLACL_PARAM("D:(A;;GX;;;WD)"); HTTP_SERVICE_CONFIG_URLACL_SET inputConfigInfoSet = new HTTP_SERVICE_CONFIG_URLACL_SET(); inputConfigInfoSet.KeyDesc = keyDesc; inputConfigInfoSet.ParamDesc = paramDesc; IntPtr pInputConfigInfo = Marshal.AllocCoTaskMem(Marshal.SizeOf(typeof(HTTP_SERVICE_CONFIG_URLACL_SET))); Marshal.StructureToPtr(inputConfigInfoSet, pInputConfigInfo, false); retVal = PInvoke.HttpSetServiceConfiguration(IntPtr.Zero, HTTP_SERVICE_CONFIG_ID.HttpServiceConfigUrlAclInfo, pInputConfigInfo, Marshal.SizeOf(inputConfigInfoSet), IntPtr.Zero); Marshal.FreeCoTaskMem(pInputConfigInfo); PInvoke.HttpTerminate(PInvoke.HTTP_INITIALIZE_CONFIG, IntPtr.Zero); if (PInvoke.NO_ERROR != retVal) { // Error Codes: // 5 - ERROR_ACCESS_DENIED // 183 - ERROR_ALREADY_EXISTS throw new Exception(string.Format("Could not set the Url Acl. Code {0}", retVal)); } _hasUrlAcl = true; }
/// <summary> /// Removes a URL ACL exception via the HTTP API. /// </summary> /// <param name="url">A string containing the URL to remove.</param> /// <param name="consoleOutput">An IConsoleOutputWrapper that provides a console for output. If NULL, then the default System.Console will be used.</param> /// <returns>A bool that indicates whether the exception was removed successfully.</returns> public static bool RemoveUrlException(string url, IConsoleOutputWrapper consoleOutput = null) { uint Result; bool ReturnValue = false; IntPtr UrlAclSetPointer; if (consoleOutput == null) { consoleOutput = new ConsoleOutput(); } InitialiseHttpApi(); HTTP_SERVICE_CONFIG_URLACL_SET UrlAclSet = new HTTP_SERVICE_CONFIG_URLACL_SET() { KeyDesc = new HTTP_SERVICE_CONFIG_URLACL_KEY(url), ParamDesc = new HTTP_SERVICE_CONFIG_URLACL_PARAM("") }; consoleOutput.WriteLine("Delete configuration for '{0}'", UrlAclSet.KeyDesc.pUrlPrefix); UrlAclSetPointer = Marshal.AllocCoTaskMem(Marshal.SizeOf(typeof(HTTP_SERVICE_CONFIG_URLACL_SET))); Marshal.StructureToPtr(UrlAclSet, UrlAclSetPointer, false); // Attempt to set the configuration and process the result Result = NativeMethods.HttpDeleteServiceConfiguration(IntPtr.Zero, HTTP_SERVICE_CONFIG_ID.HttpServiceConfigUrlAclInfo, UrlAclSetPointer, Marshal.SizeOf(typeof(HTTP_SERVICE_CONFIG_URLACL_SET)), IntPtr.Zero); switch (Result) { case 0: consoleOutput.WriteLine("Success."); ReturnValue = true; break; default: consoleOutput.WriteLine("Error {0} returned.", Result); break; } TerminateHttpApi(); consoleOutput.WriteLine(); return(ReturnValue); }
public void SetHttpNamespaceAcl(string urlPrefix, string acl) { HTTPAPI_VERSION version = new HTTPAPI_VERSION(); version.HttpApiMajorVersion = 1; version.HttpApiMinorVersion = 0; HttpInitialize(version, HTTP_INITIALIZE_CONFIG, IntPtr.Zero); HTTP_SERVICE_CONFIG_URLACL_SET urlAclConfig = new HTTP_SERVICE_CONFIG_URLACL_SET(); urlAclConfig.KeyDesc.pUrlPrefix = urlPrefix; urlAclConfig.ParamDesc.pStringSecurityDescriptor = acl; IntPtr UrlAclConfig = Marshal.AllocHGlobal(Marshal.SizeOf(urlAclConfig)); Marshal.StructureToPtr(urlAclConfig, UrlAclConfig, false); try { uint retval = HttpSetServiceConfiguration(IntPtr.Zero, HTTP_SERVICE_CONFIG_ID.HttpServiceConfigUrlAclInfo, UrlAclConfig, (uint)Marshal.SizeOf(urlAclConfig), IntPtr.Zero); if (retval != 0 && retval != 183) { throw new ExternalException("Error Setting Configuration: " + SecurityIdentity.GetErrorMessage(retval)); } } catch (Exception e) { Debug.WriteLine(e); } finally { if (UrlAclConfig != IntPtr.Zero) { Marshal.DestroyStructure(UrlAclConfig, typeof(HTTP_SERVICE_CONFIG_URLACL_SET)); Marshal.FreeHGlobal(UrlAclConfig); } } }
public static uint DeleteReservation(string networkURL) { uint retVal = NOERROR; if (String.IsNullOrEmpty(networkURL)) { throw new ArgumentNullException("networkURL"); } HTTP_SERVICE_CONFIG_URLACL_SET oldReservation = QueryReservation(networkURL); if (oldReservation.KeyDesc.pUrlPrefix == "" && networkURL.Contains("+")) { networkURL = networkURL.Replace('+', '*'); oldReservation = QueryReservation(networkURL); } if (oldReservation.KeyDesc.pUrlPrefix == "") { return(ERROR_FILE_NOT_FOUND); } CallHttpApi( delegate { IntPtr pInputConfigInfo = Marshal.AllocCoTaskMem(Marshal.SizeOf(typeof(HTTP_SERVICE_CONFIG_URLACL_SET))); Marshal.StructureToPtr(oldReservation, pInputConfigInfo, false); try { retVal = HttpDeleteServiceConfiguration(IntPtr.Zero, HTTP_SERVICE_CONFIG_ID.HttpServiceConfigUrlAclInfo, pInputConfigInfo, Marshal.SizeOf(oldReservation), IntPtr.Zero); } finally { Marshal.FreeCoTaskMem(pInputConfigInfo); } }); return(retVal); }
static extern ErrorCode HttpDeleteServiceConfiguration(IntPtr serviceIntPtr, HTTP_SERVICE_CONFIG_ID configId, ref HTTP_SERVICE_CONFIG_URLACL_SET configInformation, int configInformationLength, IntPtr pOverlapped);
public static void ReserveURL(string networkURL, string securityDescriptor) { if (String.IsNullOrEmpty(networkURL)) { throw new ArgumentNullException("networkURL"); } if (String.IsNullOrEmpty(securityDescriptor)) { throw new ArgumentNullException("securityDescriptor"); } CallHttpApi( delegate { uint retVal; HTTP_SERVICE_CONFIG_URLACL_KEY keyDesc = new HTTP_SERVICE_CONFIG_URLACL_KEY(networkURL); HTTP_SERVICE_CONFIG_URLACL_PARAM paramDesc = new HTTP_SERVICE_CONFIG_URLACL_PARAM(securityDescriptor); HTTP_SERVICE_CONFIG_URLACL_SET inputConfigInfoSet = new HTTP_SERVICE_CONFIG_URLACL_SET { KeyDesc = keyDesc, ParamDesc = paramDesc }; IntPtr pInputConfigInfo = Marshal.AllocCoTaskMem(Marshal.SizeOf(typeof(HTTP_SERVICE_CONFIG_URLACL_SET))); Marshal.StructureToPtr(inputConfigInfoSet, pInputConfigInfo, false); try { retVal = HttpSetServiceConfiguration(IntPtr.Zero, HTTP_SERVICE_CONFIG_ID.HttpServiceConfigUrlAclInfo, pInputConfigInfo, Marshal.SizeOf(inputConfigInfoSet), IntPtr.Zero); if (ERROR_ALREADY_EXISTS == retVal) { retVal = DeleteReservation(networkURL); if (ERROR_FILE_NOT_FOUND == retVal) { string networkURLOld = networkURL.Contains("https") ? networkURL.Replace("https", "http") : networkURL.Replace("http", "https"); retVal = DeleteReservation(networkURLOld); } if (NOERROR == retVal) { retVal = HttpSetServiceConfiguration(IntPtr.Zero, HTTP_SERVICE_CONFIG_ID.HttpServiceConfigUrlAclInfo, pInputConfigInfo, Marshal.SizeOf(inputConfigInfoSet), IntPtr.Zero); } } } finally { Marshal.FreeCoTaskMem(pInputConfigInfo); } if (NOERROR != retVal) { ThrowWin32ExceptionIfError(retVal); } }); }
private Dictionary <string, string> FindUrlPrefix(string urlPrefix) { Dictionary <string, string> acls = new Dictionary <string, string>(); HTTP_SERVICE_CONFIG_URLACL_QUERY query = new HTTP_SERVICE_CONFIG_URLACL_QUERY(); query.QueryDesc = HTTP_SERVICE_CONFIG_QUERY_TYPE.HttpServiceConfigQueryNext; IntPtr pQuery = Marshal.AllocHGlobal(Marshal.SizeOf(query)); try { uint retval = NO_ERROR; for (query.dwToken = 0; ; query.dwToken++) { Marshal.StructureToPtr(query, pQuery, false); try { uint returnSize = 0; // Get Size retval = HttpQueryServiceConfiguration(IntPtr.Zero, HTTP_SERVICE_CONFIG_ID.HttpServiceConfigUrlAclInfo, pQuery, (uint)Marshal.SizeOf(query), IntPtr.Zero, 0, ref returnSize, IntPtr.Zero); if (retval == ERROR_NO_MORE_ITEMS) { break; } if (retval != ERROR_INSUFFICIENT_BUFFER) { throw new Exception("HttpQueryServiceConfiguration returned unexpected error code."); } IntPtr pConfig = Marshal.AllocHGlobal((IntPtr)returnSize); string foundPrefix; string secdescriptor; try { retval = HttpQueryServiceConfiguration(IntPtr.Zero, HTTP_SERVICE_CONFIG_ID.HttpServiceConfigUrlAclInfo, pQuery, (uint)Marshal.SizeOf(query), pConfig, returnSize, ref returnSize, IntPtr.Zero); HTTP_SERVICE_CONFIG_URLACL_SET config = (HTTP_SERVICE_CONFIG_URLACL_SET)Marshal.PtrToStructure(pConfig, typeof(HTTP_SERVICE_CONFIG_URLACL_SET)); string permissions = SDDLParser.Parse(config.ParamDesc.pStringSecurityDescriptor); acls.Add(config.KeyDesc.pUrlPrefix, permissions); } finally { Marshal.FreeHGlobal(pConfig); } } finally { Marshal.DestroyStructure(pQuery, typeof(HTTP_SERVICE_CONFIG_URLACL_QUERY)); } } if (retval != ERROR_NO_MORE_ITEMS) { throw new Exception("HttpQueryServiceConfiguration returned unexpected error code."); } } finally { Marshal.FreeHGlobal(pQuery); } return(acls); }
public static extern uint HttpDeleteServiceConfiguration( IntPtr serviceIntPtr, HTTP_SERVICE_CONFIG_ID configId, HTTP_SERVICE_CONFIG_URLACL_SET pConfigInformation, int configInformationLength, IntPtr pOverlapped);
private static bool CreateUrlAclSetFromUserAccount(string key, string userAccount, out HTTP_SERVICE_CONFIG_URLACL_SET urlAclSet) { bool ReturnValue = false; // Defaults urlAclSet = default(HTTP_SERVICE_CONFIG_URLACL_SET); if (CreateSddlFromUserAccount(userAccount, out string SecurityDescriptor)) { urlAclSet = CreateUrlAclSet(key, SecurityDescriptor); ReturnValue = true; } return(ReturnValue); }
private void SetHttpUrlSddl() { InitializeHttp(); try { var keyDesc = new HTTP_SERVICE_CONFIG_URLACL_KEY(Url); var sddl = GetSecurityDescriptorSddlForm(AccessControlSections.Access); var paramDesc = new HTTP_SERVICE_CONFIG_URLACL_PARAM(sddl); var inputConfigInfoSet = new HTTP_SERVICE_CONFIG_URLACL_SET {KeyDesc = keyDesc, ParamDesc = paramDesc}; var pInputConfigInfo = Marshal.AllocCoTaskMem(Marshal.SizeOf(typeof (HTTP_SERVICE_CONFIG_URLACL_SET))); Marshal.StructureToPtr(inputConfigInfoSet, pInputConfigInfo, false); ulong retVal; var currentAccess = GetAccessRules(true, true, typeof (SecurityIdentifier)); if (currentAccess.Count == 0) { retVal = HttpDeleteServiceConfiguration(IntPtr.Zero, HTTP_SERVICE_CONFIG_ID.HttpServiceConfigUrlAclInfo, pInputConfigInfo, Marshal.SizeOf(inputConfigInfoSet), IntPtr.Zero); } else { retVal = HttpSetServiceConfiguration(IntPtr.Zero, HTTP_SERVICE_CONFIG_ID.HttpServiceConfigUrlAclInfo, pInputConfigInfo, Marshal.SizeOf(inputConfigInfoSet), IntPtr.Zero); if (Win32ErrorCodes.AlreadyExists == retVal) { retVal = HttpDeleteServiceConfiguration(IntPtr.Zero, HTTP_SERVICE_CONFIG_ID.HttpServiceConfigUrlAclInfo, pInputConfigInfo, Marshal.SizeOf(inputConfigInfoSet), IntPtr.Zero); if (Win32ErrorCodes.Ok == retVal) { retVal = HttpSetServiceConfiguration(IntPtr.Zero, HTTP_SERVICE_CONFIG_ID.HttpServiceConfigUrlAclInfo, pInputConfigInfo, Marshal.SizeOf(inputConfigInfoSet), IntPtr.Zero); } } } if (Win32ErrorCodes.Ok != retVal) { throw new Win32Exception(); } Marshal.FreeCoTaskMem(pInputConfigInfo); } finally { TerminateHttp(); } }
/// <summary> /// Gets the application access rules for the specified URL. /// </summary> public static IList <HttpAccessRule> GetAccessRules(string url) { List <HttpAccessRule> accessRules = new List <HttpAccessRule>(); HttpError error = NativeMethods.HttpInitialize( new HTTPAPI_VERSION(1, 0), HttpInitFlag.HTTP_INITIALIZE_CONFIG, IntPtr.Zero); if (error != HttpError.NO_ERROR) { throw ServiceResultException.Create( StatusCodes.BadUnexpectedError, "Could not initialize HTTP library.\r\nError={0}", error); } HTTP_SERVICE_CONFIG_URLACL_QUERY query = new HTTP_SERVICE_CONFIG_URLACL_QUERY(); query.QueryDesc = HTTP_SERVICE_CONFIG_QUERY_TYPE.HttpServiceConfigQueryNext; if (!String.IsNullOrEmpty(url)) { query.QueryDesc = HTTP_SERVICE_CONFIG_QUERY_TYPE.HttpServiceConfigQueryExact; query.KeyDesc.pUrlPrefix = url; } IntPtr pInput = Marshal.AllocHGlobal(Marshal.SizeOf <HTTP_SERVICE_CONFIG_URLACL_QUERY>()); NativeMethods.ZeroMemory(pInput, Marshal.SizeOf <HTTP_SERVICE_CONFIG_URLACL_QUERY>()); IntPtr pOutput = IntPtr.Zero; try { for (query.dwToken = 0; error == HttpError.NO_ERROR; query.dwToken++) { Marshal.StructureToPtr(query, pInput, true); int requiredBufferLength = 0; error = NativeMethods.HttpQueryServiceConfiguration( IntPtr.Zero, HTTP_SERVICE_CONFIG_ID.HttpServiceConfigUrlAclInfo, pInput, Marshal.SizeOf <HTTP_SERVICE_CONFIG_URLACL_QUERY>(), pOutput, requiredBufferLength, out requiredBufferLength, IntPtr.Zero); if (error == HttpError.ERROR_NO_MORE_ITEMS) { break; } if (!String.IsNullOrEmpty(url)) { if (error == HttpError.ERROR_FILE_NOT_FOUND) { break; } } if (error != HttpError.ERROR_INSUFFICIENT_BUFFER) { throw ServiceResultException.Create( StatusCodes.BadUnexpectedError, "Could not read access rules for HTTP url.\r\nError={1}, Url={0}", url, error); } pOutput = Marshal.AllocHGlobal(requiredBufferLength); NativeMethods.ZeroMemory(pOutput, requiredBufferLength); error = NativeMethods.HttpQueryServiceConfiguration( IntPtr.Zero, HTTP_SERVICE_CONFIG_ID.HttpServiceConfigUrlAclInfo, pInput, Marshal.SizeOf <HTTP_SERVICE_CONFIG_URLACL_QUERY>(), pOutput, requiredBufferLength, out requiredBufferLength, IntPtr.Zero); if (error != HttpError.NO_ERROR) { throw ServiceResultException.Create( StatusCodes.BadUnexpectedError, "Could not read access rules for HTTP url.\r\nError={1}, Url={0}", url, error); } HTTP_SERVICE_CONFIG_URLACL_SET result = (HTTP_SERVICE_CONFIG_URLACL_SET)Marshal.PtrToStructure <HTTP_SERVICE_CONFIG_URLACL_SET>(pOutput); // parse the SDDL and update the access list. ParseSddl(result.KeyDesc.pUrlPrefix, result.ParamDesc.pStringSecurityDescriptor, accessRules); Marshal.FreeHGlobal(pOutput); pOutput = IntPtr.Zero; // all done if requesting the results for a single url. if (!String.IsNullOrEmpty(url)) { break; } } } finally { if (pInput != IntPtr.Zero) { Marshal.DestroyStructure <HTTP_SERVICE_CONFIG_URLACL_QUERY>(pInput); Marshal.FreeHGlobal(pInput); } if (pOutput != IntPtr.Zero) { Marshal.FreeHGlobal(pOutput); } NativeMethods.HttpTerminate(HttpInitFlag.HTTP_INITIALIZE_CONFIG, IntPtr.Zero); } return(accessRules); }
internal static extern Win32Error HttpSetServiceConfiguration(IntPtr serviceHandle, HTTP_SERVICE_CONFIG_ID configId, HTTP_SERVICE_CONFIG_URLACL_SET pConfigInformation, int configInformationLength, IntPtr pOverlapped);
public static ReadOnlyCollection <UrlReservation> GetAll() { List <UrlReservation> revs = new List <UrlReservation>(); uint retVal = (uint)ErrorCodes.NOERROR; // NOERROR = 0 retVal = NativeMethods.HttpInitialize(HttpApiConstants.HTTPAPI_VERSION_1, HttpApiConstants.HTTP_INITIALIZE_CONFIG, IntPtr.Zero); if ((uint)ErrorCodes.NOERROR == retVal) { HTTP_SERVICE_CONFIG_URLACL_QUERY inputConfigInfoSet = new HTTP_SERVICE_CONFIG_URLACL_QUERY(); inputConfigInfoSet.QueryDesc = HTTP_SERVICE_CONFIG_QUERY_TYPE.HttpServiceConfigQueryNext; int i = 0; while (retVal == 0) { inputConfigInfoSet.dwToken = (uint)i; IntPtr pInputConfigInfo = Marshal.AllocCoTaskMem(Marshal.SizeOf(typeof(HTTP_SERVICE_CONFIG_URLACL_QUERY))); Marshal.StructureToPtr(inputConfigInfoSet, pInputConfigInfo, false); HTTP_SERVICE_CONFIG_URLACL_SET outputConfigInfo = new HTTP_SERVICE_CONFIG_URLACL_SET(); IntPtr pOutputConfigInfo = Marshal.AllocCoTaskMem(0); int returnLength = 0; retVal = NativeMethods.HttpQueryServiceConfiguration(IntPtr.Zero, HTTP_SERVICE_CONFIG_ID.HttpServiceConfigUrlAclInfo, pInputConfigInfo, Marshal.SizeOf(inputConfigInfoSet), pOutputConfigInfo, returnLength, out returnLength, IntPtr.Zero); if (retVal == ErrorCodes.ERROR_INSUFFICIENT_BUFFER) { Marshal.ZeroFreeCoTaskMemUnicode(pOutputConfigInfo); pOutputConfigInfo = Marshal.AllocCoTaskMem(Convert.ToInt32(returnLength)); retVal = NativeMethods.HttpQueryServiceConfiguration(IntPtr.Zero, HTTP_SERVICE_CONFIG_ID.HttpServiceConfigUrlAclInfo, pInputConfigInfo, Marshal.SizeOf(inputConfigInfoSet), pOutputConfigInfo, returnLength, out returnLength, IntPtr.Zero); } if (ErrorCodes.NOERROR == retVal) { outputConfigInfo = (HTTP_SERVICE_CONFIG_URLACL_SET)Marshal.PtrToStructure(pOutputConfigInfo, typeof(HTTP_SERVICE_CONFIG_URLACL_SET)); UrlReservation rev = new UrlReservation(outputConfigInfo.KeyDesc.pUrlPrefix, securityIdentifiersFromSDDL(outputConfigInfo.ParamDesc.pStringSecurityDescriptor)); revs.Add(rev); } Marshal.FreeCoTaskMem(pOutputConfigInfo); Marshal.FreeCoTaskMem(pInputConfigInfo); i++; } retVal = NativeMethods.HttpTerminate(HttpApiConstants.HTTP_INITIALIZE_CONFIG, IntPtr.Zero); } if ((uint)ErrorCodes.NOERROR != retVal) { throw new Win32Exception(Convert.ToInt32(retVal)); } return(new ReadOnlyCollection <UrlReservation>(revs)); }
public static void ReserveUrl(string networkUrl, string securityDescriptor) { TraceSource.WriteInfo( PortAclUtility.TraceType, "Started to Reserve Url. networkUrl: {0}, securityDescriptor: {1}.", networkUrl, securityDescriptor); uint retVal = (uint)NOERROR; // NOERROR = 0 HTTPAPI_VERSION httpApiVersion = new HTTPAPI_VERSION(1, 0); retVal = HttpInitialize(httpApiVersion, HTTP_INITIALIZE_CONFIG, IntPtr.Zero); TraceSource.WriteInfo( PortAclUtility.TraceType, "HttpInitialize completed with return value: {0}.", retVal); if ((uint)NOERROR == retVal) { HTTP_SERVICE_CONFIG_URLACL_KEY keyDesc = new HTTP_SERVICE_CONFIG_URLACL_KEY(networkUrl); HTTP_SERVICE_CONFIG_URLACL_PARAM paramDesc = new HTTP_SERVICE_CONFIG_URLACL_PARAM(securityDescriptor); HTTP_SERVICE_CONFIG_URLACL_SET inputConfigInfoSet = new HTTP_SERVICE_CONFIG_URLACL_SET { KeyDesc = keyDesc, ParamDesc = paramDesc }; IntPtr pInputConfigInfo = Marshal.AllocCoTaskMem(Marshal.SizeOf(typeof(HTTP_SERVICE_CONFIG_URLACL_SET))); Marshal.StructureToPtr(inputConfigInfoSet, pInputConfigInfo, false); retVal = HttpSetServiceConfiguration(IntPtr.Zero, HTTP_SERVICE_CONFIG_ID.HttpServiceConfigUrlAclInfo, pInputConfigInfo, Marshal.SizeOf(inputConfigInfoSet), IntPtr.Zero); TraceSource.WriteInfo( PortAclUtility.TraceType, "HttpSetServiceConfiguration completed with return value: {0}.", retVal); if ((uint)ERROR_ALREADY_EXISTS == retVal) // ERROR_ALREADY_EXISTS = 183 { retVal = HttpDeleteServiceConfiguration(IntPtr.Zero, HTTP_SERVICE_CONFIG_ID.HttpServiceConfigUrlAclInfo, pInputConfigInfo, Marshal.SizeOf(inputConfigInfoSet), IntPtr.Zero); TraceSource.WriteInfo( PortAclUtility.TraceType, "HttpDeleteServiceConfiguration(outer) completed with return value: {0}.", retVal); if ((uint)ERROR_FILE_NOT_FOUND == retVal) { // This means its possible that the URL is ACLed for the same port but different protocol (http/https) // Try deleting ACL using the other protocol var networkUrlInner = networkUrl.ToLower(); if (networkUrlInner.Contains("https")) { networkUrlInner = networkUrlInner.Replace("https", "http"); } else { networkUrlInner = networkUrlInner.Replace("http", "https"); } HTTP_SERVICE_CONFIG_URLACL_KEY keyDescInner = new HTTP_SERVICE_CONFIG_URLACL_KEY(networkUrlInner); HTTP_SERVICE_CONFIG_URLACL_SET inputConfigInfoSetInner = new HTTP_SERVICE_CONFIG_URLACL_SET { KeyDesc = keyDescInner }; IntPtr pInputConfigInfoInner = IntPtr.Zero; try { pInputConfigInfoInner = Marshal.AllocCoTaskMem(Marshal.SizeOf(typeof(HTTP_SERVICE_CONFIG_URLACL_SET))); Marshal.StructureToPtr(inputConfigInfoSetInner, pInputConfigInfoInner, false); retVal = HttpDeleteServiceConfiguration(IntPtr.Zero, HTTP_SERVICE_CONFIG_ID.HttpServiceConfigUrlAclInfo, pInputConfigInfoInner, Marshal.SizeOf(inputConfigInfoSetInner), IntPtr.Zero); TraceSource.WriteWarning( PortAclUtility.TraceType, "HttpDeleteServiceConfiguration(Inner) completed with return value: {0}.", retVal); } finally { if (IntPtr.Zero != pInputConfigInfoInner) { Marshal.FreeCoTaskMem(pInputConfigInfoInner); } } } if ((uint)NOERROR == retVal) { retVal = HttpSetServiceConfiguration(IntPtr.Zero, HTTP_SERVICE_CONFIG_ID.HttpServiceConfigUrlAclInfo, pInputConfigInfo, Marshal.SizeOf(inputConfigInfoSet), IntPtr.Zero); TraceSource.WriteInfo( PortAclUtility.TraceType, "HttpSetServiceConfiguration completed with return value: {0}.", retVal); } } Marshal.FreeCoTaskMem(pInputConfigInfo); HttpTerminate(HTTP_INITIALIZE_CONFIG, IntPtr.Zero); } if ((uint)NOERROR != retVal) { TraceSource.WriteError( PortAclUtility.TraceType, "ReserveUrl failed with error: {0}.", retVal); throw new Win32Exception(Convert.ToInt32(retVal)); } }
static extern ErrorCode HttpSetServiceConfiguration(IntPtr nullHandle, HTTP_SERVICE_CONFIG_ID configId, ref HTTP_SERVICE_CONFIG_URLACL_SET configInformation, int configInformationLength, IntPtr pOverlapped);
static extern int HttpDeleteServiceConfigurationAcl( IntPtr mustBeZero, int configID, [In] ref HTTP_SERVICE_CONFIG_URLACL_SET configInfo, int configInfoLength, IntPtr mustBeZero2);
private void Load() { var retVal = PInvoke.HttpInitialize(new HTTPAPI_VERSION(2, 0), PInvoke.HTTP_INITIALIZE_CONFIG, IntPtr.Zero); if ((uint)PInvoke.NO_ERROR != retVal) { throw new Exception(string.Format("Could not set the initialize the HTTP API. Code {0}", retVal)); } HTTP_SERVICE_CONFIG_URLACL_QUERY inputConfigInfoQuery = new HTTP_SERVICE_CONFIG_URLACL_QUERY(); inputConfigInfoQuery.QueryDesc = HTTP_SERVICE_CONFIG_QUERY_TYPE.HttpServiceConfigQueryNext; int i = 0; while (retVal == 0) { inputConfigInfoQuery.dwToken = (uint)i; IntPtr pInputConfigInfo = Marshal.AllocCoTaskMem(Marshal.SizeOf(typeof(HTTP_SERVICE_CONFIG_URLACL_QUERY))); Marshal.StructureToPtr(inputConfigInfoQuery, pInputConfigInfo, false); HTTP_SERVICE_CONFIG_URLACL_SET outputConfigInfo = new HTTP_SERVICE_CONFIG_URLACL_SET(); IntPtr pOutputConfigInfo = Marshal.AllocCoTaskMem(0); int returnLength = 0; retVal = PInvoke.HttpQueryServiceConfiguration(IntPtr.Zero, HTTP_SERVICE_CONFIG_ID.HttpServiceConfigUrlAclInfo, pInputConfigInfo, Marshal.SizeOf(inputConfigInfoQuery), pOutputConfigInfo, returnLength, out returnLength, IntPtr.Zero); if (PInvoke.ERROR_INSUFFICIENT_BUFFER == retVal) { //Marshal the proper buffer size back from the response Marshal.FreeCoTaskMem(pOutputConfigInfo); pOutputConfigInfo = Marshal.AllocCoTaskMem(Convert.ToInt32(returnLength)); retVal = PInvoke.HttpQueryServiceConfiguration(IntPtr.Zero, HTTP_SERVICE_CONFIG_ID.HttpServiceConfigUrlAclInfo, pInputConfigInfo, Marshal.SizeOf(inputConfigInfoQuery), pOutputConfigInfo, returnLength, out returnLength, IntPtr.Zero); } if (PInvoke.NO_ERROR == retVal) { outputConfigInfo = (HTTP_SERVICE_CONFIG_URLACL_SET)Marshal.PtrToStructure(pOutputConfigInfo, typeof(HTTP_SERVICE_CONFIG_URLACL_SET)); Debug.WriteLine(outputConfigInfo.KeyDesc.pUrlPrefix); this.UrlAcls.Add(new UrlAcl(outputConfigInfo)); Marshal.FreeCoTaskMem(pOutputConfigInfo); Marshal.FreeCoTaskMem(pInputConfigInfo); } else if (PInvoke.ERROR_NO_MORE_ITEMS == retVal) { Marshal.FreeCoTaskMem(pOutputConfigInfo); Marshal.FreeCoTaskMem(pInputConfigInfo); } else { Marshal.FreeCoTaskMem(pOutputConfigInfo); Marshal.FreeCoTaskMem(pInputConfigInfo); throw new Exception(string.Format("Could not list Url Acls. Code {0}", retVal)); } //Marshal.FreeCoTaskMem(pOutputConfigInfo); //Marshal.FreeCoTaskMem(pInputConfigInfo); i++; } PInvoke.HttpTerminate(PInvoke.HTTP_INITIALIZE_CONFIG, IntPtr.Zero); }
/// <summary> /// Sets the application access rules for the specified URL. /// </summary> public static void SetAccessRules(string url, IList <HttpAccessRule> rules, bool replaceExisting) { HttpError error = NativeMethods.HttpInitialize( new HTTPAPI_VERSION(1, 0), HttpInitFlag.HTTP_INITIALIZE_CONFIG, IntPtr.Zero); if (error != HttpError.NO_ERROR) { throw ServiceResultException.Create( StatusCodes.BadUnexpectedError, "Could not initialize HTTP library.\r\nError={0}", error); } // fetch existing rules if not replacing them. if (!replaceExisting) { IList <HttpAccessRule> existingRules = GetAccessRules(url); if (existingRules.Count > 0) { List <HttpAccessRule> mergedRules = new List <HttpAccessRule>(existingRules); mergedRules.AddRange(rules); rules = mergedRules; } } HTTP_SERVICE_CONFIG_URLACL_SET update = new HTTP_SERVICE_CONFIG_URLACL_SET(); update.KeyDesc.pUrlPrefix = url; update.ParamDesc.pStringSecurityDescriptor = FormatSddl(rules); IntPtr pStruct = IntPtr.Zero; int updateSize = Marshal.SizeOf <HTTP_SERVICE_CONFIG_URLACL_SET>(); try { pStruct = Marshal.AllocHGlobal(updateSize); NativeMethods.ZeroMemory(pStruct, updateSize); Marshal.StructureToPtr(update, pStruct, false); error = NativeMethods.HttpDeleteServiceConfiguration( IntPtr.Zero, HTTP_SERVICE_CONFIG_ID.HttpServiceConfigUrlAclInfo, pStruct, updateSize, IntPtr.Zero); if (error != HttpError.ERROR_FILE_NOT_FOUND && error != HttpError.NO_ERROR) { throw ServiceResultException.Create( StatusCodes.BadUnexpectedError, "Could not delete existing access rules for HTTP url.\r\nError={1}, Url={0}", url, error); } if (rules.Count > 0) { error = NativeMethods.HttpSetServiceConfiguration( IntPtr.Zero, HTTP_SERVICE_CONFIG_ID.HttpServiceConfigUrlAclInfo, pStruct, updateSize, IntPtr.Zero); if (error != HttpError.NO_ERROR) { throw ServiceResultException.Create( StatusCodes.BadUnexpectedError, "Could not set the access rules for HTTP url.\r\nError={1}, Url={0}", url, error); } } } finally { if (pStruct != IntPtr.Zero) { Marshal.DestroyStructure <HTTP_SERVICE_CONFIG_URLACL_SET>(pStruct); Marshal.FreeHGlobal(pStruct); } NativeMethods.HttpTerminate(HttpInitFlag.HTTP_INITIALIZE_CONFIG, IntPtr.Zero); } }
public static bool FindUrlPrefix(string urlPrefix) { HTTP_SERVICE_CONFIG_URLACL_QUERY query = new HTTP_SERVICE_CONFIG_URLACL_QUERY(); query.QueryDesc = HTTP_SERVICE_CONFIG_QUERY_TYPE.HttpServiceConfigQueryNext; IntPtr pQuery = Marshal.AllocHGlobal(Marshal.SizeOf(query)); try { uint retval = NO_ERROR; for (query.dwToken = 0; ; query.dwToken++) { Marshal.StructureToPtr(query, pQuery, false); try { uint returnSize = 0; // Get Size retval = HttpQueryServiceConfiguration(IntPtr.Zero, HTTP_SERVICE_CONFIG_ID.HttpServiceConfigUrlAclInfo, pQuery, (uint)Marshal.SizeOf(query), IntPtr.Zero, 0, ref returnSize, IntPtr.Zero); if (retval == ERROR_NO_MORE_ITEMS) { break; } if (retval != ERROR_INSUFFICIENT_BUFFER) { throw new Exception("HttpQueryServiceConfiguration returned unexpected error code."); } IntPtr pConfig = Marshal.AllocHGlobal((IntPtr)returnSize); string foundPrefix; try { retval = HttpQueryServiceConfiguration(IntPtr.Zero, HTTP_SERVICE_CONFIG_ID.HttpServiceConfigUrlAclInfo, pQuery, (uint)Marshal.SizeOf(query), pConfig, returnSize, ref returnSize, IntPtr.Zero); HTTP_SERVICE_CONFIG_URLACL_SET config = (HTTP_SERVICE_CONFIG_URLACL_SET)Marshal.PtrToStructure(pConfig, typeof(HTTP_SERVICE_CONFIG_URLACL_SET)); foundPrefix = config.KeyDesc.pUrlPrefix; Console.WriteLine(foundPrefix); } finally { Marshal.FreeHGlobal(pConfig); } if (foundPrefix == urlPrefix) { return(true); } } finally { Marshal.DestroyStructure(pQuery, typeof(HTTP_SERVICE_CONFIG_URLACL_QUERY)); } } if (retval != ERROR_NO_MORE_ITEMS) { throw new Exception("HttpQueryServiceConfiguration returned unexpected error code."); } } finally { Marshal.FreeHGlobal(pQuery); } return(false); }
/// <summary> /// Sets the application access rules for the specified URL. /// </summary> public static void SetAccessRules(string url, IList<HttpAccessRule> rules, bool replaceExisting) { HttpError error = NativeMethods.HttpInitialize( new HTTPAPI_VERSION(1, 0), HttpInitFlag.HTTP_INITIALIZE_CONFIG, IntPtr.Zero); if (error != HttpError.NO_ERROR) { throw ServiceResultException.Create( StatusCodes.BadUnexpectedError, "Could not initialize HTTP library.\r\nError={0}", error); } // fetch existing rules if not replacing them. if (!replaceExisting) { IList<HttpAccessRule> existingRules = GetAccessRules(url); if (existingRules.Count > 0) { List<HttpAccessRule> mergedRules = new List<HttpAccessRule>(existingRules); mergedRules.AddRange(rules); rules = mergedRules; } } HTTP_SERVICE_CONFIG_URLACL_SET update = new HTTP_SERVICE_CONFIG_URLACL_SET(); update.KeyDesc.pUrlPrefix = url; update.ParamDesc.pStringSecurityDescriptor = FormatSddl(rules); IntPtr pStruct = IntPtr.Zero; int updateSize = Marshal.SizeOf(typeof(HTTP_SERVICE_CONFIG_URLACL_SET)); try { pStruct = Marshal.AllocHGlobal(updateSize); NativeMethods.ZeroMemory(pStruct, updateSize); Marshal.StructureToPtr(update, pStruct, false); error = NativeMethods.HttpDeleteServiceConfiguration( IntPtr.Zero, HTTP_SERVICE_CONFIG_ID.HttpServiceConfigUrlAclInfo, pStruct, updateSize, IntPtr.Zero); if (error != HttpError.ERROR_FILE_NOT_FOUND && error != HttpError.NO_ERROR) { throw ServiceResultException.Create( StatusCodes.BadUnexpectedError, "Could not delete existing access rules for HTTP url.\r\nError={1}, Url={0}", url, error); } if (rules.Count > 0) { error = NativeMethods.HttpSetServiceConfiguration( IntPtr.Zero, HTTP_SERVICE_CONFIG_ID.HttpServiceConfigUrlAclInfo, pStruct, updateSize, IntPtr.Zero); if (error != HttpError.NO_ERROR) { throw ServiceResultException.Create( StatusCodes.BadUnexpectedError, "Could not set the access rules for HTTP url.\r\nError={1}, Url={0}", url, error); } } } finally { if (pStruct != IntPtr.Zero) { Marshal.DestroyStructure(pStruct, typeof(HTTP_SERVICE_CONFIG_URLACL_SET)); Marshal.FreeHGlobal(pStruct); } NativeMethods.HttpTerminate(HttpInitFlag.HTTP_INITIALIZE_CONFIG, IntPtr.Zero); } }
private static HTTP_SERVICE_CONFIG_URLACL_SET QueryReservation(string networkURL) { if (String.IsNullOrEmpty(networkURL)) { throw new ArgumentNullException("networkURL"); } HTTP_SERVICE_CONFIG_URLACL_SET res = new HTTP_SERVICE_CONFIG_URLACL_SET { KeyDesc = new HTTP_SERVICE_CONFIG_URLACL_KEY("") }; CallHttpApi( delegate { HTTP_SERVICE_CONFIG_URLACL_QUERY inputquery = new HTTP_SERVICE_CONFIG_URLACL_QUERY { QueryDesc = HTTP_SERVICE_CONFIG_QUERY_TYPE.HttpServiceConfigQueryExact, KeyDesc = new HTTP_SERVICE_CONFIG_URLACL_KEY(networkURL) }; IntPtr pInputQuery = Marshal.AllocCoTaskMem(Marshal.SizeOf(typeof(HTTP_SERVICE_CONFIG_URLACL_QUERY))); Marshal.StructureToPtr(inputquery, pInputQuery, false); IntPtr pOutputConfigInfo = IntPtr.Zero; int returnLength = 0; try { uint retVal = HttpQueryServiceConfiguration(IntPtr.Zero, HTTP_SERVICE_CONFIG_ID.HttpServiceConfigUrlAclInfo, pInputQuery, Marshal.SizeOf(inputquery), pOutputConfigInfo, returnLength, out returnLength, IntPtr.Zero); if (ERROR_INSUFFICIENT_BUFFER == retVal) { pOutputConfigInfo = Marshal.AllocCoTaskMem(returnLength); retVal = HttpQueryServiceConfiguration(IntPtr.Zero, HTTP_SERVICE_CONFIG_ID.HttpServiceConfigUrlAclInfo, pInputQuery, Marshal.SizeOf(inputquery), pOutputConfigInfo, returnLength, out returnLength, IntPtr.Zero); if (ERROR_FILE_NOT_FOUND == retVal) { return; } ThrowWin32ExceptionIfError(retVal); res = (HTTP_SERVICE_CONFIG_URLACL_SET)Marshal.PtrToStructure(pOutputConfigInfo, typeof(HTTP_SERVICE_CONFIG_URLACL_SET)); } else if (ERROR_FILE_NOT_FOUND != retVal) { ThrowWin32ExceptionIfError(retVal); } } finally { Marshal.FreeCoTaskMem(pInputQuery); if (pOutputConfigInfo != IntPtr.Zero) { Marshal.FreeCoTaskMem(pOutputConfigInfo); } } } ); return(res); }