Source code for hideinput.cs

```
using System;
```
```
using System.Collections.Generic;
```
```
using System.Text.RegularExpressions;
```
```
using System.Windows.Forms;
```
```
 
```
```
 
```
```
namespace RobvanderWoude
```
```
{
```
```
	class HideInput
```
```
	{
```
```
		static string progver = "1.03";
```
```
 
```
```
		static bool oddrow = false;
```

		public static ConsoleColor bold = ConsoleColor.White;

```
 
```
```
 
```
```
		static int Main( string[] args )
```
```
		{
```
```
			bool clearscreen = false;
```
```
			bool filter = false;
```

			FilterAction filteraction = FilterAction.Remove;

```
			string mask = null;
```
```
			int rc = 0;
```
```
 
```
```
 
```
```
			#region Command Line Parsing
```
```
 
```
```
			if ( args.Length > 0 )
```
```
			{
```
```
				foreach ( string arg in args )
```
```
				{
```

					if ( arg.Length > 1 && arg[0] == '/' )

```
					{
```

						switch ( arg[1].ToString( ).ToUpper( ) )

```
						{
```
```
							case "?":
```
```
								return ShowHelp( );
```
```
							case "C":
```
```
								if ( clearscreen )
```
```
								{
```

									return ShowHelp( "Duplicate command line switch /C" );

```
								}
```

								clearscreen = true; // No longer necessary, provided for backwards compatibility only

```
								break;
```
```
							case "F":
```
```
								if ( filter )
```
```
								{
```

									return ShowHelp( "Duplicate command line switch /F" );

```
								}
```

								if ( arg.Length > 3 && arg[2] == ':' )

```
								{
```
```
									filter = true;
```

									string action = arg.Substring( 3 );

```
									switch ( action.ToUpper( ) )
```
```
									{
```
```
										case "A":
```
```
										case "ABORT":
```

											filteraction = FilterAction.Abort;

```
											break;
```
```
										case "D":
```
```
										case "DETECT":
```
```
										case "DETECTONLY":
```

											filteraction = FilterAction.DetectOnly;

```
											break;
```
```
										case "E":
```
```
										case "END":
```
```
										case "ENDOFINPUT":
```

											filteraction = FilterAction.EndOfInput;

```
											break;
```
```
										case "R":
```
```
										case "REMOVE":
```

											filteraction = FilterAction.Remove;

```
											break;
```
```
										case "W":
```
```
										case "WHITESPACE":
```

											filteraction = FilterAction.WhiteSpace;

```
											break;
```
```
										default:
```

											return ShowHelp( "Invalid filter argument \"{0}\"", arg );

```
									}
```
```
								}
```
```
								else
```
```
								{
```

									return ShowHelp( "Invalid filter argument \"{0}\"", arg );

```
								}
```
```
								break;
```
```
							case "M":
```

								if ( !String.IsNullOrEmpty( mask ) )

```
								{
```

									return ShowHelp( "Duplicate command line switch /M" );

```
								}
```
```
								if ( arg.Length == 2 )
```
```
								{
```
```
									return HelpForMask( );
```
```
								}
```

								if ( arg.Length > 3 && arg[2] == ':' )

```
								{
```
```
									mask = arg.Substring( 3 );
```
```
								}
```
```
								else
```
```
								{
```

									return ShowHelp( "Invalid mask specification \"{0}\"", arg );

```
								}
```
```
								break;
```
```
							default:
```

								return ShowHelp( "Invalid command line argument \"{0}\"", arg );

```
						}
```
```
					}
```
```
					else
```
```
					{
```

						return ShowHelp( "Invalid command line argument \"{0}\"", arg );

```
					}
```
```
				}
```
```
			}
```
```
 
```
```
			#endregion Command Line Parsing
```
```
 
```
```
 
```
```
			#region Read Input
```
```
 
```

			// Read 1 line of input from the console

```
			string input = String.Empty;
```
```
			char key = (char) 27;
```
```
			while ( key != (char) 13 )
```
```
			{
```

				ConsoleKeyInfo keyinfo = Console.ReadKey( true );

```
				key = keyinfo.KeyChar;
```
```
				if ( key != (char) 13 )
```
```
				{
```

					input += keyinfo.KeyChar.ToString( );

```
				}
```
```
			}
```
```
 
```
```
			#endregion Read Input
```
```
 
```
```
 
```
```
			#region Clear Screen
```
```
 
```

			// Though no longer necessary for safety, this feature is provided for backwards compatibility

