How to implement a receipt URL for reliable messaging that requires a user name and a password in BizTalk Server

using System;
using  System.Runtime.InteropServices;

namespace Microsoft.Samples.BizTalk.Pipelines.CustomComponent
{
	/// <summary>
	/// This helper class parses the HTTP URL that contains the user name and the password.
	/// </summary>
	class UrlHelper
	{
		[StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)]
		private struct URL_COMPONENTS
		{
			public uint		dwStructSize;
			public string	szScheme;
			public uint		dwSchemeLength;
			public int		nScheme;  
			public string	szHostName;  
			public uint		dwHostNameLength;  
			public uint		nPort;  
			public string	szUserName;  
			public uint		dwUserNameLength;  
			public string	szPassword;  
			public uint		dwPasswordLength;  
			public string	szUrlPath;  
			public uint		dwUrlPathLength;  
			public string	szExtraInfo;  
			public uint		dwExtraInfoLength;
		}

		const int INTERNET_SCHEME_HTTP = 3;
		const int INTERNET_SCHEME_HTTPS = 4;

		const int INTERNET_MAX_HOST_NAME_LENGTH = 256;
		const int INTERNET_MAX_USER_NAME_LENGTH = 128;
		const int INTERNET_MAX_PASSWORD_LENGTH = 128;
		const int INTERNET_MAX_PATH_LENGTH = 2048;
		const int INTERNET_MAX_SCHEME_LENGTH = 32;      // This value is the longest protocol name length.
		const int INTERNET_MAX_URL_LENGTH = INTERNET_MAX_SCHEME_LENGTH + 3 + INTERNET_MAX_PATH_LENGTH;

		[DllImport("Wininet.dll", SetLastError=true, CharSet=CharSet.Unicode)]
		static private extern bool InternetCrackUrl (string url, int urlLength, int flags, ref URL_COMPONENTS urlComponents);

		/// <summary>
		/// This function tries to parse the user name and the password from the HTTP or HTTPS URL string.
		/// </summary>
		/// <param name="originalUrl">[in] Original URL</param>
		/// <param name="resultUrl">[out] If the function returns true, this parameter contains the URL that has the user name and the password removed.</param>
		/// <param name="userName">[out] param. If the function returns true, this parameter contains the user name from the URL.</param>
		/// <param name="password">[out] param. If the function returns true, this parameter contains the password from the URL.</param>
		/// <returns>
		///		true if the user name and the password were successfully parsed from the input URL.
		///		false if the URL is not an HTTP URL or does not contain the user name and password.
		/// </returns>
		static public bool ParseUserPasswordFromHttpUrl(string originalUrl, 
			out string resultUrl, 
			out string userName, 
			out string password)
		{
			bool	ContainAuthInfo = false;
			URL_COMPONENTS Result = new URL_COMPONENTS();
			
			// Initialize the parameters.
			resultUrl = string.Empty;
			userName = string.Empty;
			password = string.Empty;

			// Preallocate the buffer.
			Result.dwStructSize = (uint) Marshal.SizeOf(typeof(URL_COMPONENTS));
			Result.szScheme = new string(' ', INTERNET_MAX_SCHEME_LENGTH);
			Result.dwSchemeLength = INTERNET_MAX_SCHEME_LENGTH;
			Result.szHostName = new string(' ', INTERNET_MAX_HOST_NAME_LENGTH);  
			Result.dwHostNameLength=INTERNET_MAX_HOST_NAME_LENGTH;  
			Result.szUserName= new string(' ', INTERNET_MAX_USER_NAME_LENGTH);  
			Result.dwUserNameLength = INTERNET_MAX_USER_NAME_LENGTH;  
			Result.szPassword= new string(' ', INTERNET_MAX_PASSWORD_LENGTH);  
			Result.dwPasswordLength = INTERNET_MAX_PASSWORD_LENGTH;  
			Result.szUrlPath= new string(' ', INTERNET_MAX_PATH_LENGTH);  
			Result.dwUrlPathLength =INTERNET_MAX_PATH_LENGTH;  
			Result.szExtraInfo= new string(' ', INTERNET_MAX_URL_LENGTH);  
			Result.dwExtraInfoLength = INTERNET_MAX_URL_LENGTH;

			// Call the InternetCrackUrl function to parse the URL.
			// If the InternetCrackURL function does not parse the URL, the function returns False.
			if (InternetCrackUrl(originalUrl, originalUrl.Length, 0, ref Result))
			{
				// Only process the URL if the URL is HTTP or HTTPS.
				if (Result.nScheme == INTERNET_SCHEME_HTTP || 
					Result.nScheme == INTERNET_SCHEME_HTTPS)
				{
					// Run this code if the URL includes a user name and a password.
					if (Result.szUserName.Length > 0 || Result.szPassword.Length > 0)
					{
						if (Result.nPort == 80)
						{
							resultUrl = String.Format("{0}://{1}{2}{3}", 
								Result.szScheme, 
								Result.szHostName, 
								Result.szUrlPath, 
								Result.szExtraInfo);
						}
						else
						{
							resultUrl = String.Format("{0}://{1}:{2}{3}{4}", 
								Result.szScheme, 
								Result.szHostName, 
								Result.nPort, 
								Result.szUrlPath, 
								Result.szExtraInfo);
						}
						userName = Result.szUserName;
						password = Result.szPassword;
						ContainAuthInfo = true;
					}
				}
			}

			return ContainAuthInfo;
		}
	}
}

namespace Microsoft.Samples.BizTalk.Pipelines.CustomComponent
{
	using System;
	using System.Resources;
	using System.Drawing;
	using System.Collections;
	using System.Reflection;
	using System.ComponentModel;
	using System.Text;
	using System.IO;
	using Microsoft.BizTalk.Message.Interop;
	using Microsoft.BizTalk.Component.Interop;
	using Microsoft.XLANGs.BaseTypes;

