/// <summary> /// Seeks to the end of the writer stream in each of the writers in the /// content holders. /// </summary> /// /// <param name="contentHolders"> /// The content holders that contain the writers to be moved. /// </param> /// /// <exception cref="ProviderInvocationException"> /// If calling Seek on the content writer throws an exception. /// </exception> /// internal override void SeekContentPosition(List <ContentHolder> contentHolders) { foreach (ContentHolder holder in contentHolders) { if (holder.Writer != null) { try { holder.Writer.Seek(0, System.IO.SeekOrigin.End); } catch (Exception e) // Catch-all OK, 3rd party callout { CommandsCommon.CheckForSevereException(this, e); ProviderInvocationException providerException = new ProviderInvocationException( "ProviderSeekError", SessionStateStrings.ProviderSeekError, holder.PathInfo.Provider, holder.PathInfo.Path, e); // Log a provider health event MshLog.LogProviderHealthEvent( this.Context, holder.PathInfo.Provider.Name, providerException, Severity.Warning); throw providerException; } } } } // SeekContentPosition
internal void CloseContent(List <ContentCommandBase.ContentHolder> contentHolders, bool disposing) { if (contentHolders != null) { foreach (ContentCommandBase.ContentHolder contentHolder in contentHolders) { try { if (contentHolder.Writer != null) { contentHolder.Writer.Close(); } } catch (Exception exception1) { Exception exception = exception1; CommandsCommon.CheckForSevereException(this, exception); ProviderInvocationException providerInvocationException = new ProviderInvocationException("ProviderContentCloseError", SessionStateStrings.ProviderContentCloseError, contentHolder.PathInfo.Provider, contentHolder.PathInfo.Path, exception); MshLog.LogProviderHealthEvent(base.Context, contentHolder.PathInfo.Provider.Name, providerInvocationException, Severity.Warning); if (!disposing) { base.WriteError(new ErrorRecord(providerInvocationException.ErrorRecord, providerInvocationException)); } } try { if (contentHolder.Reader != null) { contentHolder.Reader.Close(); } } catch (Exception exception3) { Exception exception2 = exception3; CommandsCommon.CheckForSevereException(this, exception2); ProviderInvocationException providerInvocationException1 = new ProviderInvocationException("ProviderContentCloseError", SessionStateStrings.ProviderContentCloseError, contentHolder.PathInfo.Provider, contentHolder.PathInfo.Path, exception2); MshLog.LogProviderHealthEvent(base.Context, contentHolder.PathInfo.Provider.Name, providerInvocationException1, Severity.Warning); if (!disposing) { base.WriteError(new ErrorRecord(providerInvocationException1.ErrorRecord, providerInvocationException1)); } } } return; } else { throw PSTraceSource.NewArgumentNullException("contentHolders"); } }
internal override void SeekContentPosition(List <ContentCommandBase.ContentHolder> contentHolders) { foreach (ContentCommandBase.ContentHolder contentHolder in contentHolders) { if (contentHolder.Writer == null) { continue; } try { contentHolder.Writer.Seek((long)0, SeekOrigin.End); } catch (Exception exception1) { Exception exception = exception1; CommandsCommon.CheckForSevereException(this, exception); ProviderInvocationException providerInvocationException = new ProviderInvocationException("ProviderSeekError", SessionStateStrings.ProviderSeekError, contentHolder.PathInfo.Provider, contentHolder.PathInfo.Path, exception); MshLog.LogProviderHealthEvent(base.Context, contentHolder.PathInfo.Provider.Name, providerInvocationException, Severity.Warning); throw providerInvocationException; } } }
private bool FilterMatch(ManagementObject obj) { try { foreach (string desc in Description) { WildcardPattern wildcardpattern = WildcardPattern.Get(desc, WildcardOptions.IgnoreCase); if (wildcardpattern.IsMatch((string)obj["Description"])) { return(true); } if (WildcardPattern.ContainsWildcardCharacters(desc)) { _inputContainsWildcard = true; } } } catch (Exception e) { CommandsCommon.CheckForSevereException(this, e); return(false); } return(false); }
private bool FilterMatch(ManagementObject obj) { bool flag; try { string[] strArrays = this._description; int num = 0; while (num < (int)strArrays.Length) { string str = strArrays[num]; WildcardPattern wildcardPattern = new WildcardPattern(str, WildcardOptions.IgnoreCase); if (!wildcardPattern.IsMatch((string)obj["Description"])) { if (WildcardPattern.ContainsWildcardCharacters(str)) { this.inputContainsWildcard = true; } num++; } else { flag = true; return(flag); } } return(false); } catch (Exception exception1) { Exception exception = exception1; CommandsCommon.CheckForSevereException(this, exception); flag = false; } return(flag); }
/// <summary> /// Appends the content to the specified item. /// </summary> protected override void ProcessRecord() { CmdletProviderContext currentContext = GetCurrentContext(); // Initialize the content if (_content == null) { _content = new object[0]; } if (_pipingPaths) { // Make sure to clean up the content writers that are already there if (contentStreams != null && contentStreams.Count > 0) { CloseContent(contentStreams, false); _contentWritersOpen = false; contentStreams = new List <ContentHolder>(); } } if (!_contentWritersOpen) { // Since the paths are being pipelined in, we have // to get new content writers for the new paths string[] paths = GetAcceptedPaths(Path, currentContext); if (paths.Length > 0) { BeforeOpenStreams(paths); contentStreams = GetContentWriters(paths, currentContext); SeekContentPosition(contentStreams); } _contentWritersOpen = true; } // Now write the content to the item try { foreach (ContentHolder holder in contentStreams) { if (holder.Writer != null) { IList result = null; try { result = holder.Writer.Write(_content); } catch (Exception e) // Catch-all OK. 3rd party callout { CommandsCommon.CheckForSevereException(this, e); ProviderInvocationException providerException = new ProviderInvocationException( "ProviderContentWriteError", SessionStateStrings.ProviderContentWriteError, holder.PathInfo.Provider, holder.PathInfo.Path, e); // Log a provider health event MshLog.LogProviderHealthEvent( this.Context, holder.PathInfo.Provider.Name, providerException, Severity.Warning); WriteError( new ErrorRecord( providerException.ErrorRecord, providerException)); continue; } if (result != null && result.Count > 0 && PassThru) { WriteContentObject(result, result.Count, holder.PathInfo, currentContext); } } } } finally { // Need to close all the writers if the paths are being pipelined if (_pipingPaths) { CloseContent(contentStreams, false); _contentWritersOpen = false; contentStreams = new List <ContentHolder>(); } } } // ProcessRecord
} // ProcessRecord /// <summary> /// Scan forwards to get the tail content /// </summary> /// <param name="holder"></param> /// <param name="currentContext"></param> /// <returns> /// true if no error occured /// false if there was an error /// </returns> private bool ScanForwardsForTail(ContentHolder holder, CmdletProviderContext currentContext) { var fsReader = holder.Reader as FileSystemContentReaderWriter; Dbg.Diagnostics.Assert(fsReader != null, "Tail is only supported for FileSystemContentReaderWriter"); var tailResultQueue = new Queue <object>(); IList results = null; ErrorRecord error = null; do { try { results = fsReader.ReadWithoutWaitingChanges(ReadCount); } catch (Exception e) { CommandsCommon.CheckForSevereException(this, e); ProviderInvocationException providerException = new ProviderInvocationException( "ProviderContentReadError", SessionStateStrings.ProviderContentReadError, holder.PathInfo.Provider, holder.PathInfo.Path, e); // Log a provider health event MshLog.LogProviderHealthEvent( this.Context, holder.PathInfo.Provider.Name, providerException, Severity.Warning); // Create and save the error record. The error record // will be written outside the while loop. // This is to make sure the accumulated results get written // out before the error record when the 'scanForwardForTail' is true. error = new ErrorRecord( providerException.ErrorRecord, providerException); break; } if (results != null && results.Count > 0) { foreach (object entry in results) { if (tailResultQueue.Count == Tail) { tailResultQueue.Dequeue(); } tailResultQueue.Enqueue(entry); } } } while (results != null && results.Count > 0); if (tailResultQueue.Count > 0) { // Respect the ReadCount parameter. // Output single object when ReadCount == 1; Output array otherwise int count = 0; if (ReadCount <= 0 || (ReadCount >= tailResultQueue.Count && ReadCount != 1)) { count = tailResultQueue.Count; ArrayList outputList = new ArrayList(); while (tailResultQueue.Count > 0) { outputList.Add(tailResultQueue.Dequeue()); } // Write out the content as an array of objects WriteContentObject(outputList.ToArray(), count, holder.PathInfo, currentContext); } else if (ReadCount == 1) { // Write out the content as single object while (tailResultQueue.Count > 0) { WriteContentObject(tailResultQueue.Dequeue(), count++, holder.PathInfo, currentContext); } } else // ReadCount < Queue.Count { while (tailResultQueue.Count >= ReadCount) { ArrayList outputList = new ArrayList(); for (int idx = 0; idx < ReadCount; idx++, count++) { outputList.Add(tailResultQueue.Dequeue()); } // Write out the content as an array of objects WriteContentObject(outputList.ToArray(), count, holder.PathInfo, currentContext); } int remainder = tailResultQueue.Count; if (remainder > 0) { ArrayList outputList = new ArrayList(); for (; remainder > 0; remainder--, count++) { outputList.Add(tailResultQueue.Dequeue()); } // Write out the content as an array of objects WriteContentObject(outputList.ToArray(), count, holder.PathInfo, currentContext); } } } if (error != null) { WriteError(error); return(false); } return(true); }
/// <summary> /// Gets the content of an item at the specified path /// </summary> protected override void ProcessRecord() { // TotalCount and Tail should not be specified at the same time. // Throw out terminating error if this is the case. if (_totalCountSpecified && _tailSpecified) { string errMsg = StringUtil.Format(SessionStateStrings.GetContent_TailAndHeadCannotCoexist, "TotalCount", "Tail"); ErrorRecord error = new ErrorRecord(new InvalidOperationException(errMsg), "TailAndHeadCannotCoexist", ErrorCategory.InvalidOperation, null); WriteError(error); return; } if (TotalCount == 0) { // Don't read anything return; } // Get the content readers CmdletProviderContext currentContext = CmdletProviderContext; contentStreams = this.GetContentReaders(Path, currentContext); try { // Iterate through the content holders reading the content foreach (ContentHolder holder in contentStreams) { long countRead = 0; Dbg.Diagnostics.Assert( holder.Reader != null, "All holders should have a reader assigned"); if (_tailSpecified && !(holder.Reader is FileSystemContentReaderWriter)) { string errMsg = SessionStateStrings.GetContent_TailNotSupported; ErrorRecord error = new ErrorRecord(new InvalidOperationException(errMsg), "TailNotSupported", ErrorCategory.InvalidOperation, Tail); WriteError(error); continue; } // If Tail is negative, we are supposed to read all content out. This is same // as reading forwards. So we read forwards in this case. // If Tail is positive, we seek the right position. Or, if the seek failed // because of an unsupported encoding, we scan forward to get the tail content. if (Tail >= 0) { bool seekSuccess = false; try { seekSuccess = SeekPositionForTail(holder.Reader); } catch (Exception e) { CommandsCommon.CheckForSevereException(this, e); ProviderInvocationException providerException = new ProviderInvocationException( "ProviderContentReadError", SessionStateStrings.ProviderContentReadError, holder.PathInfo.Provider, holder.PathInfo.Path, e); // Log a provider health event MshLog.LogProviderHealthEvent( this.Context, holder.PathInfo.Provider.Name, providerException, Severity.Warning); WriteError(new ErrorRecord( providerException.ErrorRecord, providerException)); continue; } // If the seek was successful, we start to read forwards from that // point. Otherwise, we need to scan forwards to get the tail content. if (!seekSuccess && !ScanForwardsForTail(holder, currentContext)) { continue; } } if (TotalCount != 0) { IList results = null; do { long countToRead = ReadCount; // Make sure we only ask for the amount the user wanted // I am using TotalCount - countToRead so that I don't // have to worry about overflow if ((TotalCount > 0) && (TotalCount - countToRead < countRead)) { countToRead = TotalCount - countRead; } try { results = holder.Reader.Read(countToRead); } catch (Exception e) // Catch-all OK. 3rd party callout { CommandsCommon.CheckForSevereException(this, e); ProviderInvocationException providerException = new ProviderInvocationException( "ProviderContentReadError", SessionStateStrings.ProviderContentReadError, holder.PathInfo.Provider, holder.PathInfo.Path, e); // Log a provider health event MshLog.LogProviderHealthEvent( this.Context, holder.PathInfo.Provider.Name, providerException, Severity.Warning); WriteError(new ErrorRecord( providerException.ErrorRecord, providerException)); break; } if (results != null && results.Count > 0) { countRead += results.Count; if (ReadCount == 1) { // Write out the content as a single object WriteContentObject(results[0], countRead, holder.PathInfo, currentContext); } else { // Write out the content as an array of objects WriteContentObject(results, countRead, holder.PathInfo, currentContext); } } } while (results != null && results.Count > 0 && ((TotalCount < 0) || countRead < TotalCount)); } } // foreach holder in contentStreams } finally { // close all the content readers CloseContent(contentStreams, false); // Empty the content holder array contentStreams = new List <ContentHolder>(); } } // ProcessRecord
protected override void BeginProcessing() { if (base.ParameterSetName == "Domain") { if ((this._joinOptions & JoinOptions.PasswordPass) != 0 && (this._joinOptions & JoinOptions.UnsecuredJoin) == 0) { object[] str = new object[2]; str[0] = JoinOptions.PasswordPass.ToString(); str[1] = JoinOptions.UnsecuredJoin.ToString(); this.WriteErrorHelper(ComputerResources.InvalidJoinOptions, "InvalidJoinOptions", this._joinOptions, ErrorCategory.InvalidArgument, true, str); } if ((this._joinOptions & JoinOptions.AccountCreate) != 0) { AddComputerCommand addComputerCommand = this; addComputerCommand._joinDomainflags = addComputerCommand._joinDomainflags | 2; } if ((this._joinOptions & JoinOptions.Win9XUpgrade) != 0) { AddComputerCommand addComputerCommand1 = this; addComputerCommand1._joinDomainflags = addComputerCommand1._joinDomainflags | 16; } if ((this._joinOptions & JoinOptions.UnsecuredJoin) != 0) { AddComputerCommand addComputerCommand2 = this; addComputerCommand2._joinDomainflags = addComputerCommand2._joinDomainflags | 64; } if ((this._joinOptions & JoinOptions.PasswordPass) != 0) { AddComputerCommand addComputerCommand3 = this; addComputerCommand3._joinDomainflags = addComputerCommand3._joinDomainflags | 128; } if ((this._joinOptions & JoinOptions.DeferSPNSet) != 0) { AddComputerCommand addComputerCommand4 = this; addComputerCommand4._joinDomainflags = addComputerCommand4._joinDomainflags | 0x100; } if ((this._joinOptions & JoinOptions.JoinWithNewName) != 0) { AddComputerCommand addComputerCommand5 = this; addComputerCommand5._joinDomainflags = addComputerCommand5._joinDomainflags | 0x400; } if ((this._joinOptions & JoinOptions.JoinReadOnly) != 0) { AddComputerCommand addComputerCommand6 = this; addComputerCommand6._joinDomainflags = addComputerCommand6._joinDomainflags | 0x800; } if ((this._joinOptions & JoinOptions.InstallInvoke) != 0) { AddComputerCommand addComputerCommand7 = this; addComputerCommand7._joinDomainflags = addComputerCommand7._joinDomainflags | 0x40000; } if (this._unsecure) { AddComputerCommand addComputerCommand8 = this; addComputerCommand8._joinDomainflags = addComputerCommand8._joinDomainflags | 192; } if (this._server != null) { try { Dns.GetHostEntry(this._server); } catch (Exception exception1) { Exception exception = exception1; CommandsCommon.CheckForSevereException(this, exception); object[] objArray = new object[1]; objArray[0] = this._server; this.WriteErrorHelper(ComputerResources.CannotResolveServerName, "AddressResolutionException", this._server, ErrorCategory.InvalidArgument, true, objArray); } this._domainName = string.Concat(this._domainName, "\\", this._server); } } }
protected override void ProcessRecord() { CmdletProviderContext currentContext = base.GetCurrentContext(); if (this.content == null) { this.content = new object[0]; } if (this.pipingPaths && this.contentStreams != null && this.contentStreams.Count > 0) { base.CloseContent(this.contentStreams, false); this.contentWritersOpen = false; this.contentStreams = new List <ContentCommandBase.ContentHolder>(); } if (!this.contentWritersOpen) { string[] acceptedPaths = this.GetAcceptedPaths(base.Path, currentContext); if ((int)acceptedPaths.Length > 0) { this.BeforeOpenStreams(acceptedPaths); this.contentStreams = this.GetContentWriters(acceptedPaths, currentContext); this.SeekContentPosition(this.contentStreams); } this.contentWritersOpen = true; } try { foreach (ContentCommandBase.ContentHolder contentStream in this.contentStreams) { if (contentStream.Writer == null) { continue; } IList lists = null; try { lists = contentStream.Writer.Write(this.content); } catch (Exception exception1) { Exception exception = exception1; CommandsCommon.CheckForSevereException(this, exception); ProviderInvocationException providerInvocationException = new ProviderInvocationException("ProviderContentWriteError", SessionStateStrings.ProviderContentWriteError, contentStream.PathInfo.Provider, contentStream.PathInfo.Path, exception); MshLog.LogProviderHealthEvent(base.Context, contentStream.PathInfo.Provider.Name, providerInvocationException, Severity.Warning); base.WriteError(new ErrorRecord(providerInvocationException.ErrorRecord, providerInvocationException)); continue; } if (lists == null || lists.Count <= 0 || !base.PassThru) { continue; } base.WriteContentObject(lists, (long)lists.Count, contentStream.PathInfo, currentContext); } } finally { if (this.pipingPaths) { base.CloseContent(this.contentStreams, false); this.contentWritersOpen = false; this.contentStreams = new List <ContentCommandBase.ContentHolder>(); } } }
} // struct ContentHolder /// <summary> /// Closes the content readers and writers in the content holder array /// </summary> internal void CloseContent(List <ContentHolder> contentHolders, bool disposing) { if (contentHolders == null) { throw PSTraceSource.NewArgumentNullException("contentHolders"); } foreach (ContentHolder holder in contentHolders) { try { if (holder.Writer != null) { holder.Writer.Close(); } } catch (Exception e) // Catch-all OK. 3rd party callout { CommandsCommon.CheckForSevereException(this, e); // Catch all the exceptions caused by closing the writer // and write out an error. ProviderInvocationException providerException = new ProviderInvocationException( "ProviderContentCloseError", SessionStateStrings.ProviderContentCloseError, holder.PathInfo.Provider, holder.PathInfo.Path, e); // Log a provider health event MshLog.LogProviderHealthEvent( this.Context, holder.PathInfo.Provider.Name, providerException, Severity.Warning); if (!disposing) { WriteError( new ErrorRecord( providerException.ErrorRecord, providerException)); } } try { if (holder.Reader != null) { holder.Reader.Close(); } } catch (Exception e) // Catch-all OK. 3rd party callout { CommandsCommon.CheckForSevereException(this, e); // Catch all the exceptions caused by closing the writer // and write out an error. ProviderInvocationException providerException = new ProviderInvocationException( "ProviderContentCloseError", SessionStateStrings.ProviderContentCloseError, holder.PathInfo.Provider, holder.PathInfo.Path, e); // Log a provider health event MshLog.LogProviderHealthEvent( this.Context, holder.PathInfo.Provider.Name, providerException, Severity.Warning); if (!disposing) { WriteError( new ErrorRecord( providerException.ErrorRecord, providerException)); } } } } // CloseContent
/// <summary> /// Get the List of HotFixes installed on the Local Machine. /// </summary> protected override void BeginProcessing() { foreach (string computer in ComputerName) { bool foundRecord = false; StringBuilder QueryString = new StringBuilder(); ConnectionOptions conOptions = ComputerWMIHelper.GetConnectionOptions(AuthenticationLevel.Packet, ImpersonationLevel.Impersonate, this.Credential); ManagementScope scope = new ManagementScope(ComputerWMIHelper.GetScopeString(computer, ComputerWMIHelper.WMI_Path_CIM), conOptions); scope.Connect(); if (Id != null) { QueryString.Append("Select * from Win32_QuickFixEngineering where ("); for (int i = 0; i <= Id.Length - 1; i++) { QueryString.Append("HotFixID= '"); QueryString.Append(Id[i].ToString().Replace("'", "\\'")); QueryString.Append("'"); if (i < Id.Length - 1) { QueryString.Append(" Or "); } } QueryString.Append(")"); } else { QueryString.Append("Select * from Win32_QuickFixEngineering"); foundRecord = true; } _searchProcess = new ManagementObjectSearcher(scope, new ObjectQuery(QueryString.ToString())); foreach (ManagementObject obj in _searchProcess.Get()) { if (Description != null) { if (!FilterMatch(obj)) { continue; } } else { _inputContainsWildcard = true; } // try to translate the SID to a more friendly username // just stick with the SID if anything goes wrong string installed = (string)obj["InstalledBy"]; if (!String.IsNullOrEmpty(installed)) { try { SecurityIdentifier secObj = new SecurityIdentifier(installed); obj["InstalledBy"] = secObj.Translate(typeof(NTAccount));; } catch (IdentityNotMappedException) // thrown by SecurityIdentifier.Translate { } catch (SystemException e) // thrown by SecurityIdentifier.constr { CommandsCommon.CheckForSevereException(this, e); } //catch (ArgumentException) // thrown (indirectly) by SecurityIdentifier.constr (on XP only?) //{ catch not needed - this is already caught as SystemException //} //catch (PlatformNotSupportedException) // thrown (indirectly) by SecurityIdentifier.Translate (on Win95 only?) //{ catch not needed - this is already caught as SystemException //} //catch (UnauthorizedAccessException) // thrown (indirectly) by SecurityIdentifier.Translate //{ catch not needed - this is already caught as SystemException //} } WriteObject(obj); foundRecord = true; } if (!foundRecord && !_inputContainsWildcard) { Exception Ex = new ArgumentException(StringUtil.Format(HotFixResources.NoEntriesFound, computer)); WriteError(new ErrorRecord(Ex, "GetHotFixNoEntriesFound", ErrorCategory.ObjectNotFound, null)); } if (_searchProcess != null) { this.Dispose(); } } }//end of BeginProcessing method
protected override void BeginProcessing() { bool flag = false; string[] strArrays = this._computername; for (int i = 0; i < (int)strArrays.Length; i++) { string str = strArrays[i]; StringBuilder stringBuilder = new StringBuilder(); ConnectionOptions connection = ComputerWMIHelper.GetConnection(AuthenticationLevel.Packet, ImpersonationLevel.Impersonate, this.Credential); ManagementScope managementScope = new ManagementScope(ComputerWMIHelper.GetScopeString(str, "\\root\\cimv2"), connection); managementScope.Connect(); if (this._id == null) { stringBuilder.Append("Select * from Win32_QuickFixEngineering"); flag = true; } else { stringBuilder.Append("Select * from Win32_QuickFixEngineering where ("); for (int j = 0; j <= (int)this._id.Length - 1; j++) { stringBuilder.Append("HotFixID= '"); stringBuilder.Append(this._id[j].ToString().Replace("'", "\\'")); stringBuilder.Append("'"); if (j < (int)this._id.Length - 1) { stringBuilder.Append(" Or "); } } stringBuilder.Append(")"); } this.searchProcess = new ManagementObjectSearcher(managementScope, new ObjectQuery(stringBuilder.ToString())); foreach (ManagementObject managementObject in this.searchProcess.Get()) { if (this._description == null) { this.inputContainsWildcard = true; } else { if (!this.FilterMatch(managementObject)) { continue; } } string item = (string)managementObject["InstalledBy"]; if (!string.IsNullOrEmpty(item)) { try { SecurityIdentifier securityIdentifier = new SecurityIdentifier(item); managementObject["InstalledBy"] = securityIdentifier.Translate(typeof(NTAccount)); } catch (IdentityNotMappedException identityNotMappedException) { } catch (SystemException systemException1) { SystemException systemException = systemException1; CommandsCommon.CheckForSevereException(this, systemException); } } base.WriteObject(managementObject); flag = true; } if (!flag && !this.inputContainsWildcard) { Exception argumentException = new ArgumentException(StringUtil.Format(HotFixResources.NoEntriesFound, str)); base.WriteError(new ErrorRecord(argumentException, "GetHotFixNoEntriesFound", ErrorCategory.ObjectNotFound, null)); } if (this.searchProcess != null) { this.Dispose(); } } }
protected override void ProcessRecord() { if (!this._totalCountSpecified || !this._tailSpecified) { if (this.TotalCount != (long)0) { CmdletProviderContext cmdletProviderContext = this.CmdletProviderContext; this.contentStreams = base.GetContentReaders(base.Path, cmdletProviderContext); try { Label0: foreach (ContentCommandBase.ContentHolder contentStream in this.contentStreams) { long count = (long)0; if (!this._tailSpecified || contentStream.Reader as FileSystemContentReaderWriter != null) { if (this.Tail >= 0) { bool flag = false; try { flag = this.SeekPositionForTail(contentStream.Reader); } catch (Exception exception1) { Exception exception = exception1; CommandsCommon.CheckForSevereException(this, exception); ProviderInvocationException providerInvocationException = new ProviderInvocationException("ProviderContentReadError", SessionStateStrings.ProviderContentReadError, contentStream.PathInfo.Provider, contentStream.PathInfo.Path, exception); MshLog.LogProviderHealthEvent(base.Context, contentStream.PathInfo.Provider.Name, providerInvocationException, Severity.Warning); base.WriteError(new ErrorRecord(providerInvocationException.ErrorRecord, providerInvocationException)); continue; } if (!flag && !this.ScanForwardsForTail(contentStream, cmdletProviderContext)) { continue; } } if (this.TotalCount == (long)0) { continue; } IList lists = null; do { long readCount = this.ReadCount; if (this.TotalCount > (long)0 && this.TotalCount - readCount < count) { readCount = this.TotalCount - count; } try { lists = contentStream.Reader.Read(readCount); } catch (Exception exception3) { Exception exception2 = exception3; CommandsCommon.CheckForSevereException(this, exception2); ProviderInvocationException providerInvocationException1 = new ProviderInvocationException("ProviderContentReadError", SessionStateStrings.ProviderContentReadError, contentStream.PathInfo.Provider, contentStream.PathInfo.Path, exception2); MshLog.LogProviderHealthEvent(base.Context, contentStream.PathInfo.Provider.Name, providerInvocationException1, Severity.Warning); base.WriteError(new ErrorRecord(providerInvocationException1.ErrorRecord, providerInvocationException1)); goto Label0; } if (lists == null || lists.Count <= 0) { continue; } count = count + (long)lists.Count; if (this.ReadCount != (long)1) { base.WriteContentObject(lists, count, contentStream.PathInfo, cmdletProviderContext); } else { base.WriteContentObject(lists[0], count, contentStream.PathInfo, cmdletProviderContext); } }while (lists != null && lists.Count > 0 && (this.TotalCount < (long)0 || count < this.TotalCount)); } else { string getContentTailNotSupported = SessionStateStrings.GetContent_TailNotSupported; ErrorRecord errorRecord = new ErrorRecord(new InvalidOperationException(getContentTailNotSupported), "TailNotSupported", ErrorCategory.InvalidOperation, (object)this.Tail); base.WriteError(errorRecord); } } } finally { base.CloseContent(this.contentStreams, false); this.contentStreams = new List <ContentCommandBase.ContentHolder>(); } return; } else { return; } } else { string str = StringUtil.Format(SessionStateStrings.GetContent_TailAndHeadCannotCoexist, "TotalCount", "Tail"); ErrorRecord errorRecord1 = new ErrorRecord(new InvalidOperationException(str), "TailAndHeadCannotCoexist", ErrorCategory.InvalidOperation, null); base.WriteError(errorRecord1); return; } }
private bool ScanForwardsForTail(ContentCommandBase.ContentHolder holder, CmdletProviderContext currentContext) { FileSystemContentReaderWriter reader = holder.Reader as FileSystemContentReaderWriter; Queue <object> objs = new Queue <object>(); IList lists = null; ErrorRecord errorRecord = null; do { try { lists = reader.ReadWithoutWaitingChanges(this.ReadCount); } catch (Exception exception1) { Exception exception = exception1; CommandsCommon.CheckForSevereException(this, exception); ProviderInvocationException providerInvocationException = new ProviderInvocationException("ProviderContentReadError", SessionStateStrings.ProviderContentReadError, holder.PathInfo.Provider, holder.PathInfo.Path, exception); MshLog.LogProviderHealthEvent(base.Context, holder.PathInfo.Provider.Name, providerInvocationException, Severity.Warning); errorRecord = new ErrorRecord(providerInvocationException.ErrorRecord, providerInvocationException); break; } if (lists == null || lists.Count <= 0) { continue; } foreach (object obj in lists) { if (objs.Count == this.Tail) { objs.Dequeue(); } objs.Enqueue(obj); } }while (lists != null && lists.Count > 0); if (objs.Count > 0) { int count = 0; if (this.ReadCount <= (long)0 || this.ReadCount >= (long)objs.Count && this.ReadCount != (long)1) { count = objs.Count; ArrayList arrayLists = new ArrayList(); while (objs.Count > 0) { arrayLists.Add(objs.Dequeue()); } base.WriteContentObject(arrayLists.ToArray(), (long)count, holder.PathInfo, currentContext); } else { if (this.ReadCount != (long)1) { while ((long)objs.Count >= this.ReadCount) { ArrayList arrayLists1 = new ArrayList(); int num = 0; while ((long)num < this.ReadCount) { arrayLists1.Add(objs.Dequeue()); num++; count++; } base.WriteContentObject(arrayLists1.ToArray(), (long)count, holder.PathInfo, currentContext); } int count1 = objs.Count; if (count1 > 0) { ArrayList arrayLists2 = new ArrayList(); while (count1 > 0) { arrayLists2.Add(objs.Dequeue()); count1--; count++; } base.WriteContentObject(arrayLists2.ToArray(), (long)count, holder.PathInfo, currentContext); } } else { while (objs.Count > 0) { int num1 = count; count = num1 + 1; base.WriteContentObject(objs.Dequeue(), (long)num1, holder.PathInfo, currentContext); } } } } if (errorRecord == null) { return(true); } else { base.WriteError(errorRecord); return(false); } }
protected override void ProcessRecord() { if ((int)this.ComputerName.Length > 0 && (this._fileversioninfo.IsPresent || this._module.IsPresent)) { Exception invalidOperationException = new InvalidOperationException(ProcessResources.NoComputerNameWithFileVersion); ErrorRecord errorRecord = new ErrorRecord(invalidOperationException, "InvalidOperationException", ErrorCategory.InvalidOperation, this.ComputerName); base.ThrowTerminatingError(errorRecord); } foreach (Process process in base.MatchingProcesses()) { if (!this._module.IsPresent || !this._fileversioninfo.IsPresent) { if (!this._module.IsPresent) { if (!this._fileversioninfo.IsPresent) { base.WriteObject(process); } else { try { base.WriteObject(PsUtils.GetMainModule(process).FileVersionInfo, true); } catch (InvalidOperationException invalidOperationException2) { InvalidOperationException invalidOperationException1 = invalidOperationException2; base.WriteNonTerminatingError(process, invalidOperationException1, ProcessResources.CouldnotEnumerateFileVer, "CouldnotEnumerateFileVer", ErrorCategory.PermissionDenied); } catch (ArgumentException argumentException1) { ArgumentException argumentException = argumentException1; base.WriteNonTerminatingError(process, argumentException, ProcessResources.CouldnotEnumerateFileVer, "CouldnotEnumerateFileVer", ErrorCategory.PermissionDenied); } catch (Win32Exception win32Exception3) { Win32Exception win32Exception = win32Exception3; try { if (win32Exception.ErrorCode != 0x12b) { base.WriteNonTerminatingError(process, win32Exception, ProcessResources.CouldnotEnumerateFileVer, "CouldnotEnumerateFileVer", ErrorCategory.PermissionDenied); } else { base.WriteObject(PsUtils.GetMainModule(process).FileVersionInfo, true); } } catch (Win32Exception win32Exception2) { Win32Exception win32Exception1 = win32Exception2; base.WriteNonTerminatingError(process, win32Exception1, ProcessResources.CouldnotEnumerateFileVer, "CouldnotEnumerateFileVer", ErrorCategory.PermissionDenied); } } catch (Exception exception1) { Exception exception = exception1; CommandsCommon.CheckForSevereException(this, exception); base.WriteNonTerminatingError(process, exception, ProcessResources.CouldnotEnumerateFileVer, "CouldnotEnumerateFileVer", ErrorCategory.PermissionDenied); } } } else { try { base.WriteObject(process.Modules, true); } catch (Win32Exception win32Exception7) { Win32Exception win32Exception4 = win32Exception7; try { if (win32Exception4.ErrorCode != 0x12b) { base.WriteNonTerminatingError(process, win32Exception4, ProcessResources.CouldnotEnumerateModules, "CouldnotEnumerateModules", ErrorCategory.PermissionDenied); } else { base.WriteObject(process.Modules, true); } } catch (Win32Exception win32Exception6) { Win32Exception win32Exception5 = win32Exception6; base.WriteNonTerminatingError(process, win32Exception5, ProcessResources.CouldnotEnumerateModules, "CouldnotEnumerateModules", ErrorCategory.PermissionDenied); } } catch (Exception exception3) { Exception exception2 = exception3; CommandsCommon.CheckForSevereException(this, exception2); base.WriteNonTerminatingError(process, exception2, ProcessResources.CouldnotEnumerateModules, "CouldnotEnumerateModules", ErrorCategory.PermissionDenied); } } } else { ProcessModule processModule = null; try { ProcessModuleCollection modules = process.Modules; foreach (ProcessModule module in modules) { processModule = module; base.WriteObject(module.FileVersionInfo, true); } } catch (InvalidOperationException invalidOperationException4) { InvalidOperationException invalidOperationException3 = invalidOperationException4; base.WriteNonTerminatingError(process, invalidOperationException3, ProcessResources.CouldnotEnumerateModuleFileVer, "CouldnotEnumerateModuleFileVer", ErrorCategory.PermissionDenied); } catch (ArgumentException argumentException3) { ArgumentException argumentException2 = argumentException3; base.WriteNonTerminatingError(process, argumentException2, ProcessResources.CouldnotEnumerateModuleFileVer, "CouldnotEnumerateModuleFileVer", ErrorCategory.PermissionDenied); } catch (Win32Exception win32Exception11) { Win32Exception win32Exception8 = win32Exception11; try { if (win32Exception8.ErrorCode != 0x12b) { base.WriteNonTerminatingError(process, win32Exception8, ProcessResources.CouldnotEnumerateModuleFileVer, "CouldnotEnumerateModuleFileVer", ErrorCategory.PermissionDenied); } else { base.WriteObject(processModule.FileVersionInfo, true); } } catch (Win32Exception win32Exception10) { Win32Exception win32Exception9 = win32Exception10; base.WriteNonTerminatingError(process, win32Exception9, ProcessResources.CouldnotEnumerateModuleFileVer, "CouldnotEnumerateModuleFileVer", ErrorCategory.PermissionDenied); } } catch (Exception exception5) { Exception exception4 = exception5; CommandsCommon.CheckForSevereException(this, exception4); base.WriteNonTerminatingError(process, exception4, ProcessResources.CouldnotEnumerateModuleFileVer, "CouldnotEnumerateModuleFileVer", ErrorCategory.PermissionDenied); } } } }