```
			if ( clearscreen )
```
```
			{
```
```
				Console.Clear( );
```
```
			}
```
```
 
```
```
			#endregion Clear Screen
```
```
 
```
```
 
```
```
			#region Apply Mask to Input
```
```
 
```
```
			if ( !String.IsNullOrEmpty( mask ) )
```
```
			{
```

				using ( MaskedTextBox maskedtextbox = new MaskedTextBox( mask ) )

```
				{
```
```
					maskedtextbox.Text = String.Empty;
```
```
					maskedtextbox.AppendText( input );
```
```
					input = maskedtextbox.Text;
```
```
				}
```
```
			}
```
```
 
```
```
			#endregion Apply Mask to Input
```
```
 
```
```
 
```
```
			#region Apply Filter to Output
```
```
 
```
```
			if ( filter )
```
```
			{
```

				string specialchars= @"(\^|&|\||<|>|\(|\)|\""|'|\\|%|!)";

				Regex regex = new Regex( specialchars );

```
				if ( regex.IsMatch( input ) )
```
```
				{
```
```
					rc = 3;
```
```
					switch ( filteraction )
```
```
					{
```
```
						case FilterAction.Abort:
```
```
							input = String.Empty;
```
```
							break;
```
```
						case FilterAction.DetectOnly:
```
```
							break;
```
```
						case FilterAction.EndOfInput:
```

							int pos = input.IndexOfAny( "^&|<>()\"'\\%!".ToCharArray( ) );

```
							if ( pos != -1 )
```
```
							{
```

								input = input.Substring( 0, pos );

```
							}
```
```
							break;
```
```
						case FilterAction.Remove:
```

							input = regex.Replace( input, "" );

```
							break;
```
```
						case FilterAction.WhiteSpace:
```

							input = regex.Replace( input, " " );

```
							break;
```
```
					}
```
```
				}
```
```
			}
```
```
 
```
```
			#endregion Apply Filter to Output
```
```
 
```
```
 
```

			// Display the input - which should be redirected for this program to be of any use

```
			Console.WriteLine( input );
```
```
 
```

			// Returncode 0 for success, 2 if the input was empty or whitespace only, 3 if "forbidden" characters were detected

			if ( rc != 3 && string.IsNullOrWhiteSpace( input ) )

```
			{
```
```
				rc = 2;
```
```
			}
```
```
			return rc;
```
```
		}
```
```
 
```
```
 
```
```
		public static int HelpForMask()
```
```
		{
```
```
			int col1perc = 13;
```

			Console.Error.Write( "Help for command line switch " );

```
			Console.ForegroundColor = bold;
```

			Console.Error.WriteLine( "/M:mask" );

```
			Console.ResetColor( );
```
```
			Console.Error.WriteLine( );
```
```
			Console.Error.Write( "The " );
```
```
			Console.ForegroundColor = bold;
```
```
			Console.Error.Write( "mask" );
```
```
			Console.ResetColor( );
```

			Console.Error.WriteLine( " \"language\" is based on the Masked Edit control in Visual Basic 6.0:" );

			Console.ForegroundColor = ConsoleColor.DarkGray;

			string url1 = "http://msdn.microsoft.com/en-us/library/";

			string url2 = "system.windows.forms.maskedtextbox.mask.aspx#remarksToggle";

			if ( url1.Length + url2.Length > Console.WindowWidth )

```
			{
```
```
				Console.Error.WriteLine( url1 );
```
```
				Console.Error.WriteLine( url2 );
```
```
			}
```
```
			else
```
```
			{
```

				Console.Error.WriteLine( url1 + url2 );