	/// <summary>
	/// This code uses a custom pipeline component to extract the user name and the password from
	/// the HTTP URL in deprecated format. Then, the code sets the user name and the password in the message context.
	/// </summary>
	[ComponentCategory(CategoryTypes.CATID_PipelineComponent)]
	[ComponentCategory(CategoryTypes.CATID_Any)]
	[ComponentCategory(CategoryTypes.CATID_Validate)]
	[System.Runtime.InteropServices.Guid("041F4BBB-E37F-437f-9352-D761096CCF7A")]
	public class FixBTFHttp :
		IBaseComponent, 
		Microsoft.BizTalk.Component.Interop.IComponent,
		Microsoft.BizTalk.Component.Interop.IPersistPropertyBag
	{
		private static PropertyBase PropOutboundUrl = new BTS.OutboundTransportLocation();
		private static PropertyBase PropMessageType = new BTS.MessageType();

		private static PropertyBase PropHttpAuthType = new HTTP.AuthenticationScheme();
		private static PropertyBase PropHttpUsername = new HTTP.Username();
		private static PropertyBase PropHttpPassword = new HTTP.Password();

		/// <summary>
		/// </summary>
		public FixBTFHttp()
		{
		}

		#region IBaseComponent
        
		/// <summary>
		/// This code names the component.
		/// </summary>
		[Browsable(false)]
		public string Name
		{
			get {   return "FixBTFHttp Component";  }
		}
        
		/// <summary>
		/// This code sets the version of the component.
		/// </summary>
		[Browsable(false)]
		public string Version
		{
			get {   return "1.0";   }
		}
        
		/// <summary>
		/// This code sets the description of the component.
		/// </summary>
		[Browsable(false)]
		public string Description
		{
			get {   return "FixBTFHttp Pipeline Component"; }
		}
    
		#endregion
        
		#region IComponent

		/// <summary>
		/// This code implements the IComponent.Execute method.
		/// </summary>
		/// <param name="pc">Pipeline context</param>
		/// <param name="inmsg">Input message</param>
		/// <returns>Processed input message together with appended or prepended data.</returns>
		/// <remarks>
		/// The IComponent.Execute method is used to initiate
		/// the processing of the message in the pipeline component.
		/// </remarks>
		public IBaseMessage Execute(IPipelineContext pc, IBaseMessage inmsg)
		{
			IBaseMessageContext MsgContext		= null;
			object				PropertyValue   = null;

			string				OriginalUrl		= string.Empty;
			string				NewUrl			= string.Empty;
			string				Username		= string.Empty;
			string				Password		= string.Empty;
						
			MsgContext = inmsg.Context;

			// Verify that the message is a BizTalk Framework acknowledgement message.
			PropertyValue = MsgContext.Read(PropMessageType.Name.Name, PropMessageType.Name.Namespace);
			if (PropertyValue != null && (PropertyValue is string) && ((string)PropertyValue == "BTF2DeliveryReceipt"))
			{
				// Extract the outbound URL.
				PropertyValue = MsgContext.Read(PropOutboundUrl.Name.Name, PropOutboundUrl.Name.Namespace);
				if (PropertyValue != null && PropertyValue is string)
				{
					OriginalUrl = ((string) PropertyValue).Trim();
					// Verify that the URL is HTTP or HTTPS.
					if (OriginalUrl.ToLower(System.Globalization.CultureInfo.InvariantCulture).StartsWith("http"))
					{
						// Verify that the URL contains the user name and the password.
						if (UrlHelper.ParseUserPasswordFromHttpUrl (OriginalUrl, out NewUrl, out Username, out Password))
						{
							// Update the new outbound URL.
							MsgContext.Promote(PropOutboundUrl.Name.Name, PropOutboundUrl.Name.Namespace, NewUrl);
							// Set up HTTP basic authentication with the user name and the password.
							MsgContext.Write(PropHttpAuthType.Name.Name, PropHttpAuthType.Name.Namespace, "Basic");
							MsgContext.Write(PropHttpUsername.Name.Name, PropHttpUsername.Name.Namespace, Username);
							MsgContext.Write(PropHttpPassword.Name.Name, PropHttpPassword.Name.Namespace, Password);
						}
					}
				}
			}

			return inmsg;
		}
		#endregion

		#region IPersistPropertyBag
    
		/// <summary>
		/// This code obtains the class ID of the component that will be used. The code obtains the class ID from unmanaged code. 
		/// </summary>
		/// <param name="classid">Class ID of the component</param>
		public void GetClassID(out Guid classid)
		{
			classid = new System.Guid("041F4BBB-E37F-437f-9352-D761096CCF7A");
		}
        
		/// <summary>
		/// The InitNew method is not implemented. 
		/// </summary>
		public void InitNew()
		{
		}
        
		/// <summary>
		/// This code loads the configuration property for the component.
		/// </summary>
		/// <param name="pb">Configuration property bag</param>
		/// <param name="errlog">Error status. (This parameter is not used in this code.)</param>
		public void Load(Microsoft.BizTalk.Component.Interop.IPropertyBag pb, Int32 errlog)
		{
		}
        
		/// <summary>
		/// This code saves the current component configuration in the property bag.
		/// </summary>
		/// <param name="pb">Configuration property bag</param>
		/// <param name="fClearDirty">Not used</param>
		/// <param name="fSaveAllProperties">Not used</param>
		public void Save(Microsoft.BizTalk.Component.Interop.IPropertyBag pb, Boolean fClearDirty, Boolean fSaveAllProperties)
		{
		}

		#endregion
	}
}