PageRenderTime 71ms CodeModel.GetById 22ms RepoModel.GetById 0ms app.codeStats 1ms

/CommandLine/ADModifyMain.cs

#
C# | 3072 lines | 2468 code | 316 blank | 288 comment | 181 complexity | 2118bbae88426453d678a4c781974638 MD5 | raw file
    

  1. using System;

    2. 

  2. using System.DirectoryServices;

    3. 

  3. using ADModify.Library;

    4. 

  4. using System.Xml;

    5. 

  5. using System.IO;

    6. 

  6. using Microsoft.Win32;

    7. 

  7. 

    8. 

  8. 

    9. 

  9. namespace ADModify

    10. 

  10. {

    11. 

  11. 	

    12. 

  12. 	/// <summary>

    13. 

  13. 	/// Main is the program entry point.  In main we check for arguments and change global variables depending on what

    14. 

  14. 	/// was entered.  If we have in fact found valid attribute switches, then the GetDN method is called.  This Method

    15. 

  15. 	/// does the initial LDAP query to find the DN for all users matching the LDAP filter specified.

    16. 

  16. 	/// 

    17. 

  17. 	/// Once the have the users we test all globals for a non null value for string and a true value for boolean.  If

    18. 

  18. 	/// these test true, then we call the specified method from the ModifyAttributes class and pass all necesarry parameters.

    19. 

  19. 	/// Modification and reporting is done within the methods of the ModifyAttributes and LogFile classes.

    20. 

  20. 	/// </summary>

    21. 

  21. 	 

    22. 

  22. 

    23. 

  23. 

    24. 

  24. 	class ADModifyMain

    25. 

  25. 	{

    26. 

  26. 	

    27. 

  27. 		//public variables

    28. 

  28. 		//set all string values to null and all bool values to false

    29. 

  29. 		//later on we test these conditions and execute the modify only if string values

    30. 

  30. 		//are !null and bool values are true

    31. 

  31. 

    32. 

  32. 		public static int usercount = 0;

    33. 

  33. 		public static int querycount = 0;

    34. 

  34. 

    35. 

  35. 		//ldap settings

    36. 

  36. 		public static string servername = null;

    37. 

  37. 		public static int pageSize = 1000;

    38. 

  38. 

    39. 

  39. 		//Terminal Server Attributes

    40. 

  40. 		public static string TSProfilePath = null;

    41. 

  41. 		public static string TSFolderPath = null;

    42. 

  42. 		public static string TSHomeDrive = null;

    43. 

  43. 		public static bool TSEnable = false;

    44. 

  44. 		public static bool TSDisable = false;

    45. 

  45. 		public static bool RemoteEnable = false;

    46. 

  46. 		public static bool RemoteDisable = false;

    47. 

  47. 		public static bool RequirePermission = false;

    48. 

  48. 		public static string program = null;

    49. 

  49. 		public static string startIn = null;

    50. 

  50. 		public static bool InteractWithSession = false;

    51. 

  51. 		public static bool SetDisconnectTime = false;

    52. 

  52. 		public static int DisconnectTime;

    53. 

  53. 		public static bool SetMaxConnectionTime = false;

    54. 

  54. 		public static int MaxConnectionTime;

    55. 

  55. 		public static bool SetMaxIdleTime = false;

    56. 

  56. 		public static int MaxIdleTime;

    57. 

  57. 		public static bool SetEndSession = false;

    58. 

  58. 		public static bool EndSession = false;

    59. 

  59. 		public static bool SetOriginatingOnly = false;

    60. 

  60. 		public static bool OriginatingOnly = false;

    61. 

  61. 		public static bool SetConnectClientDrives = false;

    62. 

  62. 		public static bool ConnectClientDrives = false;

    63. 

  63. 		public static bool SetConnectClientPrinters = false;

    64. 

  64. 		public static bool ConnectClientPrinters = false;

    65. 

  65. 		public static bool SetDefaultToMainPrinter = false;

    66. 

  66. 		public static bool DefaultToMainPrinter = false;

    67. 

  67. 

    68. 

  68. 		//Exchange related attributes

    69. 

  69. 		public static bool killmail = false;

    70. 

  70. 		public static bool includeinrecipientpolicy = false;

    71. 

  71. 		public static bool excludefromrecipientpolicy = false;

    72. 

  72. 		public static bool includeinmailboxmanager = false;

    73. 

  73. 		public static bool excludefrommailboxmanager = false;

    74. 

  74. 		public static bool enablehttp = false;

    75. 

  75. 		public static bool disablehttp = false;

    76. 

  76. 		public static bool enablepop3 = false;

    77. 

  77. 		public static bool disablepop3 = false;

    78. 

  78. 		public static bool enableimap4 = false;

    79. 

  79. 		public static bool disableimap4 = false;

    80. 

  80. 		public static bool enablemapi = false;

    81. 

  81. 		public static bool disablemapi = false;

    82. 

  82. 		public static bool enablecachedmapi = false;

    83. 

  83. 		public static bool EnableOMA = false;

    84. 

  84. 		public static bool EnableUIS = false;

    85. 

  85. 		public static bool EnableUTD = false;

    86. 

  86. 		public static string smtpaddress = null;

    87. 

  87. 		public static bool setasprimary = false;

    88. 

  88. 		public static bool updatemail = false;

    89. 

  89. 		public static bool removeaddress = false;

    90. 

  90. 		public static bool keepprimary = false;

    91. 

  91. 		public static string addresstoremove = null;

    92. 

  92. 		public static bool showinaddresslists = false;

    93. 

  93. 		public static bool hidefromaddresslists = false;

    94. 

  94. 		public static bool SetMailboxRights = false;

    95. 

  95. 		public static bool ClearMailboxRights = false;

    96. 

  96. 		public static bool FixSendAs = false;

    97. 

  97. 		public static bool GrantSelfAEA = false;

    98. 

  98. 		public static bool RemoveAEAFromSelf = false;

    99. 

  99. 		public static bool RemoveSendAs = false;

    100. 

  100. 		public static bool GrantSelfFullAndRead = false;

    101. 

  101. 		public static bool RemoveSelfFullAndRead = false;

    102. 

  102. 		public static bool DumpMailboxRights = false;

    103. 

  103. 

    104. 

  104. 		//User Account Settings

    105. 

  105. 		public static bool disableaccount = false;

    106. 

  106. 		public static bool enableaccount = false;

    107. 

  107.         public static bool PasswordNotRequired = false;

    108. 

  108.         public static bool SetPasswordNotRequired = false;

    109. 

  109. 		public static bool SetPasswordNeverExpires = false;

    110. 

  110. 		public static bool PasswordNeverExpires = false;

    111. 

  111. 		public static bool MustChangePasswd = false;

    112. 

  112. 		public static bool SetMustChangePassword = false;

    113. 

  113. 		public static bool CannotChangePasswd = false;

    114. 

  114. 		public static bool SetCannotChangePassword = false;

    115. 

  115. 		public static bool UseReversibleEncryption = false;

    116. 

  116. 		public static bool SetUseReversibleEncryption = false;

    117. 

  117. 		public static bool SetRequireSmartCard = false;

    118. 

  118. 		public static bool RequireSmartCard = false;

    119. 

  119. 		public static bool SetCannotBeDelegated = false;

    120. 

  120. 		public static bool CannotBeDelegated = false;

    121. 

  121. 		public static bool SetUseDESEncryption = false;

    122. 

  122. 		public static bool UseDESEncryption = false;

    123. 

  123. 		public static bool SetDoNotRequireKerberosPreAuth = false;

    124. 

  124. 		public static bool DoNotRequireKerberosPreAuth = false;

    125. 

  125. 		public static bool AddMembersToGroup = false;

    126. 

  126. 		public static bool SetAccountExpires = false;

    127. 

  127. 		public static string ExpireTime = null;

    128. 

  128. 		public static bool RemoveMembersFromGroup = false;

    129. 

  129. 		public static string DNOfGroup = null;

    130. 

  130. 		public static bool ModifyRDN = false;

    131. 

  131. 		public static string NewRDN = null;

    132. 

  132. 		

    133. 

  133. 		//Permissions Settings

    134. 

  134. 		public static bool Setallowinheritable = false;

    135. 

  135. 		public static bool AllowInheritable = false;

    136. 

  136. 		public static bool DumpDacl = false;

    137. 

  137. 		public static bool DumpDaclInheritance = false;

    138. 

  138. 

    139. 

  139. 		//custom attribute set

    140. 

  140. 		public static string customAttributeName = null;

    141. 

  141. 		public static string customAttributeValue = null;

    142. 

  142. 		public static bool multi = false;

    143. 

  143. 		public static bool remove = false;

    144. 

  144. 		

    145. 

  145. 

    146. 

  146. 		//undo mode

    147. 

  147. 		public static bool UndoMode = false;

    148. 

  148. 		public static string logFileName = null;

    149. 

  149. 

    150. 

  150. 		//mailbox rights

    151. 

  151. 		public static bool GrantSendAsRights = false;

    152. 

  152. 		public static bool ImportMailboxRights = false;

    153. 

  153. 		public static bool ModifyMailboxRights = false;

    154. 

  154. 		public static bool RemoveMailboxRights = false;

    155. 

  155. 		public static string Trustee = null;

    156. 

  156. 		public static string Permission = null;

    157. 

  157. 		public static bool Deny = false;

    158. 

  158. 		public static bool MailboxRightsOverwrite = false;

    159. 

  159. 

    160. 

  160. 		//timer

    161. 

  161. 		public static float timeElapsed = 0;

    162. 

  162. 

    163. 

  163. 		//progress bar

    164. 

  164. 		public static int UserCountDividedWhole;

    165. 

  165. 		public static float UserCountDividedDecimalCount;

    166. 

  166. 		public static float UserCountDividedDecimalCountConst;

    167. 

  167. 		public static int dots;

    168. 

  168. 

    169. 

  169. 

    170. 

  170. 

    171. 

  171. 		/// <summary>

    172. 

  172. 		/// 

    173. 

  173. 		/// ADModifyMain::GetDN

    174. 

  174. 		/// 

    175. 

  175. 		/// Accepts:

    176. 

  176. 		///		logWriter - Handle to Writer object for logging

    177. 

  177. 		///		LDAPFilter - the LDAP filter used for object search 

    178. 

  178. 		///		SearchBase - the DN to begin the query

    179. 

  179. 		///		subtree - boolean specifies either onelevel or subtree

    180. 

  180. 		/// 

    181. 

  181. 		/// Returns:

    182. 

  182. 		///		none

    183. 

  183. 		/// 

    184. 

  184. 		/// GetDN accepts the Search Base, Scope, and LDAP Filter from args.

    185. 

  185. 		/// GetDN runs the query and returns the list of users that match.

    186. 

  186. 		/// At that point we test all public variables.  If a value other than the default

    187. 

  187. 		/// is set, we call ADModify!ModifyAttributes::*  to modify the object and pass all

    188. 

  188. 		/// appropriate arguments.

    189. 

  189. 		/// </summary>

    190. 

  190. 

    191. 

  191. 		static void GetDN(XmlWriter logWriter, string LDAPFilter, bool subtree, string SearchBase)

    192. 

  192. 		{

    193. 

  193. 

    194. 

  194. 			//Before doing anything, verify the server and base DN entered are valid

    195. 

  195. 			if(servername!=null)

    196. 

  196. 			{

    197. 

  197. 				try

    198. 

  198. 				{

    199. 

  199. 					//do this to test if we can even connect to the server

    200. 

  200. 					DirectoryEntry ent = new DirectoryEntry("LDAP://" + servername + "/" + SearchBase);

    201. 

  201. 					string myTempVar = ent.Parent.ToString();	//if the servername is invalid, this line will raise an exception

    202. 

  202. 					ent.Dispose();

    203. 

  203. 				}

    204. 

  204. 				catch(System.Exception caught)

    205. 

  205. 				{

    206. 

  206. 					if(caught.Message=="The server is not operational")

    207. 

  207. 					{

    208. 

  208. 						

    209. 

  209. 						Console.WriteLine("\nAn error has occurred connecting to server " + servername + ".");

    210. 

  210. 						Console.WriteLine("The error was: " + caught.Message + "\n");

    211. 

  211. 						

    212. 

  212. 					}

    213. 

  213. 					else if(caught.Message=="A referral was returned from the server" || caught.Message=="There is no such object on the server")

    214. 

  214. 					{

    215. 

  215. 						

    216. 

  216. 						Console.WriteLine("\nAn error has occured binding to Base DN " + SearchBase + ".");

    217. 

  217. 						Console.WriteLine("The error was: " + caught.Message + ".");

    218. 

  218. 						Console.WriteLine("Please enter a valid Base DN.\n");

    219. 

  219. 						

    220. 

  220. 					}

    221. 

  221. 					else

    222. 

  222. 					{

    223. 

  223. 						

    224. 

  224. 						Console.WriteLine("\nAn error has occurred binding to Active Directory.");

    225. 

  225. 						Console.WriteLine("The error was: " + caught.Message + "\n");

    226. 

  226. 						

    227. 

  227. 					}

    228. 

  228. 					return;

    229. 

  229. 				}

    230. 

  230. 			}

    231. 

  231. 

    232. 

  232. 			//Initialize the log file

    233. 

  233. 			LogFile log = new LogFile();

    234. 

  234. 

    235. 

  235. 			//Check for mailbox rights dump mode and create logfile if necesarry

    236. 

  236. 			XmlTextWriter DumpWriter = null;

    237. 

  237. 			if(DumpMailboxRights)

    238. 

  238. 			{

    239. 

  239. 				if(File.Exists("mbxrights.xml"))

    240. 

  240. 				{

    241. 

  241. 					

    242. 

  242. 					Console.WriteLine("\nThe file mbxrights.xml already exists.  You must remove or rename this file before you can proceed.\n");

    243. 

  243. 					return;

    244. 

  244. 				}

    245. 

  245. 				DumpWriter = new XmlTextWriter("mbxrights.xml", null);

    246. 

  246. 				DumpWriter.WriteStartElement("MailboxRights");

    247. 

  247. 			}

    248. 

  248. 			

    249. 

  249. 						

    250. 

  250. 			//get OS version to determine supportability of TS modifications

    251. 

  251.             //string OSVersionFull = System.Environment.OSVersion.ToString();

    252. 

  252.             //string OSVersion = OSVersionFull.Substring(OSVersionFull.Length - 10, 10);

    253. 

  253.             //int OSVersionNoDots = Convert.ToInt32(OSVersion.Replace(".",""),10);

    254. 

  254. 

    255. 

  255.             //Check for Win2k3 so we know whether to enable terminal services options

    256. 

  256. 			//get OS build to determine supportability of TS modifications

    257. 

  257.             //TODO: When longhorn releases we need to add their build number to this check

    258. 

  258. 

    259. 

  259.             System.OperatingSystem osInfo = System.Environment.OSVersion;

    260. 

  260. 

    261. 

  261.             //First things first... check for TS attributes.  If there are any, check OS version before proceeding.

    262. 

  262. 			if(TSProfilePath!=null | program!=null | startIn!=null | TSFolderPath!=null | TSHomeDrive!=null | TSEnable | TSDisable | RemoteEnable | RemoteDisable | SetDisconnectTime | SetMaxConnectionTime | SetMaxIdleTime | SetEndSession | SetOriginatingOnly | SetConnectClientDrives | SetConnectClientPrinters | SetDefaultToMainPrinter)

    263. 

  263. 			{

    264. 

  264.                 if (osInfo.Version.Build != 3790)

    265. 

  265. 				{

    266. 

  266. 					Console.WriteLine("Operating System must be at build 5.2.3790.0 or later to support this operation.\nCurrent OS build: " + osInfo.VersionString + "\n");

    267. 

  267. 					return;

    268. 

  268. 				}

    269. 

  269. 			}

    270. 

  270. 

    271. 

  271. 			//Also check for CDOEXM attributes.  If there are any, make sure Exchange is installed.

    272. 

  272. 			if(FixSendAs || GrantSelfAEA || RemoveAEAFromSelf || GrantSelfFullAndRead || RemoveSelfFullAndRead || DumpMailboxRights || ImportMailboxRights || ModifyMailboxRights || RemoveMailboxRights)

    273. 

  273. 			{

    274. 

  274. 				RegistryKey myRegKey = Registry.LocalMachine;

    275. 

  275. 				RegistryKey mySubKey = myRegKey.OpenSubKey("Software\\Microsoft\\Exchange\\Setup");

    276. 

  276. 				string ExchangeVersion = mySubKey.GetValue("NewestBuild").ToString();

    277. 

  277. 				int ExchangeVersionInt = Convert.ToInt32(ExchangeVersion,10);

    278. 

  278. 				if(ExchangeVersionInt<4417)

    279. 

  279. 				{

    280. 

  280. 					Console.WriteLine("Exchange Server must be installed and must be at build 4417 or later to support this modification.\nCurrent Exchange Build: " + ExchangeVersion + "\n");

    281. 

  281. 					return;

    282. 

  282. 				}

    283. 

  283. 

    284. 

  284. 			}

    285. 

  285. 

    286. 

  286. 			//bind to AD using the SearchBase specified by the user					

    287. 

  287. 			DirectoryEntry de = new DirectoryEntry("LDAP://" + SearchBase);

    288. 

  288. 

    289. 

  289. 			//set searcher object with our LDAP filter

    290. 

  290. 			DirectorySearcher src = new DirectorySearcher(LDAPFilter);

    291. 

  291. 			src.SearchRoot = de;

    292. 

  292. 			

    293. 

  293. 			//set our search scope

    294. 

  294. 			if(subtree)

    295. 

  295. 				src.SearchScope = SearchScope.Subtree;

    296. 

  296. 			else

    297. 

  297. 				src.SearchScope = SearchScope.OneLevel;

    298. 

  298. 

    299. 

  299. 			//Other settings for search 

    300. 

  300. 			src.PageSize = pageSize;

    301. 

  301. 			src.PropertiesToLoad.Add("distinguishedName");

    302. 

  302. 

    303. 

  303. 			SearchResultCollection results = null;

    304. 

  304. 

    305. 

  305. 			//execute the query

    306. 

  306. 			try

    307. 

  307. 			{

    308. 

  308. 				results = src.FindAll();

    309. 

  309. 			}

    310. 

  310. 			catch(System.Exception caught)

    311. 

  311. 			{

    312. 

  312. 				Console.WriteLine("An error occured while executing the query.  The error was: {0}", caught.Message + "\n");

    313. 

  313. 				return;

    314. 

  314. 			}

    315. 

  315. 				

    316. 

  316. 			

    317. 

  317. 			

    318. 

  318. 			Console.WriteLine("\nIssuing Query....\n");

    319. 

  319. 			if(results.Count == 1)

    320. 

  320. 			{

    321. 

  321. 				Console.WriteLine("1 item found matching the specified filter.");

    322. 

  322. 			}

    323. 

  323. 			if(results.Count >= 2)

    324. 

  324. 			{

    325. 

  325. 				Console.WriteLine(results.Count + " items found matching the specified filter.");

    326. 

  326. 			}

    327. 

  327. 			if(results.Count == 0)

    328. 

  328. 			{

    329. 

  329. 				Console.WriteLine("No items found matching the specified filter.\n");

    330. 

  330. 				return;

    331. 

  331. 			}

    332. 

  332. 			Console.WriteLine("");

    333. 

  333. 			

    334. 

  334. 			//for progress bar

    335. 

  335. 			float UserCountDivided = 50/(float)results.Count;	//this number remains constant

    336. 

  336. 			float UserCountDividedTemp = UserCountDivided;		//this number we increment

    337. 

  337. 			dots = 0;	//number of dots shown so far on progress bar

    338. 

  338. 			UserCountDividedWhole = 0;	 //number on left side of decimal to increment

    339. 

  339. 			UserCountDividedDecimalCount = 0;	//number on right side of decimal to increment

    340. 

  340. 			UserCountDividedDecimalCountConst = 0;	//number on right side of decimal, stays contstant

    341. 

  341. 			string UserCountDividedDecimalCountString = null;

    342. 

  342. 			string[] UserCountDividedString = UserCountDivided.ToString().Split('.');	//split at the decimal

    343. 

  343. 

    344. 

  344. 			//calculate the whole and decimal increment counters

    345. 

  345. 			UserCountDividedWhole = Convert.ToInt16(UserCountDividedString[0],10);	//grab the whole number on the left

    346. 

  346. 			if(UserCountDividedString.GetUpperBound(0) == 1)

    347. 

  347. 			{

    348. 

  348. 				UserCountDividedDecimalCountString = UserCountDividedString[1].Replace(".", "");

    349. 

  349. 				UserCountDividedDecimalCountString = "." + UserCountDividedDecimalCountString;

    350. 

  350. 				UserCountDividedDecimalCount = float.Parse(UserCountDividedDecimalCountString);

    351. 

  351. 			}

    352. 

  352. 			else

    353. 

  353. 			{

    354. 

  354. 				UserCountDividedDecimalCount = 0;

    355. 

  355. 			}

    356. 

  356. 

    357. 

  357. 			UserCountDividedDecimalCountConst = UserCountDividedDecimalCount;

    358. 

  358. 

    359. 

  359. 			Console.WriteLine("");

    360. 

  360. 			Console.WriteLine("0%                      50%                     100%");

    361. 

  361. 			Console.WriteLine("|----|----|----|----|----|----|----|----|----|----|");

    362. 

  362. 			Console.Write(".");

    363. 

  363. 			dots++;

    364. 

  364. 					

    365. 

  365. 

    366. 

  366. 			//increment the user count

    367. 

  367. 			usercount++;

    368. 

  368. 

    369. 

  369. 			ModifyAttributes admod = new ModifyAttributes();  //from ADModify.Library.dll

    370. 

  370. 			string UserDN;

    371. 

  371. 

    372. 

  372. 			//iterate the query results

    373. 

  373. 			for(int modusers=0; modusers<=results.Count-1; modusers++)

    374. 

  374. 			{

    375. 

  375. 	

    376. 

  376. 				if(dots<=50)		//just to be safe, make sure we're under out dots quota so we don't

    377. 

  377. 				{					//exceed the 100% mark

    378. 

  378. 					for(int b=0; b<= UserCountDividedWhole-1; b++)

    379. 

  379. 					{

    380. 

  380. 						if(dots<=50)

    381. 

  381. 						{

    382. 

  382. 							Console.Write(".");

    383. 

  383. 							dots++;

    384. 

  384. 						}

    385. 

  385. 					}

    386. 

  386. 					if(UserCountDividedDecimalCount>=1)

    387. 

  387. 					{

    388. 

  388. 						if(dots<=50)

    389. 

  389. 						{

    390. 

  390. 							UserCountDividedDecimalCount--;

    391. 

  391. 							Console.Write(".");

    392. 

  392. 							dots++;

    393. 

  393. 						}

    394. 

  394. 					}

    395. 

  395. 					UserCountDividedDecimalCount = UserCountDividedDecimalCount + UserCountDividedDecimalCountConst;

    396. 

  396. 				}

    397. 

  397. 

    398. 

  398. 				if(modusers==results.Count-1 & dots < 51)	//sometimes the decimal math doesn't leave us with a

    399. 

  399. 				{											//51st dot so we have to add it ourselves.

    400. 

  400. 					Console.Write(".");

    401. 

  401. 				}

    402. 

  402. 				if(modusers==results.Count-1)	//finish off the progress bar

    403. 

  403. 				{

    404. 

  404. 					Console.WriteLine("");

    405. 

  405. 					Console.WriteLine("");

    406. 

  406. 				}

    407. 

  407. 

    408. 

  408. 				UserDN = results[modusers].Path;

    409. 

  409. 				string UserDNWithLDAP = UserDN;

    410. 

  410. 				string UserDNWithoutLDAP = UserDNWithLDAP.Remove(0, 7); //trim the LDAP:// off the name in case we need to append servername

    411. 

  411. 					

    412. 

  412. 				//check for servername.  If its null we just pass UserDN as UserDNWithLDAP.  

    413. 

  413. 				//If it has a value we append it and add the LDAP:// back

    414. 

  414. 				if(servername==null)

    415. 

  415. 				{

    416. 

  416. 					UserDN = UserDNWithLDAP;

    417. 

  417. 				}

    418. 

  418. 				else

    419. 

  419. 				{

    420. 

  420. 					UserDN = "LDAP://" + servername + "/" + UserDNWithoutLDAP;

    421. 

  421. 				}

    422. 

  422. 

    423. 

  423. 				//test each public variable for a value, if a value other than null exists for string values or 

    424. 

  424. 				//a true value exists for boolean values then we loop the users through the applicable methods

    425. 

  425. 

    426. 

  426. 

    427. 

  427. 				//Terminal Server Attributes

    428. 

  428. 				if(TSProfilePath!=null)

    429. 

  429. 				{

    430. 

  430. 					admod.TSChangeTermServProfile(logWriter, UserDN, TSProfilePath);

    431. 

  431. 				}	

    432. 

  432. 				if(TSFolderPath!=null & TSHomeDrive==null)

    433. 

  433. 				{

    434. 

  434. 					admod.TSChangeTermServFolder(logWriter, UserDN, TSFolderPath);

    435. 

  435. 				}

    436. 

  436. 				if(TSHomeDrive!=null)

    437. 

  437. 				{

    438. 

  438. 					admod.TSChangeTermServDrive(logWriter, UserDN, TSHomeDrive, TSFolderPath);

    439. 

  439. 				}

    440. 

  440. 				if(TSEnable)

    441. 

  441. 				{

    442. 

  442. 					admod.TSEnableLogon(logWriter, UserDN);

    443. 

  443. 				}

    444. 

  444. 				if(TSDisable)

    445. 

  445. 				{

    446. 

  446. 					admod.TSDisableLogon(logWriter, UserDN);

    447. 

  447. 				}

    448. 

  448. 				if(RemoteEnable)

    449. 

  449. 				{

    450. 

  450. 					admod.TSAllowRemoteControl(logWriter, UserDN, RequirePermission, InteractWithSession);

    451. 

  451. 				}

    452. 

  452. 				if(RemoteDisable)

    453. 

  453. 				{

    454. 

  454. 					admod.TSDisableRemoteControl(logWriter, UserDN);

    455. 

  455. 				}

    456. 

  456. 				if(SetDisconnectTime)

    457. 

  457. 				{

    458. 

  458. 					admod.TSMaxDisconnectedSessionTime(logWriter, UserDN, DisconnectTime);

    459. 

  459. 				}

    460. 

  460. 				if(program!=null)

    461. 

  461. 				{

    462. 

  462. 					admod.TSRunProgramAtStartup(logWriter, UserDN, program);

    463. 

  463. 				}

    464. 

  464. 				if(startIn!=null)

    465. 

  465. 				{

    466. 

  466. 					admod.TSRunProgramAtStartupStartIn(logWriter, UserDN, startIn);

    467. 

  467. 				}

    468. 

  468. 				if(SetMaxConnectionTime)

    469. 

  469. 				{

    470. 

  470. 					admod.TSMaxConnectionTime(logWriter, UserDN, MaxConnectionTime);

    471. 

  471. 				}

    472. 

  472. 				if(SetMaxIdleTime)

    473. 

  473. 				{

    474. 

  474. 					admod.TSMaxIdleTime(logWriter, UserDN, MaxIdleTime);

    475. 

  475. 				}

    476. 

  476. 				if(SetEndSession)

    477. 

  477. 				{

    478. 

  478. 					admod.TSEndSessionAction(logWriter, UserDN, EndSession);

    479. 

  479. 				}

    480. 

  480. 				if(SetOriginatingOnly)

    481. 

  481. 				{

    482. 

  482. 					admod.TSAllowReconnectAction(logWriter, UserDN, OriginatingOnly);

    483. 

  483. 				}

    484. 

  484. 				if(SetConnectClientDrives)

    485. 

  485. 				{

    486. 

  486. 					admod.TSConnectClientDrivesAtLogon(logWriter, UserDN, ConnectClientDrives);

    487. 

  487. 				}

    488. 

  488. 				if(SetConnectClientPrinters)

    489. 

  489. 				{

    490. 

  490. 					admod.TSConnectClientPrintersAtLogon(logWriter, UserDN, ConnectClientPrinters);

    491. 

  491. 				}

    492. 

  492. 				if(SetDefaultToMainPrinter)

    493. 

  493. 				{

    494. 

  494. 					admod.TSDefaultToMainPrinter(logWriter, UserDN, DefaultToMainPrinter);

    495. 

  495. 				}

    496. 

  496. 				//Exchange Related Attributes

    497. 

  497. 				if(showinaddresslists)

    498. 

  498. 				{

    499. 

  499. 					admod.ShowInAddressLists(logWriter, UserDN);

    500. 

  500. 				}

    501. 

  501. 				if(hidefromaddresslists)

    502. 

  502. 				{

    503. 

  503. 					admod.HideFromAddressLists(logWriter, UserDN);

    504. 

  504. 				}

    505. 

  505. 				if(killmail)

    506. 

  506. 				{

    507. 

  507. 					admod.KillMail(logWriter, UserDN);

    508. 

  508. 				}

    509. 

  509. 				if(includeinrecipientpolicy)

    510. 

  510. 				{

    511. 

  511. 					admod.IncludeInRecipientPolicy(logWriter, UserDN);

    512. 

  512. 				}

    513. 

  513. 				if(excludefromrecipientpolicy)

    514. 

  514. 				{

    515. 

  515. 					admod.ExcludeFromRecipientPolicy(logWriter, UserDN);

    516. 

  516. 				}

    517. 

  517. 				if(includeinmailboxmanager)

    518. 

  518. 				{

    519. 

  519. 					admod.IncludeInMailboxManager(logWriter, UserDN);

    520. 

  520. 				}

    521. 

  521. 				if(excludefrommailboxmanager)

    522. 

  522. 				{

    523. 

  523. 					admod.ExcludeFromMailboxManager(logWriter, UserDN);

    524. 

  524. 				}

    525. 

  525. 				if(enablehttp)

    526. 

  526. 				{

    527. 

  527. 					admod.EnableHTTP(logWriter, UserDN);

    528. 

  528. 				}

    529. 

  529. 				if(disablehttp)

    530. 

  530. 				{

    531. 

  531. 					admod.DisableHTTP(logWriter, UserDN);

    532. 

  532. 				}

    533. 

  533. 				if(enablepop3)

    534. 

  534. 				{

    535. 

  535. 					admod.EnablePOP3(logWriter, UserDN);

    536. 

  536. 				}

    537. 

  537. 				if(disablepop3)

    538. 

  538. 				{

    539. 

  539. 					admod.DisablePOP3(logWriter, UserDN);

    540. 

  540. 				}

    541. 

  541. 				if(enableimap4)

    542. 

  542. 				{

    543. 

  543. 					admod.EnableIMAP4(logWriter, UserDN);

    544. 

  544. 				}

    545. 

  545. 				if(disableimap4)

    546. 

  546. 				{

    547. 

  547. 					admod.DisableIMAP4(logWriter, UserDN);

    548. 

  548. 				}

    549. 

  549. 				if(enablemapi)

    550. 

  550. 				{

    551. 

  551. 					admod.ChangeMAPISettings(logWriter, UserDN, "MAPI§1§0§§§§§§");

    552. 

  552. 				}

    553. 

  553. 				if(disablemapi)

    554. 

  554. 				{

    555. 

  555. 					admod.ChangeMAPISettings(logWriter, UserDN, "MAPI§0§0§§§§§§");

    556. 

  556. 				}

    557. 

  557. 				if(enablecachedmapi)

    558. 

  558. 				{

    559. 

  559. 					admod.ChangeMAPISettings(logWriter, UserDN, "MAPI§1§1§§§§§§");

    560. 

  560. 				}					

    561. 

  561. 				if(smtpaddress!=null)

    562. 

  562. 				{

    563. 

  563. 					admod.SetSMTPAddress(logWriter, UserDN, smtpaddress, setasprimary);

    564. 

  564. 				}

    565. 

  565. 				if(updatemail==true)

    566. 

  566. 				{

    567. 

  567. 					admod.SetCustomAttribute(logWriter, UserDN, "mail", smtpaddress, false, false);

    568. 

  568. 				}

    569. 

  569. 				if(removeaddress)

    570. 

  570. 				{

    571. 

  571. 					if(keepprimary)

    572. 

  572. 					{

    573. 

  573. 						admod.RemoveEmailAddress(logWriter, UserDN, addresstoremove, true);

    574. 

  574. 					}

    575. 

  575. 					else

    576. 

  576. 					{

    577. 

  577. 						admod.RemoveEmailAddress(logWriter, UserDN, addresstoremove, false);

    578. 

  578. 					}

    579. 

  579. 				}

    580. 

  580. 				if(SetMailboxRights)

    581. 

  581. 				{

    582. 

  582. 					admod.SetmsExchMailboxSecurityDescriptor(logWriter, UserDN);

    583. 

  583. 				}

    584. 

  584. 				if(GrantSendAsRights)

    585. 

  585. 				{

    586. 

  586. 					admod.AddSendAs(logWriter, UserDN, Trustee, Deny);

    587. 

  587. 				}

    588. 

  588. 				if(FixSendAs)

    589. 

  589. 				{

    590. 

  590. 					admod.GiveSendAsToUsersWithFullMBXAccess(logWriter, UserDN);

    591. 

  591. 				}

    592. 

  592. 				if(RemoveSendAs)

    593. 

  593. 				{

    594. 

  594. 					admod.RemoveSendAsFromUsersWithFullMBXAccess(logWriter, UserDN);

    595. 

  595. 				}

    596. 

  596. 				if(GrantSelfAEA)

    597. 

  597. 				{

    598. 

  598. 					admod.SetSelfAsAssociatedExternalAccount(logWriter, UserDN);

    599. 

  599. 				}

    600. 

  600. 				if(RemoveAEAFromSelf)

    601. 

  601. 				{

    602. 

  602. 					admod.RemoveAssociatedExternalAccountFromSelf(logWriter, UserDN);

    603. 

  603. 				}

    604. 

  604. 				if(GrantSelfFullAndRead)

    605. 

  605. 				{

    606. 

  606. 					admod.GrantSelfFullMailboxAccessAndRead(logWriter, UserDN);

    607. 

  607. 				}

    608. 

  608. 				if(RemoveSelfFullAndRead)

    609. 

  609. 				{

    610. 

  610. 					admod.RemoveFullMailboxAccessAndReadFromSelf(logWriter, UserDN);

    611. 

  611. 				}

    612. 

  612. 				if(DumpMailboxRights)

    613. 

  613. 				{

    614. 

  614. 					admod.DumpMailboxRights(logWriter, DumpWriter, UserDN);

    615. 

  615. 				}

    616. 

  616. 				if(ModifyMailboxRights)

    617. 

  617. 				{

    618. 

  618. 					admod.AddACEToMailboxRights(logWriter, UserDN, Trustee, Permission, Deny);

    619. 

  619. 				}

    620. 

  620. 				if(RemoveMailboxRights)

    621. 

  621. 				{

    622. 

  622. 					admod.RemoveACEFromMailboxRights(logWriter, UserDN, Trustee, Permission, Deny);

    623. 

  623. 				}

    624. 

  624. 

    625. 

  625. 

    626. 

  626. 				//User Account Settings

    627. 

  627. 				if(disableaccount)

    628. 

  628. 				{

    629. 

  629. 					admod.DisableAccount(logWriter, UserDN);

    630. 

  630. 				}

    631. 

  631. 				if(enableaccount)

    632. 

  632. 				{

    633. 

  633. 					admod.EnableAccount(logWriter, UserDN);

    634. 

  634. 				}

    635. 

  635.                 if (SetPasswordNotRequired & PasswordNotRequired)

    636. 

  636.                 {

    637. 

  637.                     admod.SetPasswordNotRequired(logWriter, UserDN);

    638. 

  638.                 }

    639. 

  639.                 if (SetPasswordNotRequired & !PasswordNotRequired)

    640. 

  640.                 {

    641. 

  641.                     admod.DisablePasswordNotRequired(logWriter, UserDN);

    642. 

  642.                 }

    643. 

  643. 				if(SetPasswordNeverExpires)

    644. 

  644. 				{

    645. 

  645. 					admod.SetPasswordNeverExpires(logWriter, UserDN, PasswordNeverExpires);

    646. 

  646. 				}

    647. 

  647. 				if(SetMustChangePassword)

    648. 

  648. 				{

    649. 

  649. 					admod.MustChangePassword(logWriter, UserDN, MustChangePasswd);

    650. 

  650. 				}

    651. 

  651. 				if(SetCannotChangePassword)

    652. 

  652. 				{

    653. 

  653. 					admod.CannotChangePassword(logWriter, UserDN, CannotChangePasswd);

    654. 

  654. 				}

    655. 

  655. 				if(SetUseReversibleEncryption)

    656. 

  656. 				{

    657. 

  657. 					admod.StorePasswordWithReversibleEncryption(logWriter, UserDN, UseReversibleEncryption);

    658. 

  658. 				}

    659. 

  659. 				if(SetRequireSmartCard)

    660. 

  660. 				{

    661. 

  661. 					admod.SetRequireSmartCard(logWriter, UserDN, RequireSmartCard);

    662. 

  662. 				}

    663. 

  663. 				if(SetCannotBeDelegated)

    664. 

  664. 				{

    665. 

  665. 					admod.SetCannotBeDelegated(logWriter, UserDN, CannotBeDelegated);

    666. 

  666. 				}

    667. 

  667. 				if(SetUseDESEncryption)

    668. 

  668. 				{

    669. 

  669. 					admod.SetUseDESEncryption(logWriter, UserDN, UseDESEncryption);

    670. 

  670. 				}

    671. 

  671. 				if(SetDoNotRequireKerberosPreAuth)

    672. 

  672. 				{

    673. 

  673. 					admod.SetDoNotRequireKerberosPreAuth(logWriter, UserDN, DoNotRequireKerberosPreAuth);

    674. 

  674. 				}

    675. 

  675. 				if(AddMembersToGroup)

    676. 

  676. 				{

    677. 

  677. 					admod.AddToGroup(logWriter, UserDN, DNOfGroup);

    678. 

  678. 				}

    679. 

  679. 				if(RemoveMembersFromGroup)

    680. 

  680. 				{

    681. 

  681. 					admod.RemoveFromGroup(logWriter, UserDN, DNOfGroup);

    682. 

  682. 				}

    683. 

  683. 				if(ModifyRDN)

    684. 

  684. 				{

    685. 

  685. 					admod.SetRelativeDistinguishedName(logWriter, UserDN, NewRDN);

    686. 

  686. 				}

    687. 

  687. 

    688. 

  688. 

    689. 

  689. 				//Permissions Settings

    690. 

  690. 				if(Setallowinheritable)

    691. 

  691. 				{

    692. 

  692. 					admod.AllowInheritablePermissions(logWriter, UserDN, AllowInheritable);

    693. 

  693. 				}

    694. 

  694. 

    695. 

  695. 

    696. 

  696. 				//custom attribute set

    697. 

  697. 				if(customAttributeName!=null)

    698. 

  698. 				{

    699. 

  699. 					admod.SetCustomAttribute(logWriter, UserDN, customAttributeName, customAttributeValue, multi, remove);

    700. 

  700. 				}

    701. 

  701. 

    702. 

  702. 

    703. 

  703. 			}

    704. 

  704. 

    705. 

  705. 			//finish up

    706. 

  706. 			if(DumpMailboxRights)

    707. 

  707. 			{

    708. 

  708. 				DumpWriter.WriteEndElement();

    709. 

  709. 				DumpWriter.Flush();

    710. 

  710. 				DumpWriter.Close();

    711. 

  711. 			}

    712. 

  712. 			log.showResults();

    713. 

  713. 			src.Dispose();

    714. 

  714. 			return;

    715. 

  715. 			

    716. 

  716. 		}

    717. 

  717. 

    718. 

  718. 

    719. 

  719. 

    720. 

  720. 

    721. 

  721. 

    722. 

  722. 

    723. 

  723. 

    724. 

  724. 			

    725. 

  725. 		/// <summary>

    726. 

  726. 		/// ADModifyMain::GiveCommandArgs

    727. 

  727. 		/// 

    728. 

  728. 		/// Accepts:

    729. 

  729. 		///		none

    730. 

  730. 		///	Returns:

    731. 

  731. 		///		none

    732. 

  732. 		///		

    733. 

  733. 		///	Displays command line usage back to the console.

    734. 

  734. 		/// </summary>

    735. 

  735. 		static void GiveCommandArgs()

    736. 

  736. 		{

    737. 

  737. 			Console.WriteLine("");

    738. 

  738. 			Console.WriteLine("Active Directory Bulk Modify Tool Command Line Version 2.1");

    739. 

  739. 			Console.WriteLine("");

    740. 

  740. 			Console.WriteLine("Questions or Comments?  ");

    741. 

  741. 			Console.WriteLine("Email: admodify@microsoft.com");

    742. 

  742. 			Console.WriteLine("");

    743. 

  743. 			Console.WriteLine("ADModCmd runs an LDAP query against the specified AD container.  The ");

    744. 

  744. 			Console.WriteLine("modifications are then performed against the results of the query.");

    745. 

  745. 			Console.WriteLine("");

    746. 

  746. 			Console.WriteLine("Usage:");

    747. 

  747. 			Console.WriteLine("");

    748. 

  748. 			Console.WriteLine("admodcmd [-dn BaseDN] [-p pagesize] [-s] [-server servername]");

    749. 

  749. 			Console.WriteLine("	 [-f LDAPFilter] [modification]");

    750. 

  750. 			Console.WriteLine("");

    751. 

  751. 			Console.WriteLine("");

    752. 

  752. 			Console.WriteLine("Required:");

    753. 

  753. 			Console.WriteLine("");

    754. 

  754. 			Console.WriteLine("-dn BaseDN 				Base DN to begin the LDAP query.");

    755. 

  755. 			Console.WriteLine("");

    756. 

  756. 			Console.WriteLine("modification				Modification to perform. ");

    757. 

  757. 			Console.WriteLine("					See below for details.");

    758. 

  758. 			Console.WriteLine("");

    759. 

  759. 			Console.WriteLine("Optional:");

    760. 

  760. 			Console.WriteLine("");

    761. 

  761. 			Console.WriteLine("-p pagesize				LDAP Page size to use for query.");

    762. 

  762. 			Console.WriteLine("");

    763. 

  763. 			Console.WriteLine("-s					Denotes a subtree search ");

    764. 

  764. 			Console.WriteLine("    					(If -s is not specified, search ");

    765. 

  765. 			Console.WriteLine("					defaults to onelevel).");

    766. 

  766. 			Console.WriteLine("");

    767. 

  767. 			Console.WriteLine("-server servername			Denotes the server to make the changes ");

    768. 

  768. 			Console.WriteLine("					to (If -server is not specified, ");

    769. 

  769. 			Console.WriteLine("					changes	are made locally if on a DC.  ");

    770. 

  770. 			Console.WriteLine("					If on a member, DNS is used to ");

    771. 

  771. 			Console.WriteLine("					find a DC).");

    772. 

  772. 			Console.WriteLine("");

    773. 

  773. 			Console.WriteLine("-f LDAPFilter 				A Valid LDAP filter to use when ");

    774. 

  774. 			Console.WriteLine("					enumerating objects (If -f is not ");

    775. 

  775. 			Console.WriteLine("					specified, (objectClass=user) is");

    776. 

  776. 			Console.WriteLine("					the default filter).");

    777. 

  777. 			Console.WriteLine("");

    778. 

  778. 			Console.WriteLine("");

    779. 

  779. 			Console.WriteLine("Modification Switches:");

    780. 

  780. 			Console.WriteLine("");

    781. 

  781. 			Console.WriteLine("");

    782. 

  782. 			Console.WriteLine("NOTE:  Using the word \"null\" (without quotes) as an attribute value will ");

    783. 

  783. 			Console.WriteLine("       clear the attribute.");

    784. 

  784. 			Console.WriteLine("");

    785. 

  785. 			Console.WriteLine("");

    786. 

  786. 			Console.WriteLine("============================");

    787. 

  787. 			Console.WriteLine("|Terminal Server Attributes|");

    788. 

  788. 			Console.WriteLine("============================");

    789. 

  789. 			Console.WriteLine("");

    790. 

  790. 			Console.WriteLine("Windows 2003 or later is required to modify Terminal Server attributes.");

    791. 

  791. 			Console.WriteLine("");

    792. 

  792. 			Console.WriteLine("-tsprofilepath ProfilePath		Sets the users Terminal Server ");

    793. 

  793. 			Console.WriteLine("					Profile path to the specified value.");

    794. 

  794. 			Console.WriteLine("");

    795. 

  795. 			Console.WriteLine("-tshomefolderpath FolderPath		Sets the users Terminal Server home ");

    796. 

  796. 			Console.WriteLine("					folder path to the specified value.");

    797. 

  797. 			Console.WriteLine("");

    798. 

  798. 			Console.WriteLine("-tsnetworkfolderpath driveLetter FolderPath	");

    799. 

  799. 			Console.WriteLine("					Sets the users Terminal Server home");

    800. 

  800. 			Console.WriteLine("					folder path to a network share.");

    801. 

  801. 			Console.WriteLine("					driveLetter should be the drive that");

    802. 

  802. 			Console.WriteLine("					FolderPath will be mapped to.");

    803. 

  803. 			Console.WriteLine("");

    804. 

  804. 			Console.WriteLine("-tsenable				Enables the user for Terminal Server.");

    805. 

  805. 			Console.WriteLine("");

    806. 

  806. 			Console.WriteLine("-tsdisable				Disables the user from using Terminal");

    807. 

  807. 			Console.WriteLine("					Server.");

    808. 

  808. 			Console.WriteLine("");

    809. 

  809. 			Console.WriteLine("-enableremote -required -interact	Enables Remote Control for the user.");

    810. 

  810. 			Console.WriteLine("					The -required and -interact switches");

    811. 

  811. 			Console.WriteLine("					are optional.  If required is used,");

    812. 

  812. 			Console.WriteLine("					\"Require Users Permission\" will be");

    813. 

  813. 			Console.WriteLine("					checked.  If -interact is specified, ");

    814. 

  814. 			Console.WriteLine("					then \"Interact With The Session\" will");

    815. 

  815. 			Console.WriteLine("					be checked.");

    816. 

  816. 			Console.WriteLine("");

    817. 

  817. 			Console.WriteLine("-disableremote				Disables Remote Control for the user.");

    818. 

  818. 			Console.WriteLine("");

    819. 

  819. 			Console.WriteLine("-tsstartingprogram program		Sets the program to start when the user");

    820. 

  820. 			Console.WriteLine("					logs on to Terminal Server.  ");

    821. 

  821. 			Console.WriteLine("");

    822. 

  822. 			Console.WriteLine("-tsstartin location			Sets the location for the users startup");

    823. 

  823. 			Console.WriteLine("					program to start in.");

    824. 

  824. 			Console.WriteLine("");

    825. 

  825. 			Console.WriteLine("-maxdisconnectedsession	minutes");

    826. 

  826. 			Console.WriteLine("					Sets the maximum disconnected session");

    827. 

  827. 			Console.WriteLine("					time for the user in minutes.  Setting");

    828. 

  828. 			Console.WriteLine("					to 0 minutes indicates an unlimited");

    829. 

  829. 			Console.WriteLine("					time.");

    830. 

  830. 			Console.WriteLine("");

    831. 

  831. 			Console.WriteLine("-maxconnectiontime minutes		Sets the maximum connection time for ");

    832. 

  832. 			Console.WriteLine("					the user in minutes.  Setting to 0");

    833. 

  833. 			Console.WriteLine("					indicates an unlimited time.");

    834. 

  834. 			Console.WriteLine("");

    835. 

  835. 			Console.WriteLine("-maxidletime minutes			Sets the maximum idle time for the");

    836. 

  836. 			Console.WriteLine("					user in minutes.  Setting to 0 ");

    837. 

  837. 			Console.WriteLine("					indicates an unlimited time.	");

    838. 

  838. 			Console.WriteLine("");

    839. 

  839. 			Console.WriteLine("-sessionlimitaction disconnect|end	Specifies the action to take when ");

    840. 

  840. 			Console.WriteLine("					a sessions limit has been reached.");

    841. 

  841. 			Console.WriteLine("					Specify either disconnect (disconnect");

    842. 

  842. 			Console.WriteLine("					the session) or end (end the session).");

    843. 

  843. 			Console.WriteLine("");

    844. 

  844. 			Console.WriteLine("-allowreconnect any|originating		Specifies whether or not to allow a");

    845. 

  845. 			Console.WriteLine("					reconnect from anywhere (any) or just");

    846. 

  846. 			Console.WriteLine("					the originating client (originating).");

    847. 

  847. 			Console.WriteLine("");

    848. 

  848. 			Console.WriteLine("-tsconnectclientdrives yes|no		Specifies whether or not to connect");

    849. 

  849. 			Console.WriteLine("					client drives upon logon to a Terminal");

    850. 

  850. 			Console.WriteLine("					Server session.");

    851. 

  851. 			Console.WriteLine("");

    852. 

  852. 			Console.WriteLine("-tsconnectclientprinters yes|no		Specifies whether or not to connect");

    853. 

  853. 			Console.WriteLine("					client printers upon logon to a	");

    854. 

  854. 			Console.WriteLine("					Terminal Server session.");

    855. 

  855. 			Console.WriteLine("");

    856. 

  856. 			Console.WriteLine("-tsdefaulttomainprinter yes|no		Specifies whether or not to default");

    857. 

  857. 			Console.WriteLine("					to the main client printer.");

    858. 

  858. 			Console.WriteLine("");

    859. 

  859. 			Console.WriteLine("");

    860. 

  860. 			Console.WriteLine("=============================");

    861. 

  861. 			Console.WriteLine("|Exchange Related Attributes|");

    862. 

  862. 			Console.WriteLine("=============================");

    863. 

  863. 			Console.WriteLine("");

    864. 

  864. 			Console.WriteLine("-killmail				Removes Exchange Attributes.");

    865. 

  865. 			Console.WriteLine("");

    866. 

  866. 			Console.WriteLine("-includeinrecipientpolicy		Checks \"Automatically Update E-mail");

    867. 

  867. 			Console.WriteLine("					Addresses Based on Recipient Policy\"");

    868. 

  868. 			Console.WriteLine("					Check box.");

    869. 

  869. 			Console.WriteLine("");

    870. 

  870. 			Console.WriteLine("-excludefromrecipientpolicy		Unchecks \"Automatically Update E-mail");

    871. 

  871. 			Console.WriteLine("					Addresses Based on Recipient Policy\"");

    872. 

  872. 			Console.WriteLine("					Check box.");

    873. 

  873. 			Console.WriteLine("");

    874. 

  874. 			Console.WriteLine("-hidefromaddresslists			Hides the user from all Address Lists.");

    875. 

  875. 			Console.WriteLine("");

    876. 

  876. 			Console.WriteLine("-showinaddresslists			Shows the user in address lists.");

    877. 

  877. 			Console.WriteLine("");

    878. 

  878. 			Console.WriteLine("-includeinmailboxmanager		Includes the user in mailbox manager");

    879. 

  879. 			Console.WriteLine("					policies.");

    880. 

  880. 			Console.WriteLine("");

    881. 

  881. 			Console.WriteLine("-excludefrommailboxmanager		Excludes the user from mailbox manager");

    882. 

  882. 			Console.WriteLine("					policies.");

    883. 

  883. 			Console.WriteLine("");

    884. 

  884. 			Console.WriteLine("-enablehttp				Enables HTTP for the user.");

    885. 

  885. 			Console.WriteLine("");

    886. 

  886. 			Console.WriteLine("-disablehttp				Disables HTTP for the user.");

    887. 

  887. 			Console.WriteLine("");

    888. 

  888. 			Console.WriteLine("-enablepop3				Enables POP3 for the user.");

    889. 

  889. 			Console.WriteLine("");

    890. 

  890. 			Console.WriteLine("-disablepop3				Disables POP3 for the user.");

    891. 

  891. 			Console.WriteLine("");

    892. 

  892. 			Console.WriteLine("-enableimap4				Enables IMAP4 for the user.");

    893. 

  893. 			Console.WriteLine("");

    894. 

  894. 			Console.WriteLine("-disableimap4				Disables IMAP4 for the user.");

    895. 

  895. 			Console.WriteLine("");

    896. 

  896. 			Console.WriteLine("The three MAPI settings below require that the users mailbox");

    897. 

  897. 			Console.WriteLine("is homed on an Exchange 2003 SP2 or later server.");

    898. 

  898. 			Console.WriteLine("");

    899. 

  899. 			Console.WriteLine("-enablemapi				Enables MAPI access for the user.");

    900. 

  900. 			Console.WriteLine("");

    901. 

  901. 			Console.WriteLine("-disablemapi				Disables MAPI access for the user.");

    902. 

  902. 			Console.WriteLine("");

    903. 

  903. 			Console.WriteLine("-enablecachedmapi			Enables MAPI access for users in");

    904. 

  904. 			Console.WriteLine("					cached mode only.");

    905. 

  905. 			Console.WriteLine("");

    906. 

  906. 			Console.WriteLine("-addsmtp address -setasprimary -updatemail");

    907. 

  907. 			Console.WriteLine("					Adds an SMTP address to the user.");

    908. 

  908. 			Console.WriteLine("					Address will need to be in the form");

    909. 

  909. 			Console.WriteLine("					of variable@domain.com (Information");

    910. 

  910. 			Console.WriteLine("					on variable usage can be found below");

    911. 

  911. 			Console.WriteLine("					under \"Variables\").  Specify the	");

    912. 

  912. 			Console.WriteLine("					optional setasprimary switch to set ");

    913. 

  913. 			Console.WriteLine("					the address as primary (default ");

    914. 

  914. 			Console.WriteLine("					is secondary).  Use the -updatemail");

    915. 

  915. 			Console.WriteLine("					switch to also set the E-mail address");

    916. 

  916. 			Console.WriteLine("					on the ADU&C General tab.");

    917. 

  917. 			Console.WriteLine("");

    918. 

  918. 			Console.WriteLine("-removeaddress address			Removes any address that matches the");

    919. 

  919. 			Console.WriteLine("					specified filter.  Wild cards are");

    920. 

  920. 			Console.WriteLine("					allowed.  Examples would be:\n");

    921. 

  921. 			Console.WriteLine("					smtp:*@domain.com");

    922. 

  922. 			Console.WriteLine("					smtp:*@doma??.com\n");              

    923. 

  923. 			Console.WriteLine("					Normal * and ? wildcard matching");

    924. 

  924. 			Console.WriteLine("					rules apply.  Please note that this");

    925. 

  925. 			Console.WriteLine("					can be used to remove any match found");

    926. 

  926. 			Console.WriteLine("					in the users Proxy Addresses list,");

    927. 

  927. 			Console.WriteLine("					not just SMTP addresses.  Matches are");

    928. 

  928. 			Console.WriteLine("					case-insensitive.");

    929. 

  929. 			Console.WriteLine("");

    930. 

  930. 			Console.WriteLine("");

    931. 

  931. 			Console.WriteLine("----Mailbox Rights----");

    932. 

  932. 			Console.WriteLine("");

    933. 

  933. 			Console.WriteLine("-setmailboxrights			Sets msExchMailboxSecurityDescriptor.");

    934. 

  934. 			Console.WriteLine("					KB 324353");

    935. 

  935. 			Console.WriteLine("");

    936. 

  936. 			Console.WriteLine("-fixsendas				Grants Send-As rights to users with");

    937. 

  937. 			Console.WriteLine("					Full Mailbox Access and Read.");

    938. 

  938. 			Console.WriteLine("					KB 327274");

    939. 

  939. 			Console.WriteLine("");

    940. 

  940. 			Console.WriteLine("-removefixsendas			Removes Send-As rights from users");

    941. 

  941. 			Console.WriteLine("					with Full Mailbox Access and Read.");

    942. 

  942. 			Console.WriteLine("					Undo for KB 327274");

    943. 

  943. 			Console.WriteLine("");

    944. 

  944. 			Console.WriteLine("-grantselfaea				Grants Associated External Account");

    945. 

  945. 			Console.WriteLine("					privileges to SELF.  KB 278966");

    946. 

  946. 			Console.WriteLine("");

    947. 

  947. 			Console.WriteLine("-removeaeafromself			Removes Associated External Account");

    948. 

  948. 			Console.WriteLine("					from SELF.  Undo for KB 278966");

    949. 

  949. 			Console.WriteLine("");

    950. 

  950. 			Console.WriteLine("-grantselffullandread			Grants Full Mailbox Access and Read");

    951. 

  951. 			Console.WriteLine("					to SELF.  KB 304935");

    952. 

  952. 			Console.WriteLine("");

    953. 

  953. 			Console.WriteLine("-removefullandread			Removes Full Mailbox Access and Read");

    954. 

  954. 			Console.WriteLine("					from SELF.  Undo for KB 304935");

    955. 

  955. 			Console.WriteLine("");

    956. 

  956. 			Console.WriteLine("-dumpmailboxrights			Dumps all permissions in Mailbox Rights");

    957. 

  957. 			Console.WriteLine("					to a file called mbxrights.xml.");

    958. 

  958. 			Console.WriteLine("");

    959. 

  959. 			Console.WriteLine("-importmailboxrights overwrite|append");

    960. 

  960. 			Console.WriteLine("					Imports mailbox rights from the");

    961. 

  961. 			Console.WriteLine("					mbxrights.xml created by the");

    962. 

  962. 			Console.WriteLine("					-dumpmailboxrights switch.  When using");

    963. 

  963. 			Console.WriteLine("					this switch, the -dn switch is not");

    964. 

  964. 			Console.WriteLine("					required.  Overwrite will remove all");

    965. 

  965. 			Console.WriteLine("					non-inherited ACE's before importing,");

    966. 

  966. 			Console.WriteLine("					append will not.  This switch only");

    967. 

  967. 			Console.WriteLine("					imports non-inherited mailbox");

    968. 

  968. 			Console.WriteLine("					rights.");

    969. 

  969. 			Console.WriteLine("");

    970. 

  970. 			Console.WriteLine("-addtomailboxrights DOMAIN\\USER ACCESS_MASK -deny (Optional)");

    971. 

  971. 			Console.WriteLine("					Adds an account to mailbox rights with");

    972. 

  972. 			Console.WriteLine("					the specified permissions masks.  The ");

    973. 

  973. 			Console.WriteLine("					optional -deny switch specfies a deny");

    974. 

  974. 			Console.WriteLine("					entry, default is an allow entry.");

    975. 

  975. 			Console.WriteLine("					Valid Access Masks:");

    976. 

  976. 			Console.WriteLine("");

    977. 

  977. 			Console.WriteLine("					ACE_MB_FULL_ACCESS");

    978. 

  978. 			Console.WriteLine("					ACE_MB_DELETE_MB_STORAGE");

    979. 

  979. 			Console.WriteLine("					ACE_MB_READ_PERMISSIONS");

    980. 

  980. 			Console.WriteLine("					ACE_MB_CHANGE_PERMISSION");

    981. 

  981. 			Console.WriteLine("					ACE_MB_TAKE_OWNERSHIP");

    982. 

  982. 			Console.WriteLine("");

    983. 

  983. 			Console.WriteLine("-removefrommailboxrights DOMAIN\\USER ACCESS_MASK -deny (optional)");

    984. 

  984. 			Console.WriteLine("					Removes the specified mask from");

    985. 

  985. 			Console.WriteLine("					DOMAIN\\USER in mailbox rights.  The");

    986. 

  986. 			Console.WriteLine("					-deny switch specifies a deny entry,");

    987. 

  987. 			Console.WriteLine("					default is an allow entry.");

    988. 

  988. 			Console.WriteLine("					Valid Access Masks:");

    989. 

  989. 			Console.WriteLine("");

    990. 

  990. 			Console.WriteLine("					ACE_MB_FULL_ACCESS");

    991. 

  991. 			Console.WriteLine("					ACE_MB_DELETE_MB_STORAGE");

    992. 

  992. 			Console.WriteLine("					ACE_MB_READ_PERMISSIONS");

    993. 

  993. 			Console.WriteLine("					ACE_MB_CHANGE_PERMISSION");

    994. 

  994. 			Console.WriteLine("					ACE_MB_TAKE_OWNERSHIP");

    995. 

  995. 			Console.WriteLine("					ALL");

    996. 

  996. 			Console.WriteLine("");

    997. 

  997. 			Console.WriteLine("					The ALL Mask will remove all permissions");

    998. 

  998. 			Console.WriteLine("					for the specified user.");

    999. 

  999. 			Console.WriteLine("");

    1000. 

  1000. 			Console.WriteLine("");

    1001. 

  1001. 			Console.WriteLine("=======================");

    1002. 

  1002. 			Console.WriteLine("|User Account Settings|");

    1003. 

  1003. 			Console.WriteLine("=======================");

    1004. 

  1004. 			Console.WriteLine("");

    1005. 

  1005. 			Console.WriteLine("-enableaccount				Enables the user account.");

    1006. 

  1006. 			Console.WriteLine("");

    1007. 

  1007. 			Console.WriteLine("-disableaccount				Disables the user account.");

    1008. 

  1008. 			Console.WriteLine("");

    1009. 

  1009.             Console.WriteLine("-passwordnotrequired yes|no             Specifies whether to set the password");

    1010. 

  1010.             Console.WriteLine("                                        not required option.");

    1011. 

  1011.             Console.WriteLine("");

    1012. 

  1012. 			Console.WriteLine("-passwordneverexpires yes|no		Specifies whether to check or uncheck");

    1013. 

  1013. 			Console.WriteLine("					the \"Password Never Expires\" box.");

    1014. 

  1014. 			Console.WriteLine("");

    1015. 

  1015. 			Console.WriteLine("-mustchangepassword yes|no		Specifies whether to check or uncheck");

    1016. 

  1016. 			Console.WriteLine("					the \"User Must Change Password at Next");

    1017. 

  1017. 			Console.WriteLine("					Logon\" box.");

    1018. 

  1018. 			Console.WriteLine("");

    1019. 

  1019. 			Console.WriteLine("-cannotchangepassword yes|no		Specifies whether to check or uncheck");

    1020. 

  1020. 			Console.WriteLine("					the \"User Cannot Change Password\" box.");

    1021. 

  1021. 			Console.WriteLine("");

    1022. 

  1022. 			Console.WriteLine("-usereversibleencryption yes|no		Specifies whether to check or uncheck");

    1023. 

  1023. 			Console.WriteLine("					the \"Store Password Using Reversible ");

    1024. 

  1024. 			Console.WriteLine("					Encryption\" box.");

    1025. 

  1025. 			Console.WriteLine("");

    1026. 

  1026. 			Console.WriteLine("-smartcardrequired yes|no		Specifies whether to check or uncheck");

    1027. 

  1027. 			Console.WriteLine("					the \"Smart Card is Required for ");

    1028. 

  1028. 			Console.WriteLine("					Interactive Logon\" box.");

    1029. 

  1029. 			Console.WriteLine("");

    1030. 

  1030. 			Console.WriteLine("-cannotbedelegated yes|no		Specifies whether to check or uncheck");

    1031. 

  1031. 			Console.WriteLine("					the \"Account is Sensitive and Cannot");

    1032. 

  1032. 			Console.WriteLine("					be Delegated\" box.");

    1033. 

  1033. 			Console.WriteLine("");

    1034. 

  1034. 			Console.WriteLine("-usedesencryption yes|no		Specifies whether to check or uncheck");

    1035. 

  1035. 			Console.WriteLine("					the \"Use DES Encryption Types for This");

    1036. 

  1036. 			Console.WriteLine("					Account\" box.");

    1037. 

  1037. 			Console.WriteLine("");

    1038. 

  1038. 			Console.WriteLine("-donotrequirekerberospreauth yes|no	Specifies whether to check or uncheck");

    1039. 

  1039. 			Console.WriteLine("					the \"Do Not Require Kerberos ");

    1040. 

  1040. 			Console.WriteLine("					Preauthentication\" box.");

    1041. 

  1041. 			Console.WriteLine("");

    1042. 

  1042. 			Console.WriteLine("-addtogroup DNOfGroup			Adds the user to the specified group.");

    1043. 

  1043. 			Console.WriteLine("");

    1044. 

  1044. 			Console.WriteLine("-removefromgroup DNOfGroup		Removes the user from the specified");

    1045. 

  1045. 			Console.WriteLine("					group.");

    1046. 

  1046. 			Console.WriteLine("");

    1047. 

  1047. 			Console.WriteLine("-allowinheritable yes|no		Specifies whether to check or uncheck");

    1048. 

  1048. 			Console.WriteLine("					the \"Allow inheritable permissions to");

    1049. 

  1049. 			Console.WriteLine("					propagate to this object\" box.");

    1050. 

  1050. 			Console.WriteLine("");

    1051. 

  1051. 			Console.WriteLine("-modrdn NewRDN				Changes the users Relative Distinguished");

    1052. 

  1052. 			Console.WriteLine("					Name (CN).  Variable usage is required.");

    1053. 

  1053. 			Console.WriteLine("					To change an RDN to LastName, FirstName");

    1054. 

  1054. 			Console.WriteLine("					use the following syntax:");

    1055. 

  1055. 			Console.WriteLine("					-modrdn \"%'sn'%, %'givenName'%\"");

    1056. 

  1056. 			Console.WriteLine("");

    1057. 

  1057. 			Console.WriteLine("===================");

    1058. 

  1058. 			Console.WriteLine("|Custom Attributes|");

    1059. 

  1059. 			Console.WriteLine("===================");

    1060. 

  1060. 			Console.WriteLine("");

    1061. 

  1061. 			Console.WriteLine("The -custom switch allows you to name the attribute you wish to modify.  This");

    1062. 

  1062. 			Console.WriteLine("operation is only supported against attributes of the following type:");

    1063. 

  1063. 			Console.WriteLine("");

    1064. 

  1064. 			Console.WriteLine("Boolean");

    1065. 

  1065. 			Console.WriteLine("Case Insensitive String");

    1066. 

  1066. 			Console.WriteLine("Distinguished Name");

    1067. 

  1067. 			Console.WriteLine("DN Binary");

    1068. 

  1068. 			Console.WriteLine("IA5-String");

    1069. 

  1069. 			Console.WriteLine("Integer");

    1070. 

  1070. 			Console.WriteLine("Numerical String");

    1071. 

  1071. 			Console.WriteLine("Unicode String");

    1072. 

  1072. 			Console.WriteLine("");

    1073. 

  1073. 			Console.WriteLine("Syntax: ");

    1074. 

  1074. 			Console.WriteLine("[-custom attributeName attributeValue -multi|-remove]");

    1075. 

  1075. 			Console.WriteLine("");	

    1076. 

  1076. 			Console.WriteLine("attributeName				The name of the attribute you wish");

    1077. 

  1077. 			Console.WriteLine("					to modify.");

    1078. 

  1078. 			Console.WriteLine("");

    1079. 

  1079. 			Console.WriteLine("attributeValue				The value to give the attribute.");

    1080. 

  1080. 			Console.WriteLine("");

    1081. 

  1081. 			Console.WriteLine("-multi (optional)			Specifies a multi-valued append.  If");

    1082. 

  1082. 			Console.WriteLine("					the attribute being modified is multi-");

    1083. 

  1083. 			Console.WriteLine("					valued this switch needs to be used.	");	

    1084. 

  1084. 			Console.WriteLine("					Otherwise, the value will be ");

    1085. 

  1085. 			Console.WriteLine("					overwritten, not appended.");

    1086. 

  1086. 			Console.WriteLine("");

    1087. 

  1087. 			Console.WriteLine("-remove (optional)			Specifies a multi-valued remove.  If");

    1088. 

  1088. 			Console.WriteLine("					the attribute being modified is multi-");

    1089. 

  1089. 			Console.WriteLine("					valued and -remove is used, then only");

    1090. 

  1090. 			Console.WriteLine("					the specified value will get removed.");

    1091. 

  1091. 			Console.WriteLine("");

    1092. 

  1092. 			Console.WriteLine("Example for setting description attribute:");

    1093. 

  1093. 			Console.WriteLine("");

    1094. 

  1094. 			Console.WriteLine("-custom description \"IT Department\"");

    1095. 

  1095. 			Console.WriteLine("");

    1096. 

  1096. 			Console.WriteLine("");

    1097. 

  1097. 			Console.WriteLine("==========");

    1098. 

  1098. 			Console.WriteLine("|Variables|");

    1099. 

  1099. 			Console.WriteLine("==========");

    1100. 

  1100. 			Console.WriteLine("");

    1101. 

  1101. 			Console.WriteLine("Variable usage is allowed when building attributes.  Variables can be based ");

    1102. 

  1102. 			Console.WriteLine("off of almost any current Active Directory attribute, as long as it has a ");

    1103. 

  1103. 			Console.WriteLine("value.  Variables are seperated from literal values using the % sign.");

    1104. 

  1104. 			Console.WriteLine("Variables must also be enclosed in a single tick (').");

    1105. 

  1105. 			Console.WriteLine("");

    1106. 

  1106. 			Console.WriteLine("This example shows how to set homeDirectory to the path c:\\test\\username, ");

    1107. 

  1107. 			Console.WriteLine("where username is the users sAMAccountName:");

    1108. 

  1108. 			Console.WriteLine("");

    1109. 

  1109. 			Console.WriteLine("-custom homeDirectory c:\\test\\%'sAMAccountName'%");

    1110. 

  1110. 			Console.WriteLine("");

    1111. 

  1111. 			Console.WriteLine("It is also possible to pull only a specified number of characters from the ");

    1112. 

  1112. 			Console.WriteLine("attribute as well.  Just specify the number of characters you want to use");

    1113. 

  1113. 			Console.WriteLine("after the %, and before the \"'\".  The following example shows how to add ");

    1114. 

  1114. 			Console.WriteLine("an SMTP address of FirstInitial.LastName@domain.com:");

    1115. 

  1115. 			Console.WriteLine("");

    1116. 

  1116. 			Console.WriteLine("-addsmtp %1'givenName'%.%'sn'%@domain.com");

    1117. 

  1117. 			Console.WriteLine("");

    1118. 

  1118. 			Console.WriteLine("If a % or ' is needed as a literal value, simply use the forward slash (/)");

    1119. 

  1119. 			Console.WriteLine("as an escape character:");

    1120. 

  1120. 			Console.WriteLine("");

    1121. 

  1121. 			Console.WriteLine("Example:");

    1122. 

  1122. 			Console.WriteLine("This is a percent sign: /%");

    1123. 

  1123. 			Console.WriteLine("");

    1124. 

  1124. 			Console.WriteLine("The above line will end up being:  This is a percent sign: %");

    1125. 

  1125. 			Console.WriteLine("");

    1126. 

  1126. 			Console.WriteLine("There may be times where you need a literal forward slash before the");

    1127. 

  1127. 			Console.WriteLine("percentage or single tick characters, usually when the forward slash");

    1128. 

  1128. 			Console.WriteLine("needs to be followed by a variable.  The syntax for this is //% or //'");

    1129. 

  1129. 			Console.WriteLine("An example would be adding an MS Mail address:");

    1130. 

  1130. 			Console.WriteLine("");

    1131. 

  1131. 			Console.WriteLine("ms:PO/SERVER//%'mailNickName'");

    1132. 

  1132. 			Console.WriteLine("");

    1133. 

  1133. 			Console.WriteLine("===========");

    1134. 

  1134. 			Console.WriteLine("|Undo Mode|");

    1135. 

  1135. 			Console.WriteLine("===========");

    1136. 

  1136. 			Console.WriteLine("");

    1137. 

  1137. 			Console.WriteLine("Changes made with ADModify can be undone, as long as the xml log file that");

    1138. 

  1138. 			Console.WriteLine("logged the changes still exists.  These log files are typically located in");

    1139. 

  1139. 			Console.WriteLine("the same folder as the admodify executable.");

    1140. 

  1140. 			Console.WriteLine("");

    1141. 

  1141. 			Console.WriteLine("Syntax:");

    1142. 

  1142. 			Console.WriteLine("[-undo logfilename -server servername]");

    1143. 

  1143. 			Console.WriteLine("");

    1144. 

  1144. 			Console.WriteLine("-undo logfilename			Specifes the log file that contains the");

    1145. 

  1145. 			Console.WriteLine("					changes to be undone.");

    1146. 

  1146. 			Console.WriteLine("");

    1147. 

  1147. 			Console.WriteLine("-server servername (optional)		Specifies the DC to write the changes");

    1148. 

  1148. 			Console.WriteLine("					to.  If left blank changes are written");

    1149. 

  1149. 			Console.WriteLine("					locally if the local machine is a DC.");

    1150. 

  1150. 			Console.WriteLine("					If not, DNS is used to find one.");

    1151. 

  1151. 			Console.WriteLine("");

    1152. 

  1152. 			Console.WriteLine("For information on users that were skipped during an undo process, refer");

    1153. 

  1153. 			Console.WriteLine("to the undo.log file.");

    1154. 

  1154. 			Console.WriteLine("");

    1155. 

  1155. 			Console.WriteLine("For more information on sample usage, please refer to the ADModify help.");

    1156. 

  1156. 			Console.WriteLine("");

    1157. 

  1157. 			Console.WriteLine("");

    1158. 

  1158. 	

    1159. 

  1159. 		}

    1160. 

  1160. 

    1161. 

  1161. 

    1162. 

  1162. 	

    1163. 

  1163. 

    1164. 

  1164. 		

    1165. 

  1165. 

    1166. 

  1166. 

    1167. 

  1167. 

    1168. 

  1168. 

    1169. 

  1169. 

    1170. 

  1170. 		/// <summary>

    1171. 

  1171. 		/// ADModifyMain::Main

    1172. 

  1172. 		/// 

    1173. 

  1173. 		/// Accepts:

    1174. 

  1174. 		///		args - command line arguments passed by the user

    1175. 

  1175. 		///	Returns:

    1176. 

  1176. 		///		nothing

    1177. 

  1177. 		///		

    1178. 

  1178. 		/// Here we accept all command line arguments and set the global variables for these

    1179. 

  1179. 		/// arguments accordingly.  Control is then given to the GetDN function.

    1180. 

  1180. 		/// </summary>

    1181. 

  1181. 		[STAThread]

    1182. 

  1182. 		static void Main(string[] args)

    1183. 

  1183. 		{

    1184. 

  1184. 			

    1185. 

  1185. 			LogFile log = new LogFile();

    1186. 

  1186. 

    1187. 

  1187. 			DateTime endTime;

    1188. 

  1188. 			TimeSpan finalCount;

    1189. 

  1189. 

    1190. 

  1190. 			string RawDateTime = System.DateTime.Now.ToString();

    1191. 

  1191. 			RawDateTime = RawDateTime.Replace(" ","").Replace("/","").Replace(":","");

    1192. 

  1192. 			string logFileName = RawDateTime + ".xml";

    1193. 

  1193. 			XmlTextWriter logWriter = new XmlTextWriter(logFileName, null);

    1194. 

  1194. 

    1195. 

  1195. 			

    1196. 

  1196. 			logWriter.WriteStartDocument(false);

    1197. 

  1197. 			logWriter.WriteDocType("LogFile", null, null, null);

    1198. 

  1198. 			logWriter.WriteStartElement("XmlRoot", logFileName);

    1199. 

  1199. 

    1200. 

  1200. 			DateTime startTime = System.DateTime.Now;

    1201. 

  1201. 

    1202. 

  1202. 			bool haveDN = false; //flip this bit when we have a base DN passed

    1203. 

  1203. 			int numberargs = args.Length;	

    1204. 

  1204. 			string LDAPFilter = "(objectClass=user)";  //default to this in case a filter is not specified

    1205. 

  1205. 			bool subtree = false;	//default to a onelevel search

    1206. 

  1206. 			bool bitflipped = false;	//if any valid attribute switch is given we flip this bit

    1207. 

  1207. 			string SearchBase = "blank";

    1208. 

  1208. 

    1209. 

  1209. 

    1210. 

  1210. 

    1211. 

  1211. 			//loop through args and set the necesarry information

    1212. 

  1212. 			for(int i=0; i < numberargs; i++)

    1213. 

  1213. 			{

    1214. 

  1214. 				switch(args[i].ToLower())

    1215. 

  1215. 				{

    1216. 

  1216. 					case "/?":

    1217. 

  1217. 					case "-?":

    1218. 

  1218. 						bitflipped = true;

    1219. 

  1219. 						GiveCommandArgs();

    1220. 

  1220. 						return;

    1221. 

  1221. 					case "-server":

    1222. 

  1222. 						try

    1223. 

  1223. 						{

    1224. 

  1224. 							servername = args[i+1];

    1225. 

  1225. 							i++;

    1226. 

  1226. 						}

    1227. 

  1227. 						catch(System.IndexOutOfRangeException)

    1228. 

  1228. 						{

    1229. 

  1229. 							Console.WriteLine("Please enter a server name after the -servername switch.");

    1230. 

  1230. 							return;

    1231. 

  1231. 						}

    1232. 

  1232. 						break;

    1233. 

  1233. 					case "-f":

    1234. 

  1234. 						try

    1235. 

  1235. 						{

    1236. 

  1236. 							LDAPFilter = args[i+1];

    1237. 

  1237. 							i++;

    1238. 

  1238. 						}

    1239. 

  1239. 						catch(System.IndexOutOfRangeException)

    1240. 

  1240. 						{

    1241. 

  1241. 							Console.WriteLine("Please enter an LDAP filter after the -filter switch.");

    1242. 

  1242. 							return;

    1243. 

  1243. 						}

    1244. 

  1244. 						break;

    1245. 

  1245. 					case "-p":

    1246. 

  1246. 						try

    1247. 

  1247. 						{

    1248. 

  1248. 							pageSize = Convert.ToInt32(args[i+1],10);

    1249. 

  1249. 							if(pageSize>1000 || pageSize==0)

    1250. 

  1250. 							{

    1251. 

  1251. 								Console.WriteLine("Please enter a page size between 1 and 1000.");

    1252. 

  1252. 								return;

    1253. 

  1253. 							}

    1254. 

  1254. 							i++;

    1255. 

  1255. 						}

    1256. 

  1256. 						catch(System.IndexOutOfRangeException)

    1257. 

  1257. 						{

    1258. 

  1258. 							Console.WriteLine("Please enter a page size after the -p switch.");

    1259. 

  1259. 							return;

    1260. 

  1260. 						}

    1261. 

  1261. 						break;

    1262. 

  1262. 					case "-s":

    1263. 

  1263. 						subtree = true;

    1264. 

  1264. 						break;

    1265. 

  1265. 					case "-dn":

    1266. 

  1266. 						try

    1267. 

  1267. 						{

    1268. 

  1268. 							haveDN=true;

    1269. 

  1269. 							SearchBase = args[i+1];

    1270. 

  1270. 							i++;

    1271. 

  1271. 						}

    1272. 

  1272. 						catch(System.IndexOutOfRangeException)

    1273. 

  1273. 						{

    1274. 

  1274. 							Console.WriteLine("Please enter a valid dn after the -dn switch.");

    1275. 

  1275. 							return;

    1276. 

  1276. 						}

    1277. 

  1277. 						break;

    1278. 

  1278. 

    1279. 

  1279. 

    1280. 

  1280. 					//////////////////////////////////////////////////

    1281. 

  1281. 					///			Terminal Server Attributes		   ///

    1282. 

  1282. 					//////////////////////////////////////////////////

    1283. 

  1283. 

    1284. 

  1284. 					//set TS profile path

    1285. 

  1285. 					case "-tsprofilepath":

    1286. 

  1286. 						try

    1287. 

  1287. 						{

    1288. 

  1288. 							TSProfilePath = args[i+1];

    1289. 

  1289. 							bitflipped = true;

    1290. 

  1290. 							i++;

    1291. 

  1291. 							break;

    1292. 

  1292. 

    1293. 

  1293. 						}

    1294. 

  1294. 						catch(System.IndexOutOfRangeException)

    1295. 

  1295. 						{

    1296. 

  1296. 							

    1297. 

  1297. 							Console.WriteLine("Please enter the new profile value after the -tsprofilepath path swtich.");

    1298. 

  1298. 							return;

    1299. 

  1299. 						}

    1300. 

  1300. 						catch(System.Exception caught)

    1301. 

  1301. 						{

    1302. 

  1302. 							Console.WriteLine(caught.Message);

    1303. 

  1303. 							return;

    1304. 

  1304. 						}

    1305. 

  1305. 						

    1306. 

  1306. 

    1307. 

  1307. 					//set local TS home folder path

    1308. 

  1308. 					case "-tshomefolderpath":

    1309. 

  1309. 						try

    1310. 

  1310. 						{

    1311. 

  1311. 							TSFolderPath = args[i+1];

    1312. 

  1312. 							bitflipped = true;

    1313. 

  1313. 							i++;

    1314. 

  1314. 							break;

    1315. 

  1315. 

    1316. 

  1316. 						}

    1317. 

  1317. 						catch(System.IndexOutOfRangeException)

    1318. 

  1318. 						{

    1319. 

  1319. 							

    1320. 

  1320. 							Console.WriteLine("Please enter the new home folder value after the -tshomefolderpath switch.");

    1321. 

  1321. 							return;

    1322. 

  1322. 						}

    1323. 

  1323. 						catch(System.Exception caught)

    1324. 

  1324. 						{

    1325. 

  1325. 							Console.WriteLine(caught.Message);

    1326. 

  1326. 							return;

    1327. 

  1327. 						}

    1328. 

  1328. 						

    1329. 

  1329. 

    1330. 

  1330. 					//set TS home folder path to network drive

    1331. 

  1331. 					case "-tsnetworkfolderpath":

    1332. 

  1332. 						try

    1333. 

  1333. 						{

    1334. 

  1334. 							TSHomeDrive = args[i+1];

    1335. 

  1335. 							if(TSHomeDrive=="null")

    1336. 

  1336. 							{

    1337. 

  1337. 								bitflipped = true;

    1338. 

  1338. 								TSFolderPath = TSHomeDrive;

    1339. 

  1339. 								i=i+2;

    1340. 

  1340. 								break;

    1341. 

  1341. 							}

    1342. 

  1342. 							if(!TSHomeDrive.EndsWith(":"))

    1343. 

  1343. 							{

    1344. 

  1344. 								Console.WriteLine("Drive Letter must end in a : ");

    1345. 

  1345. 								return;

    1346. 

  1346. 							}

    1347. 

  1347. 							TSFolderPath = args[i+2];

    1348. 

  1348. 							bitflipped = true;

    1349. 

  1349. 							i=i+2;

    1350. 

  1350. 							break;

    1351. 

  1351. 

    1352. 

  1352. 						}

    1353. 

  1353. 						catch(System.IndexOutOfRangeException)

    1354. 

  1354. 						{

    1355. 

  1355. 							

    1356. 

  1356. 							Console.WriteLine("Please enter a drive letter followed by a network path.");

    1357. 

  1357. 							return;

    1358. 

  1358. 						}

    1359. 

  1359. 						catch(System.Exception caught)

    1360. 

  1360. 						{

    1361. 

  1361. 							Console.WriteLine(caught.Message);

    1362. 

  1362. 							return;

    1363. 

  1363. 						}

    1364. 

  1364. 						

    1365. 

  1365. 

    1366. 

  1366. 

    1367. 

  1367. 					//enable TS access

    1368. 

  1368. 					case "-tsenable":

    1369. 

  1369. 						try

    1370. 

  1370. 						{

    1371. 

  1371. 							TSEnable = true;

    1372. 

  1372. 							bitflipped = true;

    1373. 

  1373. 						}

    1374. 

  1374. 						catch(System.Exception caught)

    1375. 

  1375. 						{

    1376. 

  1376. 							Console.WriteLine(caught.Message);

    1377. 

  1377. 						}

    1378. 

  1378. 						break;

    1379. 

  1379. 

    1380. 

  1380. 					//disable TS access

    1381. 

  1381. 					case "-tsdisable":

    1382. 

  1382. 						try

    1383. 

  1383. 						{

    1384. 

  1384. 							TSDisable = true;

    1385. 

  1385. 							bitflipped = true;

    1386. 

  1386. 						}

    1387. 

  1387. 						catch(System.Exception caught)

    1388. 

  1388. 						{

    1389. 

  1389. 							Console.WriteLine(caught.Message);

    1390. 

  1390. 						}

    1391. 

  1391. 						break;

    1392. 

  1392. 

    1393. 

  1393. 

    1394. 

  1394. 					//enable remote control, utilizes the -required and -interact switches

    1395. 

  1395. 					case "-enableremote":

    1396. 

  1396. 						try

    1397. 

  1397. 						{

    1398. 

  1398. 							RemoteEnable = true;

    1399. 

  1399. 							bitflipped = true;

    1400. 

  1400. 						}

    1401. 

  1401. 						catch(System.Exception caught)

    1402. 

  1402. 						{

    1403. 

  1403. 							Console.WriteLine(caught.Message);

    1404. 

  1404. 						}

    1405. 

  1405. 						break;

    1406. 

  1406. 

    1407. 

  1407. 					//used with the -enableremote switch

    1408. 

  1408. 					case "-required":

    1409. 

  1409. 						try

    1410. 

  1410. 						{

    1411. 

  1411. 							RequirePermission = true;

    1412. 

  1412. 						}

    1413. 

  1413. 						catch(System.Exception caught)

    1414. 

  1414. 						{

    1415. 

  1415. 							Console.WriteLine(caught.Message);

    1416. 

  1416. 						}

    1417. 

  1417. 						break;

    1418. 

  1418. 

    1419. 

  1419. 					//used with the -enableremote switch

    1420. 

  1420. 					case "-interact":

    1421. 

  1421. 						try

    1422. 

  1422. 						{

    1423. 

  1423. 							InteractWithSession = true;

    1424. 

  1424. 						}

    1425. 

  1425. 						catch(System.Exception caught)

    1426. 

  1426. 						{

    1427. 

  1427. 							Console.WriteLine(caught.Message);

    1428. 

  1428. 						}

    1429. 

  1429. 						break;

    1430. 

  1430. 

    1431. 

  1431. 					//disable remote control

    1432. 

  1432. 					case "-disableremote":

    1433. 

  1433. 						try

    1434. 

  1434. 						{

    1435. 

  1435. 							RemoteDisable = true;

    1436. 

  1436. 							bitflipped = true;

    1437. 

  1437. 						}

    1438. 

  1438. 						catch(System.Exception caught)

    1439. 

  1439. 						{

    1440. 

  1440. 							Console.WriteLine(caught.Message);

    1441. 

  1441. 						}

    1442. 

  1442. 						break;

    1443. 

  1443. 

    1444. 

  1444. 

    1445. 

  1445. 					//set TS startup program

    1446. 

  1446. 					case "-tsstartingprogram":

    1447. 

  1447. 						try

    1448. 

  1448. 						{

    1449. 

  1449. 							program = args[i+1];

    1450. 

  1450. 							bitflipped = true;

    1451. 

  1451. 							i++;

    1452. 

  1452. 						}

    1453. 

  1453. 						catch(System.IndexOutOfRangeException)

    1454. 

  1454. 						{

    1455. 

  1455. 							Console.WriteLine("Please specify a program to run after the -tsstartingprogram switch.");

    1456. 

  1456. 							return;

    1457. 

  1457. 						}

    1458. 

  1458. 						catch(System.Exception caught)

    1459. 

  1459. 						{

    1460. 

  1460. 							Console.WriteLine(caught.Message);

    1461. 

  1461. 						}

    1462. 

  1462. 						break;

    1463. 

  1463. 

    1464. 

  1464. 					//set startup location for TS startup program

    1465. 

  1465. 					case "-tsstartin":

    1466. 

  1466. 						try

    1467. 

  1467. 						{

    1468. 

  1468. 							startIn = args[i+1];

    1469. 

  1469. 							bitflipped = true;

    1470. 

  1470. 							i++;

    1471. 

  1471. 						}

    1472. 

  1472. 						catch(System.IndexOutOfRangeException)

    1473. 

  1473. 						{

    1474. 

  1474. 							Console.WriteLine("Please specify a startup location after the -tsstartin switch.");

    1475. 

  1475. 							return;

    1476. 

  1476. 						}

    1477. 

  1477. 						catch(System.Exception caught)

    1478. 

  1478. 						{

    1479. 

  1479. 							Console.WriteLine(caught.Message);

    1480. 

  1480. 						}

    1481. 

  1481. 						break;

    1482. 

  1482. 

    1483. 

  1483. 

    1484. 

  1484. 					//set disconnected session time

    1485. 

  1485. 					case "-maxdisconnectedsession":

    1486. 

  1486. 						try

    1487. 

  1487. 						{

    1488. 

  1488. 							SetDisconnectTime = true;

    1489. 

  1489. 							DisconnectTime = Convert.ToInt32(args[i+1], 10);

    1490. 

  1490. 							bitflipped = true;

    1491. 

  1491. 							i++;

    1492. 

  1492. 						}

    1493. 

  1493. 						catch(System.IndexOutOfRangeException)

    1494. 

  1494. 						{

    1495. 

  1495. 							Console.WriteLine("Please specify the number of minutes");

    1496. 

  1496. 							return;

    1497. 

  1497. 						}

    1498. 

  1498. 						catch(System.Exception caught)

    1499. 

  1499. 						{

    1500. 

  1500. 							Console.WriteLine(caught.Message);

    1501. 

  1501. 						}

    1502. 

  1502. 						break;

    1503. 

  1503. 

    1504. 

  1504. 					//set maximum session time

    1505. 

  1505. 					case "-maxconnectiontime":

    1506. 

  1506. 						try

    1507. 

  1507. 						{

    1508. 

  1508. 							SetMaxConnectionTime = true;

    1509. 

  1509. 							MaxConnectionTime = Convert.ToInt32(args[i+1], 10);

    1510. 

  1510. 							bitflipped = true;

    1511. 

  1511. 							i++;

    1512. 

  1512. 						}

    1513. 

  1513. 						catch(System.IndexOutOfRangeException)

    1514. 

  1514. 						{

    1515. 

  1515. 							Console.WriteLine("Please specify the number of minutes");

    1516. 

  1516. 							return;

    1517. 

  1517. 						}

    1518. 

  1518. 						catch(System.Exception caught)

    1519. 

  1519. 						{

    1520. 

  1520. 							Console.WriteLine(caught.Message);

    1521. 

  1521. 						}

    1522. 

  1522. 						break;

    1523. 

  1523. 

    1524. 

  1524. 					//set idle time limit

    1525. 

  1525. 					case "-maxidletime":

    1526. 

  1526. 						try

    1527. 

  1527. 						{

    1528. 

  1528. 							SetMaxIdleTime = true;

    1529. 

  1529. 							MaxIdleTime = Convert.ToInt32(args[i+1], 10);

    1530. 

  1530. 							bitflipped = true;

    1531. 

  1531. 							i++;

    1532. 

  1532. 						}

    1533. 

  1533. 						catch(System.IndexOutOfRangeException)

    1534. 

  1534. 						{

    1535. 

  1535. 							Console.WriteLine("Please specify the number of minutes");

    1536. 

  1536. 							return;

    1537. 

  1537. 						}

    1538. 

  1538. 						catch(System.Exception caught)

    1539. 

  1539. 						{

    1540. 

  1540. 							Console.WriteLine(caught.Message);

    1541. 

  1541. 						}

    1542. 

  1542. 						break;

    1543. 

  1543. 

    1544. 

  1544. 

    1545. 

  1545. 					//seesion limit or broken connection action

    1546. 

  1546. 					case "-sessionlimitaction":

    1547. 

  1547. 						try

    1548. 

  1548. 						{

    1549. 

  1549. 							SetEndSession = true;

    1550. 

  1550. 							bitflipped = true;

    1551. 

  1551. 							if(args[i+1]=="disconnect")

    1552. 

  1552. 							{

    1553. 

  1553. 								//do nothing, already set to false

    1554. 

  1554. 							}

    1555. 

  1555. 							else if(args[i+1]=="end")

    1556. 

  1556. 							{

    1557. 

  1557. 								EndSession = true;

    1558. 

  1558. 							}

    1559. 

  1559. 							else

    1560. 

  1560. 							{

    1561. 

  1561. 								Console.WriteLine(args[i+1] + " is not a valid argument.  Please specify either disconnect or end.");

    1562. 

  1562. 								return;

    1563. 

  1563. 							}

    1564. 

  1564. 							i++;

    1565. 

  1565. 							break;

    1566. 

  1566. 

    1567. 

  1567. 						}

    1568. 

  1568. 						catch(System.IndexOutOfRangeException)

    1569. 

  1569. 						{

    1570. 

  1570. 							Console.WriteLine("Please specify either disconnect or end after the -sessionlimitaction switch.");

    1571. 

  1571. 							return;

    1572. 

  1572. 						}

    1573. 

  1573. 						catch(System.Exception caught)

    1574. 

  1574. 						{

    1575. 

  1575.                             Console.WriteLine(caught.Message);

    1576. 

  1576. 							return;

    1577. 

  1577. 						}

    1578. 

  1578. 

    1579. 

  1579. 					//TS reconnect action

    1580. 

  1580. 					case "-allowreconnect":

    1581. 

  1581. 						try

    1582. 

  1582. 						{

    1583. 

  1583. 							SetOriginatingOnly = true;

    1584. 

  1584. 							bitflipped = true;

    1585. 

  1585. 							if(args[i+1]=="any")

    1586. 

  1586. 							{

    1587. 

  1587. 								//do nothing, already set to false

    1588. 

  1588. 							}

    1589. 

  1589. 							else if(args[i+1]=="originating")

    1590. 

  1590. 							{

    1591. 

  1591. 								OriginatingOnly = true;

    1592. 

  1592. 							}

    1593. 

  1593. 							else

    1594. 

  1594. 							{

    1595. 

  1595. 								Console.WriteLine(args[i+1] + " is not a valid argument.  Please specify either any or originating.");

    1596. 

  1596. 								return;

    1597. 

  1597. 							}

    1598. 

  1598. 							i++;

    1599. 

  1599. 							break;

    1600. 

  1600. 

    1601. 

  1601. 						}

    1602. 

  1602. 						catch(System.IndexOutOfRangeException)

    1603. 

  1603. 						{

    1604. 

  1604. 							Console.WriteLine("Please specify either any or originating after the -allowreconnect switch.");

    1605. 

  1605. 							return;

    1606. 

  1606. 						}

    1607. 

  1607. 						catch(System.Exception caught)

    1608. 

  1608. 						{

    1609. 

  1609. 							Console.WriteLine(caught.Message);

    1610. 

  1610. 							return;

    1611. 

  1611. 						}

    1612. 

  1612. 

    1613. 

  1613. 

    1614. 

  1614. 					//TS Connect Client Drives at Logon

    1615. 

  1615. 					case "-tsconnectclientdrives":

    1616. 

  1616. 						try

    1617. 

  1617. 						{

    1618. 

  1618. 							SetConnectClientDrives = true;

    1619. 

  1619. 							bitflipped = true;

    1620. 

  1620. 							if(args[i+1]=="yes")

    1621. 

  1621. 							{

    1622. 

  1622. 								ConnectClientDrives = true;

    1623. 

  1623. 							}

    1624. 

  1624. 							else if(args[i+1]=="no")

    1625. 

  1625. 							{

    1626. 

  1626. 								//do nothing, already set to false

    1627. 

  1627. 							}

    1628. 

  1628. 							else

    1629. 

  1629. 							{

    1630. 

  1630. 								Console.WriteLine("Please specify either yes or no after the -tsconnectclientdrives switch.");

    1631. 

  1631. 								return;

    1632. 

  1632. 							}

    1633. 

  1633. 							i++;

    1634. 

  1634. 							break;

    1635. 

  1635. 						}

    1636. 

  1636. 						catch(System.IndexOutOfRangeException)

    1637. 

  1637. 						{

    1638. 

  1638. 							Console.WriteLine("Please specify yes or no after the -tsconnectclientdrives switch.");

    1639. 

  1639. 							return;

    1640. 

  1640. 						}

    1641. 

  1641. 						catch(System.Exception caught)

    1642. 

  1642. 						{

    1643. 

  1643. 							Console.WriteLine(caught.Message);

    1644. 

  1644. 							return;

    1645. 

  1645. 						}

    1646. 

  1646. 

    1647. 

  1647. 					//TS Connect Client Printers at Logon

    1648. 

  1648. 					case "-tsconnectclientprinters":

    1649. 

  1649. 						try

    1650. 

  1650. 						{

    1651. 

  1651. 							SetConnectClientPrinters = true;

    1652. 

  1652. 							bitflipped = true;

    1653. 

  1653. 							if(args[i+1]=="yes")

    1654. 

  1654. 							{

    1655. 

  1655. 								ConnectClientPrinters = true;

    1656. 

  1656. 							}

    1657. 

  1657. 							else if(args[i+1]=="no")

    1658. 

  1658. 							{

    1659. 

  1659. 								//do nothing, already set to false

    1660. 

  1660. 							}

    1661. 

  1661. 							else

    1662. 

  1662. 							{

    1663. 

  1663. 								Console.WriteLine("Please specify either yes or no after the -tsconnectclientprinters switch.");

    1664. 

  1664. 								return;

    1665. 

  1665. 							}

    1666. 

  1666. 							i++;

    1667. 

  1667. 							break;

    1668. 

  1668. 						}

    1669. 

  1669. 						catch(System.IndexOutOfRangeException)

    1670. 

  1670. 						{

    1671. 

  1671. 							Console.WriteLine("Please specify yes or no after the -tsconectclientprinters switch.");

    1672. 

  1672. 							return;

    1673. 

  1673. 						}

    1674. 

  1674. 						catch(System.Exception caught)

    1675. 

  1675. 						{

    1676. 

  1676. 							Console.WriteLine(caught.Message);

    1677. 

  1677. 							return;

    1678. 

  1678. 						}

    1679. 

  1679. 

    1680. 

  1680. 					//TS Default to main printer

    1681. 

  1681. 					case "-tsdefaulttomainprinter":

    1682. 

  1682. 						try

    1683. 

  1683. 						{

    1684. 

  1684. 							SetDefaultToMainPrinter = true;

    1685. 

  1685. 							bitflipped = true;

    1686. 

  1686. 							if(args[i+1]=="yes")

    1687. 

  1687. 							{

    1688. 

  1688. 								DefaultToMainPrinter = true;

    1689. 

  1689. 							}

    1690. 

  1690. 							else if(args[i+1]=="no")

    1691. 

  1691. 							{

    1692. 

  1692. 								//do nothing, already set to false

    1693. 

  1693. 							}

    1694. 

  1694. 							else

    1695. 

  1695. 							{

    1696. 

  1696. 								Console.WriteLine("Please specify either yes or no after the -tsdefaulttomainprinter switch.");

    1697. 

  1697. 								return;

    1698. 

  1698. 							}

    1699. 

  1699. 							i++;

    1700. 

  1700. 							break;

    1701. 

  1701. 						}

    1702. 

  1702. 						catch(System.IndexOutOfRangeException)

    1703. 

  1703. 						{

    1704. 

  1704. 							Console.WriteLine("Please specify yes or no after the -tsdefaulttomainprinter switch.");

    1705. 

  1705. 							return;

    1706. 

  1706. 						}

    1707. 

  1707. 						catch(System.Exception caught)

    1708. 

  1708. 						{

    1709. 

  1709. 							Console.WriteLine(caught.Message);

    1710. 

  1710. 							return;

    1711. 

  1711. 						}

    1712. 

  1712. 

    1713. 

  1713. 

    1714. 

  1714. 					//////////////////////////////////////////////////

    1715. 

  1715. 					///			Exchange Related Attributes		   ///

    1716. 

  1716. 					//////////////////////////////////////////////////

    1717. 

  1717. 

    1718. 

  1718. 					

    1719. 

  1719. 	

    1720. 

  1720. 					///

    1721. 

  1721. 					///killmail Switch

    1722. 

  1722. 					///

    1723. 

  1723. 					case "-killmail":

    1724. 

  1724. 						try

    1725. 

  1725. 						{

    1726. 

  1726. 							killmail = true;

    1727. 

  1727. 							bitflipped = true;

    1728. 

  1728. 							

    1729. 

  1729. 						}

    1730. 

  1730. 						catch(System.Exception caught)

    1731. 

  1731. 						{

    1732. 

  1732. 							Console.WriteLine(caught.Message);

    1733. 

  1733. 							return;

    1734. 

  1734. 						}

    1735. 

  1735. 						

    1736. 

  1736. 						break;

    1737. 

  1737. 

    1738. 

  1738. 					///

    1739. 

  1739. 					///Include in Recipient Policy Switch

    1740. 

  1740. 					///

    1741. 

  1741. 					case "-includeinrecipientpolicy":

    1742. 

  1742. 						try

    1743. 

  1743. 						{

    1744. 

  1744. 							includeinrecipientpolicy = true;

    1745. 

  1745. 							bitflipped = true;

    1746. 

  1746. 							

    1747. 

  1747. 						}

    1748. 

  1748. 						catch(System.Exception caught)

    1749. 

  1749. 						{

    1750. 

  1750. 							Console.WriteLine(caught.Message);

    1751. 

  1751. 							return;

    1752. 

  1752. 						}

    1753. 

  1753. 						

    1754. 

  1754. 						break;

    1755. 

  1755. 

    1756. 

  1756. 					///

    1757. 

  1757. 					///Exclude from Recipient Policy Switch

    1758. 

  1758. 					///

    1759. 

  1759. 					case "-excludefromrecipientpolicy":

    1760. 

  1760. 						try

    1761. 

  1761. 						{

    1762. 

  1762. 							excludefromrecipientpolicy = true;

    1763. 

  1763. 							bitflipped = true;

    1764. 

  1764. 							

    1765. 

  1765. 						}

    1766. 

  1766. 						catch(System.Exception caught)

    1767. 

  1767. 						{

    1768. 

  1768. 							Console.WriteLine(caught.Message);

    1769. 

  1769. 							return;

    1770. 

  1770. 						}

    1771. 

  1771. 						

    1772. 

  1772. 						break;

    1773. 

  1773. 

    1774. 

  1774. 

    1775. 

  1775. 					///

    1776. 

  1776. 					///hide from address lists

    1777. 

  1777. 					///

    1778. 

  1778. 

    1779. 

  1779. 					case "-hidefromaddresslists":

    1780. 

  1780. 						try

    1781. 

  1781. 						{

    1782. 

  1782. 							hidefromaddresslists = true;

    1783. 

  1783. 							bitflipped = true;

    1784. 

  1784. 						}

    1785. 

  1785. 						catch(System.Exception caught)

    1786. 

  1786. 						{

    1787. 

  1787. 							Console.WriteLine(caught.Message);

    1788. 

  1788. 							return;

    1789. 

  1789. 						}

    1790. 

  1790. 						break;

    1791. 

  1791. 

    1792. 

  1792. 

    1793. 

  1793. 					///

    1794. 

  1794. 					///show in address lists

    1795. 

  1795. 					///

    1796. 

  1796. 

    1797. 

  1797. 					case "-showinaddresslists":

    1798. 

  1798. 						try

    1799. 

  1799. 						{

    1800. 

  1800. 							showinaddresslists = true;

    1801. 

  1801. 							bitflipped = true;

    1802. 

  1802. 						}

    1803. 

  1803. 						catch(System.Exception caught)

    1804. 

  1804. 						{

    1805. 

  1805. 							Console.WriteLine(caught.Message);

    1806. 

  1806. 							return;

    1807. 

  1807. 						}

    1808. 

  1808. 						break;

    1809. 

  1809. 

    1810. 

  1810. 

    1811. 

  1811. 

    1812. 

  1812. 					///

    1813. 

  1813. 					///Include in Mailbox Manager Policy Switch

    1814. 

  1814. 					///

    1815. 

  1815. 					case "-includeinmailboxmanager":

    1816. 

  1816. 						try

    1817. 

  1817. 						{

    1818. 

  1818. 							includeinmailboxmanager = true;

    1819. 

  1819. 							bitflipped = true;

    1820. 

  1820. 							

    1821. 

  1821. 						}

    1822. 

  1822. 						catch(System.Exception caught)

    1823. 

  1823. 						{

    1824. 

  1824. 							Console.WriteLine(caught.Message);

    1825. 

  1825. 							return;

    1826. 

  1826. 						}

    1827. 

  1827. 						

    1828. 

  1828. 						break;

    1829. 

  1829. 

    1830. 

  1830. 

    1831. 

  1831. 						

    1832. 

  1832. 					///

    1833. 

  1833. 					///Exclude from Mailbox Manager Policy Switch

    1834. 

  1834. 					///

    1835. 

  1835. 					case "-excludefrommailboxmanager":

    1836. 

  1836. 						try

    1837. 

  1837. 						{

    1838. 

  1838. 							excludefrommailboxmanager = true;

    1839. 

  1839. 							bitflipped = true;

    1840. 

  1840. 							

    1841. 

  1841. 						}

    1842. 

  1842. 						catch(System.Exception caught)

    1843. 

  1843. 						{

    1844. 

  1844. 							Console.WriteLine(caught.Message);

    1845. 

  1845. 							return;

    1846. 

  1846. 						}

    1847. 

  1847. 						

    1848. 

  1848. 						break;

    1849. 

  1849. 

    1850. 

  1850. 

    1851. 

  1851. 					///

    1852. 

  1852. 					///Enable HTTP

    1853. 

  1853. 					///

    1854. 

  1854. 					case "-enablehttp":

    1855. 

  1855. 						try

    1856. 

  1856. 						{

    1857. 

  1857. 							enablehttp = true;

    1858. 

  1858. 							bitflipped = true;

    1859. 

  1859. 

    1860. 

  1860. 						}

    1861. 

  1861. 						catch(System.Exception caught)

    1862. 

  1862. 						{

    1863. 

  1863. 							Console.WriteLine(caught.Message);

    1864. 

  1864. 							return;

    1865. 

  1865. 						}

    1866. 

  1866. 						break;

    1867. 

  1867. 

    1868. 

  1868. 					///

    1869. 

  1869. 					///disable HTTP

    1870. 

  1870. 					///

    1871. 

  1871. 					case "-disablehttp":

    1872. 

  1872. 						try

    1873. 

  1873. 						{

    1874. 

  1874. 							disablehttp = true;

    1875. 

  1875. 							bitflipped = true;

    1876. 

  1876. 

    1877. 

  1877. 						}

    1878. 

  1878. 						catch(System.Exception caught)

    1879. 

  1879. 						{

    1880. 

  1880. 							Console.WriteLine(caught.Message);

    1881. 

  1881. 							return;

    1882. 

  1882. 						}

    1883. 

  1883. 						break;

    1884. 

  1884. 

    1885. 

  1885. 					///

    1886. 

  1886. 					///Enable POP3

    1887. 

  1887. 					///

    1888. 

  1888. 					case "-enablepop3":

    1889. 

  1889. 						try

    1890. 

  1890. 						{

    1891. 

  1891. 							enablepop3 = true;

    1892. 

  1892. 							bitflipped = true;

    1893. 

  1893. 

    1894. 

  1894. 						}

    1895. 

  1895. 						catch(System.Exception caught)

    1896. 

  1896. 						{

    1897. 

  1897. 							Console.WriteLine(caught.Message);

    1898. 

  1898. 							return;

    1899. 

  1899. 						}

    1900. 

  1900. 						break;

    1901. 

  1901. 

    1902. 

  1902. 

    1903. 

  1903. 					///

    1904. 

  1904. 					///Disable POP3

    1905. 

  1905. 					///

    1906. 

  1906. 					case "-disablepop3":

    1907. 

  1907. 						try

    1908. 

  1908. 						{

    1909. 

  1909. 							disablepop3 = true;

    1910. 

  1910. 							bitflipped = true;

    1911. 

  1911. 

    1912. 

  1912. 						}

    1913. 

  1913. 						catch(System.Exception caught)

    1914. 

  1914. 						{

    1915. 

  1915. 							Console.WriteLine(caught.Message);

    1916. 

  1916. 							return;

    1917. 

  1917. 						}

    1918. 

  1918. 						break;

    1919. 

  1919. 

    1920. 

  1920. 

    1921. 

  1921. 					///

    1922. 

  1922. 					///Enable IMAP4

    1923. 

  1923. 					///

    1924. 

  1924. 					case "-enableimap4":

    1925. 

  1925. 						try

    1926. 

  1926. 						{

    1927. 

  1927. 							enableimap4 = true;

    1928. 

  1928. 							bitflipped = true;

    1929. 

  1929. 

    1930. 

  1930. 						}

    1931. 

  1931. 						catch(System.Exception caught)

    1932. 

  1932. 						{

    1933. 

  1933. 							Console.WriteLine(caught.Message);

    1934. 

  1934. 							return;

    1935. 

  1935. 						}

    1936. 

  1936. 						break;

    1937. 

  1937. 

    1938. 

  1938. 

    1939. 

  1939. 					///

    1940. 

  1940. 					///Disable IMAP4

    1941. 

  1941. 					///

    1942. 

  1942. 					case "-disableimap4":

    1943. 

  1943. 						try

    1944. 

  1944. 						{

    1945. 

  1945. 							disableimap4 = true;

    1946. 

  1946. 							bitflipped = true;

    1947. 

  1947. 

    1948. 

  1948. 						}

    1949. 

  1949. 						catch(System.Exception caught)

    1950. 

  1950. 						{

    1951. 

  1951. 							Console.WriteLine(caught.Message);

    1952. 

  1952. 							return;

    1953. 

  1953. 						}

    1954. 

  1954. 						break;

    1955. 

  1955. 

    1956. 

  1956. 					///

    1957. 

  1957. 					///Enable MAPI

    1958. 

  1958. 					///

    1959. 

  1959. 

    1960. 

  1960. 					case "-enablemapi":

    1961. 

  1961. 						try

    1962. 

  1962. 						{

    1963. 

  1963. 							enablemapi=true;

    1964. 

  1964. 							bitflipped=true;

    1965. 

  1965. 						}

    1966. 

  1966. 						catch(System.Exception caught)

    1967. 

  1967. 						{

    1968. 

  1968. 							Console.WriteLine(caught.Message);

    1969. 

  1969. 							return;

    1970. 

  1970. 						}

    1971. 

  1971. 						break;

    1972. 

  1972. 						

    1973. 

  1973. 					///

    1974. 

  1974. 					///Disable MAPI

    1975. 

  1975. 					///

    1976. 

  1976. 					case "-disablemapi":

    1977. 

  1977. 						try

    1978. 

  1978. 						{

    1979. 

  1979. 							disablemapi=true;

    1980. 

  1980. 							bitflipped=true;

    1981. 

  1981. 						}

    1982. 

  1982. 						catch(System.Exception caught)

    1983. 

  1983. 						{

    1984. 

  1984. 							Console.WriteLine(caught.Message);

    1985. 

  1985. 							return;

    1986. 

  1986. 						}

    1987. 

  1987. 						break;

    1988. 

  1988. 

    1989. 

  1989. 					///

    1990. 

  1990. 					///Enable cached mode MAPI only

    1991. 

  1991. 					///

    1992. 

  1992. 					case "-enablecachedmapi":

    1993. 

  1993. 						try

    1994. 

  1994. 						{

    1995. 

  1995. 							enablecachedmapi=true;

    1996. 

  1996. 							bitflipped=true;

    1997. 

  1997. 						}

    1998. 

  1998. 						catch(System.Exception caught)

    1999. 

  1999. 						{

    2000. 

  2000. 							Console.WriteLine(caught.Message);

    2001. 

  2001. 							return;

    2002. 

  2002. 						}

    2003. 

  2003. 						break;

    2004. 

  2004. 

    2005. 

  2005. 

    2006. 

  2006.                     

    2007. 

  2007. 					///

    2008. 

  2008. 					///Add SMTP address switch

    2009. 

  2009. 					///

    2010. 

  2010. 					case "-addsmtp":

    2011. 

  2011. 						try

    2012. 

  2012. 						{

    2013. 

  2013. 

    2014. 

  2014. 						

    2015. 

  2015. 							if(args[i+1].StartsWith("@"))

    2016. 

  2016. 							{

    2017. 

  2017. 								Console.WriteLine("SMTP Address must begin with a variable, not an @ sign");

    2018. 

  2018. 								return;

    2019. 

  2019. 							}

    2020. 

  2020. 							else

    2021. 

  2021. 							{

    2022. 

  2022. 								smtpaddress = args[i+1];

    2023. 

  2023. 								i++;

    2024. 

  2024. 								bitflipped=true;

    2025. 

  2025. 								break;

    2026. 

  2026. 							}

    2027. 

  2027. 

    2028. 

  2028. 

    2029. 

  2029. 						}

    2030. 

  2030. 						catch(System.IndexOutOfRangeException)

    2031. 

  2031. 						{

    2032. 

  2032. 							

    2033. 

  2033. 							Console.WriteLine("Invalid value entered for E-mail address");

    2034. 

  2034. 							return;

    2035. 

  2035. 						}

    2036. 

  2036. 						catch(System.Exception caught)

    2037. 

  2037. 						{

    2038. 

  2038. 							Console.WriteLine(caught.Message);

    2039. 

  2039. 							return;

    2040. 

  2040. 						}

    2041. 

  2041. 						

    2042. 

  2042. 

    2043. 

  2043. 					///

    2044. 

  2044. 					///SMTP set as primary switch

    2045. 

  2045. 					///

    2046. 

  2046. 

    2047. 

  2047. 					case "-setasprimary":

    2048. 

  2048. 						try

    2049. 

  2049. 						{

    2050. 

  2050. 							setasprimary = true;

    2051. 

  2051. 						}

    2052. 

  2052. 						catch(System.Exception caught)

    2053. 

  2053. 						{

    2054. 

  2054. 							Console.WriteLine(caught.Message);

    2055. 

  2055. 							return;

    2056. 

  2056. 						}

    2057. 

  2057. 						break;

    2058. 

  2058. 

    2059. 

  2059. 					///

    2060. 

  2060. 					///Update mail attribute on general tab

    2061. 

  2061. 					///

    2062. 

  2062. 					case "-updatemail":

    2063. 

  2063. 						try

    2064. 

  2064. 						{

    2065. 

  2065. 							updatemail=true;

    2066. 

  2066. 						}

    2067. 

  2067. 						catch(System.Exception caught)

    2068. 

  2068. 						{

    2069. 

  2069. 							Console.WriteLine(caught.Message);

    2070. 

  2070. 							return;

    2071. 

  2071. 						}

    2072. 

  2072. 						break;

    2073. 

  2073. 

    2074. 

  2074. 

    2075. 

  2075. 

    2076. 

  2076. 					///

    2077. 

  2077. 					///Remove address switch

    2078. 

  2078. 					///

    2079. 

  2079. 						

    2080. 

  2080. 					case "-removeaddress":

    2081. 

  2081. 						try

    2082. 

  2082. 						{

    2083. 

  2083. 							if(args[i+1]!=null)

    2084. 

  2084. 							{

    2085. 

  2085. 								removeaddress = true;

    2086. 

  2086. 								addresstoremove = args[i+1];

    2087. 

  2087. 								i++;

    2088. 

  2088. 								bitflipped = true;

    2089. 

  2089. 								break;

    2090. 

  2090. 							}

    2091. 

  2091. 							else

    2092. 

  2092. 							{

    2093. 

  2093. 								Console.WriteLine("Please specify an address string for removal.");

    2094. 

  2094. 								return;

    2095. 

  2095. 							}

    2096. 

  2096. 						}

    2097. 

  2097. 						catch(System.IndexOutOfRangeException)

    2098. 

  2098. 						{

    2099. 

  2099. 							

    2100. 

  2100. 							Console.WriteLine("Invalid address string entered.");

    2101. 

  2101. 							return;

    2102. 

  2102. 						}

    2103. 

  2103. 						catch(System.Exception caught)

    2104. 

  2104. 						{

    2105. 

  2105. 							Console.WriteLine(caught.Message);

    2106. 

  2106. 							return;

    2107. 

  2107. 						}

    2108. 

  2108. 

    2109. 

  2109. 					///

    2110. 

  2110. 					///Do not remove primary address when removing email addresses

    2111. 

  2111. 					///

    2112. 

  2112. 					case "-keepprimary":

    2113. 

  2113. 						try

    2114. 

  2114. 						{

    2115. 

  2115. 							keepprimary=true;

    2116. 

  2116. 						}

    2117. 

  2117. 						catch(System.Exception caught)

    2118. 

  2118. 						{

    2119. 

  2119. 							Console.WriteLine(caught.Message);

    2120. 

  2120. 							return;

    2121. 

  2121. 						}

    2122. 

  2122. 						break;

    2123. 

  2123. 

    2124. 

  2124. 

    2125. 

  2125. 					///

    2126. 

  2126. 					///Add send-as for the specified account

    2127. 

  2127. 					///

    2128. 

  2128. 					

    2129. 

  2129. 					///some bugs so far with this one, it seems to add more than send-as.

    2130. 

  2130. 					///disabling this feature until we can determine the cause.

    2131. 

  2131. 					

    2132. 

  2132. 					case "-grantsendas":

    2133. 

  2133. 						try

    2134. 

  2134. 						{

    2135. 

  2135. 							GrantSendAsRights = true;

    2136. 

  2136. 							bitflipped = true;

    2137. 

  2137. 							Trustee = args[i+1];

    2138. 

  2138. 							i++;

    2139. 

  2139. 

    2140. 

  2140. 							break;

    2141. 

  2141. 						}

    2142. 

  2142. 						catch(System.IndexOutOfRangeException)

    2143. 

  2143. 						{

    2144. 

  2144. 							Console.WriteLine("Please enter a valid DOMAIN\\user after the -grantsendas switch.");

    2145. 

  2145. 							return;

    2146. 

  2146. 						}

    2147. 

  2147. 						catch(System.Exception caught)

    2148. 

  2148. 						{

    2149. 

  2149. 							Console.WriteLine(caught.Message);

    2150. 

  2150. 							return;

    2151. 

  2151. 						}

    2152. 

  2152. 							

    2153. 

  2153. 

    2154. 

  2154. 					///

    2155. 

  2155. 					///Set msExchMailboxSecurityDescriptor

    2156. 

  2156. 					///

    2157. 

  2157. 					

    2158. 

  2158. 					case "-setmailboxrights":

    2159. 

  2159. 						try

    2160. 

  2160. 						{

    2161. 

  2161. 							SetMailboxRights = true;

    2162. 

  2162. 							bitflipped = true;

    2163. 

  2163. 							break;

    2164. 

  2164. 						}

    2165. 

  2165. 						catch(System.Exception caught)

    2166. 

  2166. 						{

    2167. 

  2167. 							Console.WriteLine(caught.Message);

    2168. 

  2168. 							return;

    2169. 

  2169. 						}

    2170. 

  2170. 

    2171. 

  2171. 

    2172. 

  2172. 					///

    2173. 

  2173. 					///Grand send-as rights to users with full mailbox access and read

    2174. 

  2174. 					///

    2175. 

  2175. 					

    2176. 

  2176. 					case "-fixsendas":

    2177. 

  2177. 						try

    2178. 

  2178. 						{

    2179. 

  2179. 							FixSendAs = true;

    2180. 

  2180. 							bitflipped = true;

    2181. 

  2181. 							break;

    2182. 

  2182. 						}

    2183. 

  2183. 						catch(System.Exception caught)

    2184. 

  2184. 						{

    2185. 

  2185. 							Console.WriteLine(caught.Message);

    2186. 

  2186. 							return;

    2187. 

  2187. 						}

    2188. 

  2188. 

    2189. 

  2189. 

    2190. 

  2190. 					///

    2191. 

  2191. 					///Remove Send-As permissions from users with full mailbox access

    2192. 

  2192. 					///

    2193. 

  2193. 

    2194. 

  2194. 					case "-removefixsendas":

    2195. 

  2195. 						try

    2196. 

  2196. 						{

    2197. 

  2197. 							RemoveSendAs = true;

    2198. 

  2198. 							bitflipped = true;

    2199. 

  2199. 							break;

    2200. 

  2200. 						}

    2201. 

  2201. 						catch(System.Exception caught)

    2202. 

  2202. 						{

    2203. 

  2203. 							Console.WriteLine(caught.Message);

    2204. 

  2204. 							return;

    2205. 

  2205. 						}

    2206. 

  2206. 

    2207. 

  2207. 

    2208. 

  2208. 					///

    2209. 

  2209. 					///Grant SELF associated external account privileges

    2210. 

  2210. 					///

    2211. 

  2211. 

    2212. 

  2212. 					case "-grantselfaea":

    2213. 

  2213. 						try

    2214. 

  2214. 						{

    2215. 

  2215. 							GrantSelfAEA = true;

    2216. 

  2216. 							bitflipped = true;

    2217. 

  2217. 							break;

    2218. 

  2218. 						}

    2219. 

  2219. 						catch(System.Exception caught)

    2220. 

  2220. 						{

    2221. 

  2221. 							Console.WriteLine(caught.Message);

    2222. 

  2222. 							return;

    2223. 

  2223. 						}

    2224. 

  2224. 

    2225. 

  2225. 					///

    2226. 

  2226. 					///Remove associated external account from SELF

    2227. 

  2227. 					///

    2228. 

  2228. 

    2229. 

  2229. 					case "-removeaeafromself":

    2230. 

  2230. 						try

    2231. 

  2231. 						{

    2232. 

  2232. 							RemoveAEAFromSelf = true;

    2233. 

  2233. 							bitflipped = true;

    2234. 

  2234. 							break;

    2235. 

  2235. 						}

    2236. 

  2236. 						catch(System.Exception caught)

    2237. 

  2237. 						{

    2238. 

  2238. 							Console.WriteLine(caught.Message);

    2239. 

  2239. 							return;

    2240. 

  2240. 						}

    2241. 

  2241. 

    2242. 

  2242. 					///

    2243. 

  2243. 					///Grant SELF full mailbox access and Read

    2244. 

  2244. 					///

    2245. 

  2245. 

    2246. 

  2246. 					case "-grantselffullandread":

    2247. 

  2247. 						try

    2248. 

  2248. 						{

    2249. 

  2249. 							GrantSelfFullAndRead = true;

    2250. 

  2250. 							bitflipped = true;

    2251. 

  2251. 							break;

    2252. 

  2252. 						}

    2253. 

  2253. 						catch(System.Exception caught)

    2254. 

  2254. 						{

    2255. 

  2255. 							Console.WriteLine(caught.Message);

    2256. 

  2256. 							return;

    2257. 

  2257. 						}

    2258. 

  2258. 

    2259. 

  2259. 					///

    2260. 

  2260. 					///Remove Full Mailbox Access and Read from SELF

    2261. 

  2261. 					///

    2262. 

  2262. 

    2263. 

  2263. 					case "-removefullandread":

    2264. 

  2264. 						try

    2265. 

  2265. 						{

    2266. 

  2266. 							RemoveSelfFullAndRead = true;

    2267. 

  2267. 							bitflipped = true;

    2268. 

  2268. 							break;

    2269. 

  2269. 						}

    2270. 

  2270. 						catch(System.Exception caught)

    2271. 

  2271. 						{

    2272. 

  2272. 							Console.WriteLine(caught.Message);

    2273. 

  2273. 							return;

    2274. 

  2274. 						}

    2275. 

  2275. 

    2276. 

  2276. 

    2277. 

  2277. 					///

    2278. 

  2278. 					///Dump Mailbox Rights to XML file

    2279. 

  2279. 					///

    2280. 

  2280. 

    2281. 

  2281. 					case "-dumpmailboxrights":

    2282. 

  2282. 						try

    2283. 

  2283. 						{

    2284. 

  2284. 							DumpMailboxRights = true;

    2285. 

  2285. 							bitflipped = true;

    2286. 

  2286. 							break;

    2287. 

  2287. 						}

    2288. 

  2288. 						catch(System.Exception caught)

    2289. 

  2289. 						{

    2290. 

  2290. 							Console.WriteLine(caught.Message);

    2291. 

  2291. 							return;

    2292. 

  2292. 						}

    2293. 

  2293. 	

    2294. 

  2294. 					///

    2295. 

  2295. 					///Imports mailbox rights from mbxrights.xml

    2296. 

  2296. 					///

    2297. 

  2297. 

    2298. 

  2298. 					case "-importmailboxrights":

    2299. 

  2299. 						try

    2300. 

  2300. 						{

    2301. 

  2301. 							if(args[i+1].ToLower()=="overwrite")

    2302. 

  2302. 							{

    2303. 

  2303. 								MailboxRightsOverwrite = true;

    2304. 

  2304. 							}

    2305. 

  2305. 							else if(args[i+1].ToLower()=="append")

    2306. 

  2306. 							{

    2307. 

  2307. 								//do nothing, already false

    2308. 

  2308. 							}

    2309. 

  2309. 							else

    2310. 

  2310. 							{

    2311. 

  2311. 								Console.WriteLine("You must enter either overwrite or append after the -importmailboxrights switch.");

    2312. 

  2312. 								return;

    2313. 

  2313. 							}

    2314. 

  2314. 							i+=2;

    2315. 

  2315. 							ImportMailboxRights = true;

    2316. 

  2316. 							bitflipped = true;

    2317. 

  2317. 							break;

    2318. 

  2318. 						}

    2319. 

  2319. 						catch(System.IndexOutOfRangeException)

    2320. 

  2320. 						{

    2321. 

  2321. 							Console.WriteLine("You must enter either overwrite or append after the -importmailboxrights switch.");

    2322. 

  2322. 							return;

    2323. 

  2323. 						}

    2324. 

  2324. 						catch(System.Exception caught)

    2325. 

  2325. 						{

    2326. 

  2326. 							Console.WriteLine(caught.Message);

    2327. 

  2327. 							return;

    2328. 

  2328. 						}

    2329. 

  2329. 

    2330. 

  2330. 

    2331. 

  2331. 					///

    2332. 

  2332. 					///Add permission to mailbox rights

    2333. 

  2333. 					///

    2334. 

  2334. 

    2335. 

  2335. 					case "-addtomailboxrights":

    2336. 

  2336. 						try

    2337. 

  2337. 						{

    2338. 

  2338. 							bitflipped = true;

    2339. 

  2339. 							ModifyMailboxRights = true;

    2340. 

  2340. 							Trustee = args[i+1].ToUpper();

    2341. 

  2341. 							Permission = args[i+2].ToUpper();

    2342. 

  2342. 							if(Permission!="ACE_MB_FULL_ACCESS" && Permission!="ACE_MB_ASSOC_EXT_ACCT" && Permission!="ACE_MB_DELETE_MB_STORAGE" && Permission!="ACE_MB_READ_PERMISSIONS" && Permission!="ACE_MB_CHANGE_PERMISSION" && Permission!="ACE_MB_TAKE_OWNERSHIP" && Permission!="ALL")

    2343. 

  2343. 							{

    2344. 

  2344. 								Console.WriteLine("You must enter one of the following as a permissions mask:");

    2345. 

  2345. 								Console.WriteLine("\nACE_MB_FULL_ACCESS\nACE_MB_ASSOC_EXT_ACCT\nACE_MB_DELETE_MB_STORAGE\nACE_MB_READ_PERMISSIONS\nACE_MB_CHANGE_PERMISSION\nACE_MB_TAKE_OWNERSHIP\nALL\n");

    2346. 

  2346. 								Console.WriteLine("\nTo set a deny, use the -deny switch.");

    2347. 

  2347. 								return;

    2348. 

  2348. 							}

    2349. 

  2349. 							i+=2;

    2350. 

  2350. 							break;

    2351. 

  2351. 						}

    2352. 

  2352. 						catch(System.IndexOutOfRangeException)

    2353. 

  2353. 						{

    2354. 

  2354. 							

    2355. 

  2355. 							Console.WriteLine("You must enter an account to grant permissions to, followed by the permission you wish to grant.");

    2356. 

  2356. 							Console.WriteLine("The account must be in DOMAIN\\User format, and permission must be one of the following:");

    2357. 

  2357. 							Console.WriteLine("\nACE_MB_FULL_ACCESS\nACE_MB_ASSOC_EXT_ACCT\nACE_MB_DELETE_MB_STORAGE\nACE_MB_READ_PERMISSIONS\nACE_MB_CHANGE_PERMISSION\nACE_MB_TAKE_OWNERSHIP\nALL\n");

    2358. 

  2358. 							Console.WriteLine("\nTo set a deny, use the -deny switch.");

    2359. 

  2359. 							return;

    2360. 

  2360. 						}

    2361. 

  2361. 						catch(System.Exception caught)

    2362. 

  2362. 						{

    2363. 

  2363. 							Console.WriteLine(caught.Message);

    2364. 

  2364. 							return;

    2365. 

  2365. 						}

    2366. 

  2366. 

    2367. 

  2367. 					///

    2368. 

  2368. 					///Remove permissions from mailbox rights

    2369. 

  2369. 					///

    2370. 

  2370. 					case "-removefrommailboxrights":

    2371. 

  2371. 						try

    2372. 

  2372. 						{

    2373. 

  2373. 							bitflipped = true;

    2374. 

  2374. 							RemoveMailboxRights = true;

    2375. 

  2375. 							Trustee = args[i+1].ToUpper();

    2376. 

  2376. 							Permission = args[i+2].ToUpper();

    2377. 

  2377. 							if(Permission!="ACE_MB_FULL_ACCESS" && Permission!="ACE_MB_ASSOC_EXT_ACCT" && Permission!="ACE_MB_DELETE_MB_STORAGE" && Permission!="ACE_MB_READ_PERMISSIONS" && Permission!="ACE_MB_CHANGE_PERMISSION" && Permission!="ACE_MB_TAKE_OWNERSHIP" && Permission!="ALL")

    2378. 

  2378. 							{

    2379. 

  2379. 								Console.WriteLine("You must enter one of the following as a permissions mask:");

    2380. 

  2380. 								Console.WriteLine("\nACE_MB_FULL_ACCESS\nACE_MB_ASSOC_EXT_ACCT\nACE_MB_DELETE_MB_STORAGE\nACE_MB_READ_PERMISSIONS\nACE_MB_CHANGE_PERMISSION\nACE_MB_TAKE_OWNERSHIP\nALL\n");

    2381. 

  2381. 								Console.WriteLine("\nTo set a deny, use the -deny switch.");

    2382. 

  2382. 								return;

    2383. 

  2383. 							}

    2384. 

  2384. 							i+=2;

    2385. 

  2385. 							break;

    2386. 

  2386. 						}

    2387. 

  2387. 						catch(System.IndexOutOfRangeException)

    2388. 

  2388. 						{

    2389. 

  2389. 							

    2390. 

  2390. 							Console.WriteLine("You must enter an account to remove permissions from, followed by the permission you wish to remove.");

    2391. 

  2391. 							Console.WriteLine("The account must be in DOMAIN\\User format, and permission must be one of the following:");

    2392. 

  2392. 							Console.WriteLine("\nACE_MB_FULL_ACCESS\nACE_MB_ASSOC_EXT_ACCT\nACE_MB_DELETE_MB_STORAGE\nACE_MB_READ_PERMISSIONS\nACE_MB_CHANGE_PERMISSION\nACE_MB_TAKE_OWNERSHIP\nALL\n");

    2393. 

  2393. 							Console.WriteLine("\nTo set a deny, use the -deny switch.");

    2394. 

  2394. 							return;

    2395. 

  2395. 						}

    2396. 

  2396. 						catch(System.Exception caught)

    2397. 

  2397. 						{

    2398. 

  2398. 							Console.WriteLine(caught.Message);

    2399. 

  2399. 							return;

    2400. 

  2400. 						}

    2401. 

  2401. 

    2402. 

  2402. 

    2403. 

  2403. 					case "-deny":

    2404. 

  2404. 						try

    2405. 

  2405. 						{

    2406. 

  2406. 							Deny = true;

    2407. 

  2407. 							break;

    2408. 

  2408. 						}

    2409. 

  2409. 						catch(System.Exception caught)

    2410. 

  2410. 						{

    2411. 

  2411. 							Console.WriteLine(caught.Message);

    2412. 

  2412. 							return;

    2413. 

  2413. 						}

    2414. 

  2414. 

    2415. 

  2415. 

    2416. 

  2416. 					//////////////////////////////////////////////

    2417. 

  2417. 					///			User Account Settings		   ///

    2418. 

  2418. 					//////////////////////////////////////////////			

    2419. 

  2419. 				

    2420. 

  2420. 

    2421. 

  2421. 

    2422. 

  2422. 					///

    2423. 

  2423. 					///Disable Account Switch

    2424. 

  2424. 					///

    2425. 

  2425. 					case "-disableaccount":

    2426. 

  2426. 						try

    2427. 

  2427. 						{

    2428. 

  2428. 							disableaccount = true;

    2429. 

  2429. 							bitflipped = true;

    2430. 

  2430. 							

    2431. 

  2431. 						}

    2432. 

  2432. 						catch(System.Exception caught)

    2433. 

  2433. 						{

    2434. 

  2434. 							Console.WriteLine(caught.Message);

    2435. 

  2435. 							return;

    2436. 

  2436. 						}

    2437. 

  2437. 						break;

    2438. 

  2438. 

    2439. 

  2439. 

    2440. 

  2440. 					///

    2441. 

  2441. 					///Enable Account Switch

    2442. 

  2442. 					///

    2443. 

  2443. 					case "-enableaccount":

    2444. 

  2444. 						try

    2445. 

  2445. 						{

    2446. 

  2446. 							enableaccount = true;

    2447. 

  2447. 							bitflipped = true;

    2448. 

  2448. 							

    2449. 

  2449. 						}

    2450. 

  2450. 						catch(System.Exception caught)

    2451. 

  2451. 						{

    2452. 

  2452. 							Console.WriteLine(caught.Message);

    2453. 

  2453. 							return;

    2454. 

  2454. 						}

    2455. 

  2455. 						break;

    2456. 

  2456. 

    2457. 

  2457.                     ///

    2458. 

  2458.                     ///Set Password Not Required

    2459. 

  2459.                     ///

    2460. 

  2460. 

    2461. 

  2461.                     case "-passwordnotrequired":

    2462. 

  2462.                         try

    2463. 

  2463.                         {

    2464. 

  2464.                             SetPasswordNotRequired = true;

    2465. 

  2465.                             bitflipped = true;

    2466. 

  2466.                             if(args[i+1]=="yes")

    2467. 

  2467.                             {

    2468. 

  2468.                                 PasswordNotRequired = true;

    2469. 

  2469.                             }

    2470. 

  2470.                             else if(args[i+1]=="no")

    2471. 

  2471.                             {

    2472. 

  2472.                                 //do nothing, already set to false

    2473. 

  2473.                             }

    2474. 

  2474.                             else

    2475. 

  2475.                             {

    2476. 

  2476.                                 Console.WriteLine("Please specify either yes or no after the -passwordnotrequired switch.");

    2477. 

  2477.                             }

    2478. 

  2478.                             i++;

    2479. 

  2479.                             break;

    2480. 

  2480.                         }

    2481. 

  2481.                         catch (System.IndexOutOfRangeException)

    2482. 

  2482.                         {

    2483. 

  2483.                             Console.WriteLine("Please specify either yes or no after the -passwordnotrequired switch.");

    2484. 

  2484.                             return;

    2485. 

  2485.                         }

    2486. 

  2486.                         catch (System.Exception caught)

    2487. 

  2487.                         {

    2488. 

  2488.                             Console.WriteLine(caught.Message);

    2489. 

  2489.                             return;

    2490. 

  2490.                         }

    2491. 

  2491. 

    2492. 

  2492. 					//

    2493. 

  2493. 					//Password Never Expires Switch

    2494. 

  2494. 					//

    2495. 

  2495. 					case "-passwordneverexpires":

    2496. 

  2496. 						try

    2497. 

  2497. 						{

    2498. 

  2498. 							SetPasswordNeverExpires = true;

    2499. 

  2499. 							bitflipped = true;

    2500. 

  2500. 							if(args[i+1]=="yes")

    2501. 

  2501. 							{

    2502. 

  2502. 								PasswordNeverExpires = true;

    2503. 

  2503. 							}

    2504. 

  2504. 							else if(args[i+1]=="no")

    2505. 

  2505. 							{

    2506. 

  2506. 								//do nothing, already set to false

    2507. 

  2507. 							}

    2508. 

  2508. 							else

    2509. 

  2509. 							{

    2510. 

  2510. 								Console.WriteLine("Please specify either yes or no after the -passwordneverexpires switch.");

    2511. 

  2511. 							}

    2512. 

  2512. 							i++;

    2513. 

  2513. 							break;

    2514. 

  2514. 							

    2515. 

  2515. 						}

    2516. 

  2516. 						catch(System.IndexOutOfRangeException)

    2517. 

  2517. 						{

    2518. 

  2518. 							Console.WriteLine("Please specify either yes or no after the -passwordneverexpires switch.");

    2519. 

  2519. 							return;

    2520. 

  2520. 						}

    2521. 

  2521. 						catch(System.Exception caught)

    2522. 

  2522. 						{

    2523. 

  2523. 							Console.WriteLine(caught.Message);

    2524. 

  2524. 							return;

    2525. 

  2525. 						}

    2526. 

  2526. 						

    2527. 

  2527. 

    2528. 

  2528. 					//User Must Change Password At Next Logon

    2529. 

  2529. 					case "-mustchangepassword":

    2530. 

  2530. 						try

    2531. 

  2531. 						{

    2532. 

  2532. 							SetMustChangePassword = true;

    2533. 

  2533. 							bitflipped = true;

    2534. 

  2534. 							if(args[i+1]=="yes")

    2535. 

  2535. 							{

    2536. 

  2536. 								MustChangePasswd = true;

    2537. 

  2537. 							}

    2538. 

  2538. 							else if(args[i+1]=="no")

    2539. 

  2539. 							{

    2540. 

  2540. 								//do nothing, already set to false

    2541. 

  2541. 							}

    2542. 

  2542. 							else

    2543. 

  2543. 							{

    2544. 

  2544. 								Console.WriteLine("Please specify either yes or no after the -expirepassword switch.");

    2545. 

  2545. 								return;

    2546. 

  2546. 							}

    2547. 

  2547. 							i++;

    2548. 

  2548. 							break;

    2549. 

  2549. 						}

    2550. 

  2550. 						catch(System.IndexOutOfRangeException)

    2551. 

  2551. 						{

    2552. 

  2552. 							Console.WriteLine("Please specify yes or no after the -expirepassword switch.");

    2553. 

  2553. 							return;

    2554. 

  2554. 						}

    2555. 

  2555. 						catch(System.Exception caught)

    2556. 

  2556. 						{

    2557. 

  2557. 							Console.WriteLine(caught.Message);

    2558. 

  2558. 							return;

    2559. 

  2559. 						}

    2560. 

  2560. 

    2561. 

  2561. 

    2562. 

  2562. 					//User cannot change password

    2563. 

  2563. 					case "-cannotchangepassword":

    2564. 

  2564. 						try

    2565. 

  2565. 						{

    2566. 

  2566. 							SetCannotChangePassword = true;

    2567. 

  2567. 							bitflipped = true;

    2568. 

  2568. 							if(args[i+1]=="yes")

    2569. 

  2569. 							{

    2570. 

  2570. 								CannotChangePasswd = true;

    2571. 

  2571. 							}

    2572. 

  2572. 							else if(args[i+1]=="no")

    2573. 

  2573. 							{

    2574. 

  2574. 								//do nothing, already set to false

    2575. 

  2575. 							}

    2576. 

  2576. 							else

    2577. 

  2577. 							{

    2578. 

  2578. 								Console.WriteLine("Please specify either yes or no after the -cannotchangepassword switch.");

    2579. 

  2579. 								return;

    2580. 

  2580. 							}

    2581. 

  2581. 							i++;

    2582. 

  2582. 							break;

    2583. 

  2583. 						}

    2584. 

  2584. 						catch(System.IndexOutOfRangeException)

    2585. 

  2585. 						{

    2586. 

  2586. 							Console.WriteLine("Please specify yes or no after the -cannotchangepassword switch.");

    2587. 

  2587. 							return;

    2588. 

  2588. 						}

    2589. 

  2589. 						catch(System.Exception caught)

    2590. 

  2590. 						{

    2591. 

  2591. 							Console.WriteLine(caught.Message);

    2592. 

  2592. 							return;

    2593. 

  2593. 						}

    2594. 

  2594. 

    2595. 

  2595. 

    2596. 

  2596. 					//store password using reversible encryption

    2597. 

  2597. 					case "-usereversibleencryption":

    2598. 

  2598. 						try

    2599. 

  2599. 						{

    2600. 

  2600. 							SetUseReversibleEncryption = true;

    2601. 

  2601. 							bitflipped = true;

    2602. 

  2602. 							if(args[i+1]=="yes")

    2603. 

  2603. 							{

    2604. 

  2604. 								UseReversibleEncryption = true;

    2605. 

  2605. 							}

    2606. 

  2606. 							else if(args[i+1]=="no")

    2607. 

  2607. 							{

    2608. 

  2608. 								//do nothing, already set to false

    2609. 

  2609. 							}

    2610. 

  2610. 							else

    2611. 

  2611. 							{

    2612. 

  2612. 								Console.WriteLine("Please specify either yes or no after the -usereversibleencryption switch.");

    2613. 

  2613. 								return;

    2614. 

  2614. 							}

    2615. 

  2615. 							i++;

    2616. 

  2616. 							break;

    2617. 

  2617. 						}

    2618. 

  2618. 						catch(System.IndexOutOfRangeException)

    2619. 

  2619. 						{

    2620. 

  2620. 							Console.WriteLine("Please specify yes or no after the -usereversibleencryption switch.");

    2621. 

  2621. 							return;

    2622. 

  2622. 						}

    2623. 

  2623. 						catch(System.Exception caught)

    2624. 

  2624. 						{

    2625. 

  2625. 							Console.WriteLine(caught.Message);

    2626. 

  2626. 							return;

    2627. 

  2627. 						}

    2628. 

  2628. 

    2629. 

  2629. 

    2630. 

  2630. 					//smart card required for interactive logon

    2631. 

  2631. 					case "-smartcardrequired":

    2632. 

  2632. 						try

    2633. 

  2633. 						{

    2634. 

  2634. 							SetRequireSmartCard = true;

    2635. 

  2635. 							bitflipped = true;

    2636. 

  2636. 							if(args[i+1]=="yes")

    2637. 

  2637. 							{

    2638. 

  2638. 								RequireSmartCard = true;

    2639. 

  2639. 							}

    2640. 

  2640. 							else if(args[i+1]=="no")

    2641. 

  2641. 							{

    2642. 

  2642. 								//do nothing, already set to false

    2643. 

  2643. 							}

    2644. 

  2644. 							else

    2645. 

  2645. 							{

    2646. 

  2646. 								Console.WriteLine("Please specify either yes or no after the -smartcardrequired switch.");

    2647. 

  2647. 								return;

    2648. 

  2648. 							}

    2649. 

  2649. 							i++;

    2650. 

  2650. 							break;

    2651. 

  2651. 						}

    2652. 

  2652. 						catch(System.IndexOutOfRangeException)

    2653. 

  2653. 						{

    2654. 

  2654. 							Console.WriteLine("Please specify yes or no after the -smartcardrequired switch.");

    2655. 

  2655. 							return;

    2656. 

  2656. 						}

    2657. 

  2657. 						catch(System.Exception caught)

    2658. 

  2658. 						{

    2659. 

  2659. 							Console.WriteLine(caught.Message);

    2660. 

  2660. 							return;

    2661. 

  2661. 						}

    2662. 

  2662. 

    2663. 

  2663. 

    2664. 

  2664. 					//account cannot be delegated

    2665. 

  2665. 					case "-cannotbedelegated":

    2666. 

  2666. 						try

    2667. 

  2667. 						{

    2668. 

  2668. 							SetCannotBeDelegated = true;

    2669. 

  2669. 							bitflipped = true;

    2670. 

  2670. 							if(args[i+1]=="yes")

    2671. 

  2671. 							{

    2672. 

  2672. 								CannotBeDelegated = true;

    2673. 

  2673. 							}

    2674. 

  2674. 							else if(args[i+1]=="no")

    2675. 

  2675. 							{

    2676. 

  2676. 								//do nothing, already set to false

    2677. 

  2677. 							}

    2678. 

  2678. 							else

    2679. 

  2679. 							{

    2680. 

  2680. 								Console.WriteLine("Please specify either yes or no after the -cannotbedelegated switch.");

    2681. 

  2681. 								return;

    2682. 

  2682. 							}

    2683. 

  2683. 							i++;

    2684. 

  2684. 							break;

    2685. 

  2685. 						}

    2686. 

  2686. 						catch(System.IndexOutOfRangeException)

    2687. 

  2687. 						{

    2688. 

  2688. 							Console.WriteLine("Please specify yes or no after the -cannotbedelegated switch.");

    2689. 

  2689. 							return;

    2690. 

  2690. 						}

    2691. 

  2691. 						catch(System.Exception caught)

    2692. 

  2692. 						{

    2693. 

  2693. 							Console.WriteLine(caught.Message);

    2694. 

  2694. 							return;

    2695. 

  2695. 						}

    2696. 

  2696. 

    2697. 

  2697. 

    2698. 

  2698. 					//account cannot be delegated

    2699. 

  2699. 					case "-usedesencryption":

    2700. 

  2700. 						try

    2701. 

  2701. 						{

    2702. 

  2702. 							SetUseDESEncryption = true;

    2703. 

  2703. 							bitflipped = true;

    2704. 

  2704. 							if(args[i+1]=="yes")

    2705. 

  2705. 							{

    2706. 

  2706. 								UseDESEncryption = true;

    2707. 

  2707. 							}

    2708. 

  2708. 							else if(args[i+1]=="no")

    2709. 

  2709. 							{

    2710. 

  2710. 								//do nothing, already set to false

    2711. 

  2711. 							}

    2712. 

  2712. 							else

    2713. 

  2713. 							{

    2714. 

  2714. 								Console.WriteLine("Please specify either yes or no after the -usedesencryption switch.");

    2715. 

  2715. 								return;

    2716. 

  2716. 							}

    2717. 

  2717. 							i++;

    2718. 

  2718. 							break;

    2719. 

  2719. 						}

    2720. 

  2720. 						catch(System.IndexOutOfRangeException)

    2721. 

  2721. 						{

    2722. 

  2722. 							Console.WriteLine("Please specify yes or no after the -usedesencryption switch.");

    2723. 

  2723. 							return;

    2724. 

  2724. 						}

    2725. 

  2725. 						catch(System.Exception caught)

    2726. 

  2726. 						{

    2727. 

  2727. 							Console.WriteLine(caught.Message);

    2728. 

  2728. 							return;

    2729. 

  2729. 						}

    2730. 

  2730. 

    2731. 

  2731. 

    2732. 

  2732. 					

    2733. 

  2733. 					//account cannot be delegated

    2734. 

  2734. 					case "-donotrequirekerberospreauth":

    2735. 

  2735. 						try

    2736. 

  2736. 						{

    2737. 

  2737. 							SetDoNotRequireKerberosPreAuth = true;

    2738. 

  2738. 							bitflipped = true;

    2739. 

  2739. 							if(args[i+1]=="yes")

    2740. 

  2740. 							{

    2741. 

  2741. 								DoNotRequireKerberosPreAuth = true;

    2742. 

  2742. 							}

    2743. 

  2743. 							else if(args[i+1]=="no")

    2744. 

  2744. 							{

    2745. 

  2745. 								//do nothing, already set to false

    2746. 

  2746. 							}

    2747. 

  2747. 							else

    2748. 

  2748. 							{

    2749. 

  2749. 								Console.WriteLine("Please specify either yes or no after the -donotrequirekerberospreauth switch.");

    2750. 

  2750. 								return;

    2751. 

  2751. 							}

    2752. 

  2752. 							i++;

    2753. 

  2753. 							break;

    2754. 

  2754. 						}

    2755. 

  2755. 						catch(System.IndexOutOfRangeException)

    2756. 

  2756. 						{

    2757. 

  2757. 							Console.WriteLine("Please specify yes or no after the -donotrequirekerberospreauth switch.");

    2758. 

  2758. 							return;

    2759. 

  2759. 						}

    2760. 

  2760. 						catch(System.Exception caught)

    2761. 

  2761. 						{

    2762. 

  2762. 							Console.WriteLine(caught.Message);

    2763. 

  2763. 							return;

    2764. 

  2764. 						}

    2765. 

  2765. 

    2766. 

  2766. 					//Account expires

    2767. 

  2767. 					case "-accountexpires":

    2768. 

  2768. 						try

    2769. 

  2769. 						{

    2770. 

  2770. 							SetAccountExpires = true;

    2771. 

  2771. 							bitflipped = true;

    2772. 

  2772. 							ExpireTime = args[i+1];

    2773. 

  2773. 						}

    2774. 

  2774. 						catch(System.IndexOutOfRangeException)

    2775. 

  2775. 						{

    2776. 

  2776. 							Console.WriteLine("Please specify a valid date/time after the -accountexpires switch.");

    2777. 

  2777. 							return;

    2778. 

  2778. 						}

    2779. 

  2779. 						catch(System.Exception caught)

    2780. 

  2780. 						{

    2781. 

  2781. 							Console.WriteLine(caught.Message);

    2782. 

  2782. 							return;

    2783. 

  2783. 						}

    2784. 

  2784. 						i++;

    2785. 

  2785. 						break;

    2786. 

  2786. 

    2787. 

  2787. 

    2788. 

  2788. 					//add users to a group

    2789. 

  2789. 					case "-addtogroup":

    2790. 

  2790. 						try

    2791. 

  2791. 						{

    2792. 

  2792. 							AddMembersToGroup = true;

    2793. 

  2793. 							DNOfGroup = args[i+1];

    2794. 

  2794. 							bitflipped = true;

    2795. 

  2795. 							i++;

    2796. 

  2796. 							break;

    2797. 

  2797. 						}

    2798. 

  2798. 						catch(System.IndexOutOfRangeException)

    2799. 

  2799. 						{

    2800. 

  2800. 							Console.WriteLine("Please specify the DN of the group to add members to after the -addtogroup switch.");

    2801. 

  2801. 							return;

    2802. 

  2802. 						}

    2803. 

  2803. 						catch(System.Exception caught)

    2804. 

  2804. 						{

    2805. 

  2805. 							Console.WriteLine(caught.Message);

    2806. 

  2806. 							return;

    2807. 

  2807. 						}

    2808. 

  2808. 						

    2809. 

  2809. 

    2810. 

  2810. 

    2811. 

  2811. 					//remove users from a group

    2812. 

  2812. 					case "-removefromgroup":

    2813. 

  2813. 						try

    2814. 

  2814. 						{

    2815. 

  2815. 							RemoveMembersFromGroup = true;

    2816. 

  2816. 							DNOfGroup = args[i+1];

    2817. 

  2817. 							bitflipped = true;

    2818. 

  2818. 							i++;

    2819. 

  2819. 							break;

    2820. 

  2820. 						}

    2821. 

  2821. 						catch(System.IndexOutOfRangeException)

    2822. 

  2822. 						{

    2823. 

  2823. 							Console.WriteLine("Please specify the DN of the group to remove members from after the -removefromgroup switch.");

    2824. 

  2824. 						}

    2825. 

  2825. 						catch(System.Exception caught)

    2826. 

  2826. 						{

    2827. 

  2827. 							Console.WriteLine(caught.Message);

    2828. 

  2828. 							return;

    2829. 

  2829. 						}

    2830. 

  2830. 						break;

    2831. 

  2831. 

    2832. 

  2832. 

    2833. 

  2833. 					//change RDN

    2834. 

  2834. 					case "-modrdn":

    2835. 

  2835. 						try

    2836. 

  2836. 						{

    2837. 

  2837. 							ModifyRDN = true;

    2838. 

  2838. 							NewRDN = args[i+1];

    2839. 

  2839. 							bitflipped = true;

    2840. 

  2840. 							i++;

    2841. 

  2841. 							break;

    2842. 

  2842. 						}

    2843. 

  2843. 						catch(System.IndexOutOfRangeException)

    2844. 

  2844. 						{

    2845. 

  2845. 							Console.WriteLine("Please specify the new RDN value after the -modrdn switch.");

    2846. 

  2846. 							return;

    2847. 

  2847. 						}

    2848. 

  2848. 						catch(System.Exception caught)

    2849. 

  2849. 						{

    2850. 

  2850. 							Console.WriteLine(caught.Message);

    2851. 

  2851. 							return;

    2852. 

  2852. 						}

    2853. 

  2853. 						

    2854. 

  2854. 

    2855. 

  2855. 

    2856. 

  2856. 					////////////////////////////////////////////

    2857. 

  2857. 					///			Permissions Settings		 ///

    2858. 

  2858. 					////////////////////////////////////////////

    2859. 

  2859. 					

    2860. 

  2860. 

    2861. 

  2861. 					//

    2862. 

  2862. 					// Allow inheritable permissions to propagate switch

    2863. 

  2863. 					//

    2864. 

  2864. 					case "-allowinheritable":

    2865. 

  2865. 						try

    2866. 

  2866. 						{

    2867. 

  2867. 							if(args[i+1]=="yes")

    2868. 

  2868. 							{

    2869. 

  2869. 								AllowInheritable = true;

    2870. 

  2870. 							}

    2871. 

  2871. 							else if(args[i+1]=="no")

    2872. 

  2872. 							{

    2873. 

  2873. 								//do nothing, already false

    2874. 

  2874. 							}

    2875. 

  2875. 							else

    2876. 

  2876. 							{

    2877. 

  2877. 								Console.WriteLine("Please specify yes or no after the -allowinheritable switch.");

    2878. 

  2878. 								return;

    2879. 

  2879. 							}

    2880. 

  2880. 							Setallowinheritable = true;

    2881. 

  2881. 							bitflipped = true;

    2882. 

  2882. 							i++;

    2883. 

  2883. 							

    2884. 

  2884. 							

    2885. 

  2885. 						}

    2886. 

  2886. 						catch(System.IndexOutOfRangeException)

    2887. 

  2887. 						{

    2888. 

  2888. 							Console.WriteLine("Please specify yes or no after the -allowinheritable switch.");

    2889. 

  2889. 							return;

    2890. 

  2890. 						}

    2891. 

  2891. 						catch(System.Exception caught)

    2892. 

  2892. 						{

    2893. 

  2893. 							Console.WriteLine(caught.Message);

    2894. 

  2894. 							return;

    2895. 

  2895. 						}

    2896. 

  2896. 						break;

    2897. 

  2897. 					

    2898. 

  2898. 

    2899. 

  2899. 

    2900. 

  2900. 					default:

    2901. 

  2901. 						//An inavlid switch was entered, notify the user

    2902. 

  2902. 						Console.WriteLine("\n" + args[i] + " is not a valid switch.  Please type admodify -? for usage.");

    2903. 

  2903. 						return;

    2904. 

  2904. 						

    2905. 

  2905. 

    2906. 

  2906. 					///////////////////////////////////////////

    2907. 

  2907. 					///			Customized Attributes		///

    2908. 

  2908. 					///////////////////////////////////////////

    2909. 

  2909. 					

    2910. 

  2910. 					///This section is why we removed the switches that modify most Integer/String values.

    2911. 

  2911. 					///Basically, instead of building in code for all of these attributes, we can just have

    2912. 

  2912. 					///the user name the attribute and the value instead.  

    2913. 

  2913. 					

    2914. 

  2914. 

    2915. 

  2915. 					case "-custom":

    2916. 

  2916. 						try

    2917. 

  2917. 						{

    2918. 

  2918. 							customAttributeName = args[i+1];

    2919. 

  2919. 							customAttributeValue = args[i+2];

    2920. 

  2920. 							i=i+2;

    2921. 

  2921. 							bitflipped = true;

    2922. 

  2922. 							break;

    2923. 

  2923. 						}

    2924. 

  2924. 						catch(System.IndexOutOfRangeException)

    2925. 

  2925. 						{

    2926. 

  2926. 							Console.WriteLine("\nPlease specify an attribute name and value.");

    2927. 

  2927. 							return;

    2928. 

  2928. 						}

    2929. 

  2929. 						catch(System.Exception caught)

    2930. 

  2930. 						{

    2931. 

  2931. 							Console.WriteLine(caught.Message);

    2932. 

  2932. 							return;

    2933. 

  2933. 						}

    2934. 

  2934. 

    2935. 

  2935. 					//for appending to multivalued attributes

    2936. 

  2936. 					case "-multi":

    2937. 

  2937. 						try

    2938. 

  2938. 						{

    2939. 

  2939. 							multi = true;

    2940. 

  2940. 							if(remove)

    2941. 

  2941. 							{

    2942. 

  2942. 								Console.WriteLine("You cannot specify -multi and -remove at the same time.");

    2943. 

  2943. 								return;

    2944. 

  2944. 							}

    2945. 

  2945. 							break;

    2946. 

  2946. 						}

    2947. 

  2947. 						catch(System.Exception caught)

    2948. 

  2948. 						{

    2949. 

  2949. 							Console.WriteLine(caught.Message);

    2950. 

  2950. 							return;

    2951. 

  2951. 						}

    2952. 

  2952. 					

    2953. 

  2953. 					//for removing a single line from multivalued attributes

    2954. 

  2954. 					case "-remove":

    2955. 

  2955. 						try

    2956. 

  2956. 						{

    2957. 

  2957. 							remove = true;

    2958. 

  2958. 							if(multi)

    2959. 

  2959. 							{

    2960. 

  2960. 								Console.WriteLine("You cannot specify -multi and -remove at the same time.");

    2961. 

  2961. 								return;

    2962. 

  2962. 							}

    2963. 

  2963. 							break;

    2964. 

  2964. 						}

    2965. 

  2965. 						catch(System.Exception caught)

    2966. 

  2966. 						{

    2967. 

  2967. 							Console.WriteLine(caught.Message);

    2968. 

  2968. 							return;

    2969. 

  2969. 						}

    2970. 

  2970. 

    2971. 

  2971. 

    2972. 

  2972. 

    2973. 

  2973. 

    2974. 

  2974. 					///////////////////////////////

    2975. 

  2975. 					///		Undo Mode			///

    2976. 

  2976. 					///////////////////////////////

    2977. 

  2977. 						

    2978. 

  2978. 					case "-undo":

    2979. 

  2979. 						try

    2980. 

  2980. 						{

    2981. 

  2981. 							UndoMode = true;

    2982. 

  2982. 							logFileName = args[i+1];

    2983. 

  2983. 							i++;

    2984. 

  2984. 							break;

    2985. 

  2985. 						}

    2986. 

  2986. 						catch(System.IndexOutOfRangeException)

    2987. 

  2987. 						{

    2988. 

  2988. 							Console.WriteLine("Please Specify the name of the logfile");

    2989. 

  2989. 							return;

    2990. 

  2990. 						}

    2991. 

  2991. 						catch(System.Exception caught)

    2992. 

  2992. 						{

    2993. 

  2993. 							Console.WriteLine(caught.Message);

    2994. 

  2994. 							return;

    2995. 

  2995. 						}

    2996. 

  2996. 

    2997. 

  2997. 

    2998. 

  2998. 

    2999. 

  2999. 

    3000. 

  3000. 				}

    3001. 

  3001. 			}

    3002. 

  3002. 

    3003. 

  3003. 

    3004. 

  3004. 

    3005. 

  3005. 						//check for MBX rights import mode 			

    3006. 

  3006. 						if(ImportMailboxRights)

    3007. 

  3007. 						{

    3008. 

  3008. 							if(!File.Exists("mbxrights.xml"))

    3009. 

  3009. 							{

    3010. 

  3010. 								Console.WriteLine("\nThe file mbxrights.xml does not exist in the current directory.\nMailbox rights import cannot continue.");

    3011. 

  3011. 								return;

    3012. 

  3012. 							}

    3013. 

  3013. 							bool CMDMode = true;

    3014. 

  3014. 							ImportMailboxRights import = new ImportMailboxRights();

    3015. 

  3015. 							import.ParseXML(logWriter, CMDMode, MailboxRightsOverwrite);

    3016. 

  3016. 							endTime = System.DateTime.Now;

    3017. 

  3017. 							finalCount = endTime.Subtract(startTime);

    3018. 

  3018. 							Console.WriteLine("Operation Completed in {0} seconds.", finalCount.TotalSeconds);

    3019. 

  3019. 							return;	

    3020. 

  3020. 						}

    3021. 

  3021. 						//check for undo mode

    3022. 

  3022. 						if(UndoMode)

    3023. 

  3023. 						{

    3024. 

  3024. 							

    3025. 

  3025. 							Console.WriteLine("\nStarting ADModify in Undo mode using log file {0}", logFileName);

    3026. 

  3026. 							bool CMDMode = true;	

    3027. 

  3027. 							string ServerName = servername;	//pass the server name to write changes to

    3028. 

  3028. 							Undo undo = new Undo();

    3029. 

  3029. 							undo.ParseXML(logWriter, logFileName, CMDMode, ServerName);

    3030. 

  3030. 							endTime = System.DateTime.Now;

    3031. 

  3031. 							finalCount = endTime.Subtract(startTime);

    3032. 

  3032. 							Console.WriteLine("Operation Completed in {0} seconds.", finalCount.TotalSeconds);

    3033. 

  3033. 							return;						

    3034. 

  3034. 						}

    3035. 

  3035. 						//If no base DN was passed we fail

    3036. 

  3036. 						if(!haveDN)

    3037. 

  3037. 						{

    3038. 

  3038. 							Console.WriteLine("\nNo valid base DN was passed.  Please use the -dn switch followed by a valid base DN.\n");

    3039. 

  3039. 							return;

    3040. 

  3040. 						}

    3041. 

  3041. 						//If no valid args were passed we fail

    3042. 

  3042. 						if(!bitflipped)

    3043. 

  3043. 						{

    3044. 

  3044. 							Console.WriteLine("\nNo valid arguments were passed.  To view the admodify help, type admodcmd -?.\n");

    3045. 

  3045. 							return;

    3046. 

  3046. 						}

    3047. 

  3047. 						//If no searchbase was specified we throw an error

    3048. 

  3048. 						else if(SearchBase=="blank")

    3049. 

  3049. 						{

    3050. 

  3050. 							Console.WriteLine("Please enter a valid search base.");

    3051. 

  3051. 							return;

    3052. 

  3052. 						}

    3053. 

  3053. 						//everything checked out, now lets do some modifying.  

    3054. 

  3054. 						else		

    3055. 

  3055. 						{

    3056. 

  3056. 							GetDN(logWriter, LDAPFilter, subtree, SearchBase);

    3057. 

  3057. 						}

    3058. 

  3058. 

    3059. 

  3059. 				endTime = System.DateTime.Now;

    3060. 

  3060. 				finalCount = endTime.Subtract(startTime);

    3061. 

  3061. 				logWriter.Flush();

    3062. 

  3062. 				logWriter.Close();

    3063. 

  3063. 				Console.WriteLine("Operation Completed in {0} seconds.", finalCount.TotalSeconds);

    3064. 

  3064. 				return;

    3065. 

  3065. 

    3066. 

  3066. 				}

    3067. 

  3067. 			}

    3068. 

  3068. 

    3069. 

  3069. 	

    3070. 

  3070. 

    3071. 

  3071. 		}

    3072. 

  3072. 	
    3073.