```
			}
```
```
			Console.ResetColor( );
```
```
			Console.Error.WriteLine( );
```

			WriteTableRow( "Masking element", "Description", col1perc, true, true );

			WriteTableRow( "0", "Digit, required. This element will accept any single digit between 0 and 9.", col1perc );

			WriteTableRow( "9", "Digit or space, optional.", col1perc );

			WriteTableRow( "#", "Digit or space, optional. If this position is blank in the mask, it will be rendered as a space in the Text property. Plus (+) and minus (-) signs are allowed.", col1perc );

			WriteTableRow( "L", "Letter, required. Restricts input to the ASCII letters a-z and A-Z. This mask element is equivalent to [a-zA-Z] in regular expressions.", col1perc );

			WriteTableRow( "?", "Letter, optional. Restricts input to the ASCII letters a-z and A-Z. This mask element is equivalent to [a-zA-Z]? in regular expressions.", col1perc );

			WriteTableRow( "&", "Character, required. Any non-control character. If ASCII only is set (/A), this element behaves like the \"A\" element.", col1perc );

			WriteTableRow( "C", "Character, optional. Any non-control character. If ASCII only is set (/A), this element behaves like the \"a\" element.", col1perc );

			WriteTableRow( "A", "Alphanumeric, required. If ASCII only is set (/A), the only characters it will accept are the ASCII letters a-z and A-Z and numbers. This mask element behaves like the \"&\" element.", col1perc );

			WriteTableRow( "a", "Alphanumeric, optional. If ASCII only is set (/A), the only characters it will accept are the ASCII letters a-z and A-Z and numbers. This mask element behaves like the \"C\" element.", col1perc );

			WriteTableRow( ".", "Decimal placeholder.", col1perc );

			WriteTableRow( ",", "Thousands placeholder.", col1perc );

			WriteTableRow( ":", "Time separator.", col1perc );

			WriteTableRow( "/", "Date separator.", col1perc );

			WriteTableRow( "$", "Currency symbol.", col1perc );

			WriteTableRow( "<", "Shift down. Converts all characters that follow to lowercase.", col1perc );

			WriteTableRow( ">", "Shift up. Converts all characters that follow to uppercase.", col1perc );

			WriteTableRow( "|", "Disable a previous shift up or shift down.", col1perc );

			WriteTableRow( @"\", "Escape. Escapes a mask character, turning it into a literal. \"\\\\\" is the escape sequence for a backslash.", col1perc );

			WriteTableRow( "All other characters", "Literals. All non-mask elements will appear as themselves within MaskedTextBox. Literals always occupy a static position in the mask at run time, and cannot be moved or deleted by the user.", col1perc );

```
 
```
```
			return 1;
```
```
		}
```
```
 
```
```
 
```

		public static int ShowHelp( params string[] errmsg )

```
		{
```
```
			#region Help Text
```
```
 
```
```
			/*
```
```
			HideInput,  Version 1.03
```

			Batch utility to read 1 line of input while hiding what's being typed

```
 
```

			Usage:   FOR /F "tokens=*" %%A IN ('HIDEINPUT  [ options ]') DO SET passwd=%%A

```
 
```

			   or:   HIDEINPUT  [ options ] > file

```
 
```

			Options: /C        Clear screen afterwards (no longer required to remove input

			                   from keyboard buffer; provided for backwards compatibility)

			         /F:action Filter special characters ^ & | < > ( ) " ' % ! and \

			                   action can be A = Abort (input is discarded), D = DetectOnly

			                   (input is left unchanged), E = EndOfInput (input is chopped

			                   at first "forbidden" character), R = Remove (remove

			                   "forbidden" characters) or W = WhiteSpace (replace

			                   "forbidden" characters with spaces)

			         /M:mask   specifies an optional mask that will be applied to the input

```
 
```

			Notes:   HIDEINPUT /M without a mask will show help for the "mask language".

			         Return code ("errorlevel") is 0 if valid input is received, 1 in case

			         of (command line) errors, 2 if input is empty or whitespace only, 3 if

			         "forbidden" characters were detected by the filter.

```
 
```
```
			Written by Rob van der Woude
```
```
			http://www.robvanderwoude.com
```
```
			*/
```
```
 
```
```
			#endregion Help Text
```
```
 
```
```
 
```
```
			#region Error Message
```
```
 
```
```
			if ( errmsg.Length > 0 )
```
```
			{
```

				List<string> errargs = new List<string>( errmsg );

```
				errargs.RemoveAt( 0 );
```
```
				Console.Error.WriteLine( );
```

				Console.ForegroundColor = ConsoleColor.Red;

```
				Console.Error.Write( "ERROR:\t" );
```

				Console.ForegroundColor = ConsoleColor.White;

				Console.Error.WriteLine( errmsg[0], errargs.ToArray( ) );

```
				Console.ResetColor( );
```
```
			}
```
```
 
```
```
			#endregion Error Message
```
```
 
```
```
 
```
```
			#region Display Help Text
```
```
 
```
```
			Console.Error.WriteLine( );
```
```
 
```

			Console.Error.WriteLine( "HideInput,  Version {0}", progver );

