private PathInfo ResolvePath(string pathToResolve, bool isLiteralPath, bool allowNonexistingPaths, PSCmdlet cmdlet)
{
CmdletProviderContext context = new CmdletProviderContext(cmdlet) {
SuppressWildcardExpansion = isLiteralPath
};
Collection<PathInfo> targetObject = new Collection<PathInfo>();
try
{
foreach (PathInfo info in cmdlet.SessionState.Path.GetResolvedPSPathFromPSPath(pathToResolve, context))
{
targetObject.Add(info);
}
}
catch (PSNotSupportedException exception)
{
cmdlet.ThrowTerminatingError(new ErrorRecord(exception.ErrorRecord, exception));
}
catch (DriveNotFoundException exception2)
{
cmdlet.ThrowTerminatingError(new ErrorRecord(exception2.ErrorRecord, exception2));
}
catch (ProviderNotFoundException exception3)
{
cmdlet.ThrowTerminatingError(new ErrorRecord(exception3.ErrorRecord, exception3));
}
catch (ItemNotFoundException exception4)
{
if (allowNonexistingPaths)
{
ProviderInfo provider = null;
PSDriveInfo drive = null;
string path = cmdlet.SessionState.Path.GetUnresolvedProviderPathFromPSPath(pathToResolve, context, out provider, out drive);
PathInfo item = new PathInfo(drive, provider, path, cmdlet.SessionState);
targetObject.Add(item);
}
else
{
cmdlet.ThrowTerminatingError(new ErrorRecord(exception4.ErrorRecord, exception4));
}
}
if (targetObject.Count == 1)
{
return targetObject[0];
}
Exception exception5 = PSTraceSource.NewNotSupportedException();
cmdlet.ThrowTerminatingError(new ErrorRecord(exception5, "NotSupported", ErrorCategory.NotImplemented, targetObject));
return null;
}
/// <summary>
/// To generate Catalog for the folder
/// </summary>
/// <param name="Path"> Path to folder or File </param>
/// <param name="catalogFilePath"> Catalog File Path </param>
/// <param name="catalogVersion"> Catalog File Path </param>
/// <param name="cmdlet"> Instance of cmdlet calling this method </param>
/// <returns> true if able to generate .cat file or false </returns>
internal static FileInfo GenerateCatalog(PSCmdlet cmdlet, Collection <string> Path, string catalogFilePath, int catalogVersion)
{
_cmdlet = cmdlet;
string hashAlgorithm = GetCatalogHashAlgorithm(catalogVersion);
if (!String.IsNullOrEmpty(hashAlgorithm))
{
// Generate Path for Catalog Definition File
string cdfFilePath = System.IO.Path.Combine(System.IO.Path.GetTempPath(), System.IO.Path.GetRandomFileName());
cdfFilePath = cdfFilePath + ".cdf";
try
{
cdfFilePath = GenerateCDFFile(Path, catalogFilePath, cdfFilePath, catalogVersion, hashAlgorithm);
if (!File.Exists(cdfFilePath))
{
// If we are not able to generate catalog definition file we can not continue generating catalog
// throw PSTraceSource.NewInvalidOperationException("catalog", CatalogStrings.CatalogDefinitionFileNotGenerated);
ErrorRecord errorRecord = new ErrorRecord(new InvalidOperationException(CatalogStrings.CatalogDefinitionFileNotGenerated), "CatalogDefinitionFileNotGenerated", ErrorCategory.InvalidOperation, null);
_cmdlet.ThrowTerminatingError(errorRecord);
}
GenerateCatalogFile(cdfFilePath);
if (File.Exists(catalogFilePath))
{
return(new FileInfo(catalogFilePath));
}
}
finally
{
File.Delete(cdfFilePath);
}
}
return(null);
}
internal void IncrementModuleNestingDepth(PSCmdlet cmdlet, string path)
{
if (++this._moduleNestingDepth > 10)
{
InvalidOperationException exception = new InvalidOperationException(StringUtil.Format(Modules.ModuleTooDeeplyNested, path, 10));
ErrorRecord errorRecord = new ErrorRecord(exception, "Modules_ModuleTooDeeplyNested", ErrorCategory.InvalidOperation, path);
cmdlet.ThrowTerminatingError(errorRecord);
}
}
internal void IncrementModuleNestingDepth(PSCmdlet cmdlet, string path)
{
if (++this._moduleNestingDepth <= ModuleIntrinsics.MaxModuleNestingDepth)
{
return;
}
ErrorRecord errorRecord = new ErrorRecord((Exception) new InvalidOperationException(ResourceManagerCache.FormatResourceString("Modules", "ModuleTooDeeplyNested", (object)path, (object)ModuleIntrinsics.MaxModuleNestingDepth)), "Modules_ModuleTooDeeplyNested", ErrorCategory.InvalidOperation, (object)path);
cmdlet.ThrowTerminatingError(errorRecord);
}
internal static DirectoryInfo CreateModuleDirectory(PSCmdlet cmdlet, string moduleNameOrPath, bool force)
{
DirectoryInfo targetObject = null;
try
{
string str = ModuleCmdletBase.ResolveRootedFilePath(moduleNameOrPath, cmdlet.Context);
if (string.IsNullOrEmpty(str) && moduleNameOrPath.StartsWith(".", StringComparison.OrdinalIgnoreCase))
{
str = Path.Combine(cmdlet.CurrentProviderLocation(cmdlet.Context.ProviderNames.FileSystem).ProviderPath, moduleNameOrPath);
}
if (string.IsNullOrEmpty(str))
{
str = Path.Combine(ModuleIntrinsics.GetPersonalModulePath(), moduleNameOrPath);
}
targetObject = new DirectoryInfo(str);
if (targetObject.Exists)
{
if (!force)
{
ErrorDetails details = new ErrorDetails(string.Format(CultureInfo.InvariantCulture, PathUtilsStrings.ExportPSSession_ErrorDirectoryExists, new object[] { targetObject.FullName }));
ErrorRecord errorRecord = new ErrorRecord(new ArgumentException(details.Message), "ExportProxyCommand_OutputDirectoryExists", ErrorCategory.ResourceExists, targetObject);
cmdlet.ThrowTerminatingError(errorRecord);
}
return(targetObject);
}
targetObject.Create();
}
catch (Exception exception)
{
CommandProcessorBase.CheckForSevereException(exception);
ErrorDetails details2 = new ErrorDetails(string.Format(CultureInfo.InvariantCulture, PathUtilsStrings.ExportPSSession_CannotCreateOutputDirectory, new object[] { moduleNameOrPath, exception.Message }));
ErrorRecord record2 = new ErrorRecord(new ArgumentException(details2.Message, exception), "ExportProxyCommand_CannotCreateOutputDirectory", ErrorCategory.ResourceExists, moduleNameOrPath);
cmdlet.ThrowTerminatingError(record2);
}
return(targetObject);
}
internal static GraphicalHostReflectionWrapper GetGraphicalHostReflectionWrapper(PSCmdlet parentCmdlet, string graphicalHostHelperTypeName, string featureName)
{
GraphicalHostReflectionWrapper wrapper = new GraphicalHostReflectionWrapper();
if (IsInputFromRemoting(parentCmdlet))
{
ErrorRecord errorRecord = new ErrorRecord(new NotSupportedException(StringUtil.Format(HelpErrors.RemotingNotSupportedForFeature, featureName)), "RemotingNotSupported", ErrorCategory.InvalidOperation, parentCmdlet);
parentCmdlet.ThrowTerminatingError(errorRecord);
}
AssemblyName assemblyRef = new AssemblyName {
Name = "Microsoft.PowerShell.GraphicalHost",
Version = new Version(3, 0, 0, 0),
CultureInfo = new CultureInfo(string.Empty)
};
assemblyRef.SetPublicKeyToken(new byte[] { 0x31, 0xbf, 0x38, 0x56, 0xad, 0x36, 0x4e, 0x35 });
try
{
wrapper.graphicalHostAssembly = Assembly.Load(assemblyRef);
}
catch (FileNotFoundException exception)
{
string message = StringUtil.Format(HelpErrors.GraphicalHostAssemblyIsNotFound, featureName, exception.Message);
parentCmdlet.ThrowTerminatingError(new ErrorRecord(new NotSupportedException(message, exception), "ErrorLoadingAssembly", ErrorCategory.ObjectNotFound, assemblyRef));
}
catch (Exception exception2)
{
CommandProcessorBase.CheckForSevereException(exception2);
parentCmdlet.ThrowTerminatingError(new ErrorRecord(exception2, "ErrorLoadingAssembly", ErrorCategory.ObjectNotFound, assemblyRef));
}
wrapper.graphicalHostHelperType = wrapper.graphicalHostAssembly.GetType(graphicalHostHelperTypeName);
ConstructorInfo info = wrapper.graphicalHostHelperType.GetConstructor(BindingFlags.NonPublic | BindingFlags.Instance, null, new Type[0], null);
if (info != null)
{
wrapper.graphicalHostHelperObject = info.Invoke(new object[0]);
}
return wrapper;
}
internal static DirectoryInfo CreateModuleDirectory(PSCmdlet cmdlet, string moduleNameOrPath, bool force)
{
DirectoryInfo targetObject = null;
try
{
string str = ModuleCmdletBase.ResolveRootedFilePath(moduleNameOrPath, cmdlet.Context);
if (string.IsNullOrEmpty(str) && moduleNameOrPath.StartsWith(".", StringComparison.OrdinalIgnoreCase))
{
str = Path.Combine(cmdlet.CurrentProviderLocation(cmdlet.Context.ProviderNames.FileSystem).ProviderPath, moduleNameOrPath);
}
if (string.IsNullOrEmpty(str))
{
str = Path.Combine(ModuleIntrinsics.GetPersonalModulePath(), moduleNameOrPath);
}
targetObject = new DirectoryInfo(str);
if (targetObject.Exists)
{
if (!force)
{
ErrorDetails details = new ErrorDetails(string.Format(CultureInfo.InvariantCulture, PathUtilsStrings.ExportPSSession_ErrorDirectoryExists, new object[] { targetObject.FullName }));
ErrorRecord errorRecord = new ErrorRecord(new ArgumentException(details.Message), "ExportProxyCommand_OutputDirectoryExists", ErrorCategory.ResourceExists, targetObject);
cmdlet.ThrowTerminatingError(errorRecord);
}
return targetObject;
}
targetObject.Create();
}
catch (Exception exception)
{
CommandProcessorBase.CheckForSevereException(exception);
ErrorDetails details2 = new ErrorDetails(string.Format(CultureInfo.InvariantCulture, PathUtilsStrings.ExportPSSession_CannotCreateOutputDirectory, new object[] { moduleNameOrPath, exception.Message }));
ErrorRecord record2 = new ErrorRecord(new ArgumentException(details2.Message, exception), "ExportProxyCommand_CannotCreateOutputDirectory", ErrorCategory.ResourceExists, moduleNameOrPath);
cmdlet.ThrowTerminatingError(record2);
}
return targetObject;
}
internal static void MasterStreamOpen(PSCmdlet cmdlet, string filePath, Encoding resolvedEncoding, bool defaultEncoding, bool Append, bool Force, bool NoClobber, out FileStream fileStream, out StreamWriter streamWriter, out FileInfo readOnlyFileInfo, bool isLiteralPath)
{
fileStream = null;
streamWriter = null;
readOnlyFileInfo = null;
string path = ResolveFilePath(filePath, cmdlet, isLiteralPath);
try
{
FileMode create = FileMode.Create;
if (Append)
{
create = FileMode.Append;
}
else if (NoClobber)
{
create = FileMode.CreateNew;
}
if ((Force && (Append || !NoClobber)) && File.Exists(path))
{
FileInfo info = new FileInfo(path);
if ((info.Attributes & System.IO.FileAttributes.ReadOnly) == System.IO.FileAttributes.ReadOnly)
{
readOnlyFileInfo = info;
info.Attributes &= ~System.IO.FileAttributes.ReadOnly;
}
}
FileShare share = Force ? FileShare.ReadWrite : FileShare.Read;
fileStream = new FileStream(path, create, FileAccess.Write, share);
if (defaultEncoding)
{
streamWriter = new StreamWriter(fileStream);
}
else
{
streamWriter = new StreamWriter(fileStream, resolvedEncoding);
}
}
catch (ArgumentException exception)
{
ReportFileOpenFailure(cmdlet, path, exception);
}
catch (IOException exception2)
{
if (NoClobber && File.Exists(path))
{
ErrorRecord errorRecord = new ErrorRecord(exception2, "NoClobber", ErrorCategory.ResourceExists, path)
{
ErrorDetails = new ErrorDetails(cmdlet, "PathUtilsStrings", "UtilityFileExistsNoClobber", new object[] { filePath, "NoClobber" })
};
cmdlet.ThrowTerminatingError(errorRecord);
}
ReportFileOpenFailure(cmdlet, path, exception2);
}
catch (UnauthorizedAccessException exception3)
{
ReportFileOpenFailure(cmdlet, path, exception3);
}
catch (NotSupportedException exception4)
{
ReportFileOpenFailure(cmdlet, path, exception4);
}
catch (SecurityException exception5)
{
ReportFileOpenFailure(cmdlet, path, exception5);
}
}
internal static void MasterStreamOpen(
PSCmdlet cmdlet,
string filePath,
string encoding,
bool defaultEncoding,
bool Append,
bool Force,
bool NoClobber,
out FileStream fileStream,
out StreamWriter streamWriter,
out FileInfo readOnlyFileInfo)
{
fileStream = (FileStream)null;
streamWriter = (StreamWriter)null;
readOnlyFileInfo = (FileInfo)null;
string str = PathUtils.ResolveFilePath(filePath, cmdlet);
Encoding encoding1 = EncodingConversion.Convert((Cmdlet)cmdlet, encoding);
try
{
FileMode mode = FileMode.Create;
if (Append)
{
mode = FileMode.Append;
}
else if (NoClobber)
{
mode = FileMode.CreateNew;
}
if (Force && (Append || !NoClobber) && File.Exists(str))
{
FileInfo fileInfo = new FileInfo(str);
if ((fileInfo.Attributes & FileAttributes.ReadOnly) == FileAttributes.ReadOnly)
{
readOnlyFileInfo = fileInfo;
fileInfo.Attributes &= ~FileAttributes.ReadOnly;
}
}
FileShare share = Force ? FileShare.ReadWrite : FileShare.Read;
fileStream = new FileStream(str, mode, FileAccess.Write, share);
if (defaultEncoding)
{
streamWriter = new StreamWriter((Stream)fileStream);
}
else
{
streamWriter = new StreamWriter((Stream)fileStream, encoding1);
}
}
catch (ArgumentException ex)
{
PathUtils.ReportFileOpenFailure((Cmdlet)cmdlet, str, (Exception)ex);
}
catch (IOException ex)
{
if (NoClobber && File.Exists(str))
{
cmdlet.ThrowTerminatingError(new ErrorRecord((Exception)ex, nameof(NoClobber), ErrorCategory.ResourceExists, (object)str)
{
ErrorDetails = new ErrorDetails((Cmdlet)cmdlet, nameof(PathUtils), "UtilityFileExistsNoClobber", new object[2]
{
(object)filePath,
(object)nameof(NoClobber)
})
});
}
PathUtils.ReportFileOpenFailure((Cmdlet)cmdlet, str, (Exception)ex);
}
catch (UnauthorizedAccessException ex)
{
PathUtils.ReportFileOpenFailure((Cmdlet)cmdlet, str, (Exception)ex);
}
catch (NotSupportedException ex)
{
PathUtils.ReportFileOpenFailure((Cmdlet)cmdlet, str, (Exception)ex);
}
catch (SecurityException ex)
{
PathUtils.ReportFileOpenFailure((Cmdlet)cmdlet, str, (Exception)ex);
}
}
internal static void MasterStreamOpen(PSCmdlet cmdlet, string filePath, Encoding resolvedEncoding, bool defaultEncoding, bool Append, bool Force, bool NoClobber, out FileStream fileStream, out StreamWriter streamWriter, out FileInfo readOnlyFileInfo, bool isLiteralPath)
{
fileStream = null;
streamWriter = null;
readOnlyFileInfo = null;
string path = ResolveFilePath(filePath, cmdlet, isLiteralPath);
try
{
FileMode create = FileMode.Create;
if (Append)
{
create = FileMode.Append;
}
else if (NoClobber)
{
create = FileMode.CreateNew;
}
if ((Force && (Append || !NoClobber)) && File.Exists(path))
{
FileInfo info = new FileInfo(path);
if ((info.Attributes & System.IO.FileAttributes.ReadOnly) == System.IO.FileAttributes.ReadOnly)
{
readOnlyFileInfo = info;
info.Attributes &= ~System.IO.FileAttributes.ReadOnly;
}
}
FileShare share = Force ? FileShare.ReadWrite : FileShare.Read;
fileStream = new FileStream(path, create, FileAccess.Write, share);
if (defaultEncoding)
{
streamWriter = new StreamWriter(fileStream);
}
else
{
streamWriter = new StreamWriter(fileStream, resolvedEncoding);
}
}
catch (ArgumentException exception)
{
ReportFileOpenFailure(cmdlet, path, exception);
}
catch (IOException exception2)
{
if (NoClobber && File.Exists(path))
{
ErrorRecord errorRecord = new ErrorRecord(exception2, "NoClobber", ErrorCategory.ResourceExists, path) {
ErrorDetails = new ErrorDetails(cmdlet, "PathUtilsStrings", "UtilityFileExistsNoClobber", new object[] { filePath, "NoClobber" })
};
cmdlet.ThrowTerminatingError(errorRecord);
}
ReportFileOpenFailure(cmdlet, path, exception2);
}
catch (UnauthorizedAccessException exception3)
{
ReportFileOpenFailure(cmdlet, path, exception3);
}
catch (NotSupportedException exception4)
{
ReportFileOpenFailure(cmdlet, path, exception4);
}
catch (SecurityException exception5)
{
ReportFileOpenFailure(cmdlet, path, exception5);
}
}
/// <summary>
/// THE method for opening a file for writing.
/// Should be used by all cmdlets that write to a file.
/// </summary>
/// <param name="cmdlet">cmdlet that is opening the file (used mainly for error reporting)</param>
/// <param name="filePath">path to the file (as specified on the command line - this method will resolve the path)</param>
/// <param name="resolvedEncoding">encoding (this method will convert the command line string to an Encoding instance)</param>
/// <param name="defaultEncoding">if <c>true</c>, then we will use default .NET encoding instead of the encoding specified in <paramref name="encoding"/> parameter</param>
/// <param name="Append"></param>
/// <param name="Force"></param>
/// <param name="NoClobber"></param>
/// <param name="fileStream">Result1: <see cref="FileStream"/> opened for writing</param>
/// <param name="streamWriter">Result2: <see cref="StreamWriter"/> (inherits from <see cref="TextWriter"/>) opened for writing</param>
/// <param name="readOnlyFileInfo">Result3: file info that should be used to restore file attributes after done with the file (<c>null</c> is this is not needed)</param>
/// <param name="isLiteralPath">True if wildcard expansion should be bypassed.</param>
internal static void MasterStreamOpen(
PSCmdlet cmdlet,
string filePath,
Encoding resolvedEncoding,
bool defaultEncoding,
bool Append,
bool Force,
bool NoClobber,
out FileStream fileStream,
out StreamWriter streamWriter,
out FileInfo readOnlyFileInfo,
bool isLiteralPath)
{
fileStream = null;
streamWriter = null;
readOnlyFileInfo = null;
// resolve the path and the encoding
string resolvedPath = ResolveFilePath(filePath, cmdlet, isLiteralPath);
try
{
// variable to track file open mode
// this is controlled by append/force parameters
FileMode mode = FileMode.Create;
if (Append)
{
mode = FileMode.Append;
}
else if (NoClobber)
{
// throw IOException if file exists
mode = FileMode.CreateNew;
}
if (Force && (Append || !NoClobber))
{
if (File.Exists(resolvedPath))
{
FileInfo fInfo = new FileInfo(resolvedPath);
if ((fInfo.Attributes & FileAttributes.ReadOnly) == FileAttributes.ReadOnly)
{
// remember to reset the read-only attribute later
readOnlyFileInfo = fInfo;
// Clear the read-only attribute
fInfo.Attributes &= ~(FileAttributes.ReadOnly);
}
}
}
// if the user knows what he/she is doing and uses "-Force" switch,
// then we let more than 1 process write to the same file at the same time
FileShare fileShare = Force ? FileShare.ReadWrite : FileShare.Read;
// mode is controlled by force and ShouldContinue()
fileStream = new FileStream(resolvedPath, mode, FileAccess.Write, fileShare);
// create stream writer
// NTRAID#Windows Out Of Band Releases-931008-2006/03/27
// For some reason, calling this without specifying
// the encoding is different from passing Encoding.Default.
if (defaultEncoding)
streamWriter = new StreamWriter(fileStream);
else
streamWriter = new StreamWriter(fileStream, resolvedEncoding);
}
// These are the known exceptions for File.Load and StreamWriter.ctor
catch (ArgumentException e)
{
// NOTE: this call will throw
ReportFileOpenFailure(cmdlet, resolvedPath, e);
}
catch (IOException e)
{
if (NoClobber && File.Exists(resolvedPath))
{
// This probably happened because the file already exists
ErrorRecord errorRecord = new ErrorRecord(
e, "NoClobber", ErrorCategory.ResourceExists, resolvedPath);
errorRecord.ErrorDetails = new ErrorDetails(
cmdlet,
"PathUtilsStrings",
"UtilityFileExistsNoClobber",
filePath,
"NoClobber"); // prevents localization
// NOTE: this call will throw
cmdlet.ThrowTerminatingError(errorRecord);
}
// NOTE: this call will throw
ReportFileOpenFailure(cmdlet, resolvedPath, e);
}
catch (UnauthorizedAccessException e)
{
// NOTE: this call will throw
ReportFileOpenFailure(cmdlet, resolvedPath, e);
}
catch (NotSupportedException e)
{
// NOTE: this call will throw
ReportFileOpenFailure(cmdlet, resolvedPath, e);
}
catch (System.Security.SecurityException e)
{
// NOTE: this call will throw
ReportFileOpenFailure(cmdlet, resolvedPath, e);
}
} // void MasterStreamOpen
internal static void ResetMachineAccountPassword(string domain, string localMachineName, string server, PSCredential credential, PSCmdlet cmdlet)
{
// Get domain directory entry and reset the password on the machine account of the local machine
string newPassword = null;
string domainOrServerName = server ?? domain;
try
{
string dUserName = credential != null ? credential.UserName : null;
string dPassword = credential != null ? Utils.GetStringFromSecureString(credential.Password) : null;
using (var domainEntry = new DirectoryEntry(
"LDAP://" + domainOrServerName,
dUserName,
dPassword,
AuthenticationTypes.Secure))
{
using (var searcher = new DirectorySearcher(domainEntry))
{
searcher.Filter = "(&(objectClass=computer)(|(cn=" + localMachineName + ")(dn=" + localMachineName + ")))";
SearchResult result = searcher.FindOne();
if (result == null)
{
string format = server != null
? ComputerResources.CannotFindMachineAccountFromServer
: ComputerResources.CannotFindMachineAccountFromDomain;
string errMsg = StringUtil.Format(format, domainOrServerName);
ErrorRecord error = new ErrorRecord(new InvalidOperationException(errMsg), "CannotFindMachineAccount",
ErrorCategory.OperationStopped, localMachineName);
cmdlet.ThrowTerminatingError(error);
}
else
{
// Generate a random password of length 120, and reset the password on the machine account
using (var targetEntry = result.GetDirectoryEntry())
{
newPassword = ComputerWMIHelper.GetRandomPassword(PasswordLength);
targetEntry.Invoke("SetPassword", new object[] { newPassword });
targetEntry.Properties["LockOutTime"].Value = 0;
}
}
}
}
}
catch (DirectoryServicesCOMException ex)
{
string errMsg = StringUtil.Format(ComputerResources.FailToResetPasswordOnDomain, ex.Message);
ErrorRecord error = new ErrorRecord(new InvalidOperationException(errMsg), "FailToResetPasswordOnDomain",
ErrorCategory.OperationStopped, localMachineName);
cmdlet.ThrowTerminatingError(error);
}
catch (TargetInvocationException ex)
{
string errMsg = StringUtil.Format(ComputerResources.FailToResetPasswordOnDomain, ex.InnerException.Message);
ErrorRecord error = new ErrorRecord(new InvalidOperationException(errMsg), "FailToResetPasswordOnDomain",
ErrorCategory.OperationStopped, localMachineName);
cmdlet.ThrowTerminatingError(error);
}
catch (COMException ex)
{
string errMsg = StringUtil.Format(ComputerResources.FailToResetPasswordOnDomain, ex.Message);
ErrorRecord error = new ErrorRecord(new InvalidOperationException(errMsg), "FailToResetPasswordOnDomain",
ErrorCategory.OperationStopped, localMachineName);
cmdlet.ThrowTerminatingError(error);
}
// Set the same password to the local machine
Dbg.Diagnostics.Assert(newPassword != null, "the newPassword should not be null at this point");
// A direct translation of function NetpManageMachineSecret2 in //depot/winmain/ds/netapi/netjoin/joinutl.c
// Initialize the LSA_OBJECT_ATTRIBUTES
var lsaAttr = new SAMAPI.LSA_OBJECT_ATTRIBUTES();
lsaAttr.RootDirectory = IntPtr.Zero;
lsaAttr.ObjectName = IntPtr.Zero;
lsaAttr.Attributes = 0;
lsaAttr.SecurityDescriptor = IntPtr.Zero;
lsaAttr.SecurityQualityOfService = IntPtr.Zero;
lsaAttr.Length = Marshal.SizeOf(typeof(SAMAPI.LSA_OBJECT_ATTRIBUTES));
// Initialize the policy handle and secret handle
IntPtr policyHandle = IntPtr.Zero;
IntPtr secretHandle = IntPtr.Zero;
// Initialize variables for LsaQuerySecret call
IntPtr currentPassword = IntPtr.Zero;
// Declare the key, newData and currentData
var key = new SAMAPI.LSA_UNICODE_STRING { Buffer = IntPtr.Zero };
var newData = new SAMAPI.LSA_UNICODE_STRING { Buffer = IntPtr.Zero };
// Initialize the systemName for the localhost
var localhost = new SAMAPI.LSA_UNICODE_STRING();
localhost.Buffer = IntPtr.Zero;
localhost.Length = 0;
localhost.MaximumLength = 0;
try
{
// Open the LSA policy
uint ret = SAMAPI.LsaOpenPolicy(ref localhost, ref lsaAttr, (int)SAMAPI.LSA_ACCESS.AllAccess, out policyHandle);
if (ret == STATUS_ACCESS_DENIED)
{
string errMsg = ComputerResources.NeedAdminPrivilegeToResetPassword;
ErrorRecord error = new ErrorRecord(new InvalidOperationException(errMsg), "UnauthorizedAccessException",
ErrorCategory.InvalidOperation, localMachineName);
cmdlet.ThrowTerminatingError(error);
}
if (ret != 0)
{
ThrowOutLsaError(ret, cmdlet);
}
// Initialize secret key, new secret
SAMAPI.InitLsaString(SecretKey, ref key);
SAMAPI.InitLsaString(newPassword, ref newData);
bool secretCreated = false;
// Open the secret. If the secret is not found, create the secret
ret = SAMAPI.LsaOpenSecret(policyHandle, ref key, SECRET_SET_VALUE | SECRET_QUERY_VALUE, out secretHandle);
if (ret == STATUS_OBJECT_NAME_NOT_FOUND)
{
ret = SAMAPI.LsaCreateSecret(policyHandle, ref key, SECRET_SET_VALUE, out secretHandle);
secretCreated = true;
}
if (ret != 0)
{
ThrowOutLsaError(ret, cmdlet);
}
SAMAPI.LSA_UNICODE_STRING currentData;
// Get the current password
if (secretCreated)
{
// Use the new password as the current one
currentData = newData;
}
else
{
// Query for the current password
ret = SAMAPI.LsaQuerySecret(secretHandle, out currentPassword, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
if (ret != 0)
{
ThrowOutLsaError(ret, cmdlet);
}
currentData = (SAMAPI.LSA_UNICODE_STRING)Marshal.PtrToStructure(currentPassword, typeof(SAMAPI.LSA_UNICODE_STRING));
}
ret = SAMAPI.LsaSetSecret(secretHandle, ref newData, ref currentData);
if (ret != 0)
{
ThrowOutLsaError(ret, cmdlet);
}
}
finally
{
// Release pointers
if (currentPassword != IntPtr.Zero)
{
int releaseResult = SAMAPI.LsaFreeMemory(currentPassword);
Dbg.Diagnostics.Assert(releaseResult == 0, "LsaFreeMemory returned non-zero value");
}
// Release handles
if (policyHandle != IntPtr.Zero)
{
int releaseResult = SAMAPI.LsaClose(policyHandle);
Dbg.Diagnostics.Assert(releaseResult == 0, "LsaClose returned non-zero value");
}
if (secretHandle != IntPtr.Zero)
{
int releaseResult = SAMAPI.LsaClose(secretHandle);
Dbg.Diagnostics.Assert(releaseResult == 0, "LsaClose returned non-zero value");
}
// Release LSA_UNICODE_STRING
SAMAPI.FreeLsaString(ref key);
SAMAPI.FreeLsaString(ref newData);
}
}
internal static GraphicalHostReflectionWrapper GetGraphicalHostReflectionWrapper(PSCmdlet parentCmdlet, string graphicalHostHelperTypeName, string featureName)
{
GraphicalHostReflectionWrapper returnValue = new GraphicalHostReflectionWrapper();
if (GraphicalHostReflectionWrapper.IsInputFromRemoting(parentCmdlet))
{
ErrorRecord error = new ErrorRecord(
new NotSupportedException(StringUtil.Format(HelpErrors.RemotingNotSupportedForFeature, featureName)),
"RemotingNotSupported",
ErrorCategory.InvalidOperation,
parentCmdlet);
parentCmdlet.ThrowTerminatingError(error);
}
// Prepare the full assembly name.
AssemblyName graphicalHostAssemblyName = new AssemblyName();
graphicalHostAssemblyName.Name = "Microsoft.PowerShell.GraphicalHost";
graphicalHostAssemblyName.Version = new Version(3, 0, 0, 0);
graphicalHostAssemblyName.CultureInfo = new CultureInfo(String.Empty); // Neutral culture
graphicalHostAssemblyName.SetPublicKeyToken(new byte[] { 0x31, 0xbf, 0x38, 0x56, 0xad, 0x36, 0x4e, 0x35 });
try
{
returnValue._graphicalHostAssembly = Assembly.Load(graphicalHostAssemblyName);
}
catch (FileNotFoundException fileNotFoundEx)
{
// This exception is thrown if the Microsoft.PowerShell.GraphicalHost.dll could not be found (was not installed).
string errorMessage = StringUtil.Format(
HelpErrors.GraphicalHostAssemblyIsNotFound,
featureName,
fileNotFoundEx.Message);
parentCmdlet.ThrowTerminatingError(
new ErrorRecord(
new NotSupportedException(errorMessage, fileNotFoundEx),
"ErrorLoadingAssembly",
ErrorCategory.ObjectNotFound,
graphicalHostAssemblyName));
}
catch (Exception e)
{
CommandProcessorBase.CheckForSevereException(e);
parentCmdlet.ThrowTerminatingError(
new ErrorRecord(
e,
"ErrorLoadingAssembly",
ErrorCategory.ObjectNotFound,
graphicalHostAssemblyName));
}
returnValue._graphicalHostHelperType = returnValue._graphicalHostAssembly.GetType(graphicalHostHelperTypeName);
Diagnostics.Assert(returnValue._graphicalHostHelperType != null, "the type exists in Microsoft.PowerShell.GraphicalHost");
ConstructorInfo constructor = returnValue._graphicalHostHelperType.GetConstructor(
BindingFlags.NonPublic | BindingFlags.Instance,
null,
new Type[] { },
null);
if (constructor != null)
{
returnValue._graphicalHostHelperObject = constructor.Invoke(new object[] { });
Diagnostics.Assert(returnValue._graphicalHostHelperObject != null, "the constructor does not throw anything");
}
return returnValue;
}
/// <summary>
/// Combines an array of strings or hashtables into a single string block
/// </summary>
internal static string CombineHashTableOrStringArray(object[] values, StreamWriter writer, PSCmdlet caller)
{
StringBuilder sb = new StringBuilder();
for (int i = 0; i < values.Length; i++)
{
string strVal = values[i] as string;
if (!String.IsNullOrEmpty(strVal))
{
sb.Append(QuoteName(strVal));
}
else
{
Hashtable hashVal = values[i] as Hashtable;
if (null == hashVal)
{
string message = StringUtil.Format(RemotingErrorIdStrings.DISCTypeMustBeStringOrHashtableArray,
ConfigFileConstants.ModulesToImport);
PSArgumentException e = new PSArgumentException(message);
caller.ThrowTerminatingError(e.ErrorRecord);
}
sb.Append(CombineHashtable(hashVal, writer));
}
if (i < (values.Length - 1))
{
sb.Append(", ");
}
}
return sb.ToString();
}
internal static void MasterStreamOpen(
PSCmdlet cmdlet,
string filePath,
Encoding resolvedEncoding,
bool defaultEncoding,
bool append,
bool force,
bool noClobber,
out FileStream fileStream,
out StreamWriter streamWriter,
out FileInfo readOnlyFileInfo,
bool isLiteralPath)
{
fileStream = null;
streamWriter = null;
readOnlyFileInfo = null;
var str = ResolveFilePath(filePath, cmdlet, isLiteralPath);
try
{
var mode = FileMode.Create;
if (append)
{
mode = FileMode.Append;
}
else if (noClobber)
{
mode = FileMode.CreateNew;
}
if (force && (append || !noClobber) && File.Exists(str))
{
var fileInfo1 = new FileInfo(str);
if ((fileInfo1.Attributes & FileAttributes.ReadOnly) == FileAttributes.ReadOnly)
{
readOnlyFileInfo = fileInfo1;
var fileInfo2 = fileInfo1;
var num = (int) (fileInfo2.Attributes & ~FileAttributes.ReadOnly);
fileInfo2.Attributes = (FileAttributes) num;
}
}
var share = force ? FileShare.ReadWrite : FileShare.Read;
fileStream = new FileStream(str, mode, FileAccess.Write, share);
streamWriter = defaultEncoding
? new StreamWriter(fileStream)
: new StreamWriter(fileStream, resolvedEncoding);
}
catch (ArgumentException ex)
{
ReportFileOpenFailure(cmdlet, str, ex);
}
catch (IOException ex)
{
if (noClobber && File.Exists(str))
{
cmdlet.ThrowTerminatingError(
new ErrorRecord(ex, "NoClobber", ErrorCategory.ResourceExists, str)
{
ErrorDetails =
new ErrorDetails(
cmdlet,
"PathUtilsStrings",
"UtilityFileExistsNoClobber",
new object[]
{
filePath,
"NoClobber"
})
});
}
ReportFileOpenFailure(cmdlet, str, ex);
}
catch (UnauthorizedAccessException ex)
{
ReportFileOpenFailure(cmdlet, str, ex);
}
catch (NotSupportedException ex)
{
ReportFileOpenFailure(cmdlet, str, ex);
}
catch (SecurityException ex)
{
ReportFileOpenFailure(cmdlet, str, ex);
}
}
/// <summary>
/// To generate Catalog for the folder
/// </summary>
///
/// <param name="Path"> Path to folder or File </param>
/// <param name="catalogFilePath"> Catalog File Path </param>
/// <param name="catalogVersion"> Catalog File Path </param>
/// <param name="cmdlet"> Instance of cmdlet calling this method </param>
/// <returns> true if able to generate .cat file or false </returns>
internal static FileInfo GenerateCatalog(PSCmdlet cmdlet, Collection<string> Path, string catalogFilePath, int catalogVersion)
{
_cmdlet = cmdlet;
string hashAlgorithm = GetCatalogHashAlgorithm(catalogVersion);
if (!String.IsNullOrEmpty(hashAlgorithm))
{
// Generate Path for Catalog Definition File
string cdfFilePath = System.IO.Path.Combine(System.IO.Path.GetTempPath(), System.IO.Path.GetRandomFileName());
cdfFilePath = cdfFilePath + ".cdf";
try
{
cdfFilePath = GenerateCDFFile(Path, catalogFilePath, cdfFilePath, catalogVersion, hashAlgorithm);
if (!File.Exists(cdfFilePath))
{
// If we are not able to generate catalog definition file we can not continue generating catalog
// throw PSTraceSource.NewInvalidOperationException("catalog", CatalogStrings.CatalogDefinitionFileNotGenerated);
ErrorRecord errorRecord = new ErrorRecord(new InvalidOperationException(CatalogStrings.CatalogDefinitionFileNotGenerated), "CatalogDefinitionFileNotGenerated", ErrorCategory.InvalidOperation, null);
_cmdlet.ThrowTerminatingError(errorRecord);
}
GenerateCatalogFile(cdfFilePath);
if (File.Exists(catalogFilePath))
{
return new FileInfo(catalogFilePath);
}
}
finally
{
File.Delete(cdfFilePath);
}
}
return null;
}
/// <summary>
/// Resolves the specified path to PathInfo objects
/// </summary>
///
/// <param name="pathToResolve">
/// The path to be resolved. Each path may contain glob characters.
/// </param>
///
/// <param name="isLiteralPath">
/// True if wildcard expansion should be suppressed for pathToResolve.
/// </param>
///
/// <param name="allowNonexistingPaths">
/// If true, resolves the path even if it doesn't exist.
/// </param>
///
/// <param name="cmdlet">
/// Calling cmdlet
/// </param>
///
/// <returns>
/// A string representing the resolved path.
/// </returns>
///
private static PathInfo ResolvePath(
string pathToResolve,
bool isLiteralPath,
bool allowNonexistingPaths,
PSCmdlet cmdlet)
{
// Construct cmdletprovidercontext
CmdletProviderContext cmdContext = new CmdletProviderContext(cmdlet);
cmdContext.SuppressWildcardExpansion = isLiteralPath;
Collection<PathInfo> results = new Collection<PathInfo>();
try
{
// First resolve path
Collection<PathInfo> pathInfos =
cmdlet.SessionState.Path.GetResolvedPSPathFromPSPath(
pathToResolve,
cmdContext);
foreach (PathInfo pathInfo in pathInfos)
{
results.Add(pathInfo);
}
}
catch (PSNotSupportedException notSupported)
{
cmdlet.ThrowTerminatingError(
new ErrorRecord(
notSupported.ErrorRecord,
notSupported));
}
catch (System.Management.Automation.DriveNotFoundException driveNotFound)
{
cmdlet.ThrowTerminatingError(
new ErrorRecord(
driveNotFound.ErrorRecord,
driveNotFound));
}
catch (ProviderNotFoundException providerNotFound)
{
cmdlet.ThrowTerminatingError(
new ErrorRecord(
providerNotFound.ErrorRecord,
providerNotFound));
}
catch (ItemNotFoundException pathNotFound)
{
if (allowNonexistingPaths)
{
ProviderInfo provider = null;
System.Management.Automation.PSDriveInfo drive = null;
string unresolvedPath =
cmdlet.SessionState.Path.GetUnresolvedProviderPathFromPSPath(
pathToResolve,
cmdContext,
out provider,
out drive);
PathInfo pathInfo =
new PathInfo(
drive,
provider,
unresolvedPath,
cmdlet.SessionState);
results.Add(pathInfo);
}
else
{
cmdlet.ThrowTerminatingError(
new ErrorRecord(
pathNotFound.ErrorRecord,
pathNotFound));
}
}
if (results.Count == 1)
{
return results[0];
}
else //if (results.Count > 1)
{
Exception e = PSTraceSource.NewNotSupportedException();
cmdlet.ThrowTerminatingError(
new ErrorRecord(e,
"NotSupported",
ErrorCategory.NotImplemented,
results));
return null;
}
} // ResolvePath
internal static DirectoryInfo CreateModuleDirectory(PSCmdlet cmdlet, string moduleNameOrPath, bool force)
{
Dbg.Assert(cmdlet != null, "Caller should verify cmdlet != null");
Dbg.Assert(!string.IsNullOrEmpty(moduleNameOrPath), "Caller should verify !string.IsNullOrEmpty(moduleNameOrPath)");
DirectoryInfo directoryInfo = null;
try
{
string rootedPath = Microsoft.PowerShell.Commands.ModuleCmdletBase.ResolveRootedFilePath(moduleNameOrPath, cmdlet.Context);
if (string.IsNullOrEmpty(rootedPath) && moduleNameOrPath.StartsWith('.'))
{
PathInfo currentPath = cmdlet.CurrentProviderLocation(cmdlet.Context.ProviderNames.FileSystem);
rootedPath = Path.Combine(currentPath.ProviderPath, moduleNameOrPath);
}
if (string.IsNullOrEmpty(rootedPath))
{
string personalModuleRoot = ModuleIntrinsics.GetPersonalModulePath();
rootedPath = Path.Combine(personalModuleRoot, moduleNameOrPath);
}
directoryInfo = new DirectoryInfo(rootedPath);
if (directoryInfo.Exists)
{
if (!force)
{
string errorMessage = string.Format(
CultureInfo.InvariantCulture, // directory name should be treated as culture-invariant
PathUtilsStrings.ExportPSSession_ErrorDirectoryExists,
directoryInfo.FullName);
ErrorDetails details = new ErrorDetails(errorMessage);
ErrorRecord errorRecord = new ErrorRecord(
new ArgumentException(details.Message),
"ExportProxyCommand_OutputDirectoryExists",
ErrorCategory.ResourceExists,
directoryInfo);
cmdlet.ThrowTerminatingError(errorRecord);
}
}
else
{
directoryInfo.Create();
}
}
catch (Exception e)
{
string errorMessage = string.Format(
CultureInfo.InvariantCulture, // directory name should be treated as culture-invariant
PathUtilsStrings.ExportPSSession_CannotCreateOutputDirectory,
moduleNameOrPath,
e.Message);
ErrorDetails details = new ErrorDetails(errorMessage);
ErrorRecord errorRecord = new ErrorRecord(
new ArgumentException(details.Message, e),
"ExportProxyCommand_CannotCreateOutputDirectory",
ErrorCategory.ResourceExists,
moduleNameOrPath);
cmdlet.ThrowTerminatingError(errorRecord);
}
return(directoryInfo);
}
/// <summary>
/// Throw out terminating error for LSA function invocations
/// </summary>
/// <param name="ret"></param>
/// <param name="cmdlet"></param>
private static void ThrowOutLsaError(uint ret, PSCmdlet cmdlet)
{
var ex = new Win32Exception(SAMAPI.LsaNtStatusToWinError((int)ret));
string errMsg = StringUtil.Format(ComputerResources.FailToResetPasswordOnLocalMachine, ex.Message);
ErrorRecord error = new ErrorRecord(new InvalidOperationException(errMsg), "FailToResetPasswordOnLocalMachine",
ErrorCategory.OperationStopped, Dns.GetHostName());
cmdlet.ThrowTerminatingError(error);
}
internal static DirectoryInfo CreateModuleDirectory(PSCmdlet cmdlet, string moduleNameOrPath, bool force)
{
Dbg.Assert(cmdlet != null, "Caller should verify cmdlet != null");
Dbg.Assert(!string.IsNullOrEmpty(moduleNameOrPath), "Caller should verify !string.IsNullOrEmpty(moduleNameOrPath)");
DirectoryInfo directoryInfo = null;
try
{
string rootedPath = Microsoft.PowerShell.Commands.ModuleCmdletBase.ResolveRootedFilePath(moduleNameOrPath, cmdlet.Context);
if (string.IsNullOrEmpty(rootedPath) && moduleNameOrPath.StartsWith(".", StringComparison.OrdinalIgnoreCase))
{
PathInfo currentPath = cmdlet.CurrentProviderLocation(cmdlet.Context.ProviderNames.FileSystem);
rootedPath = Path.Combine(currentPath.ProviderPath, moduleNameOrPath);
}
if (string.IsNullOrEmpty(rootedPath))
{
string personalModuleRoot = ModuleIntrinsics.GetPersonalModulePath();
rootedPath = Path.Combine(personalModuleRoot, moduleNameOrPath);
}
directoryInfo = new DirectoryInfo(rootedPath);
if (directoryInfo.Exists)
{
if (!force)
{
string errorMessage = string.Format(
CultureInfo.InvariantCulture, // directory name should be treated as culture-invariant
PathUtilsStrings.ExportPSSession_ErrorDirectoryExists,
directoryInfo.FullName);
ErrorDetails details = new ErrorDetails(errorMessage);
ErrorRecord errorRecord = new ErrorRecord(
new ArgumentException(details.Message),
"ExportProxyCommand_OutputDirectoryExists",
ErrorCategory.ResourceExists,
directoryInfo);
cmdlet.ThrowTerminatingError(errorRecord);
}
}
else
{
directoryInfo.Create();
}
}
catch (Exception e)
{
CommandProcessorBase.CheckForSevereException(e);
string errorMessage = string.Format(
CultureInfo.InvariantCulture, // directory name should be treated as culture-invariant
PathUtilsStrings.ExportPSSession_CannotCreateOutputDirectory,
moduleNameOrPath,
e.Message);
ErrorDetails details = new ErrorDetails(errorMessage);
ErrorRecord errorRecord = new ErrorRecord(
new ArgumentException(details.Message, e),
"ExportProxyCommand_CannotCreateOutputDirectory",
ErrorCategory.ResourceExists,
moduleNameOrPath);
cmdlet.ThrowTerminatingError(errorRecord);
}
return directoryInfo;
}
/// <summary>
/// Find out the Version of Catalog by reading its Meta data. We can have either version 1 or version 2 catalog
/// </summary>
/// <param name="catalogHandle">Handle to open catalog file.</param>
/// <returns>Version of the catalog.</returns>
private static int GetCatalogVersion(IntPtr catalogHandle)
{
int catalogVersion = -1;
IntPtr catalogData = NativeMethods.CryptCATStoreFromHandle(catalogHandle);
NativeMethods.CRYPTCATSTORE catalogInfo = Marshal.PtrToStructure <NativeMethods.CRYPTCATSTORE>(catalogData);
if (catalogInfo.dwPublicVersion == catalogVersion2)
{
catalogVersion = 2;
}
// One Windows 7 this API sent version information as decimal 1 not hex (0X100 = 256)
// so we are checking for that value as well. Reason we are not checking for version 2 above in
// this scenario because catalog version 2 is not supported on win7.
else if ((catalogInfo.dwPublicVersion == catalogVersion1) || (catalogInfo.dwPublicVersion == 1))
{
catalogVersion = 1;
}
else
{
// catalog version we don't understand
Exception exception = new InvalidOperationException(StringUtil.Format(CatalogStrings.UnKnownCatalogVersion,
catalogVersion1.ToString("X"),
catalogVersion2.ToString("X")));
ErrorRecord errorRecord = new ErrorRecord(exception, "UnKnownCatalogVersion", ErrorCategory.InvalidOperation, null);
_cmdlet.ThrowTerminatingError(errorRecord);
}
return(catalogVersion);
}
internal static void ResetMachineAccountPassword(string domain, string localMachineName, string server, PSCredential credential, PSCmdlet cmdlet)
{
SAMAPI.LSA_UNICODE_STRING structure;
string userName;
string stringFromSecureString;
string cannotFindMachineAccountFromServer;
DirectoryEntry directoryEntry = null;
DirectoryEntry directoryEntry1 = null;
DirectorySearcher directorySearcher = null;
string randomPassword = null;
string str = server;
string str1 = str;
if (str == null)
{
str1 = domain;
}
string str2 = str1;
try
{
try
{
if (credential != null)
{
userName = credential.UserName;
}
else
{
userName = null;
}
string str3 = userName;
if (credential != null)
{
stringFromSecureString = Utils.GetStringFromSecureString(credential.Password);
}
else
{
stringFromSecureString = null;
}
string str4 = stringFromSecureString;
directoryEntry = new DirectoryEntry(string.Concat("LDAP://", str2), str3, str4, AuthenticationTypes.Secure);
directorySearcher = new DirectorySearcher(directoryEntry);
string[] strArrays = new string[5];
strArrays[0] = "(&(objectClass=computer)(|(cn=";
strArrays[1] = localMachineName;
strArrays[2] = ")(dn=";
strArrays[3] = localMachineName;
strArrays[4] = ")))";
directorySearcher.Filter = string.Concat(strArrays);
SearchResult searchResult = directorySearcher.FindOne();
if (searchResult != null)
{
directoryEntry1 = searchResult.GetDirectoryEntry();
randomPassword = ComputerWMIHelper.GetRandomPassword(120);
object[] objArray = new object[1];
objArray[0] = randomPassword;
directoryEntry1.Invoke("SetPassword", objArray);
directoryEntry1.Properties["LockOutTime"].Value = 0;
}
else
{
if (server != null)
{
cannotFindMachineAccountFromServer = ComputerResources.CannotFindMachineAccountFromServer;
}
else
{
cannotFindMachineAccountFromServer = ComputerResources.CannotFindMachineAccountFromDomain;
}
string str5 = cannotFindMachineAccountFromServer;
string str6 = StringUtil.Format(str5, str2);
ErrorRecord errorRecord = new ErrorRecord(new InvalidOperationException(str6), "CannotFindMachineAccount", ErrorCategory.OperationStopped, localMachineName);
cmdlet.ThrowTerminatingError(errorRecord);
}
}
#if !MONO
catch (DirectoryServicesCOMException directoryServicesCOMException1)
{
DirectoryServicesCOMException directoryServicesCOMException = directoryServicesCOMException1;
string str7 = StringUtil.Format(ComputerResources.FailToResetPasswordOnDomain, directoryServicesCOMException.Message);
ErrorRecord errorRecord1 = new ErrorRecord(new InvalidOperationException(str7), "FailToResetPasswordOnDomain", ErrorCategory.OperationStopped, localMachineName);
cmdlet.ThrowTerminatingError(errorRecord1);
}
#endif
catch (TargetInvocationException targetInvocationException1)
{
TargetInvocationException targetInvocationException = targetInvocationException1;
string str8 = StringUtil.Format(ComputerResources.FailToResetPasswordOnDomain, targetInvocationException.InnerException.Message);
ErrorRecord errorRecord2 = new ErrorRecord(new InvalidOperationException(str8), "FailToResetPasswordOnDomain", ErrorCategory.OperationStopped, localMachineName);
cmdlet.ThrowTerminatingError(errorRecord2);
}
catch (COMException cOMException1)
{
COMException cOMException = cOMException1;
string str9 = StringUtil.Format(ComputerResources.FailToResetPasswordOnDomain, cOMException.Message);
ErrorRecord errorRecord3 = new ErrorRecord(new InvalidOperationException(str9), "FailToResetPasswordOnDomain", ErrorCategory.OperationStopped, localMachineName);
cmdlet.ThrowTerminatingError(errorRecord3);
}
}
finally
{
if (directoryEntry != null)
{
directoryEntry.Close();
directoryEntry.Dispose();
}
if (directorySearcher != null)
{
directorySearcher.Dispose();
}
if (directoryEntry1 != null)
{
directoryEntry1.Close();
directoryEntry1.Dispose();
}
}
SAMAPI.LSA_OBJECT_ATTRIBUTES zero = new SAMAPI.LSA_OBJECT_ATTRIBUTES();
zero.RootDirectory = IntPtr.Zero;
zero.ObjectName = IntPtr.Zero;
zero.Attributes = 0;
zero.SecurityDescriptor = IntPtr.Zero;
zero.SecurityQualityOfService = IntPtr.Zero;
zero.Length = Marshal.SizeOf(typeof(SAMAPI.LSA_OBJECT_ATTRIBUTES));
IntPtr intPtr = IntPtr.Zero;
IntPtr zero1 = IntPtr.Zero;
IntPtr intPtr1 = IntPtr.Zero;
SAMAPI.LSA_UNICODE_STRING lSAUNICODESTRING = new SAMAPI.LSA_UNICODE_STRING();
lSAUNICODESTRING.Buffer = IntPtr.Zero;
SAMAPI.LSA_UNICODE_STRING lSAUNICODESTRING1 = lSAUNICODESTRING;
SAMAPI.LSA_UNICODE_STRING zero2 = new SAMAPI.LSA_UNICODE_STRING();
zero2.Buffer = IntPtr.Zero;
SAMAPI.LSA_UNICODE_STRING lSAUNICODESTRING2 = zero2;
SAMAPI.LSA_UNICODE_STRING zero3 = new SAMAPI.LSA_UNICODE_STRING();
zero3.Buffer = IntPtr.Zero;
zero3.Length = 0;
zero3.MaximumLength = 0;
try
{
uint num = SAMAPI.LsaOpenPolicy(ref zero3, ref zero, 0xf0fff, out intPtr);
if (num == -1073741790)
{
string needAdminPrivilegeToResetPassword = ComputerResources.NeedAdminPrivilegeToResetPassword;
ErrorRecord errorRecord4 = new ErrorRecord(new InvalidOperationException(needAdminPrivilegeToResetPassword), "UnauthorizedAccessException", ErrorCategory.InvalidOperation, localMachineName);
cmdlet.ThrowTerminatingError(errorRecord4);
}
if (num != 0)
{
ResetComputerMachinePasswordCommand.ThrowOutLsaError(num, cmdlet);
}
SAMAPI.InitLsaString("$MACHINE.ACC", ref lSAUNICODESTRING1);
SAMAPI.InitLsaString(randomPassword, ref lSAUNICODESTRING2);
bool flag = false;
num = SAMAPI.LsaOpenSecret(intPtr, ref lSAUNICODESTRING1, 3, out zero1);
if (num == -1073741772)
{
num = SAMAPI.LsaCreateSecret(intPtr, ref lSAUNICODESTRING1, 1, out zero1);
flag = true;
}
if (num != 0)
{
ResetComputerMachinePasswordCommand.ThrowOutLsaError(num, cmdlet);
}
if (!flag)
{
num = SAMAPI.LsaQuerySecret(zero1, out intPtr1, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
if (num != 0)
{
ResetComputerMachinePasswordCommand.ThrowOutLsaError(num, cmdlet);
}
structure = (SAMAPI.LSA_UNICODE_STRING)Marshal.PtrToStructure(intPtr1, typeof(SAMAPI.LSA_UNICODE_STRING));
}
else
{
structure = lSAUNICODESTRING2;
}
num = SAMAPI.LsaSetSecret(zero1, ref lSAUNICODESTRING2, ref structure);
if (num != 0)
{
ResetComputerMachinePasswordCommand.ThrowOutLsaError(num, cmdlet);
}
}
finally
{
if (intPtr1 != IntPtr.Zero)
{
SAMAPI.LsaFreeMemory(intPtr1);
}
if (intPtr != IntPtr.Zero)
{
SAMAPI.LsaClose(intPtr);
}
if (zero1 != IntPtr.Zero)
{
SAMAPI.LsaClose(zero1);
}
SAMAPI.FreeLsaString(ref lSAUNICODESTRING1);
SAMAPI.FreeLsaString(ref lSAUNICODESTRING2);
}
}
/// <summary>
/// THE method for opening a file for writing.
/// Should be used by all cmdlets that write to a file.
/// </summary>
/// <param name="cmdlet">Cmdlet that is opening the file (used mainly for error reporting).</param>
/// <param name="filePath">Path to the file (as specified on the command line - this method will resolve the path).</param>
/// <param name="resolvedEncoding">Encoding (this method will convert the command line string to an Encoding instance).</param>
/// <param name="defaultEncoding">If <see langword="true"/>, then we will use default .NET encoding instead of the encoding specified in <paramref name="encoding"/> parameter.</param>
/// <param name="Append"></param>
/// <param name="Force"></param>
/// <param name="NoClobber"></param>
/// <param name="fileStream">Result1: <see cref="FileStream"/> opened for writing.</param>
/// <param name="streamWriter">Result2: <see cref="StreamWriter"/> (inherits from <see cref="TextWriter"/>) opened for writing.</param>
/// <param name="readOnlyFileInfo">Result3: file info that should be used to restore file attributes after done with the file (<see langword="null"/> is this is not needed).</param>
/// <param name="isLiteralPath">True if wildcard expansion should be bypassed.</param>
internal static void MasterStreamOpen(
PSCmdlet cmdlet,
string filePath,
Encoding resolvedEncoding,
bool defaultEncoding,
bool Append,
bool Force,
bool NoClobber,
out FileStream fileStream,
out StreamWriter streamWriter,
out FileInfo readOnlyFileInfo,
bool isLiteralPath)
{
fileStream = null;
streamWriter = null;
readOnlyFileInfo = null;
// resolve the path and the encoding
string resolvedPath = ResolveFilePath(filePath, cmdlet, isLiteralPath);
try
{
// variable to track file open mode
// this is controlled by append/force parameters
FileMode mode = FileMode.Create;
if (Append)
{
mode = FileMode.Append;
}
else if (NoClobber)
{
// throw IOException if file exists
mode = FileMode.CreateNew;
}
if (Force && (Append || !NoClobber))
{
if (File.Exists(resolvedPath))
{
FileInfo fInfo = new FileInfo(resolvedPath);
if ((fInfo.Attributes & FileAttributes.ReadOnly) == FileAttributes.ReadOnly)
{
// remember to reset the read-only attribute later
readOnlyFileInfo = fInfo;
// Clear the read-only attribute
fInfo.Attributes &= ~(FileAttributes.ReadOnly);
}
}
}
// if the user knows what he/she is doing and uses "-Force" switch,
// then we let more than 1 process write to the same file at the same time
FileShare fileShare = Force ? FileShare.ReadWrite : FileShare.Read;
// mode is controlled by force and ShouldContinue()
fileStream = new FileStream(resolvedPath, mode, FileAccess.Write, fileShare);
// create stream writer
// NTRAID#Windows Out Of Band Releases-931008-2006/03/27
// For some reason, calling this without specifying
// the encoding is different from passing Encoding.Default.
if (defaultEncoding)
{
streamWriter = new StreamWriter(fileStream);
}
else
{
streamWriter = new StreamWriter(fileStream, resolvedEncoding);
}
}
// These are the known exceptions for File.Load and StreamWriter.ctor
catch (ArgumentException e)
{
// NOTE: this call will throw
ReportFileOpenFailure(cmdlet, resolvedPath, e);
}
catch (IOException e)
{
if (NoClobber && File.Exists(resolvedPath))
{
// This probably happened because the file already exists
ErrorRecord errorRecord = new ErrorRecord(
e, "NoClobber", ErrorCategory.ResourceExists, resolvedPath);
errorRecord.ErrorDetails = new ErrorDetails(
cmdlet,
"PathUtilsStrings",
"UtilityFileExistsNoClobber",
filePath,
"NoClobber"); // prevents localization
// NOTE: this call will throw
cmdlet.ThrowTerminatingError(errorRecord);
}
// NOTE: this call will throw
ReportFileOpenFailure(cmdlet, resolvedPath, e);
}
catch (UnauthorizedAccessException e)
{
// NOTE: this call will throw
ReportFileOpenFailure(cmdlet, resolvedPath, e);
}
catch (NotSupportedException e)
{
// NOTE: this call will throw
ReportFileOpenFailure(cmdlet, resolvedPath, e);
}
catch (System.Security.SecurityException e)
{
// NOTE: this call will throw
ReportFileOpenFailure(cmdlet, resolvedPath, e);
}
}
internal static DirectoryInfo CreateModuleDirectory(PSCmdlet cmdlet, string moduleNameOrPath, bool force)
{
Dbg.Assert(cmdlet != null, "Caller should verify cmdlet != null");
Dbg.Assert(!string.IsNullOrEmpty(moduleNameOrPath), "Caller should verify !string.IsNullOrEmpty(moduleNameOrPath)");
DirectoryInfo directoryInfo = null;
try
{
// Even if 'moduleNameOrPath' is a rooted path, 'ResolveRootedFilePath' may return null when the path doesn't exist yet,
// or when it contains wildcards but cannot be resolved to a single path.
string rootedPath = ModuleCmdletBase.ResolveRootedFilePath(moduleNameOrPath, cmdlet.Context);
if (string.IsNullOrEmpty(rootedPath) && moduleNameOrPath.StartsWith('.'))
{
PathInfo currentPath = cmdlet.CurrentProviderLocation(cmdlet.Context.ProviderNames.FileSystem);
rootedPath = Path.Combine(currentPath.ProviderPath, moduleNameOrPath);
}
if (string.IsNullOrEmpty(rootedPath))
{
if (Path.IsPathRooted(moduleNameOrPath))
{
rootedPath = moduleNameOrPath;
}
else
{
string personalModuleRoot = ModuleIntrinsics.GetPersonalModulePath();
if (string.IsNullOrEmpty(personalModuleRoot))
{
cmdlet.ThrowTerminatingError(
new ErrorRecord(
new ArgumentException(StringUtil.Format(PathUtilsStrings.ExportPSSession_ErrorModuleNameOrPath, moduleNameOrPath)),
"ExportPSSession_ErrorModuleNameOrPath",
ErrorCategory.InvalidArgument,
cmdlet));
}
rootedPath = Path.Combine(personalModuleRoot, moduleNameOrPath);
}
}
directoryInfo = new DirectoryInfo(rootedPath);
if (directoryInfo.Exists)
{
if (!force)
{
string errorMessage = string.Format(
CultureInfo.InvariantCulture, // directory name should be treated as culture-invariant
PathUtilsStrings.ExportPSSession_ErrorDirectoryExists,
directoryInfo.FullName);
ErrorDetails details = new ErrorDetails(errorMessage);
ErrorRecord errorRecord = new ErrorRecord(
new ArgumentException(details.Message),
"ExportProxyCommand_OutputDirectoryExists",
ErrorCategory.ResourceExists,
directoryInfo);
cmdlet.ThrowTerminatingError(errorRecord);
}
}
else
{
directoryInfo.Create();
}
}
catch (Exception e)
{
string errorMessage = string.Format(
CultureInfo.InvariantCulture, // directory name should be treated as culture-invariant
PathUtilsStrings.ExportPSSession_CannotCreateOutputDirectory,
moduleNameOrPath,
e.Message);
ErrorDetails details = new ErrorDetails(errorMessage);
ErrorRecord errorRecord = new ErrorRecord(
new ArgumentException(details.Message, e),
"ExportProxyCommand_CannotCreateOutputDirectory",
ErrorCategory.ResourceExists,
moduleNameOrPath);
cmdlet.ThrowTerminatingError(errorRecord);
}
return(directoryInfo);
}