```
 
```

			Console.Error.WriteLine( "Batch utility to read 1 line of input while hiding what's being typed" );

```
 
```
```
			Console.Error.WriteLine( );
```
```
 
```

			Console.Error.Write( "Usage:   FOR /F \"tokens=*\" %%A IN ('" );

			Console.ForegroundColor = ConsoleColor.White;

			Console.Error.Write( "HIDEINPUT  [ options ]" );

```
			Console.ResetColor( );
```

			Console.Error.WriteLine( "') DO SET passwd=%%A" );

```
 
```
```
			Console.Error.WriteLine( );
```
```
 
```
```
			Console.Error.Write( "   or:   " );
```

			Console.ForegroundColor = ConsoleColor.White;

			Console.Error.WriteLine( "HIDEINPUT  [ options ] > file" );

```
			Console.ResetColor( );
```
```
 
```
```
			Console.Error.WriteLine( );
```
```
 
```
```
			Console.Error.Write( "Options: " );
```

			Console.ForegroundColor = ConsoleColor.White;

			Console.Error.Write( "/C        C" );

```
			Console.ResetColor( );
```

			Console.Error.WriteLine( "lear screen afterwards (no longer required to remove input" );

```
 
```

			Console.Error.WriteLine( "                   from keyboard buffer; provided for backwards compatibility)" );

```
 
```

			Console.ForegroundColor = ConsoleColor.White;

			Console.Error.Write( "         /F:action F" );

```
			Console.ResetColor( );
```

			Console.Error.WriteLine( "ilter special characters ^ & | < > ( ) \" ' % ! and \\" );

```
 
```

			Console.ForegroundColor = ConsoleColor.White;

			Console.Error.Write( "                   action" );

```
			Console.ResetColor( );
```
```
			Console.Error.Write( " can be " );
```

			Console.ForegroundColor = ConsoleColor.White;

```
			Console.Error.Write( "A" );
```
```
			Console.ResetColor( );
```

			Console.Error.Write( " = Abort (input is discarded), " );

			Console.ForegroundColor = ConsoleColor.White;

```
			Console.Error.Write( "D" );
```
```
			Console.ResetColor( );
```

			Console.Error.WriteLine( " = DetectOnly" );

```
 
```

			Console.Error.Write( "                   (input is left unchanged), " );

			Console.ForegroundColor = ConsoleColor.White;

```
			Console.Error.Write( "E" );
```
```
			Console.ResetColor( );
```

			Console.Error.WriteLine( " = EndOfInput (input is chopped" );

```
 
```

			Console.Error.Write( "                   at first \"forbidden\" character), " );

			Console.ForegroundColor = ConsoleColor.White;

```
			Console.Error.Write( "R" );
```
```
			Console.ResetColor( );
```

			Console.Error.WriteLine( " = Remove (remove" );

```
 
```

			Console.Error.Write( "                   \"forbidden\" characters) or " );

			Console.ForegroundColor = ConsoleColor.White;

```
			Console.Error.Write( "W" );
```
```
			Console.ResetColor( );
```

			Console.Error.WriteLine( " = WhiteSpace (replace" );

```
 
```

			Console.Error.WriteLine( "                   \"forbidden\" characters with spaces)" );

```
 
```

			Console.ForegroundColor = ConsoleColor.White;

			Console.Error.Write( "         /M:mask" );

```
			Console.ResetColor( );
```

			Console.Error.Write( "   specifies an optional " );

			Console.ForegroundColor = ConsoleColor.White;

```
			Console.Error.Write( "mask" );
```
```
			Console.ResetColor( );
```

			Console.Error.WriteLine( " that will be applied to the input" );

```
 
```
```
			Console.Error.WriteLine( );
```
```
 
```
```
			Console.Error.Write( "Notes:   " );
```

			Console.ForegroundColor = ConsoleColor.White;

			Console.Error.Write( "HIDEINPUT /M" );

```
			Console.ResetColor( );
```

			Console.Error.WriteLine( " without a mask will show help for the \"mask language\"." );

```
 
```

			Console.Error.WriteLine( "         Return code (\"errorlevel\") is 0 if valid input is received, 1 in case" );

```
 
```

			Console.Error.WriteLine( "         of (command line) errors, 2 if input is empty or whitespace only, 3 if" );

```
 
```

			Console.Error.WriteLine( "         \"forbidden\" characters were detected by the filter." );

```
 
```
```
			Console.Error.WriteLine( );
```
```
 
```

			Console.Error.WriteLine( "Written by Rob van der Woude" );

```
 
```

			Console.Error.WriteLine( "http://www.robvanderwoude.com" );

```
 
```
```
			#endregion Display Help Text
```
```
 
```
```
 
```
```
			return 1;
```
```
		}
```
```
 
```
```
 
```

		static void WriteTableRow( string col1text, string col2text, int col1percentage, bool col1bold = true, bool col2bold = false )

```
		{
```
```
			// Wrap text to fit in 2 columns
```
```
			oddrow = !oddrow;
```

			int windowwidth = Console.WindowWidth;

			int col1width = Convert.ToInt32( windowwidth * col1percentage / 100 );

			int col2width = windowwidth - col1width - 5; // Column separator = 4, subtract 1 extra to prevent automatic line wrap

			List<string> col1lines = new List<string>( );

			List<string> col2lines = new List<string>( );

```
			// Column 1
```
```
			if ( col1text.Length > col1width )
```
```
			{
```

				Regex regex = new Regex( @".{1," + col1width + @"}(?=\s|$)" );

```
				if ( regex.IsMatch( col1text ) )
```
```
				{
```

					MatchCollection matches = regex.Matches( col1text );

```
					foreach ( Match match in matches )
```
```
					{
```

						col1lines.Add( match.ToString( ).Trim( ) );

```
					}
```
```
				}
```
```
				else
```
```
				{
```
```
					while ( col1text.Length > 0 )
```
```
					{
```

						col1lines.Add( col1text.Trim( ).Substring( 0, Math.Min( col1width, col1text.Length ) ) );

						col1text = col1text.Substring( Math.Min( col1width, col1text.Length ) ).Trim( );

```
					}
```
```
				}
```
```
			}
```
```
			else
```
```
			{
```
```
				col1lines.Add( col1text.Trim( ) );
```
```
			}
```
```
			// Column 2
```
```
			if ( col2text.Length > col2width )
```
```
			{
```

				Regex regex = new Regex( @".{1," + col2width + @"}(?=\s|$)" );

```
				if ( regex.IsMatch( col2text ) )
```
```
				{
```

					MatchCollection matches = regex.Matches( col2text );

```
					foreach ( Match match in matches )
```
```
					{
```

						col2lines.Add( match.ToString( ).Trim( ) );

```
					}
```
```
				}
```
```
				else
```
```
				{
```
```
					while ( col2text.Length > 0 )
```
```
					{
```

						col2lines.Add( col2text.Trim( ).Substring( 0, Math.Min( col2width, col2text.Length ) ) );

						col2text = col2text.Substring( Math.Min( col2width, col2text.Length ) ).Trim( );

```
					}
```
```
				}
```
```
			}
```
```
			else
```
```
			{
```
```
				col2lines.Add( col2text.Trim( ) );
```
```
			}
```

			for ( int i = 0; i < Math.Max( col1lines.Count, col2lines.Count ); i++ )

```
			{
```
```
				if ( oddrow )
```
```
				{
```

					Console.BackgroundColor = ConsoleColor.DarkGray;

```
				}
```
```
				if ( col1bold || oddrow )
```
```
				{
```
```
					Console.ForegroundColor = bold;
```
```
				}
```

				Console.Write( "{0,-" + col1width + "}    ", ( i < col1lines.Count ? col1lines[i] : String.Empty ) );

```
				Console.ResetColor( );
```
```
				if ( oddrow )
```
```
				{
```

					Console.BackgroundColor = ConsoleColor.DarkGray;

```
				}
```
```
				if ( col2bold || oddrow )
```
```
				{
```
```
					Console.ForegroundColor = bold;
```
```
				}
```

				Console.WriteLine( "{0,-" + col2width + "}", ( i < col2lines.Count ? col2lines[i] : String.Empty ) );

```
				Console.ResetColor( );
```
```
			}
```
```
		}
```
```
	}
```
```
 
```
```
 
```
```
	public enum FilterAction
```
```
	{
```
```
		Abort,
```
```
		DetectOnly,
```
```
		EndOfInput,
```
```
		Remove,
```
```
		WhiteSpace
```
```
	}
```
```
}
```
```
 
```