PowerShellCookbook.psm1

function Add-ExtendedFileProperties
{
    ##############################################################################
    ##
    ## Add-ExtendedFileProperties
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Add the extended file properties normally shown in Exlorer's
    "File Properties" tab.
    
    .EXAMPLE
    
    PS > Get-ChildItem | Add-ExtendedFileProperties.ps1 | Format-Table Name,"Bit Rate"
    
    #>
    
    begin
    {
        Set-StrictMode -Version 3
    
        ## Create the Shell.Application COM object that provides this
        ## functionality
        $shellObject = New-Object -Com Shell.Application
       
        ## Remember the column property mappings
        $columnMappings = @{}
    }
    
    process
    {
        ## Store the property names and identifiers for all of the shell
        ## properties
        $itemProperties = @{}
    
        ## Get the file from the input pipeline. If it is just a filename
        ## (rather than a real file,) piping it to the Get-Item cmdlet will
        ## get the file it represents.
        $fileItem = $_ | Get-Item
    
        ## Don't process directories
        if($fileItem.PsIsContainer)
        {
            $fileItem
            return
        }
    
        ## Extract the file name and directory name
        $directoryName = $fileItem.DirectoryName
        $filename = $fileItem.Name
    
        ## Create the folder object and shell item from the COM object
        $folderObject = $shellObject.NameSpace($directoryName)
        $item = $folderObject.ParseName($filename)
    
        ## Populate the item properties
        $counter = 0
        $columnName = ""
        do
        {
            if(-not $columnMappings[$counter])
            {
                $columnMappings[$counter] = $folderObject.GetDetailsOf(
                    $folderObject.Items, $counter)
            }
            
            $columnName = $columnMappings[$counter]
            if($columnName)
            {
                $itemProperties[$columnName] =
                    $folderObject.GetDetailsOf($item, $counter)
            }
    
            $counter++
        } while($columnName)
        
        ## Process extended properties
        foreach($name in
            $item.ExtendedProperty('System.PropList.FullDetails').Split(';'))
        {
            $name = $name.Replace("*","")
            $itemProperties[$name] = $item.ExtendedProperty($name)
        }
    
        ## Now, go through each property and add its information as a
        ## property to the file we are about to return
        foreach($itemProperty in $itemProperties.Keys)
        {
            $value = $itemProperties[$itemProperty]
            if($value)
            {
                $fileItem | Add-Member NoteProperty $itemProperty `
                    $value -ErrorAction `
                    SilentlyContinue
            }
        }
    
        ## Finally, return the file with the extra shell information
        $fileItem
    }
}

function Add-FormatData
{
    ##############################################################################
    ##
    ## Add-FormatData
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Adds a table formatting definition for the specified type name.
    
    .EXAMPLE
    
    PS > $r = [PSCustomObject] @{
        Name = "Lee";
        Phone = "555-1212";
        SSN = "123-12-1212"
    }
    PS > $r.PSTypeNames.Add("AddressRecord")
    PS > Add-FormatData -TypeName AddressRecord -TableColumns Name, Phone
    PS > $r
    
    Name Phone
    ---- -----
    Lee  555-1212
    
    #>
    
    param(
        ## The type name (or PSTypeName) that the table definition should
        ## apply to.
        $TypeName,
    
        ## The columns to be displayed by default
        [string[]] $TableColumns
    )
    
    Set-StrictMode -Version 3
    
    ## Define the columns within a table control row
    $rowDefinition = New-Object Management.Automation.TableControlRow
    
    ## Create left-aligned columns for each provided column name
    foreach($column in $TableColumns)
    {
        $rowDefinition.Columns.Add(
    	    (New-Object Management.Automation.TableControlColumn "Left", 
                (New-Object Management.Automation.DisplayEntry $column,"Property")))
    }
    
    $tableControl = New-Object Management.Automation.TableControl
    $tableControl.Rows.Add($rowDefinition)
    
    ## And then assign the table control to a new format view,
    ## which we then add to an extended type definition. Define this view for the
    ## supplied custom type name.
    $formatViewDefinition = New-Object Management.Automation.FormatViewDefinition "TableView",$tableControl
    $extendedTypeDefinition = New-Object Management.Automation.ExtendedTypeDefinition $TypeName
    $extendedTypeDefinition.FormatViewDefinition.Add($formatViewDefinition)
    
    ## Add the definition to the session, and refresh the format data
    [Runspace]::DefaultRunspace.InitialSessionState.Formats.Add($extendedTypeDefinition)
    Update-FormatData
}

function Add-FormatTableIndexParameter
{
    ##############################################################################
    ##
    ## Add-FormatTableIndexParameter
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Adds a new -IncludeIndex switch parameter to the Format-Table command
    to help with array indexing.
    
    .NOTES
    
    This commands builds on New-CommandWrapper, also included in the Windows
    PowerShell Cookbook.
    
    .EXAMPLE
    
    PS > $items = dir
    PS > $items | Format-Table -IncludeIndex
    PS > $items[4]
    
    #>
    
    Set-StrictMode -Version 3
    
    New-CommandWrapper Format-Table `
        -AddParameter @{
            @{
                Name = 'IncludeIndex';
                Attributes = "[Switch]"
            } = {
    
            function Add-IndexParameter {
                begin
                {
                    $psIndex = 0
                }
                process
                {
                    ## If this is the Format-Table header
                    if($_.GetType().FullName -eq `
                        "Microsoft.PowerShell.Commands.Internal." +
                        "Format.FormatStartData")
                    {
                        ## Take the first column and create a copy of it
                        $formatStartType =
                            $_.shapeInfo.tableColumnInfoList[0].GetType()
                        $clone =
                            $formatStartType.GetConstructors()[0].Invoke($null)
    
                        ## Add a PSIndex property
                        $clone.PropertyName = "PSIndex"
                        $clone.Width = $clone.PropertyName.Length
    
                        ## And add its information to the header information
                        $_.shapeInfo.tableColumnInfoList.Insert(0, $clone)
                    }
    
                    ## If this is a Format-Table entry
                    if($_.GetType().FullName -eq `
                        "Microsoft.PowerShell.Commands.Internal." +
                        "Format.FormatEntryData")
                    {
                        ## Take the first property and create a copy of it
                        $firstField =
                            $_.formatEntryInfo.formatPropertyFieldList[0]
                        $formatFieldType = $firstField.GetType()
                        $clone =
                            $formatFieldType.GetConstructors()[0].Invoke($null)
    
                        ## Set the PSIndex property value
                        $clone.PropertyValue = $psIndex
                        $psIndex++
    
                        ## And add its information to the entry information
                        $_.formatEntryInfo.formatPropertyFieldList.Insert(
                            0, $clone)
                    }
    
                    $_
                }
            }
    
            $newPipeline = { __ORIGINAL_COMMAND__ | Add-IndexParameter }
        }
    }
}

function Add-ObjectCollector
{
    ##############################################################################
    ##
    ## Add-ObjectCollector
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Adds a new Out-Default command wrapper to store up to 500 elements from
    the previous command. This wrapper stores output in the $ll variable.
    
    .EXAMPLE
    
    PS > Get-Command $pshome\powershell.exe
    
    CommandType     Name                          Definition
    -----------     ----                          ----------
    Application     powershell.exe                C:\Windows\System32\Windo...
    
    PS > $ll.Definition
    C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe
    
    .NOTES
    
    This command builds on New-CommandWrapper, also included in the Windows
    PowerShell Cookbook.
    
    #>
    
    Set-StrictMode -Version 3
    
    New-CommandWrapper Out-Default `
        -Begin {
            $cachedOutput = New-Object System.Collections.ArrayList
        } `
        -Process {
            ## If we get an input object, add it to our list of objects
            if($_ -ne $null) { $null = $cachedOutput.Add($_) }
            while($cachedOutput.Count -gt 500) { $cachedOutput.RemoveAt(0) }
        } `
        -End {
            ## Be sure we got objects that were not just errors (
            ## so that we don't wipe out the saved output when we get errors
            ## trying to work with it.)
            ## Also don't caputre formatting information, as those objects
            ## can't be worked with.
            $uniqueOutput = $cachedOutput | Foreach-Object {
                $_.GetType().FullName } | Select -Unique
            $containsInterestingTypes = ($uniqueOutput -notcontains `
                "System.Management.Automation.ErrorRecord") -and
                ($uniqueOutput -notlike `
                    "Microsoft.PowerShell.Commands.Internal.Format.*")
    
            ## If we actually had output, and it was interesting information,
            ## save the output into the $ll variable
            if(($cachedOutput.Count -gt 0) -and $containsInterestingTypes)
            {
                $GLOBAL:ll = $cachedOutput | % { $_ }
            }
        }
}

function Add-RelativePathCapture
{
    ##############################################################################
    ##
    ## Add-RelativePathCapture
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Adds a new CommandNotFound handler that captures relative path
    navigation without having to explicitly call 'Set-Location'
    
    .EXAMPLE
    
    PS C:\Users\Lee\Documents>..
    PS C:\Users\Lee>...
    PS C:\>
    
    #>
    
    Set-StrictMode -Version 3
    
    $executionContext.SessionState.InvokeCommand.CommandNotFoundAction = {
        param($CommandName, $CommandLookupEventArgs)
    
        ## If the command is only dots
        if($CommandName -match '^\.+$')
        {
            ## Associate a new command that should be invoked instead    
            $CommandLookupEventArgs.CommandScriptBlock = {
    
                ## Count the number of dots, and run "Set-Location .." one
                ## less time.
                for($counter = 0; $counter -lt $CommandName.Length - 1; $counter++)
                {
                    Set-Location ..
                }
    
            ## We call GetNewClosure() so that the reference to $CommandName can
            ## be used in the new command.
            }.GetNewClosure()
    
            ## Stop going through the command resolution process. This isn't
            ## strictly required in the CommandNotFoundAction.
            $CommandLookupEventArgs.StopSearch = $true
        }
    }
}

function Compare-Property
{
    ##############################################################################
    ##
    ## Compare-Property
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Compare the property you provide against the input supplied to the script.
    This provides the functionality of simple Where-Object comparisons without
    the syntax required for that cmdlet.
    
    .EXAMPLE
    
    PS Get-Process | Compare-Property Handles gt 1000
    
    .EXAMPLE
    
    PS > Set-Alias ?? Compare-Property
    PS > dir | ?? PsIsContainer
    
    #>
    
    param(
        ## The property to compare
        $Property,
    
        ## The operator to use in the comparison
        $Operator = "eq",
    
        ## The value to compare with
        $MatchText = "$true"
    )
    
    Begin { $expression = "`$_.$property -$operator `"$matchText`"" }
    Process { if(Invoke-Expression $expression) { $_ } }
}

function Connect-WebService
{
    ##############################################################################
    ##
    ## Connect-WebService
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ## Connect to a given web service, and create a type that allows you to
    ## interact with that web service. In PowerShell version two, use the
    ## New-WebserviceProxy cmdlet.
    ##
    ## Example:
    ##
    ## $wsdl = "http://www.terraserver-usa.com/TerraService2.asmx?WSDL"
    ## $terraServer = Connect-WebService $wsdl
    ## $place = New-Object Place
    ## $place.City = "Redmond"
    ## $place.State = "WA"
    ## $place.Country = "USA"
    ## $facts = $terraserver.GetPlaceFacts($place)
    ## $facts.Center
    ##
    ##############################################################################
    
    param(
        ## The URL that contains the WSDL
        [string] $WsdlLocation = $(throw "Please specify a WSDL location"),
    
        ## The namespace to use to contain the web service proxy
        [string] $Namespace,
    
        ## Switch to identify web services that require authentication
        [Switch] $RequiresAuthentication
    )
    
    ## Create the web service cache, if it doesn't already exist
    if(-not (Test-Path Variable:\Lee.Holmes.WebServiceCache))
    {
        ${GLOBAL:Lee.Holmes.WebServiceCache} = @{}
    }
    
    ## Check if there was an instance from a previous connection to
    ## this web service. If so, return that instead.
    $oldInstance = ${GLOBAL:Lee.Holmes.WebServiceCache}[$wsdlLocation]
    if($oldInstance)
    {
        $oldInstance
        return
    }
    
    ## Load the required Web Services DLL
    $null = [Reflection.Assembly]::LoadWithPartialName("System.Web.Services")
    
    ## Download the WSDL for the service, and create a service description from
    ## it.
    $wc = New-Object System.Net.WebClient
    
    if($requiresAuthentication)
    {
        $wc.UseDefaultCredentials = $true
    }
    
    $wsdlStream = $wc.OpenRead($wsdlLocation)
    
    ## Ensure that we were able to fetch the WSDL
    if(-not (Test-Path Variable:\wsdlStream))
    {
        return
    }
    
    $serviceDescription =
        [Web.Services.Description.ServiceDescription]::Read($wsdlStream)
    $wsdlStream.Close()
    
    ## Ensure that we were able to read the WSDL into a service description
    if(-not (Test-Path Variable:\serviceDescription))
    {
        return
    }
    
    ## Import the web service into a CodeDom
    $serviceNamespace = New-Object System.CodeDom.CodeNamespace
    if($namespace)
    {
        $serviceNamespace.Name = $namespace
    }
    
    $codeCompileUnit = New-Object System.CodeDom.CodeCompileUnit
    $serviceDescriptionImporter =
        New-Object Web.Services.Description.ServiceDescriptionImporter
    $serviceDescriptionImporter.AddServiceDescription(
        $serviceDescription, $null, $null)
    [void] $codeCompileUnit.Namespaces.Add($serviceNamespace)
    [void] $serviceDescriptionImporter.Import(
        $serviceNamespace, $codeCompileUnit)
    
    ## Generate the code from that CodeDom into a string
    $generatedCode = New-Object Text.StringBuilder
    $stringWriter = New-Object IO.StringWriter $generatedCode
    $provider = New-Object Microsoft.CSharp.CSharpCodeProvider
    $provider.GenerateCodeFromCompileUnit($codeCompileUnit, $stringWriter, $null)
    
    ## Compile the source code.
    $references = @("System.dll", "System.Web.Services.dll", "System.Xml.dll")
    $compilerParameters = New-Object System.CodeDom.Compiler.CompilerParameters
    $compilerParameters.ReferencedAssemblies.AddRange($references)
    $compilerParameters.GenerateInMemory = $true
    
    $compilerResults =
        $provider.CompileAssemblyFromSource($compilerParameters, $generatedCode)
    
    ## Write any errors if generated.
    if($compilerResults.Errors.Count -gt 0)
    {
        $errorLines = ""
        foreach($error in $compilerResults.Errors)
        {
            $errorLines += "`n`t" + $error.Line + ":`t" + $error.ErrorText
        }
    
        Write-Error $errorLines
        return
    }
    ## There were no errors.  Create the webservice object and return it.
    else
    {
        ## Get the assembly that we just compiled
        $assembly = $compilerResults.CompiledAssembly
    
        ## Find the type that had the WebServiceBindingAttribute.
        ## There may be other "helper types" in this file, but they will
        ## not have this attribute
        $type = $assembly.GetTypes() |
            Where-Object { $_.GetCustomAttributes(
                [System.Web.Services.WebServiceBindingAttribute], $false) }
    
        if(-not $type)
        {
            Write-Error "Could not generate web service proxy."
            return
        }
    
        ## Create an instance of the type, store it in the cache,
        ## and return it to the user.
        $instance = $assembly.CreateInstance($type)
    
        ## Many services that support authentication also require it on the
        ## resulting objects
        if($requiresAuthentication)
        {
            if(@($instance.PsObject.Properties |
                where { $_.Name -eq "UseDefaultCredentials" }).Count -eq 1)
            {
                $instance.UseDefaultCredentials = $true
            }
        }
    
        ${GLOBAL:Lee.Holmes.WebServiceCache}[$wsdlLocation] = $instance
    
        $instance
    }
}

function Convert-TextObject
{
    ##############################################################################
    ##
    ## Convert-TextObject
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Convert a simple string into a custom PowerShell object.
    
    .EXAMPLE
    
    PS > "Hello World" | Convert-TextObject
    Generates an Object with "P1=Hello" and "P2=World"
    
    .EXAMPLE
    
    PS > "Hello World" | Convert-TextObject -Delimiter "ll"
    Generates an Object with "P1=He" and "P2=o World"
    
    .EXAMPLE
    
    PS > "Hello World" | Convert-TextObject -Pattern "He(ll.*o)r(ld)"
    Generates an Object with "P1=llo Wo" and "P2=ld"
    
    .EXAMPLE
    
    PS > "Hello World" | Convert-TextObject -PropertyName FirstWord,SecondWord
    Generates an Object with "FirstWord=Hello" and "SecondWord=World
    
    .EXAMPLE
    
    PS > "123 456" | Convert-TextObject -PropertyType $([string],[int])
    Generates an Object with "Property1=123" and "Property2=456"
    The second property is an integer, as opposed to a string
    
    .EXAMPLE
    
    PS > $ipAddress = (ipconfig | Convert-TextObject -Delim ": ")[2].P2
    PS > $ipAddress
    192.168.1.104
    
    #>
    
    [CmdletBinding(DefaultParameterSetName = "ByDelimiter")]
    param(
        ## If specified, gives the .NET Regular Expression with which to
        ## split the string. The script generates properties for the
        ## resulting object out of the elements resulting from this split.
        ## If not specified, defaults to splitting on the maximum amount
        ## of whitespace: "\s+", as long as Pattern is not
        ## specified either.
        [Parameter(ParameterSetName = "ByDelimiter", Position = 0)]
        [string] $Delimiter = "\s+",
    
        ## If specified, gives the .NET Regular Expression with which to
        ## parse the string. The script generates properties for the
        ## resulting object out of the groups captured by this regular
        ## expression.
        [Parameter(Mandatory = $true,
            ParameterSetName = "ByPattern",
            Position = 0)]
        [string] $Pattern,
    
        ## If specified, the script will pair the names from this object
        ## definition with the elements from the parsed string.  If not
        ## specified (or the generated object contains more properties
        ## than you specify,) the script uses property names in the
        ## pattern of P1,P2,...,PN
        [Parameter(Position = 1)]
        [Alias("PN")]
        [string[]] $PropertyName = @(),
    
        ## If specified, the script will pair the types from this list with
        ## the properties from the parsed string.  If not specified (or the
        ## generated object contains more properties than you specify,) the
        ## script sets the properties to be of type [string]
        [Parameter(Position = 2)]
        [Alias("PT")]
        [type[]] $PropertyType = @(),
    
        ## The input object to process
        [Parameter(ValueFromPipeline = $true)]
        [string] $InputObject
    )
    
    begin {
        Set-StrictMode -Version 3
    }
    
    process {
        $returnObject = New-Object PSObject
    
        $matches = $null
        $matchCount = 0
    
        if($PSBoundParameters["Pattern"])
        {
            ## Verify that the input contains the pattern
            ## Populates the matches variable by default
            if(-not ($InputObject -match $pattern))
            {
                return
            }
    
            $matchCount = $matches.Count
        $startIndex = 1
        }
        else
        {
            ## Verify that the input contains the delimiter
            if(-not ($InputObject -match $delimiter))
            {
                return
            }
    
            ## If so, split the input on that delimiter
            $matches = $InputObject -split $delimiter
            $matchCount = $matches.Length
            $startIndex = 0
        }
    
        ## Go through all of the matches, and add them as notes to the output
        ## object.
        for($counter = $startIndex; $counter -lt $matchCount; $counter++)
        {
            $currentPropertyName = "P$($counter - $startIndex + 1)"
            $currentPropertyType = [string]
    
            ## Get the property name
            if($counter -lt $propertyName.Length)
            {
                if($propertyName[$counter])
                {
                    $currentPropertyName = $propertyName[$counter - 1]
                }
            }
    
            ## Get the property value
            if($counter -lt $propertyType.Length)
            {
                if($propertyType[$counter])
                {
                    $currentPropertyType = $propertyType[$counter - 1]
                }
            }
    
            Add-Member -InputObject $returnObject NoteProperty `
                -Name $currentPropertyName `
                -Value ($matches[$counter].Trim() -as $currentPropertyType)
        }
    
        $returnObject
    }
}

function ConvertFrom-FahrenheitWithFunction
{
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    
    param([double] $Fahrenheit)
    
    Set-StrictMode -Version 3
    
    ## Convert Fahrenheit to Celsius
    function ConvertFahrenheitToCelsius([double] $fahrenheit)
    {
        $celsius = $fahrenheit - 32
        $celsius = $celsius / 1.8
        $celsius
    }
    
    $celsius = ConvertFahrenheitToCelsius $fahrenheit
    
    ## Output the answer
    "$fahrenheit degrees Fahrenheit is $celsius degrees Celsius."
}

function ConvertFrom-FahrenheitWithoutFunction
{
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    
    param([double] $Fahrenheit)
    
    Set-StrictMode -Version 3
    
    ## Convert it to Celsius
    $celsius = $fahrenheit - 32
    $celsius = $celsius / 1.8
    
    ## Output the answer
    "$fahrenheit degrees Fahrenheit is $celsius degrees Celsius."
}

function Copy-History
{
    ##############################################################################
    ##
    ## Copy-History
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Copy selected commands from the history buffer into the clipboard as a script.
    
    .EXAMPLE
    
    PS > Copy-History
    Copies the entire contents of the history buffer into the clipboard.
    
    .EXAMPLE
    
    PS > Copy-History -5
    Copies the last five commands into the clipboard.
    
    .EXAMPLE
    
    PS > Copy-History 2,5,8,4
    Copies commands 2,5,8, and 4.
    
    .EXAMPLE
    
    PS > Copy-History (1..10+5+6)
    Copies commands 1 through 10, then 5, then 6, using PowerShell's array
    slicing syntax.
    
    #>
    
    param(
        ## The range of history IDs to copy
        [int[]] $Range
    )
    
    Set-StrictMode -Version 3
    
    $history = @()
    
    ## If they haven't specified a range, assume it's everything
    if((-not $range) -or ($range.Count -eq 0))
    {
        $history = @(Get-History -Count ([Int16]::MaxValue))
    }
    ## If it's a negative number, copy only that many
    elseif(($range.Count -eq 1) -and ($range[0] -lt 0))
    {
        $count = [Math]::Abs($range[0])
        $history = (Get-History -Count $count)
    }
    ## Otherwise, go through each history ID in the given range
    ## and add it to our history list.
    else
    {
        foreach($commandId in $range)
        {
            if($commandId -eq -1) { $history += Get-History -Count 1 }
            else { $history += Get-History -Id $commandId }
        }
    }
    
    ## Finally, export the history to the clipboard.
    $history | Foreach-Object { $_.CommandLine } | clip.exe
}

function Enable-BreakOnError
{
    #############################################################################
    ##
    ## Enable-BreakOnError
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Creates a breakpoint that only fires when PowerShell encounters an error
    
    .EXAMPLE
    
    PS > Enable-BreakOnError
    
    ID Script           Line Command         Variable        Action
    -- ------           ---- -------         --------        ------
     0                       Out-Default                     ...
    
    PS > 1/0
    Entering debug mode. Use h or ? for help.
    
    Hit Command breakpoint on 'Out-Default'
    
    
    PS > $error
    Attempted to divide by zero.
    
    #>
    
    Set-StrictMode -Version 3
    
    ## Store the current number of errors seen in the session so far
    $GLOBAL:EnableBreakOnErrorLastErrorCount = $error.Count
    
    Set-PSBreakpoint -Command Out-Default -Action {
    
        ## If we're generating output, and the error count has increased,
        ## break into the debugger.
        if($error.Count -ne $EnableBreakOnErrorLastErrorCount)
        {
            $GLOBAL:EnableBreakOnErrorLastErrorCount = $error.Count
            break
        }
    }
}

function Enable-HistoryPersistence
{
    ##############################################################################
    ##
    ## Enable-HistoryPersistence
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Reloads any previously saved command history, and registers for the
    PowerShell.Exiting engine event to save new history when the shell
    exits.
    
    #>
    
    Set-StrictMode -Version 3
    
    ## Load our previous history
    $GLOBAL:maximumHistoryCount = 32767
    $historyFile = (Join-Path (Split-Path $profile) "commandHistory.clixml")
    if(Test-Path $historyFile)
    {
        Import-CliXml $historyFile | Add-History
    }
    
    ## Register for the engine shutdown event
    $null = Register-EngineEvent -SourceIdentifier `
        ([System.Management.Automation.PsEngineEvent]::Exiting) -Action {
    
        ## Save our history
        $historyFile = (Join-Path (Split-Path $profile) "commandHistory.clixml")
        $maximumHistoryCount = 1kb
    
        ## Get the previous history items
        $oldEntries = @()
        if(Test-Path $historyFile)
        {
            $oldEntries = Import-CliXml $historyFile -ErrorAction SilentlyContinue
        }
    
        ## And merge them with our changes
        $currentEntries = Get-History -Count $maximumHistoryCount
        $additions = Compare-Object $oldEntries $currentEntries `
            -Property CommandLine | Where-Object { $_.SideIndicator -eq "=>" } |
            Foreach-Object { $_.CommandLine }
    
        $newEntries = $currentEntries | ? { $additions -contains $_.CommandLine }
    
        ## Keep only unique command lines. First sort by CommandLine in
        ## descending order (so that we keep the newest entries,) and then
        ## re-sort by StartExecutionTime.
        $history = @($oldEntries + $newEntries) |
            Sort -Unique -Descending CommandLine | Sort StartExecutionTime
    
        ## Finally, keep the last 100
        Remove-Item $historyFile
        $history | Select -Last 100 | Export-CliXml $historyFile
    }
}

function Enable-RemoteCredSSP
{
    ##############################################################################
    ##
    ## Enable-RemoteCredSSP
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Enables CredSSP support on a remote computer. Requires that the machine
    have PowerShell Remoting enabled, and that its operating system is Windows
    Vista or later.
    
    .EXAMPLE
    
    PS > Enable-RemoteCredSSP <Computer>
    
    #>
    
    param(
        ## The computer on which to enable CredSSP
        $Computername,
    
        ## The credential to use when connecting
        $Credential = (Get-Credential)
    )
    
    Set-StrictMode -Version 3
    
    ## Call Get-Credential again, so that the user can type something like
    ## Enable-RemoteCredSSP -Computer Computer -Cred DOMAIN\user
    $credential = Get-Credential $credential
    $username = $credential.Username
    $password = $credential.GetNetworkCredential().Password
    
    ## Define the script we will use to create the scheduled task
    $powerShellCommand =
        "powershell -noprofile -command Enable-WsManCredSSP -Role Server -Force"
    $script = @"
    schtasks /CREATE /TN 'Enable CredSSP' /SC WEEKLY /RL HIGHEST ``
        /RU $username /RP $password ``
        /TR "$powerShellCommand" /F
    
    schtasks /RUN /TN 'Enable CredSSP'
"@
    
    ## Create the task on the remote system to configure CredSSP
    $command = [ScriptBlock]::Create($script)
    Invoke-Command $computername $command -Cred $credential
    
    ## Wait for the remoting changes to come into effect
    for($count = 1; $count -le 10; $count++)
    {
        $output =
            Invoke-Command $computername { 1 } -Auth CredSSP -Cred $credential
        if($output -eq 1) { break; }
    
        "Attempt $count : Not ready yet."
        Sleep 5
    }
    
    ## Clean up
    $command = [ScriptBlock]::Create($script)
    Invoke-Command $computername {
        schtasks /DELETE /TN 'Enable CredSSP' /F } -Cred $credential
    
    ## Verify the output
    Invoke-Command $computername {
        Get-WmiObject Win32_ComputerSystem } -Auth CredSSP -Cred $credential
}

function Enable-RemotePsRemoting
{
    ##############################################################################
    ##
    ## Enable-RemotePsRemoting
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Enables PowerShell Remoting on a remote computer. Requires that the machine
    responds to WMI requests, and that its operating system is Windows Vista or
    later.
    
    .EXAMPLE
    
    PS > Enable-RemotePsRemoting <Computer>
    
    #>
    
    param(
        ## The computer on which to enable remoting
        $Computername,
    
        ## The credential to use when connecting
        $Credential = (Get-Credential)
    )
    
    Set-StrictMode -Version 3
    
    $VerbosePreference = "Continue"
    
    $credential = Get-Credential $credential
    $username = $credential.Username
    $password = $credential.GetNetworkCredential().Password
    
    $script = @"
    
    `$log = Join-Path `$env:TEMP Enable-RemotePsRemoting.output.txt
    Remove-Item -Force `$log -ErrorAction SilentlyContinue
    Start-Transcript -Path `$log
    
    ## Create a task that will run with full network privileges.
    ## In this task, we call Enable-PsRemoting
    schtasks /CREATE /TN 'Enable Remoting' /SC WEEKLY /RL HIGHEST ``
        /RU $username /RP $password ``
        /TR "powershell -noprofile -command Enable-PsRemoting -Force" /F |
        Out-String
    schtasks /RUN /TN 'Enable Remoting' | Out-String
    
    `$securePass = ConvertTo-SecureString $password -AsPlainText -Force
    `$credential =
        New-Object Management.Automation.PsCredential $username,`$securepass
    
    ## Wait for the remoting changes to come into effect
    for(`$count = 1; `$count -le 10; `$count++)
    {
        `$output = Invoke-Command localhost { 1 } -Cred `$credential ``
            -ErrorAction SilentlyContinue
        if(`$output -eq 1) { break; }
    
        "Attempt `$count : Not ready yet."
        Sleep 5
    }
    
    ## Delete the temporary task
    schtasks /DELETE /TN 'Enable Remoting' /F | Out-String
    Stop-Transcript
    
"@
    
    $commandBytes = [System.Text.Encoding]::Unicode.GetBytes($script)
    $encoded = [Convert]::ToBase64String($commandBytes)
    
    Write-Verbose "Configuring $computername"
    $command = "powershell -NoProfile -EncodedCommand $encoded"
    $null = Invoke-WmiMethod -Computer $computername -Credential $credential `
        Win32_Process Create -Args $command
    
    Write-Verbose "Testing connection"
    Invoke-Command $computername {
        Get-WmiObject Win32_ComputerSystem } -Credential $credential
}

function Enter-Module
{
    ##############################################################################
    ##
    ## Enter-Module
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Lets you examine internal module state and functions by executing user
    input in the scope of the supplied module.
    
    .EXAMPLE
    
    PS > Import-Module PersistentState
    PS > Get-Module PersistentState
    
    ModuleType Name                      ExportedCommands
    ---------- ----                      ----------------
    Script     PersistentState           {Set-Memory, Get-Memory}
    
    
    PS > "Hello World" | Set-Memory
    PS > $m = Get-Module PersistentState
    PS > Enter-Module $m
    PersistentState: dir variable:\mem*
    
    Name                           Value
    ----                           -----
    memory                         {Hello World}
    
    PersistentState: exit
    PS >
    
    #>
    
    param(
        ## The module to examine
        [System.Management.Automation.PSModuleInfo] $Module
    )
    
    Set-StrictMode -Version 3
    
    $userInput = Read-Host $($module.Name)
    while($userInput -ne "exit")
    {
        $scriptblock = [ScriptBlock]::Create($userInput)
        & $module $scriptblock
    
        $userInput = Read-Host $($module.Name)
    }
}

function Format-Hex
{
    ##############################################################################
    ##
    ## Format-Hex
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Outputs a file or pipelined input as a hexadecimal display. To determine the
    offset of a character in the input, add the number at the far-left of the row
    with the the number at the top of the column for that character.
    
    .EXAMPLE
    
    PS > "Hello World" | Format-Hex
    
                0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
    
    00000000   48 00 65 00 6C 00 6C 00 6F 00 20 00 57 00 6F 00  H.e.l.l.o. .W.o.
    00000010   72 00 6C 00 64 00                                r.l.d.
    
    .EXAMPLE
    
    PS > Format-Hex c:\temp\example.bmp
    
    #>
    
    [CmdletBinding(DefaultParameterSetName = "ByPath")]
    param(
        ## The file to read the content from
        [Parameter(ParameterSetName = "ByPath", Position = 0)]
        [string] $Path,
    
        ## The input (bytes or strings) to format as hexadecimal
        [Parameter(
            ParameterSetName = "ByInput", Position = 0,
            ValueFromPipeline = $true)]
        [Object] $InputObject
    )
    
    begin
    {
        Set-StrictMode -Version 3
    
        ## Create the array to hold the content. If the user specified the
        ## -Path parameter, read the bytes from the path.
        [byte[]] $inputBytes = $null
        if($Path) { $inputBytes = Get-Content $Path -Encoding Byte -Raw }
    
        ## Store our header, and formatting information
        $counter = 0
        $header = "            0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F"
        $nextLine = "{0}   " -f  [Convert]::ToString(
            $counter, 16).ToUpper().PadLeft(8, '0')
        $asciiEnd = ""
    
        ## Output the header
        "`r`n$header`r`n"
    }
    
    process
    {
        ## If they specified the -InputObject parameter, retrieve the bytes
        ## from that input
        if($PSCmdlet.ParameterSetName -eq "ByInput")
        {
            ## If it's an actual byte, add it to the inputBytes array.
            if($InputObject -is [Byte])
            {
                $inputBytes = $InputObject
            }
            else
            {
                ## Otherwise, convert it to a string and extract the bytes
                ## from that.
                $inputString = [string] $InputObject
                $inputBytes = [Text.Encoding]::Unicode.GetBytes($inputString)
            }
        }
    
        ## Now go through the input bytes
        foreach($byte in $inputBytes)
        {
            ## Display each byte, in 2-digit hexidecimal, and add that to the
            ## left-hand side.
            $nextLine += "{0:X2} " -f $byte
    
            ## If the character is printable, add its ascii representation to
            ## the right-hand side.  Otherwise, add a dot to the right hand side.
            if(($byte -ge 0x20) -and ($byte -le 0xFE))
            {
                $asciiEnd += [char] $byte
            }
            else
            {
                $asciiEnd += "."
            }
    
            $counter++;
    
            ## If we've hit the end of a line, combine the right half with the
            ## left half, and start a new line.
            if(($counter % 16) -eq 0)
            {
    
                "$nextLine $asciiEnd"
                $nextLine = "{0}   " -f [Convert]::ToString(
                    $counter, 16).ToUpper().PadLeft(8, '0')
                $asciiEnd = "";
            }
        }
    }
    
    end
    {
        ## At the end of the file, we might not have had the chance to output
        ## the end of the line yet.  Only do this if we didn't exit on the 16-byte
        ## boundary, though.
        if(($counter % 16) -ne 0)
        {
            while(($counter % 16) -ne 0)
            {
                $nextLine += "   "
                $asciiEnd += " "
                $counter++;
            }
            "$nextLine $asciiEnd"
        }
    
        ""
    }
}

function Format-String
{
    ##############################################################################
    ##
    ## Format-String
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Replaces text in a string based on named replacement tags
    
    .EXAMPLE
    
    PS > Format-String "Hello {NAME}" @{ NAME = 'PowerShell' }
    Hello PowerShell
    
    .EXAMPLE
    
    PS > Format-String "Your score is {SCORE:P}" @{ SCORE = 0.85 }
    Your score is 85.00 %
    
    #>
    
    param(
        ## The string to format. Any portions in the form of {NAME}
        ## will be automatically replaced by the corresponding value
        ## from  the supplied hashtable.
        $String,
    
        ## The named replacements to use in the string
        [hashtable] $Replacements
    )
    
    Set-StrictMode -Version 3
    
    $currentIndex = 0
    $replacementList = @()
    
    if($String -match "{{|}}")
    {
        throw "Escaping of replacement terms are not supported."
    }
    
    ## Go through each key in the hashtable
    foreach($key in $replacements.Keys)
    {
        ## Convert the key into a number, so that it can be used by
        ## String.Format
        $inputPattern = '{(.*)' + $key + '(.*)}'
        $replacementPattern = '{${1}' + $currentIndex + '${2}}'
        $string = $string -replace $inputPattern,$replacementPattern
        $replacementList += $replacements[$key]
    
        $currentIndex++
    }
    
    ## Now use String.Format to replace the numbers in the
    ## format string.
    $string -f $replacementList
}

function Get-AclMisconfiguration
{
    ##############################################################################
    ##
    ## Get-AclMisconfiguration
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Demonstration of functionality exposed by the Get-Acl cmdlet. This script
    goes through all access rules in all files in the current directory, and
    ensures that the Administrator group has full control of that file.
    
    #>
    
    Set-StrictMode -Version 3
    
    ## Get all files in the current directory
    foreach($file in Get-ChildItem)
    {
        ## Retrieve the ACL from the current file
        $acl = Get-Acl $file
        if(-not $acl)
        {
            continue
        }
    
        $foundAdministratorAcl = $false
    
        ## Go through each access rule in that ACL
        foreach($accessRule in $acl.Access)
        {
            ## If we find the Administrator, Full Control access rule,
            ## then set the $foundAdministratorAcl variable
            if(($accessRule.IdentityReference -like "*Administrator*") -and
                ($accessRule.FileSystemRights -eq "FullControl"))
            {
                $foundAdministratorAcl = $true
            }
        }
    
        ## If we didn't find the administrator ACL, output a message
        if(-not $foundAdministratorAcl)
        {
            "Found possible ACL Misconfiguration: $file"
        }
    }
}

function Get-AliasSuggestion
{
    ##############################################################################
    ##
    ## Get-AliasSuggestion
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Get an alias suggestion from the full text of the last command. Intended to
    be added to your prompt function to help learn aliases for commands.
    
    .EXAMPLE
    
    PS > Get-AliasSuggestion Remove-ItemProperty
    Suggestion: An alias for Remove-ItemProperty is rp
    
    #>
    
    param(
        ## The full text of the last command
        $LastCommand
    )
    
    Set-StrictMode -Version 3
    
    $helpMatches = @()
    
    ## Find all of the commands in their last input
    $tokens = [Management.Automation.PSParser]::Tokenize(
        $lastCommand, [ref] $null)
    $commands = $tokens | Where-Object { $_.Type -eq "Command" }
    
    ## Go through each command
    foreach($command in $commands)
    {
        ## Get the alias suggestions
        foreach($alias in Get-Alias -Definition $command.Content)
        {
            $helpMatches += "Suggestion: An alias for " +
                "$($alias.Definition) is $($alias.Name)"
        }
    }
    
    $helpMatches
}

function Get-Answer
{
    ##############################################################################
    ##
    ## Get-Answer
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Uses Bing Answers to answer your question
    
    .EXAMPLE
    
    PS > Get-Answer "sqrt(2)"
    sqrt(2) = 1.41421356
    
    .EXAMPLE
    
    PS > Get-Answer msft stock
    Microsoft Corp (US:MSFT) NASDAQ
    29.66  -0.35 (-1.17%)
    After Hours: 30.02 +0.36 (1.21%)
    Open: 30.09    Day's Range: 29.59 - 30.20
    Volume: 55.60 M    52 Week Range: 17.27 - 31.50
    P/E Ratio: 16.30    Market Cap: 260.13 B
    
    .EXAMPLE
    
    PS > Get-Answer "What is the time in Seattle, WA?"
    Current time in Seattle, WA
    01:12:41 PM
    08/18/2012 ? Pacific Daylight Time
    
    #>
    
    Set-StrictMode -Version 3
    
    $question = $args -join " "
    
    function Main
    {
        ## Load the System.Web.HttpUtility DLL, to let us URLEncode
        Add-Type -Assembly System.Web
    
        ## Get the web page into a single string with newlines between
        ## the lines.
        $encoded = [System.Web.HttpUtility]::UrlEncode($question)
        $url = "http://www.bing.com/search?q=$encoded"
        $text = [String] (Invoke-WebRequest $url)
    
        ## Find the start of the answers section
        $startIndex = $text.IndexOf('<div class="ans"')
    
        ## The end is either defined by an "attribution" div
        ## or the start of a "results" div
        $endIndex = $text.IndexOf('<div class="sn_att2"', $startIndex)
        if($endIndex -lt 0) { $endIndex = $text.IndexOf('<div id="results"', $startIndex) }
    
        ## If we found a result, then filter the result
        if(($startIndex -ge 0) -and ($endIndex -ge 0))
        {
            ## Pull out the text between the start and end portions
            $partialText = $text.Substring($startIndex, $endIndex - $startIndex)
    
            ## Very fragile screen scraping here. Replace a bunch of
            ## tags that get placed on new lines with the newline
            ## character, and a few others with spaces.
            $partialText = $partialText -replace '<div[^>]*>',"`n"
            $partialText = $partialText -replace '<tr[^>]*>',"`n"
            $partialText = $partialText -replace '<li[^>]*>',"`n"
            $partialText = $partialText -replace '<br[^>]*>',"`n"
            $partialText = $partialText -replace '<p [^>]*>',"`n"
            $partialText = $partialText -replace '<span[^>]*>'," "
            $partialText = $partialText -replace '<td[^>]*>',"    "
    
            $partialText = CleanHtml $partialText
    
            ## Now split the results on newlines, trim each line, and then
            ## join them back.
            $partialText = $partialText -split "`n" |
                Foreach-Object { $_.Trim() } | Where-Object { $_ }
            $partialText = $partialText -join "`n"
    
            [System.Web.HttpUtility]::HtmlDecode($partialText.Trim())
        }
        else
        {
            "No answer found."
        }
    }
    
    ## Clean HTML from a text chunk
    function CleanHtml ($htmlInput)
    {
        $tempString = [Regex]::Replace($htmlInput, "(?s)<[^>]*>", "")
        $tempString.Replace("&nbsp&nbsp", "")
    }
    
    Main
}

function Get-Arguments
{
    ##############################################################################
    ##
    ## Get-Arguments
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Uses command-line arguments
    
    #>
    
    param(
        ## The first named argument
        $FirstNamedArgument,
    
        ## The second named argument
        [int] $SecondNamedArgument = 0
    )
    
    Set-StrictMode -Version 3
    
    ## Display the arguments by name
    "First named argument is: $firstNamedArgument"
    "Second named argument is: $secondNamedArgument"
    
    function GetArgumentsFunction
    {
        ## We could use a param statement here, as well
        ## param($firstNamedArgument, [int] $secondNamedArgument = 0)
    
        ## Display the arguments by position
        "First positional function argument is: " + $args[0]
        "Second positional function argument is: " + $args[1]
    }
    
    GetArgumentsFunction One Two
    
    $scriptBlock =
    {
        param($firstNamedArgument, [int] $secondNamedArgument = 0)
    
        ## We could use $args here, as well
        "First named scriptblock argument is: $firstNamedArgument"
        "Second named scriptblock argument is: $secondNamedArgument"
    }
    
    & $scriptBlock -First One -Second 4.5
}

function Get-Characteristics
{
    ##############################################################################
    ##
    ## Get-Characteristics
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Get the file characteristics of a file in the PE Executable File Format.
    
    .EXAMPLE
    
    PS > Get-Characteristics $env:WINDIR\notepad.exe
    IMAGE_FILE_LOCAL_SYMS_STRIPPED
    IMAGE_FILE_RELOCS_STRIPPED
    IMAGE_FILE_EXECUTABLE_IMAGE
    IMAGE_FILE_32BIT_MACHINE
    IMAGE_FILE_LINE_NUMS_STRIPPED
    
    #>
    
    param(
        ## The path to the file to check
        [Parameter(Mandatory = $true)]
        [string] $Path
    )
    
    Set-StrictMode -Version 3
    
    ## Define the characteristics used in the PE file file header.
    ## Taken from:
    ## http://www.microsoft.com/whdc/system/platform/firmware/PECOFF.mspx
    $characteristics = @{}
    $characteristics["IMAGE_FILE_RELOCS_STRIPPED"] = 0x0001
    $characteristics["IMAGE_FILE_EXECUTABLE_IMAGE"] = 0x0002
    $characteristics["IMAGE_FILE_LINE_NUMS_STRIPPED"] = 0x0004
    $characteristics["IMAGE_FILE_LOCAL_SYMS_STRIPPED"] = 0x0008
    $characteristics["IMAGE_FILE_AGGRESSIVE_WS_TRIM"] = 0x0010
    $characteristics["IMAGE_FILE_LARGE_ADDRESS_AWARE"] = 0x0020
    $characteristics["RESERVED"] = 0x0040
    $characteristics["IMAGE_FILE_BYTES_REVERSED_LO"] = 0x0080
    $characteristics["IMAGE_FILE_32BIT_MACHINE"] = 0x0100
    $characteristics["IMAGE_FILE_DEBUG_STRIPPED"] = 0x0200
    $characteristics["IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP"] = 0x0400
    $characteristics["IMAGE_FILE_NET_RUN_FROM_SWAP"] = 0x0800
    $characteristics["IMAGE_FILE_SYSTEM"] = 0x1000
    $characteristics["IMAGE_FILE_DLL"] = 0x2000
    $characteristics["IMAGE_FILE_UP_SYSTEM_ONLY"] = 0x4000
    $characteristics["IMAGE_FILE_BYTES_REVERSED_HI"] = 0x8000
    
    ## Get the content of the file, as an array of bytes
    $fileBytes = Get-Content $path -ReadCount 0 -Encoding byte
    
    ## The offset of the signature in the file is stored at location 0x3c.
    $signatureOffset = $fileBytes[0x3c]
    
    ## Ensure it is a PE file
    $signature = [char[]] $fileBytes[$signatureOffset..($signatureOffset + 3)]
    if(($signature -join '') -ne "PE`0`0")
    {
        throw "This file does not conform to the PE specification."
    }
    
    ## The location of the COFF header is 4 bytes into the signature
    $coffHeader = $signatureOffset + 4
    
    ## The characteristics data are 18 bytes into the COFF header. The
    ## BitConverter class manages the conversion of the 4 bytes into an integer.
    $characteristicsData = [BitConverter]::ToInt32($fileBytes, $coffHeader + 18)
    
    ## Go through each of the characteristics. If the data from the file has that
    ## flag set, then output that characteristic.
    foreach($key in $characteristics.Keys)
    {
        $flag = $characteristics[$key]
        if(($characteristicsData -band $flag) -eq $flag)
        {
            $key
        }
    }
}

function Get-Clipboard
{
    #############################################################################
    ##
    ## Get-Clipboard
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Retrieve the text contents of the Windows Clipboard.
    
    .EXAMPLE
    
    PS > Get-Clipboard
    Hello World
    
    #>
    
    Set-StrictMode -Version 3
    
    Add-Type -Assembly PresentationCore
    [Windows.Clipboard]::GetText()
}

function Get-DetailedSystemInformation
{
    ##############################################################################
    ##
    ## Get-DetailedSystemInformation
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Get detailed information about a system.
    
    .EXAMPLE
    
    PS > Get-DetailedSystemInformation LEE-DESK > output.txt
    Gets detailed information about LEE-DESK and stores the output into output.txt
    
    #>
    
    param(
        ## The computer to analyze
        $Computer = "."
    )
    
    Set-StrictMode -Version 3
    
    "#"*80
    "System Information Summary"
    "Generated $(Get-Date)"
    "#"*80
    ""
    ""
    
    "#"*80
    "Computer System Information"
    "#"*80
    Get-CimInstance Win32_ComputerSystem -Computer $computer | Format-List *
    
    "#"*80
    "Operating System Information"
    "#"*80
    Get-CimInstance Win32_OperatingSystem -Computer $computer | Format-List *
    
    "#"*80
    "BIOS Information"
    "#"*80
    Get-CimInstance Win32_Bios -Computer $computer | Format-List *
    
    "#"*80
    "Memory Information"
    "#"*80
    Get-CimInstance Win32_PhysicalMemory -Computer $computer | Format-List *
    
    "#"*80
    "Physical Disk Information"
    "#"*80
    Get-CimInstance Win32_DiskDrive -Computer $computer | Format-List *
    
    "#"*80
    "Logical Disk Information"
    "#"*80
    Get-CimInstance Win32_LogicalDisk -Computer $computer | Format-List *
}

function Get-DiskUsage
{
    ##############################################################################
    ##
    ## Get-DiskUsage
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Retrieve information about disk usage in the current directory and all
    subdirectories. If you specify the -IncludeSubdirectories flag, this
    script accounts for the size of subdirectories in the size of a directory.
    
    .EXAMPLE
    
    PS > Get-DiskUsage
    Gets the disk usage for the current directory.
    
    .EXAMPLE
    
    PS > Get-DiskUsage -IncludeSubdirectories
    Gets the disk usage for the current directory and those below it,
    adding the size of child directories to the directory that contains them.
    
    #>
    
    param(
        ## Switch to include subdirectories in the size of each directory
        [switch] $IncludeSubdirectories
    )
    
    Set-StrictMode -Version 3
    
    ## If they specify the -IncludeSubdirectories flag, then we want to account
    ## for all subdirectories in the size of each directory
    if($includeSubdirectories)
    {
        Get-ChildItem -Directory |
            Select-Object Name,
                @{ Name="Size";
                Expression={ ($_ | Get-ChildItem -Recurse |
                    Measure-Object -Sum Length).Sum + 0 } }
    }
    ## Otherwise, we just find all directories below the current directory,
    ## and determine their size
    else
    {
        Get-ChildItem -Recurse -Directory |
            Select-Object FullName,
                @{ Name="Size";
                Expression={ ($_ | Get-ChildItem |
                    Measure-Object -Sum Length).Sum + 0 } }
    }
}

function Get-FacebookNotification
{
    $cred = Get-Credential
    $login = Invoke-WebRequest http://www.facebook.com/login.php -SessionVariable fb
    $login.Forms[0].Fields.email = $cred.GetNetworkCredential().UserName
    $login.Forms[0].Fields.pass = $cred.GetNetworkCredential().Password
    $mainPage = Invoke-WebRequest $login.Forms[0].Action -WebSession $fb -Body $login -Method Post
    $mainPage.ParsedHtml.getElementById("notificationsCountValue").InnerText
}

function Get-FileEncoding
{
    ##############################################################################
    ##
    ## Get-FileEncoding
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Gets the encoding of a file
    
    .EXAMPLE
    
    Get-FileEncoding.ps1 .\UnicodeScript.ps1
    
    BodyName          : unicodeFFFE
    EncodingName      : Unicode (Big-Endian)
    HeaderName        : unicodeFFFE
    WebName           : unicodeFFFE
    WindowsCodePage   : 1200
    IsBrowserDisplay  : False
    IsBrowserSave     : False
    IsMailNewsDisplay : False
    IsMailNewsSave    : False
    IsSingleByte      : False
    EncoderFallback   : System.Text.EncoderReplacementFallback
    DecoderFallback   : System.Text.DecoderReplacementFallback
    IsReadOnly        : True
    CodePage          : 1201
    
    #>
    
    param(
        ## The path of the file to get the encoding of.
        $Path
    )
    
    Set-StrictMode -Version 3
    
    ## First, check if the file is binary. That is, if the first
    ## 5 lines contain any non-printable characters.
    $nonPrintable = [char[]] (0..8 + 10..31 + 127 + 129 + 141 + 143 + 144 + 157)
    $lines = Get-Content $Path -ErrorAction Ignore -TotalCount 5
    $result = @($lines | Where-Object { $_.IndexOfAny($nonPrintable) -ge 0 })
    if($result.Count -gt 0)
    {
        "Binary"
        return
    }
    
    ## Next, check if it matches a well-known encoding.
    
    ## The hashtable used to store our mapping of encoding bytes to their
    ## name. For example, "255-254 = Unicode"
    $encodings = @{}
    
    ## Find all of the encodings understood by the .NET Framework. For each,
    ## determine the bytes at the start of the file (the preamble) that the .NET
    ## Framework uses to identify that encoding.
    foreach($encoding in [System.Text.Encoding]::GetEncodings())
    {
        $preamble = $encoding.GetEncoding().GetPreamble()
        if($preamble)
        {
            $encodingBytes = $preamble -join '-'
            $encodings[$encodingBytes] = $encoding.GetEncoding()
        }
    }
    
    ## Find out the lengths of all of the preambles.
    $encodingLengths = $encodings.Keys | Where-Object { $_ } |
        Foreach-Object { ($_ -split "-").Count }
    
    ## Assume the encoding is UTF7 by default
    $result = [System.Text.Encoding]::UTF7
    
    ## Go through each of the possible preamble lengths, read that many
    ## bytes from the file, and then see if it matches one of the encodings
    ## we know about.
    foreach($encodingLength in $encodingLengths | Sort -Descending)
    {
        $bytes = Get-Content -encoding byte -readcount $encodingLength $path | Select -First 1
        $encoding = $encodings[$bytes -join '-']
    
        ## If we found an encoding that had the same preamble bytes,
        ## save that output and break.
        if($encoding)
        {
            $result = $encoding
            break
        }
    }
    
    ## Finally, output the encoding.
    $result
}

function Get-InstalledSoftware
{
    ##############################################################################
    ##
    ## Get-InstalledSoftware
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Lists installed software on the current computer.
    
    .EXAMPLE
    
    PS > Get-InstalledSoftware *Frame* | Select DisplayName
    
    DisplayName
    -----------
    Microsoft .NET Framework 3.5 SP1
    Microsoft .NET Framework 3.5 SP1
    Hotfix for Microsoft .NET Framework 3.5 SP1 (KB953595)
    Hotfix for Microsoft .NET Framework 3.5 SP1 (KB958484)
    Update for Microsoft .NET Framework 3.5 SP1 (KB963707)
    
    #>
    
    param(
        ## The name of the software to search for
        $DisplayName = "*"
    )
    
    Set-StrictMode -Off
    
    ## Get all the listed software in the Uninstall key
    $keys =
        Get-ChildItem HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall
    
    ## Get all of the properties from those items
    $items = $keys | Foreach-Object { Get-ItemProperty $_.PsPath }
    
    ## For each of those items, display the DisplayName and Publisher
    foreach($item in $items)
    {
        if(($item.DisplayName) -and ($item.DisplayName -like $displayName))
        {
            $item
        }
    }
}

function Get-InvocationInfo
{
    ##############################################################################
    ##
    ## Get-InvocationInfo
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Display the information provided by the $myInvocation variable
    
    #>
    
    param(
        ## Switch to no longer recursively call ourselves
        [switch] $PreventExpansion
    )
    
    Set-StrictMode -Version 3
    
    ## Define a helper function, so that we can see how $myInvocation changes
    ## when it is called, and when it is dot-sourced
    function HelperFunction
    {
        "    MyInvocation from function:"
        "-"*50
        $myInvocation
    
        "    Command from function:"
        "-"*50
        $myInvocation.MyCommand
    }
    
    ## Define a script block, so that we can see how $myInvocation changes
    ## when it is called, and when it is dot-sourced
    $myScriptBlock = {
        "    MyInvocation from script block:"
        "-"*50
        $myInvocation
    
        "    Command from script block:"
        "-"*50
        $myInvocation.MyCommand
    }
    
    ## Define a helper alias
    Set-Alias gii .\Get-InvocationInfo
    
    ## Illustrate how $myInvocation.Line returns the entire line that the
    ## user typed.
    "You invoked this script by typing: " + $myInvocation.Line
    
    ## Show the information that $myInvocation returns from a script
    "MyInvocation from script:"
    "-"*50
    $myInvocation
    
    "Command from script:"
    "-"*50
    $myInvocation.MyCommand
    
    ## If we were called with the -PreventExpansion switch, don't go
    ## any further
    if($preventExpansion)
    {
        return
    }
    
    ## Show the information that $myInvocation returns from a function
    "Calling HelperFunction"
    "-"*50
    HelperFunction
    
    ## Show the information that $myInvocation returns from a dot-sourced
    ## function
    "Dot-Sourcing HelperFunction"
    "-"*50
    . HelperFunction
    
    ## Show the information that $myInvocation returns from an aliased script
    "Calling aliased script"
    "-"*50
    gii -PreventExpansion
    
    ## Show the information that $myInvocation returns from a script block
    "Calling script block"
    "-"*50
    & $myScriptBlock
    
    ## Show the information that $myInvocation returns from a dot-sourced
    ## script block
    "Dot-Sourcing script block"
    "-"*50
    . $myScriptBlock
    
    ## Show the information that $myInvocation returns from an aliased script
    "Calling aliased script"
    "-"*50
    gii -PreventExpansion
}

function Get-MachineStartupShutdownScript
{
    ##############################################################################
    ##
    ## Get-MachineStartupShutdownScript
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Get the startup or shutdown scripts assigned to a machine
    
    .EXAMPLE
    
    PS > Get-MachineStartupShutdownScript -ScriptType Startup
    Gets startup scripts for the machine
    
    #>
    
    param(
        ## The type of script to search for: Startup, or Shutdown.
        [Parameter(Mandatory = $true)]
        [ValidateSet("Startup","Shutdown")]
        $ScriptType
    )
    
    Set-StrictMode -Version 3
    
    ## Store the location of the group policy scripts for the machine
    $registryKey = "HKLM:\SOFTWARE\Policies\Microsoft\Windows\System\Scripts"
    
    ## There may be no scripts defined
    if(-not (Test-Path $registryKey))
    {
        return
    }
    
    ## Go through each of the policies in the specified key
    foreach($policy in Get-ChildItem $registryKey\$scriptType)
    {
        ## For each of the scripts in that policy, get its script name
        ## and parameters
        foreach($script in Get-ChildItem $policy.PsPath)
        {
            Get-ItemProperty $script.PsPath | Select Script,Parameters
        }
    }
}

function Get-OfficialTime
{
    ##############################################################################
    ##
    ## Get-OfficialTime
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Gets the official US time (PST) from time.gov
    
    #>
    
    Set-StrictMode -Version 3
    
    ## Create the URL that contains the Twitter search results
    Add-Type -Assembly System.Web
    $url = 'http://www.time.gov/timezone.cgi?Pacific/d/-8'
    
    ## Download the web page
    $results = Invoke-WebRequest $url | Foreach-Object Content
    
    ## Extract the text of the time, which is contained in
    ## a segment that looks like "<font size="7" color="white"><b>...<br>"
    $match = $results -match '<font [^>]*><b>(.*)<br>'
    if($matches)
    {
        $time = $matches[1]
    }
    
    ## Output the time
    $time
}

function Get-OperatingSystemSku
{
    ##############################################################################
    ##
    ## Get-OperatingSystemSku
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Gets the sku information for the current operating system
    
    .EXAMPLE
    
    PS > Get-OperatingSystemSku
    Professional with Media Center
    
    #>
    
    param($Sku = 
        (Get-CimInstance Win32_OperatingSystem).OperatingSystemSku)
    
    Set-StrictMode -Version 3
    
    switch ($Sku)
    {
        0   { "An unknown product"; break; }
        1   { "Ultimate"; break; }
        2   { "Home Basic"; break; }
        3   { "Home Premium"; break; }
        4   { "Enterprise"; break; }
        5   { "Home Basic N"; break; }
        6   { "Business"; break; }
        7   { "Server Standard"; break; }
        8   { "Server Datacenter (full installation)"; break; }
        9   { "Windows Small Business Server"; break; }
        10  { "Server Enterprise (full installation)"; break; }
        11  { "Starter"; break; }
        12  { "Server Datacenter (core installation)"; break; }
        13  { "Server Standard (core installation)"; break; }
        14  { "Server Enterprise (core installation)"; break; }
        15  { "Server Enterprise for Itanium-based Systems"; break; }
        16  { "Business N"; break; }
        17  { "Web Server (full installation)"; break; }
        18  { "HPC Edition"; break; }
        19  { "Windows Storage Server 2008 R2 Essentials"; break; }
        20  { "Storage Server Express"; break; }
        21  { "Storage Server Standard"; break; }
        22  { "Storage Server Workgroup"; break; }
        23  { "Storage Server Enterprise"; break; }
        24  { "Windows Server 2008 for Windows Essential Server Solutions"; break; }
        25  { "Small Business Server Premium"; break; }
        26  { "Home Premium N"; break; }
        27  { "Enterprise N"; break; }
        28  { "Ultimate N"; break; }
        29  { "Web Server (core installation)"; break; }
        30  { "Windows Essential Business Server Management Server"; break; }
        31  { "Windows Essential Business Server Security Server"; break; }
        32  { "Windows Essential Business Server Messaging Server"; break; }
        33  { "Server Foundation"; break; }
        34  { "Windows Home Server 2011"; break; }
        35  { "Windows Server 2008 without Hyper-V for Windows Essential Server Solutions"; break; }
        36  { "Server Standard without Hyper-V"; break; }
        37  { "Server Datacenter without Hyper-V (full installation)"; break; }
        38  { "Server Enterprise without Hyper-V (full installation)"; break; }
        39  { "Server Datacenter without Hyper-V (core installation)"; break; }
        40  { "Server Standard without Hyper-V (core installation)"; break; }
        41  { "Server Enterprise without Hyper-V (core installation)"; break; }
        42  { "Microsoft Hyper-V Server"; break; }
        43  { "Storage Server Express (core installation)"; break; }
        44  { "Storage Server Standard (core installation)"; break; }
        45  { "Storage Server Workgroup (core installation)"; break; }
        46  { "Storage Server Enterprise (core installation)"; break; }
        46  { "Storage Server Enterprise (core installation)"; break; }
        47  { "Starter N"; break; }
        48  { "Professional"; break; }
        49  { "Professional N"; break; }
        50  { "Windows Small Business Server 2011 Essentials"; break; }
        51  { "Server For SB Solutions"; break; }
        52  { "Server Solutions Premium"; break; }
        53  { "Server Solutions Premium (core installation)"; break; }
        54  { "Server For SB Solutions EM"; break; }
        55  { "Server For SB Solutions EM"; break; }
        56  { "Windows MultiPoint Server"; break; }
        59  { "Windows Essential Server Solution Management"; break; }
        60  { "Windows Essential Server Solution Additional"; break; }
        61  { "Windows Essential Server Solution Management SVC"; break; }
        62  { "Windows Essential Server Solution Additional SVC"; break; }
        63  { "Small Business Server Premium (core installation)"; break; }
        64  { "Server Hyper Core V"; break; }
        72  { "Server Enterprise (evaluation installation)"; break; }
        76  { "Windows MultiPoint Server Standard (full installation)"; break; }
        77  { "Windows MultiPoint Server Premium (full installation)"; break; }
        79  { "Server Standard (evaluation installation)"; break; }
        80  { "Server Datacenter (evaluation installation)"; break; }
        84  { "Enterprise N (evaluation installation)"; break; }
        95  { "Storage Server Workgroup (evaluation installation)"; break; }
        96  { "Storage Server Standard (evaluation installation)"; break; }
        98  { "Windows 8 N"; break; }
        99  { "Windows 8 China"; break; }
        100 { "Windows 8 Single Language"; break; }
        101 { "Windows 8"; break; }
        103 { "Professional with Media Center"; break; }
    
        default {"UNKNOWN: " + $SKU }
    }
}

function Get-OwnerReport
{
    ##############################################################################
    ##
    ## Get-OwnerReport
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Gets a list of files in the current directory, but with their owner added
    to the resulting objects.
    
    .EXAMPLE
    
    PS > Get-OwnerReport | Format-Table Name,LastWriteTime,Owner
    Retrieves all files in the current directory, and displays the
    Name, LastWriteTime, and Owner
    
    #>
    
    Set-StrictMode -Version 3
    
    $files = Get-ChildItem
    foreach($file in $files)
    {
        $owner = (Get-Acl $file).Owner
        $file | Add-Member NoteProperty Owner $owner
        $file
    }
}

function Get-PageUrls
{
    ##############################################################################
    ##
    ## Get-PageUrls
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Parse all of the URLs out of a given file.
    
    .EXAMPLE
    
    PS > Get-PageUrls microsoft.html http://www.microsoft.com
    Gets all of the URLs from HTML stored in microsoft.html, and converts relative
    URLs to the domain of http://www.microsoft.com
    
    .EXAMPLE
    
    PS > Get-PageUrls microsoft.html http://www.microsoft.com 'aspx$'
    Gets all of the URLs from HTML stored in microsoft.html, converts relative
    URLs to the domain of http://www.microsoft.com, and returns only URLs that end
    in 'aspx'.
    
    #>
    
    param(
        ## The filename to parse
        [Parameter(Mandatory = $true)]
        [string] $Path,
    
        ## The URL from which you downloaded the page.
        ## For example, http://www.microsoft.com
        [Parameter(Mandatory = $true)]
        [string] $BaseUrl,
    
        [switch] $Images,
        
        ## The Regular Expression pattern with which to filter
        ## the returned URLs
        [string] $Pattern = ".*"
    )
    
    Set-StrictMode -Version 3
    
    ## Load the System.Web DLL so that we can decode URLs
    Add-Type -Assembly System.Web
    
    ## Defines the regular expression that will parse an URL
    ## out of an anchor tag.
    $regex = "<\s*a\s*[^>]*?href\s*=\s*[`"']*([^`"'>]+)[^>]*?>"
    if($Images)
    {
        $regex = "<\s*img\s*[^>]*?src\s*=\s*[`"']*([^`"'>]+)[^>]*?>"
    }
    
    ## Parse the file for links
    function Main
    {
        ## Do some minimal source URL fixups, by switching backslashes to
        ## forward slashes
        $baseUrl = $baseUrl.Replace("\", "/")
    
        if($baseUrl.IndexOf("://") -lt 0)
        {
            throw "Please specify a base URL in the form of " +
                "http://server/path_to_file/file.html"
        }
    
        ## Determine the server from which the file originated.  This will
        ## help us resolve links such as "/somefile.zip"
        $baseUrl = $baseUrl.Substring(0, $baseUrl.LastIndexOf("/") + 1)
        $baseSlash = $baseUrl.IndexOf("/", $baseUrl.IndexOf("://") + 3)
    
        if($baseSlash -ge 0)
        {
            $domain = $baseUrl.Substring(0, $baseSlash)
        }
        else
        {
            $domain = $baseUrl
        }
    
    
        ## Put all of the file content into a big string, and
        ## get the regular expression matches
        $content = (Get-Content $path) -join ' '
        $contentMatches = @(GetMatches $content $regex)
    
        foreach($contentMatch in $contentMatches)
        {
            if(-not ($contentMatch -match $pattern)) { continue }
            if($contentMatch -match "javascript:") { continue }
    
            $contentMatch = $contentMatch.Replace("\", "/")
    
            ## Hrefs may look like:
            ## ./file
            ## file
            ## ../../../file
            ## /file
            ## url
            ## We'll keep all of the relative paths, as they will resolve.
            ## We only need to resolve the ones pointing to the root.
            if($contentMatch.IndexOf("://") -gt 0)
            {
                $url = $contentMatch
            }
            elseif($contentMatch[0] -eq "/")
            {
                $url = "$domain$contentMatch"
            }
            else
            {
                $url = "$baseUrl$contentMatch"
                $url = $url.Replace("/./", "/")
            }
    
            ## Return the URL, after first removing any HTML entities
            [System.Web.HttpUtility]::HtmlDecode($url)
        }
    }
    
    function GetMatches([string] $content, [string] $regex)
    {
        $returnMatches = new-object System.Collections.ArrayList
    
        ## Match the regular expression against the content, and
        ## add all trimmed matches to our return list
        $resultingMatches = [Regex]::Matches($content, $regex, "IgnoreCase")
        foreach($match in $resultingMatches)
        {
            $cleanedMatch = $match.Groups[1].Value.Trim()
            [void] $returnMatches.Add($cleanedMatch)
        }
    
        $returnMatches
    }
    
    . Main
}

function Get-ParameterAlias
{
    ##############################################################################
    ##
    ## Get-ParameterAlias
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Looks in the session history, and returns any aliases that apply to
    parameters of commands that were used.
    
    .EXAMPLE
    
    PS > dir -ErrorAction SilentlyContinue
    PS > Get-ParameterAlias
    An alias for the 'ErrorAction' parameter of 'dir' is ea
    
    #>
    
    Set-StrictMode -Version 3
    
    ## Get the last item from their session history
    $history = Get-History -Count 1
    if(-not $history)
    {
        return
    }
    
    ## And extract the actual command line they typed
    $lastCommand = $history.CommandLine
    
    ## Use the Tokenizer API to determine which portions represent
    ## commands and parameters to those commands
    $tokens = [System.Management.Automation.PsParser]::Tokenize(
        $lastCommand, [ref] $null)
    $currentCommand = $null
    
    ## Now go through each resulting token
    foreach($token in $tokens)
    {
        ## If we've found a new command, store that.
        if($token.Type -eq "Command")
        {
            $currentCommand = $token.Content
        }
    
        ## If we've found a command parameter, start looking for aliases
        if(($token.Type -eq "CommandParameter") -and ($currentCommand))
        {
            ## Remove the leading "-" from the parameter
            $currentParameter = $token.Content.TrimStart("-")
    
            ## Determine all of the parameters for the current command.
            (Get-Command $currentCommand).Parameters.GetEnumerator() |
    
                ## For parameters that start with the current parameter name,
                Where-Object { $_.Key -like "$currentParameter*" } |
    
                ## return all of the aliases that apply. We use "starts with"
                ## because the user might have typed a shortened form of
                ## the parameter name.
                Foreach-Object {
                    $_.Value.Aliases | Foreach-Object {
                        "Suggestion: An alias for the '$currentParameter' " +
                        "parameter of '$currentCommand' is '$_'"
                    }
                }
        }
    }
}

function Get-PrivateProfileString
{
    #############################################################################
    ##
    ## Get-PrivateProfileString
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Retrieves an element from a standard .INI file
    
    .EXAMPLE
    
    PS > Get-PrivateProfileString c:\windows\system32\tcpmon.ini `
        "<Generic Network Card>" Name
    Generic Network Card
    
    #>
    
    param(
        ## The INI file to retrieve
        $Path,
    
        ## The section to retrieve from
        $Category,
    
        ## The item to retrieve
        $Key
    )
    
    Set-StrictMode -Version 3
    
    ## The signature of the Windows API that retrieves INI
    ## settings
    $signature = @'
    [DllImport("kernel32.dll")]
    public static extern uint GetPrivateProfileString(
        string lpAppName,
        string lpKeyName,
        string lpDefault,
        StringBuilder lpReturnedString,
        uint nSize,
        string lpFileName);
'@
    
    ## Create a new type that lets us access the Windows API function
    $type = Add-Type -MemberDefinition $signature `
        -Name Win32Utils -Namespace GetPrivateProfileString `
        -Using System.Text -PassThru
    
    ## The GetPrivateProfileString function needs a StringBuilder to hold
    ## its output. Create one, and then invoke the method
    $builder = New-Object System.Text.StringBuilder 1024
    $null = $type::GetPrivateProfileString($category,
        $key, "", $builder, $builder.Capacity, $path)
    
    ## Return the output
    $builder.ToString()
}

function Get-RemoteRegistryChildItem
{
    ##############################################################################
    ##
    ## Get-RemoteRegistryChildItem
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Get the list of subkeys below a given key on a remote computer.
    
    .EXAMPLE
    
    Get-RemoteRegistryChildItem LEE-DESK HKLM:\Software
    
    #>
    
    param(
        ## The computer that you wish to connect to
        [Parameter(Mandatory = $true)]
        $ComputerName,
    
        ## The path to the registry items to retrieve
        [Parameter(Mandatory = $true)]
        $Path
    )
    
    Set-StrictMode -Version 3
    
    ## Validate and extract out the registry key
    if($path -match "^HKLM:\\(.*)")
    {
        $baseKey = [Microsoft.Win32.RegistryKey]::OpenRemoteBaseKey(
            "LocalMachine", $computername)
    }
    elseif($path -match "^HKCU:\\(.*)")
    {
        $baseKey = [Microsoft.Win32.RegistryKey]::OpenRemoteBaseKey(
            "CurrentUser", $computername)
    }
    else
    {
        Write-Error ("Please specify a fully-qualified registry path " +
            "(i.e.: HKLM:\Software) of the registry key to open.")
        return
    }
    
    ## Open the key
    $key = $baseKey.OpenSubKey($matches[1])
    
    ## Retrieve all of its children
    foreach($subkeyName in $key.GetSubKeyNames())
    {
        ## Open the subkey
        $subkey = $key.OpenSubKey($subkeyName)
    
        ## Add information so that PowerShell displays this key like regular
        ## registry key
        $returnObject = [PsObject] $subKey
        $returnObject | Add-Member NoteProperty PsChildName $subkeyName
        $returnObject | Add-Member NoteProperty Property $subkey.GetValueNames()
    
        ## Output the key
        $returnObject
    
        ## Close the child key
        $subkey.Close()
    }
    
    ## Close the key and base keys
    $key.Close()
    $baseKey.Close()
}

function Get-RemoteRegistryKeyProperty
{
    ##############################################################################
    ##
    ## Get-RemoteRegistryKeyProperty
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Get the value of a remote registry key property
    
    .EXAMPLE
    
    PS > $registryPath =
         "HKLM:\software\Microsoft\PowerShell\1\ShellIds\Microsoft.PowerShell"
    PS > Get-RemoteRegistryKeyProperty LEE-DESK $registryPath ExecutionPolicy
    
    #>
    
    param(
        ## The computer that you wish to connect to
        [Parameter(Mandatory = $true)]
        $ComputerName,
    
        ## The path to the registry item to retrieve
        [Parameter(Mandatory = $true)]
        $Path,
    
        ## The specific property to retrieve
        $Property = "*"
    )
    
    Set-StrictMode -Version 3
    
    ## Validate and extract out the registry key
    if($path -match "^HKLM:\\(.*)")
    {
        $baseKey = [Microsoft.Win32.RegistryKey]::OpenRemoteBaseKey(
            "LocalMachine", $computername)
    }
    elseif($path -match "^HKCU:\\(.*)")
    {
        $baseKey = [Microsoft.Win32.RegistryKey]::OpenRemoteBaseKey(
            "CurrentUser", $computername)
    }
    else
    {
        Write-Error ("Please specify a fully-qualified registry path " +
            "(i.e.: HKLM:\Software) of the registry key to open.")
        return
    }
    
    ## Open the key
    $key = $baseKey.OpenSubKey($matches[1])
    $returnObject = New-Object PsObject
    
    ## Go through each of the properties in the key
    foreach($keyProperty in $key.GetValueNames())
    {
        ## If the property matches the search term, add it as a
        ## property to the output
        if($keyProperty -like $property)
        {
            $returnObject |
                Add-Member NoteProperty $keyProperty $key.GetValue($keyProperty)
        }
    }
    
    ## Return the resulting object
    $returnObject
    
    ## Close the key and base keys
    $key.Close()
    $baseKey.Close()
}

function Get-ScriptCoverage
{
    #############################################################################
    ##
    ## Get-ScriptCoverage
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Uses conditional breakpoints to obtain information about what regions of
    a script are executed when run.
    
    .EXAMPLE
    
    PS > Get-Content c:\temp\looper.ps1
    
    param($userInput)
    
    for($count = 0; $count -lt 10; $count++)
    {
        "Count is: $count"
    }
    
    if($userInput -eq "One")
    {
        "Got 'One'"
    }
    
    if($userInput -eq "Two")
    {
        "Got 'Two'"
    }
    
    PS > $action = { c:\temp\looper.ps1 -UserInput 'One' }
    PS > $coverage = Get-ScriptCoverage c:\temp\looper.ps1 -Action $action
    PS > $coverage | Select Content,StartLine,StartColumn | Format-Table -Auto
    
    Content   StartLine StartColumn
    -------   --------- -----------
    userInput         1           7
    Got 'Two'        15           5
    
    This example exercises a 'looper.ps1' script, and supplies it with some
    user input. The output demonstrates that we didn't exercise the
    "Got 'Two'" statement.
    
    #>
    
    param(
        ## The path of the script to monitor
        $Path,
    
        ## The command to exercise the script
        [ScriptBlock] $Action = { & $path }
    )
    
    Set-StrictMode -Version 3
    
    ## Determine all of the tokens in the script
    $scriptContent = Get-Content $path
    $ignoreTokens = "Comment","NewLine","StatementSeparator","Keyword",
        "GroupStart","GroupEnd"
    $tokens = [System.Management.Automation.PsParser]::Tokenize(
        $scriptContent, [ref] $null) |
        Where-Object { $ignoreTokens -notcontains $_.Type }
    $tokens = $tokens | Sort-Object StartLine,StartColumn
    
    ## Create a variable to hold the tokens that PowerShell actually hits
    $visited = New-Object System.Collections.ArrayList
    
    ## Go through all of the tokens
    $breakpoints = foreach($token in $tokens)
    {
        ## Create a new action. This action logs the token that we
        ## hit. We call GetNewClosure() so that the $token variable
        ## gets the _current_ value of the $token variable, as opposed
        ## to the value it has when the breakpoints gets hit.
        $breakAction = { $null = $visited.Add($token) }.GetNewClosure()
    
        ## Set a breakpoint on the line and column of the current token.
        ## We use the action from above, which simply logs that we've hit
        ## that token.
        Set-PsBreakpoint $path -Line `
            $token.StartLine -Column $token.StartColumn -Action $breakAction
    }
    
    ## Invoke the action that exercises the script
    $null = . $action
    
    ## Remove the temporary breakpoints we set
    $breakpoints | Remove-PsBreakpoint
    
    ## Sort the tokens that we hit, and compare them with all of the tokens
    ## in the script. Output the result of that comparison.
    $visited = $visited | Sort-Object -Unique StartLine,StartColumn
    Compare-Object $tokens $visited -Property StartLine,StartColumn -PassThru
    
    ## Clean up our temporary variable
    Remove-Item variable:\visited
}

function Get-ScriptPerformanceProfile
{
    #############################################################################
    ##
    ## Get-ScriptPerformanceProfile
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Computes the performance characteristics of a script, based on the transcript
    of it running at trace level 1.
    
    .DESCRIPTION
    
    To profile a script:
    
       1) Turn on script tracing in the window that will run the script:
          Set-PsDebug -trace 1
       2) Turn on the transcript for the window that will run the script:
          Start-Transcript
          (Note the filename that PowerShell provides as the logging destination.)
       3) Type in the script name, but don't actually start it.
       4) Open another PowerShell window, and navigate to the directory holding
          this script.  Type in '.\Get-ScriptPerformanceProfile <transcript>',
          replacing <transcript> with the path given in step 2.  Don't
          press <Enter> yet.
       5) Switch to the profiled script window, and start the script.
          Switch to the window containing this script, and press <Enter>
       6) Wait until your profiled script exits, or has run long enough to be
          representative of its work.  To be statistically accurate, your script
          should run for at least ten seconds.
       7) Switch to the window running this script, and press a key.
       8) Switch to the window holding your profiled script, and type:
          Stop-Transcript
       9) Delete the transcript.
    
    .NOTES
    
    You can profile regions of code (ie: functions) rather than just lines
    by placing the following call at the start of the region:
          Write-Debug "ENTER <region_name>"
    and the following call and the end of the region:
          Write-Debug "EXIT"
    This is implemented to account exclusively for the time spent in that
    region, and does not include time spent in regions contained within the
    region.  For example, if FunctionA calls FunctionB, and you've surrounded
    each by region markers, the statistics for FunctionA will not include the
    statistics for FunctionB.
    
    #>
    
    param(
        ## The path of the transcript log file
        [Parameter(Mandatory = $true)]
        $Path
    )
    
    Set-StrictMode -Version 3
    
    function Main
    {
        ## Run the actual profiling of the script.  $uniqueLines gets
        ## the mapping of line number to actual script content.
        ## $samples gets a hashtable mapping line number to the number of times
        ## we observed the script running that line.
        $uniqueLines = @{}
        $samples = GetSamples $uniqueLines
    
        "Breakdown by line:"
        "----------------------------"
    
        ## Create a new hash table that flips the $samples hashtable --
        ## one that maps the number of times sampled to the line sampled.
        ## Also, figure out how many samples we got altogether.
        $counts = @{}
        $totalSamples = 0;
        foreach($item in $samples.Keys)
        {
            $counts[$samples[$item]] = $item
            $totalSamples += $samples[$item]
        }
    
        ## Go through the flipped hashtable, in descending order of number of
        ## samples.  As we do so, output the number of samples as a percentage of
        ## the total samples.  This gives us the percentage of the time our
        ## script spent executing that line.
        foreach($count in ($counts.Keys | Sort-Object -Descending))
        {
            $line = $counts[$count]
            $percentage = "{0:#0}" -f ($count * 100 / $totalSamples)
            "{0,3}%: Line {1,4} -{2}" -f $percentage,$line,
                $uniqueLines[$line]
        }
    
        ## Go through the transcript log to figure out which lines are part of
        ## any marked regions.  This returns a hashtable that maps region names
        ## to the lines they contain.
        ""
        "Breakdown by marked regions:"
        "----------------------------"
        $functionMembers = GenerateFunctionMembers
    
        ## For each region name, cycle through the lines in the region.  As we
        ## cycle through the lines, sum up the time spent on those lines and
        ## output the total.
        foreach($key in $functionMembers.Keys)
        {
            $totalTime = 0
            foreach($line in $functionMembers[$key])
            {
                $totalTime += ($samples[$line] * 100 / $totalSamples)
            }
    
            $percentage = "{0:#0}" -f $totalTime
            "{0,3}%: {1}" -f $percentage,$key
        }
    }
    
    ## Run the actual profiling of the script.  $uniqueLines gets
    ## the mapping of line number to actual script content.
    ## Return a hashtable mapping line number to the number of times
    ## we observed the script running that line.
    function GetSamples($uniqueLines)
    {
        ## Open the log file.  We use the .Net file I/O, so that we keep
        ## monitoring just the end of the file.  Otherwise, we would make our
        ## timing inaccurate as we scan the entire length of the file every time.
        $logStream = [System.IO.File]::Open($Path, "Open", "Read", "ReadWrite")
        $logReader = New-Object System.IO.StreamReader $logStream
    
        $random = New-Object Random
        $samples = @{}
    
        $lastCounted = $null
    
        ## Gather statistics until the user presses a key.
        while(-not $host.UI.RawUI.KeyAvailable)
        {
            ## We sleep a slightly random amount of time.  If we sleep a constant
            ## amount of time, we run the very real risk of improperly sampling
            ## scripts that exhibit periodic behaviour.
            $sleepTime = [int] ($random.NextDouble() * 100.0)
            Start-Sleep -Milliseconds $sleepTime
    
            ## Get any content produced by the transcript since our last poll.
            ## From that poll, extract the last DEBUG statement (which is the last
            ## line executed.)
            $rest = $logReader.ReadToEnd()
            $lastEntryIndex = $rest.LastIndexOf("DEBUG: ")
    
            ## If we didn't get a new line, then the script is still working on
            ## the last line that we captured.
            if($lastEntryIndex -lt 0)
            {
                if($lastCounted) { $samples[$lastCounted] ++ }
                continue;
            }
    
            ## Extract the debug line.
            $lastEntryFinish = $rest.IndexOf("\n", $lastEntryIndex)
            if($lastEntryFinish -eq -1) { $lastEntryFinish = $rest.length }
    
            $scriptLine = $rest.Substring(
                $lastEntryIndex, ($lastEntryFinish - $lastEntryIndex)).Trim()
            if($scriptLine -match 'DEBUG:[ \t]*([0-9]*)\+(.*)')
            {
                ## Pull out the line number from the line
                $last = $matches[1]
    
                $lastCounted = $last
                $samples[$last] ++
    
                ## Pull out the actual script line that matches the line number
                $uniqueLines[$last] = $matches[2]
            }
    
            ## Discard anything that's buffered during this poll, and start
            ## waiting again
            $logReader.DiscardBufferedData()
        }
    
        ## Clean up
        $logStream.Close()
        $logReader.Close()
    
        $samples
    }
    
    ## Go through the transcript log to figure out which lines are part of any
    ## marked regions.  This returns a hashtable that maps region names to
    ## the lines they contain.
    function GenerateFunctionMembers
    {
        ## Create a stack that represents the callstack.  That way, if a marked
        ## region contains another marked region, we attribute the statistics
        ## appropriately.
        $callstack = New-Object System.Collections.Stack
        $currentFunction = "Unmarked"
        $callstack.Push($currentFunction)
    
        $functionMembers = @{}
    
        ## Go through each line in the transcript file, from the beginning
        foreach($line in (Get-Content $Path))
        {
            ## Check if we're entering a monitor block
            ## If so, store that we're in that function, and push it onto
            ## the callstack.
            if($line -match 'write-debug "ENTER (.*)"')
            {
                $currentFunction = $matches[1]
                $callstack.Push($currentFunction)
            }
            ## Check if we're exiting a monitor block
            ## If so, clear the "current function" from the callstack,
            ## and store the new "current function" onto the callstack.
            elseif($line -match 'write-debug "EXIT"')
            {
                [void] $callstack.Pop()
                $currentFunction = $callstack.Peek()
            }
            ## Otherwise, this is just a line with some code.
            ## Add the line number as a member of the "current function"
            else
            {
                if($line -match 'DEBUG:[ \t]*([0-9]*)\+')
                {
                    ## Create the arraylist if it's not initialized
                    if(-not $functionMembers[$currentFunction])
                    {
                        $functionMembers[$currentFunction] =
                            New-Object System.Collections.ArrayList
                    }
    
                    ## Add the current line to the ArrayList
                    $hitLines = $functionMembers[$currentFunction]
                    if(-not $hitLines.Contains($matches[1]))
                    {
                        [void] $hitLines.Add($matches[1])
                    }
                }
            }
        }
    
        $functionMembers
    }
    
    . Main
}

function Get-Tomorrow
{
    ##############################################################################
    ## Get-Tomorrow
    ##
    ## Get the date that represents tomorrow
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    Set-StrictMode -Version 3
    
    function GetDate
    {
        Get-Date
    }
    
    $tomorrow = (GetDate).AddDays(1)
    $tomorrow
}

function Get-UserLogonLogoffScript
{
    ##############################################################################
    ##
    ## Get-UserLogonLogoffScript
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Get the logon or logoff scripts assigned to a specific user
    
    .EXAMPLE
    
    Get-UserLogonLogoffScript LEE-DESK\LEE Logon
    Gets all logon scripts for the user 'LEE-DESK\Lee'
    
    #>
    
    param(
        ## The username to examine
        [Parameter(Mandatory = $true)]
        $Username,
    
        [Parameter(Mandatory = $true)]
        [ValidateSet("Logon","Logoff")]
        $ScriptType
    )
    
    Set-StrictMode -Version 3
    
    ## Find the SID for the username
    $account = New-Object System.Security.Principal.NTAccount $username
    $sid =
        $account.Translate([System.Security.Principal.SecurityIdentifier]).Value
    
    ## Map that to their group policy scripts
    $registryKey = "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\" +
        "Group Policy\State\$sid\Scripts"
    
    if(-not (Test-Path $registryKey))
    {
        return
    }
    
    ## Go through each of the policies in the specified key
    foreach($policy in Get-ChildItem $registryKey\$scriptType)
    {
        ## For each of the scripts in that policy, get its script name
        ## and parameters
        foreach($script in Get-ChildItem $policy.PsPath)
        {
            Get-ItemProperty $script.PsPath | Select Script,Parameters
        }
    }
}

function Get-WarningsAndErrors
{
    ##############################################################################
    ##
    ## Get-WarningsAndErrors
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Demonstrates the functionality of the Write-Warning, Write-Error, and throw
    statements
    
    #>
    
    Set-StrictMode -Version 3
    
    Write-Warning "Warning: About to generate an error"
    Write-Error "Error: You are running this script"
    throw "Could not complete operation."
}

function Get-WmiClassKeyProperty
{
    ##############################################################################
    ##
    ## Get-WmiClassKeyProperty
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Get all of the properties that you may use in a WMI filter for a given class.
    
    .EXAMPLE
    
    PS > Get-WmiClassKeyProperty Win32_Process
    Handle
    
    #>
    
    param(
        ## The WMI class to examine
        [WmiClass] $WmiClass
    )
    
    Set-StrictMode -Version 3
    
    ## WMI classes have properties
    foreach($currentProperty in $wmiClass.Properties)
    {
        ## WMI properties have qualifiers to explain more about them
        foreach($qualifier in $currentProperty.Qualifiers)
        {
            ## If it has a 'Key' qualifier, then you may use it in a filter
            if($qualifier.Name -eq "Key")
            {
                $currentProperty.Name
            }
        }
    }
}

function Grant-RegistryAccessFullControl
{
    ##############################################################################
    ##
    ## Grant-RegistryAccessFullControl
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Grants full control access to a user for the specified registry key.
    
    .EXAMPLE
    
    PS > $registryPath = "HKLM:\Software\MyProgram"
    PS > Grant-RegistryAccessFullControl "LEE-DESK\LEE" $registryPath
    
    #>
    
    param(
        ## The user to grant full control
        [Parameter(Mandatory = $true)]
        $User,
    
        ## The registry path that should have its permissions modified
        [Parameter(Mandatory = $true)]
        $RegistryPath
    )
    
    Set-StrictMode -Version 3
    
    Push-Location
    Set-Location -LiteralPath $registryPath
    
    ## Retrieve the ACL from the registry key
    $acl = Get-Acl .
    
    ## Prepare the access rule, and set the access rule
    $arguments = $user,"FullControl","Allow"
    $accessRule = New-Object Security.AccessControl.RegistryAccessRule $arguments
    $acl.SetAccessRule($accessRule)
    
    ## Apply the modified ACL to the regsitry key
    $acl | Set-Acl  .
    
    Pop-Location
}

function Import-ADUser
{
    #############################################################################
    ##
    ## Import-AdUser
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    #############################################################################
    
    <#
    
    .SYNOPSIS
    
    Create users in Active Directory from the content of a CSV.
    
    .DESCRIPTION
    
    In the user CSV, One column must be named "CN" for the user name.
    All other columns represent properties in Active Directory for that user.
    
    For example:
    CN,userPrincipalName,displayName,manager
    MyerKen,Ken.Myer@fabrikam.com,Ken Myer,
    DoeJane,Jane.Doe@fabrikam.com,Jane Doe,"CN=MyerKen,OU=West,OU=Sales,DC=..."
    SmithRobin,Robin.Smith@fabrikam.com,Robin Smith,"CN=MyerKen,OU=West,OU=..."
    
    .EXAMPLE
    
    PS > $container = "LDAP://localhost:389/ou=West,ou=Sales,dc=Fabrikam,dc=COM"
    PS > Import-ADUser.ps1 $container .\users.csv
    
    #>
    
    param(
        ## The container in which to import users
        ## For example:
        ## "LDAP://localhost:389/ou=West,ou=Sales,dc=Fabrikam,dc=COM)")
        [Parameter(Mandatory = $true)]
        $Container,
    
        ## The path to the CSV that contains the user records
        [Parameter(Mandatory = $true)]
        $Path
    )
    
    Set-StrictMode -Off
    
    ## Bind to the container
    $userContainer = [adsi] $container
    
    ## Ensure that the container was valid
    if(-not $userContainer.Name)
    {
        Write-Error "Could not connect to $container"
        return
    }
    
    ## Load the CSV
    $users = @(Import-Csv $Path)
    if($users.Count -eq 0)
    {
        return
    }
    
    ## Go through each user from the CSV
    foreach($user in $users)
    {
        ## Pull out the name, and create that user
        $username = $user.CN
        $newUser = $userContainer.Create("User", "CN=$username")
    
        ## Go through each of the properties from the CSV, and set its value
        ## on the user
        foreach($property in $user.PsObject.Properties)
        {
            ## Skip the property if it was the CN property that sets the
            ## user name
            if($property.Name -eq "CN")
            {
                continue
            }
    
            ## Ensure they specified a value for the property
            if(-not $property.Value)
            {
                continue
            }
    
            ## Set the value of the property
            $newUser.Put($property.Name, $property.Value)
        }
    
        ## Finalize the information in Active Directory
        $newUser.SetInfo()
    }
}

function Invoke-AddTypeTypeDefinition
{
    #############################################################################
    ##
    ## Invoke-AddTypeTypeDefinition
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Demonstrates the use of the -TypeDefinition parameter of the Add-Type
    cmdlet.
    
    #>
    
    Set-StrictMode -Version 3
    
    ## Define the new C# class
    $newType = @'
    using System;
    
    namespace PowerShellCookbook
    {
        public class AddTypeTypeDefinitionDemo
        {
            public string SayHello(string name)
            {
                string result = String.Format("Hello {0}", name);
                return result;
            }
        }
    }
    
'@
    
    ## Add it to the Powershell session
    Add-Type -TypeDefinition $newType
    
    ## Show that we can access it like any other .NET type
    $greeter = New-Object PowerShellCookbook.AddTypeTypeDefinitionDemo
    $greeter.SayHello("World")
}

function Invoke-AdvancedFunction
{
    param(
        [Parameter(Mandatory = $true)]
        [ScriptBlock] $Scriptblock
        )
    
    ## Invoke the scriptblock supplied by the user.
    & $scriptblock
}

function Invoke-BinaryProcess
{
    ##############################################################################
    ##
    ## Invoke-BinaryProcess
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Invokes a process that emits or consumes binary data.
    
    .EXAMPLE
    
    PS > Invoke-BinaryProcess binaryProcess.exe -RedirectOutput -ArgumentList "-Emit" |
           Invoke-BinaryProcess binaryProcess.exe -RedirectInput -ArgumentList "-Consume"
    
    #>
    
    param(
        ## The name of the process to invoke
        [string] $ProcessName,
    
        ## Specifies that input to the process should be treated as
        ## binary
        [Alias("Input")]
        [switch] $RedirectInput,
    
        ## Specifies that the output of the process should be treated
        ## as binary
        [Alias("Output")]
        [switch] $RedirectOutput,
    
        ## Specifies the arguments for the process
        [string] $ArgumentList
    )
    
    Set-StrictMode -Version 3
    
    ## Prepare to invoke the process
    $processStartInfo = New-Object System.Diagnostics.ProcessStartInfo
    $processStartInfo.FileName = (Get-Command $processname).Definition
    $processStartInfo.WorkingDirectory = (Get-Location).Path
    if($argumentList) { $processStartInfo.Arguments = $argumentList }
    $processStartInfo.UseShellExecute = $false
    
    ## Always redirect the input and output of the process.
    ## Sometimes we will capture it as binary, other times we will
    ## just treat it as strings.
    $processStartInfo.RedirectStandardOutput = $true
    $processStartInfo.RedirectStandardInput = $true
    
    $process = [System.Diagnostics.Process]::Start($processStartInfo)
    
    ## If we've been asked to redirect the input, treat it as bytes.
    ## Otherwise, write any input to the process as strings.
    if($redirectInput)
    {
        $inputBytes = @($input)
        $process.StandardInput.BaseStream.Write($inputBytes, 0, $inputBytes.Count)
        $process.StandardInput.Close()
    }
    else
    {
        $input | % { $process.StandardInput.WriteLine($_) }
        $process.StandardInput.Close()
    }
    
    ## If we've been asked to redirect the output, treat it as bytes.
    ## Otherwise, read any input from the process as strings.
    if($redirectOutput)
    {
        $byteRead = -1
        do
        {
            $byteRead = $process.StandardOutput.BaseStream.ReadByte()
            if($byteRead -ge 0) { $byteRead }
        } while($byteRead -ge 0)
    }
    else
    {
        $process.StandardOutput.ReadToEnd()
    }
}

function Invoke-CmdScript
{
    ##############################################################################
    ##
    ## Invoke-CmdScript
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Invoke the specified batch file (and parameters), but also propigate any
    environment variable changes back to the PowerShell environment that
    called it.
    
    .EXAMPLE
    
    PS > type foo-that-sets-the-FOO-env-variable.cmd
    @set FOO=%*
    echo FOO set to %FOO%.
    
    PS > $env:FOO
    PS > Invoke-CmdScript "foo-that-sets-the-FOO-env-variable.cmd" Test
    
    C:\Temp>echo FOO set to Test.
    FOO set to Test.
    
    PS > $env:FOO
    Test
    
    #>
    
    param(
        ## The path to the script to run
        [Parameter(Mandatory = $true)]
        [string] $Path,
    
        ## The arguments to the script
        [string] $ArgumentList
    )
    
    Set-StrictMode -Version 3
    
    $tempFile = [IO.Path]::GetTempFileName()
    
    ## Store the output of cmd.exe.  We also ask cmd.exe to output
    ## the environment table after the batch file completes
    cmd /c " `"$Path`" $argumentList && set > `"$tempFile`" "
    
    ## Go through the environment variables in the temp file.
    ## For each of them, set the variable in our local environment.
    Get-Content $tempFile | Foreach-Object {
        if($_ -match "^(.*?)=(.*)$")
        {
            Set-Content "env:\$($matches[1])" $matches[2]
        }
    }
    
    Remove-Item $tempFile
}

function Invoke-ComplexDebuggerScript
{
    #############################################################################
    ##
    ## Invoke-ComplexDebuggerScript
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Demonstrates the functionality of PowerShell's debugging support.
    
    #>
    
    Set-StrictMode -Version 3
    
    function HelperFunction
    {
        $dirCount = 0
    }
    
    Write-Host "Calculating lots of complex information"
    
    $runningTotal = 0
    $runningTotal += [Math]::Pow(5 * 5 + 10, 2)
    $runningTotal
    
    $dirCount = @(Get-ChildItem $env:WINDIR).Count
    $dirCount
    
    HelperFunction
    
    $dirCount
    
    $runningTotal -= 10
    $runningTotal /= 2
    $runningTotal
    
    $runningTotal *= 3
    $runningTotal /= 2
    $runningTotal
}

function Invoke-ComplexScript
{
    #############################################################################
    ##
    ## Invoke-ComplexScript
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Demonstrates the functionality of PowerShell's debugging support.
    
    #>
    
    Set-StrictMode -Version 3
    
    Write-Host "Calculating lots of complex information"
    
    $runningTotal = 0
    $runningTotal += [Math]::Pow(5 * 5 + 10, 2)
    
    Write-Debug "Current value: $runningTotal"
    
    Set-PsDebug -Trace 1
    $dirCount = @(Get-ChildItem $env:WINDIR).Count
    
    Set-PsDebug -Trace 2
    $runningTotal -= 10
    $runningTotal /= 2
    
    Set-PsDebug -Step
    $runningTotal *= 3
    $runningTotal /= 2
    
    $host.EnterNestedPrompt()
    
    Set-PsDebug -off
}

function Invoke-DemonstrationScript
{
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    
    "The script ran!"
}

function Invoke-ElevatedCommand
{
    ##############################################################################
    ##
    ## Invoke-ElevatedCommand
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Runs the provided script block under an elevated instance of PowerShell as
    through it were a member of a regular pipeline.
    
    .EXAMPLE
    
    PS > Get-Process | Invoke-ElevatedCommand.ps1 {
        $input | Where-Object { $_.Handles -gt 500 } } | Sort Handles
    
    #>
    
    param(
        ## The script block to invoke elevated
        [Parameter(Mandatory = $true)]
        [ScriptBlock] $Scriptblock,
    
        ## Any input to give the elevated process
        [Parameter(ValueFromPipeline = $true)]
        $InputObject,
    
        ## Switch to enable the user profile
        [switch] $EnableProfile
    )
    
    begin
    {
        Set-StrictMode -Version 3
        $inputItems = New-Object System.Collections.ArrayList
    }
    
    process
    {
        $null = $inputItems.Add($inputObject)
    }
    
    end
    {
        ## Create some temporary files for streaming input and output
        $outputFile = [IO.Path]::GetTempFileName()
        $inputFile = [IO.Path]::GetTempFileName()
    
        ## Stream the input into the input file
        $inputItems.ToArray() | Export-CliXml -Depth 1 $inputFile
    
        ## Start creating the command line for the elevated PowerShell session
        $commandLine = ""
        if(-not $EnableProfile) { $commandLine += "-NoProfile " }
    
        ## Convert the command into an encoded command for PowerShell
        $commandString = "Set-Location '$($pwd.Path)'; " +
            "`$output = Import-CliXml '$inputFile' | " +
            "& {" + $scriptblock.ToString() + "} 2>&1; " +
            "`$output | Export-CliXml -Depth 1 '$outputFile'"
    
        $commandBytes = [System.Text.Encoding]::Unicode.GetBytes($commandString)
        $encodedCommand = [Convert]::ToBase64String($commandBytes)
        $commandLine += "-EncodedCommand $encodedCommand"
    
        ## Start the new PowerShell process
        $process = Start-Process -FilePath (Get-Command powershell).Definition `
            -ArgumentList $commandLine -Verb RunAs `
            -WindowStyle Hidden `
            -Passthru
        $process.WaitForExit()
    
        ## Return the output to the user
        if((Get-Item $outputFile).Length -gt 0)
        {
            Import-CliXml $outputFile
        }
    
        ## Clean up
        [Console]::WriteLine($outputFile)
        # Remove-Item $outputFile
        Remove-Item $inputFile
    }
}

function Invoke-Inline
{
    #############################################################################
    ##
    ## Invoke-Inline
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    #############################################################################
    
    <#
    
    .SYNOPSIS
    
    Demonstrates the Add-Type cmdlet to invoke in-line C#
    
    #>
    
    Set-StrictMode -Version 3
    
    $inlineType = Add-Type -Name InvokeInline_Inline -PassThru `
        -MemberDefinition @'
        public static int RightShift(int original, int places)
        {
            return original >> places;
        }
'@
    
    $inlineType::RightShift(1024, 3)
}

function Invoke-LocalizedScript
{
    Set-StrictMode -Version 3
    
    ## Create some default messages for English cultures, and
    ## when culture-specific messages are not available.
    $messages = DATA {
        @{
            Greeting = "Hello, {0}"
            Goodbye = "So long."
        }
    }
    
    ## Import localized messages for the current culture.
    Import-LocalizedData messages -ErrorAction SilentlyContinue
    
    ## Output the localized messages
    $messages.Greeting -f "World"
    $messages.Goodbye
}

function Invoke-LongRunningOperation
{
    ##############################################################################
    ##
    ## Invoke-LongRunningOperation
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Demonstrates the functionality of the Write-Progress cmdlet
    
    #>
    
    Set-StrictMode -Version 3
    
    $activity = "A long running operation"
    $status = "Initializing"
    
    ## Initialize the long-running operation
    for($counter = 0; $counter -lt 100; $counter++)
    {
        $currentOperation = "Initializing item $counter"
        Write-Progress $activity $status -PercentComplete $counter `
            -CurrentOperation $currentOperation
        Start-Sleep -m 20
    }
    
    $status = "Running"
    
    ## Initialize the long-running operation
    for($counter = 0; $counter -lt 100; $counter++)
    {
        $currentOperation = "Running task $counter"
        Write-Progress $activity $status -PercentComplete $counter `
            -CurrentOperation $currentOperation
        Start-Sleep -m 20
    }
}

function Invoke-Member
{
    ##############################################################################
    ##
    ## Invoke-Member
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Enables easy access to methods and properties of pipeline objects.
    
    .EXAMPLE
    
    PS > "Hello","World" | .\Invoke-Member Length
    5
    5
    
    .EXAMPLE
    
    PS > "Hello","World" | .\Invoke-Member -m ToUpper
    HELLO
    WORLD
    
    .EXAMPLE
    
    PS > "Hello","World" | .\Invoke-Member Replace l w
    Hewwo
    Worwd
    
    #>
    
    [CmdletBinding(DefaultParameterSetName= "Member")]
    param(
    
        ## A switch parameter to identify the requested member as a method.
        ## Only required for methods that take no arguments.
        [Parameter(ParameterSetName = "Method")]
        [Alias("M","Me")]
        [switch] $Method,
    
        ## The name of the member to retrieve
        [Parameter(ParameterSetName = "Method", Position = 0)]
        [Parameter(ParameterSetName = "Member", Position = 0)]
        [string] $Member,
    
        ## Arguments for the method, if any
        [Parameter(
            ParameterSetName = "Method", Position = 1,
            Mandatory = $false, ValueFromRemainingArguments = $true)]
        [object[]] $ArgumentList = @(),
    
        ## The object from which to retrieve the member
        [Parameter(ValueFromPipeline = $true)]
        $InputObject
        )
    
    process
    {
        ## If the user specified a method, invoke it
        ## with any required arguments.
        if($psCmdlet.ParameterSetName -eq "Method")
        {
            $inputObject.$member.Invoke(@($argumentList))
        }
        ## Otherwise, retrieve the property
        else
        {
            $inputObject.$member
        }
    }
}

function Invoke-RemoteExpression
{
    ##############################################################################
    ##
    ## Invoke-RemoteExpression
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Invoke a PowerShell expression on a remote machine. Requires PsExec from
    http://live.sysinternals.com/tools/psexec.exe. If the remote machine
    supports PowerShell version two, use PowerShell remoting instead.
    
    .EXAMPLE
    
    PS > Invoke-RemoteExpression LEE-DESK { Get-Process }
    Retrieves the output of a simple command from a remote machine
    
    .EXAMPLE
    
    PS > (Invoke-RemoteExpression LEE-DESK { Get-Date }).AddDays(1)
    Invokes a command on a remote machine. Since the command returns one of
    PowerShell's primitive types (a DateTime object,) you can manipulate
    its output as an object afterward.
    
    .EXAMPLE
    
    PS > Invoke-RemoteExpression LEE-DESK { Get-Process } | Sort Handles
    Invokes a command on a remote machine. The command does not return one of
    PowerShell's primitive types, but you can still use PowerShell's filtering
    cmdlets to work with its structured output.
    
    #>
    
    param(
        ## The computer on which to invoke the command.
        $ComputerName = "$ENV:ComputerName",
    
        ## The scriptblock to invoke on the remote machine.
        [Parameter(Mandatory = $true)]
        [ScriptBlock] $ScriptBlock,
    
        ## The username / password to use in the connection
        $Credential,
    
        ## Determines if PowerShell should load the user's PowerShell profile
        ## when invoking the command.
        [switch] $NoProfile
    )
    
    Set-StrictMode -Version 3
    
    ## Prepare the computername for PSExec
    if($ComputerName -notmatch '^\\')
    {
        $ComputerName = "\\$ComputerName"
    }
    
    ## Prepare the command line for PsExec. We use the XML output encoding so
    ## that PowerShell can convert the output back into structured objects.
    ## PowerShell expects that you pass it some input when being run by PsExec
    ## this way, so the 'echo .' statement satisfies that appetite.
    $commandLine = "echo . | powershell -Output XML "
    
    if($noProfile)
    {
        $commandLine += "-NoProfile "
    }
    
    ## Convert the command into an encoded command for PowerShell
    $commandBytes = [System.Text.Encoding]::Unicode.GetBytes($scriptblock)
    $encodedCommand = [Convert]::ToBase64String($commandBytes)
    $commandLine += "-EncodedCommand $encodedCommand"
    
    ## Collect the output and error output
    $errorOutput = [IO.Path]::GetTempFileName()
    
    if($Credential)
    {
        ## This lets users pass either a username, or full credential to our
        ## credential parameter
        $credential = Get-Credential $credential
        $networkCredential = $credential.GetNetworkCredential()
        $username = $networkCredential.Username
        $password = $networkCredential.Password
    
        $output = psexec $computername /user $username /password $password `
            /accepteula cmd /c $commandLine 2>$errorOutput
    }
    else
    {
        $output = psexec /acceptEula $computername cmd /c $commandLine 2>$errorOutput
    }
    
    ## Check for any errors
    $errorContent = Get-Content $errorOutput
    Remove-Item $errorOutput
    
    if($lastExitCode -ne 0)
    {
        $OFS = "`n"
        $errorMessage = "Could not execute remote expression. "
        $errorMessage += "Ensure that your account has administrative " +
            "privileges on the target machine.`n"
        $errorMessage += ($errorContent -match "psexec.exe :")
    
        Write-Error $errorMessage
    }
    
    ## Return the output to the user
    $output
}

function Invoke-ScriptBlock
{
    ##############################################################################
    ##
    ## Invoke-ScriptBlock
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Apply the given mapping command to each element of the input. (Note that
    PowerShell includes this command natively, and calls it Foreach-Object)
    
    .EXAMPLE
    
    PS > 1,2,3 | Invoke-ScriptBlock { $_ * 2 }
    
    #>
    
    param(
        ## The scriptblock to apply to each incoming element
        [ScriptBlock] $MapCommand
    )
    
    begin
    {
        Set-StrictMode -Version 3
    }
    process
    {
        & $mapCommand
    }
}

function Invoke-ScriptBlockClosure
{
    ##############################################################################
    ##
    ## Invoke-ScriptBlockClosure
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Demonstrates the GetNewClosure() method on a script block that pulls variables
    in from the user's session (if they are defined.)
    
    .EXAMPLE
    
    PS > $name = "Hello There"
    PS > Invoke-ScriptBlockClosure { $name }
    Hello There
    Hello World
    Hello There
    
    #>
    
    param(
        ## The scriptblock to invoke
        [ScriptBlock] $ScriptBlock
    )
    
    Set-StrictMode -Version 3
    
    ## Create a new script block that pulls variables
    ## from the user's scope (if defined.)
    $closedScriptBlock = $scriptBlock.GetNewClosure()
    
    ## Invoke the script block normally. The contents of
    ## the $name variable will be from the user's session.
    & $scriptBlock
    
    ## Define a new variable
    $name = "Hello World"
    
    ## Invoke the script block normally. The contents of
    ## the $name variable will be "Hello World", now from
    ## our scope.
    & $scriptBlock
    
    ## Invoke the "closed" script block. The contents of
    ## the $name variable will still be whatever was in the user's session
    ## (if it was defined.)
    & $closedScriptBlock
}

function Invoke-ScriptThatRequiresMta
{
    ###########################################################################
    ##
    ## Invoke-ScriptThatRequiresMta
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ###########################################################################
    
    <#
    
    .SYNOPSIS
    
    Demonstrates a technique to relaunch a script that requires MTA mode.
    This is useful only for simple parameter definitions that can be
    specified positionally.
    
    #>
    
    param(
        $Parameter1,
        $Parameter2
    )
    
    Set-StrictMode -Version 3
    
    "Current threading mode: " + $host.Runspace.ApartmentState
    "Parameter1 is: $parameter1"
    "Parameter2 is: $parameter2"
    
    if($host.Runspace.ApartmentState -eq "STA")
    {
        "Relaunching"
        $file = $myInvocation.MyCommand.Path
        powershell -NoProfile -Mta -File $file $parameter1 $parameter2
        return
    }
    
    "After relaunch - current threading mode: " + $host.Runspace.ApartmentState
}

function Invoke-SqlCommand
{
    ##############################################################################
    ##
    ## Invoke-SqlCommand
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Return the results of a SQL query or operation
    
    .EXAMPLE
    
    Invoke-SqlCommand.ps1 -Sql "SELECT TOP 10 * FROM Orders"
    Invokes a command using Windows authentication
    
    .EXAMPLE
    
    PS > $cred = Get-Credential
    PS > Invoke-SqlCommand.ps1 -Sql "SELECT TOP 10 * FROM Orders" -Cred $cred
    Invokes a command using SQL Authentication
    
    .EXAMPLE
    
    PS > $server = "MYSERVER"
    PS > $database = "Master"
    PS > $sql = "UPDATE Orders SET EmployeeID = 6 WHERE OrderID = 10248"
    PS > Invoke-SqlCommand $server $database $sql
    Invokes a command that performs an update
    
    .EXAMPLE
    
    PS > $sql = "EXEC SalesByCategory 'Beverages'"
    PS > Invoke-SqlCommand -Sql $sql
    Invokes a stored procedure
    
    .EXAMPLE
    
    PS > Invoke-SqlCommand (Resolve-Path access_test.mdb) -Sql "SELECT * FROM Users"
    Access an Access database
    
    .EXAMPLE
    
    PS > Invoke-SqlCommand (Resolve-Path xls_test.xls) -Sql 'SELECT * FROM [Sheet1$]'
    Access an Excel file
    
    #>
    
    param(
        ## The data source to use in the connection
        [string] $DataSource = ".\SQLEXPRESS",
    
        ## The database within the data source
        [string] $Database = "Northwind",
    
        ## The SQL statement(s) to invoke against the database
        [Parameter(Mandatory = $true)]
        [string[]] $SqlCommand,
    
        ## The timeout, in seconds, to wait for the query to complete
        [int] $Timeout = 60,
    
        ## The credential to use in the connection, if any.
        $Credential
    )
    
    
    Set-StrictMode -Version 3
    
    ## Prepare the authentication information. By default, we pick
    ## Windows authentication
    $authentication = "Integrated Security=SSPI;"
    
    ## If the user supplies a credential, then they want SQL
    ## authentication
    if($credential)
    {
        $credential = Get-Credential $credential
        $plainCred = $credential.GetNetworkCredential()
        $authentication =
            ("uid={0};pwd={1};" -f $plainCred.Username,$plainCred.Password)
    }
    
    ## Prepare the connection string out of the information they
    ## provide
    $connectionString = "Provider=sqloledb; " +
                        "Data Source=$dataSource; " +
                        "Initial Catalog=$database; " +
                        "$authentication; "
    
    ## If they specify an Access database or Excel file as the connection
    ## source, modify the connection string to connect to that data source
    if($dataSource -match '\.xls$|\.mdb$')
    {
        $connectionString = "Provider=Microsoft.Jet.OLEDB.4.0; " +
            "Data Source=$dataSource; "
    
        if($dataSource -match '\.xls$')
        {
            $connectionString += 'Extended Properties="Excel 8.0;"; '
    
            ## Generate an error if they didn't specify the sheet name properly
            if($sqlCommand -notmatch '\[.+\$\]')
            {
                $error = 'Sheet names should be surrounded by square brackets, ' +
                    'and have a dollar sign at the end: [Sheet1$]'
                Write-Error $error
                return
            }
        }
    }
    
    ## Connect to the data source and open it
    $connection = New-Object System.Data.OleDb.OleDbConnection $connectionString
    $connection.Open()
    
    foreach($commandString in $sqlCommand)
    {
        $command = New-Object Data.OleDb.OleDbCommand $commandString,$connection
        $command.CommandTimeout = $timeout
    
        ## Fetch the results, and close the connection
        $adapter = New-Object System.Data.OleDb.OleDbDataAdapter $command
        $dataset = New-Object System.Data.DataSet
        [void] $adapter.Fill($dataSet)
    
        ## Return all of the rows from their query
        $dataSet.Tables | Select-Object -Expand Rows
    }
    
    $connection.Close()
}

function Invoke-WindowsApi
{
    ##############################################################################
    ##
    ## Invoke-WindowsApi
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Invoke a native Windows API call that takes and returns simple data types.
    
    .EXAMPLE
    
    ## Prepare the parameter types and parameters for the CreateHardLink function
    PS > $filename = "c:\temp\hardlinked.txt"
    PS > $existingFilename = "c:\temp\link_target.txt"
    PS > Set-Content $existingFilename "Hard Link target"
    PS > $parameterTypes = [string], [string], [IntPtr]
    PS > $parameters = [string] $filename, [string] $existingFilename,
        [IntPtr]::Zero
    
    ## Call the CreateHardLink method in the Kernel32 DLL
    PS > $result = Invoke-WindowsApi "kernel32" ([bool]) "CreateHardLink" `
        $parameterTypes $parameters
    PS > Get-Content C:\temp\hardlinked.txt
    Hard Link target
    
    #>
    
    param(
        ## The name of the DLL that contains the Windows API, such as "kernel32"
        [string] $DllName,
    
        ## The return type expected from Windows API
        [Type] $ReturnType,
    
        ## The name of the Windows API
        [string] $MethodName,
    
        ## The types of parameters expected by the Windows API
        [Type[]] $ParameterTypes,
    
        ## Parameter values to pass to the Windows API
        [Object[]] $Parameters
    )
    
    Set-StrictMode -Version 3
    
    ## Begin to build the dynamic assembly
    $domain = [AppDomain]::CurrentDomain
    $name = New-Object Reflection.AssemblyName 'PInvokeAssembly'
    $assembly = $domain.DefineDynamicAssembly($name, 'Run')
    $module = $assembly.DefineDynamicModule('PInvokeModule')
    $type = $module.DefineType('PInvokeType', "Public,BeforeFieldInit")
    
    ## Go through all of the parameters passed to us.  As we do this,
    ## we clone the user's inputs into another array that we will use for
    ## the P/Invoke call.
    $inputParameters = @()
    $refParameters = @()
    
    for($counter = 1; $counter -le $parameterTypes.Length; $counter++)
    {
        ## If an item is a PSReference, then the user
        ## wants an [out] parameter.
        if($parameterTypes[$counter - 1] -eq [Ref])
        {
            ## Remember which parameters are used for [Out] parameters
            $refParameters += $counter
    
            ## On the cloned array, we replace the PSReference type with the
            ## .Net reference type that represents the value of the PSReference,
            ## and the value with the value held by the PSReference.
            $parameterTypes[$counter - 1] =
                $parameters[$counter - 1].Value.GetType().MakeByRefType()
            $inputParameters += $parameters[$counter - 1].Value
        }
        else
        {
            ## Otherwise, just add their actual parameter to the
            ## input array.
            $inputParameters += $parameters[$counter - 1]
        }
    }
    
    ## Define the actual P/Invoke method, adding the [Out]
    ## attribute for any parameters that were originally [Ref]
    ## parameters.
    $method = $type.DefineMethod(
        $methodName, 'Public,HideBySig,Static,PinvokeImpl',
        $returnType, $parameterTypes)
    foreach($refParameter in $refParameters)
    {
        [void] $method.DefineParameter($refParameter, "Out", $null)
    }
    
    ## Apply the P/Invoke constructor
    $ctor = [Runtime.InteropServices.DllImportAttribute].GetConstructor([string])
    $attr = New-Object Reflection.Emit.CustomAttributeBuilder $ctor, $dllName
    $method.SetCustomAttribute($attr)
    
    ## Create the temporary type, and invoke the method.
    $realType = $type.CreateType()
    
    $realType.InvokeMember(
        $methodName, 'Public,Static,InvokeMethod', $null, $null,$inputParameters)
    
    ## Finally, go through all of the reference parameters, and update the
    ## values of the PSReference objects that the user passed in.
    foreach($refParameter in $refParameters)
    {
        $parameters[$refParameter - 1].Value = $inputParameters[$refParameter - 1]
    }
}

function Measure-CommandPerformance
{
    ##############################################################################
    ##
    ## Measure-CommandPerformance
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Measures the average time of a command, accounting for natural variability by
    automatically ignoring the top and bottom ten percent.
    
    .EXAMPLE
    
    PS > Measure-CommandPerformance.ps1 { Start-Sleep -m 300 }
    
    Count    : 30
    Average  : 312.10155
    (...)
    
    #>
    
    param(
        ## The command to measure
        [Scriptblock] $Scriptblock,
    
        ## The number of times to measure the command's performance
        [int] $Iterations = 30
    )
    
    Set-StrictMode -Version 3
    
    ## Figure out how many extra iterations we need to account for the outliers
    $buffer = [int] ($iterations * 0.1)
    $totalIterations = $iterations + (2 * $buffer)
    
    ## Get the results
    $results = 1..$totalIterations |
        Foreach-Object { Measure-Command $scriptblock }
    
    ## Sort the results, and skip the outliers
    $middleResults = $results | Sort TotalMilliseconds |
        Select -Skip $buffer -First $iterations
    
    ## Show the average
    $middleResults | Measure-Object -Average TotalMilliseconds
}

function Move-LockedFile
{
    ##############################################################################
    ##
    ## Move-LockedFile
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Registers a locked file to be moved at the next system restart.
    
    .EXAMPLE
    
    PS > Move-LockedFile c:\temp\locked.txt c:\temp\locked.txt.bak
    
    #>
    
    param(
        ## The current location of the file to move
        $Path,
    
        ## The target location of the file
        $Destination
    )
    
    Set-StrictMode -Version 3
    
    ## Convert the the path and destination to fully qualified paths
    $path = (Resolve-Path $path).Path
    $destination = $executionContext.SessionState.`
        Path.GetUnresolvedProviderPathFromPSPath($destination)
    
    ## Define a new .NET type that calls into the Windows API to
    ## move a locked file.
    $MOVEFILE_DELAY_UNTIL_REBOOT = 0x00000004
    $memberDefinition = @'
    [DllImport("kernel32.dll", SetLastError=true, CharSet=CharSet.Auto)]
    public static extern bool MoveFileEx(
        string lpExistingFileName, string lpNewFileName, int dwFlags);
'@
    $type = Add-Type -Name MoveFileUtils `
        -MemberDefinition $memberDefinition -PassThru
    
    ## Move the file
    $type::MoveFileEx($path, $destination, $MOVEFILE_DELAY_UNTIL_REBOOT)
}

function New-CommandWrapper
{
    ##############################################################################
    ##
    ## New-CommandWrapper
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Adds parameters and functionality to existing cmdlets and functions.
    
    .EXAMPLE
    
    New-CommandWrapper Get-Process `
          -AddParameter @{
              SortBy = {
                  $newPipeline = {
                      __ORIGINAL_COMMAND__ | Sort-Object -Property $SortBy
                  }
              }
          }
    
    This example adds a 'SortBy' parameter to Get-Process. It accomplishes
    this by adding a Sort-Object command to the pipeline.
    
    .EXAMPLE
    
    $parameterAttributes = @'
              [Parameter(Mandatory = $true)]
              [ValidateRange(50,75)]
              [Int]
'@
    
    New-CommandWrapper Clear-Host `
          -AddParameter @{
              @{
                  Name = 'MyMandatoryInt';
                  Attributes = $parameterAttributes
              } = {
                  Write-Host $MyMandatoryInt
                  Read-Host "Press ENTER"
             }
          }
    
    This example adds a new mandatory 'MyMandatoryInt' parameter to
    Clear-Host. This parameter is also validated to fall within the range
    of 50 to 75. It doesn't alter the pipeline, but does display some
    information on the screen before processing the original pipeline.
    
    #>
    
    param(
        ## The name of the command to extend
        [Parameter(Mandatory = $true)]
        $Name,
    
        ## Script to invoke before the command begins
        [ScriptBlock] $Begin,
    
        ## Script to invoke for each input element
        [ScriptBlock] $Process,
    
        ## Script to invoke at the end of the command
        [ScriptBlock] $End,
    
        ## Parameters to add, and their functionality.
        ##
        ## The Key of the hashtable can be either a simple parameter name,
        ## or a more advanced parameter description.
        ##
        ## If you want to add additional parameter validation (such as a
        ## parameter type,) then the key can itself be a hashtable with the keys
        ## 'Name' and 'Attributes'. 'Attributes' is the text you would use when
        ## defining this parameter as part of a function.
        ##
        ## The Value of each hashtable entry is a scriptblock to invoke
        ## when this parameter is selected. To customize the pipeline,
        ## assign a new scriptblock to the $newPipeline variable. Use the
        ## special text, __ORIGINAL_COMMAND__, to represent the original
        ## command. The $targetParameters variable represents a hashtable
        ## containing the parameters that will be passed to the original
        ## command.
        [HashTable] $AddParameter
    )
    
    Set-StrictMode -Version 3
    
    ## Store the target command we are wrapping, and its command type
    $target = $Name
    $commandType = "Cmdlet"
    
    ## If a function already exists with this name (perhaps it's already been
    ## wrapped,) rename the other function and chain to its new name.
    if(Test-Path function:\$Name)
    {
        $target = "$Name" + "-" + [Guid]::NewGuid().ToString().Replace("-","")
        Rename-Item function:\GLOBAL:$Name GLOBAL:$target
        $commandType = "Function"
    }
    
    ## The template we use for generating a command proxy
    $proxy = @'
    
    __CMDLET_BINDING_ATTRIBUTE__
    param(
    __PARAMETERS__
    )
    begin
    {
        try {
            __CUSTOM_BEGIN__
    
            ## Access the REAL Foreach-Object command, so that command
            ## wrappers do not interfere with this script
            $foreachObject = $executionContext.InvokeCommand.GetCmdlet(
                "Microsoft.PowerShell.Core\Foreach-Object")
    
            $wrappedCmd = $ExecutionContext.InvokeCommand.GetCommand(
                '__COMMAND_NAME__',
                [System.Management.Automation.CommandTypes]::__COMMAND_TYPE__)
    
            ## TargetParameters represents the hashtable of parameters that
            ## we will pass along to the wrapped command
            $targetParameters = @{}
            $PSBoundParameters.GetEnumerator() |
                & $foreachObject {
                    if($command.Parameters.ContainsKey($_.Key))
                    {
                        $targetParameters.Add($_.Key, $_.Value)
                    }
                }
    
            ## finalPipeline represents the pipeline we wil ultimately run
            $newPipeline = { & $wrappedCmd @targetParameters }
            $finalPipeline = $newPipeline.ToString()
    
            __CUSTOM_PARAMETER_PROCESSING__
    
            $steppablePipeline = [ScriptBlock]::Create(
                $finalPipeline).GetSteppablePipeline()
            $steppablePipeline.Begin($PSCmdlet)
        } catch {
            throw
        }
    }
    
    process
    {
        try {
            __CUSTOM_PROCESS__
            $steppablePipeline.Process($_)
        } catch {
            throw
        }
    }
    
    end
    {
        try {
            __CUSTOM_END__
            $steppablePipeline.End()
        } catch {
            throw
        }
    }
    
    dynamicparam
    {
        ## Access the REAL Get-Command, Foreach-Object, and Where-Object
        ## commands, so that command wrappers do not interfere with this script
        $getCommand = $executionContext.InvokeCommand.GetCmdlet(
            "Microsoft.PowerShell.Core\Get-Command")
        $foreachObject = $executionContext.InvokeCommand.GetCmdlet(
            "Microsoft.PowerShell.Core\Foreach-Object")
        $whereObject = $executionContext.InvokeCommand.GetCmdlet(
            "Microsoft.PowerShell.Core\Where-Object")
    
        ## Find the parameters of the original command, and remove everything
        ## else from the bound parameter list so we hide parameters the wrapped
        ## command does not recognize.
        $command = & $getCommand __COMMAND_NAME__ -Type __COMMAND_TYPE__
        $targetParameters = @{}
        $PSBoundParameters.GetEnumerator() |
            & $foreachObject {
                if($command.Parameters.ContainsKey($_.Key))
                {
                    $targetParameters.Add($_.Key, $_.Value)
                }
            }
    
        ## Get the argumment list as it would be passed to the target command
        $argList = @($targetParameters.GetEnumerator() |
            Foreach-Object { "-$($_.Key)"; $_.Value })
    
        ## Get the dynamic parameters of the wrapped command, based on the
        ## arguments to this command
        $command = $null
        try
        {
            $command = & $getCommand __COMMAND_NAME__ -Type __COMMAND_TYPE__ `
                -ArgumentList $argList
        }
        catch
        {
    
        }
    
        $dynamicParams = @($command.Parameters.GetEnumerator() |
            & $whereObject { $_.Value.IsDynamic })
    
        ## For each of the dynamic parameters, add them to the dynamic
        ## parameters that we return.
        if ($dynamicParams.Length -gt 0)
        {
            $paramDictionary = `
                New-Object Management.Automation.RuntimeDefinedParameterDictionary
            foreach ($param in $dynamicParams)
            {
                $param = $param.Value
                $arguments = $param.Name, $param.ParameterType, $param.Attributes
                $newParameter = `
                    New-Object Management.Automation.RuntimeDefinedParameter `
                    $arguments
                $paramDictionary.Add($param.Name, $newParameter)
            }
            return $paramDictionary
        }
    }
    
    <#
    
    .ForwardHelpTargetName __COMMAND_NAME__
    .ForwardHelpCategory __COMMAND_TYPE__
    
    #>
    
'@
    
    ## Get the information about the original command
    $originalCommand = Get-Command $target
    $metaData = New-Object System.Management.Automation.CommandMetaData `
        $originalCommand
    $proxyCommandType = [System.Management.Automation.ProxyCommand]
    
    ## Generate the cmdlet binding attribute, and replace information
    ## about the target
    $proxy = $proxy.Replace("__CMDLET_BINDING_ATTRIBUTE__",
        $proxyCommandType::GetCmdletBindingAttribute($metaData))
    $proxy = $proxy.Replace("__COMMAND_NAME__", $target)
    $proxy = $proxy.Replace("__COMMAND_TYPE__", $commandType)
    
    ## Stores new text we'll be putting in the param() block
    $newParamBlockCode = ""
    
    ## Stores new text we'll be putting in the begin block
    ## (mostly due to parameter processing)
    $beginAdditions = ""
    
    ## If the user wants to add a parameter
    $currentParameter = $originalCommand.Parameters.Count
    if($AddParameter)
    {
        foreach($parameter in $AddParameter.Keys)
        {
            ## Get the code associated with this parameter
            $parameterCode = $AddParameter[$parameter]
    
            ## If it's an advanced parameter declaration, the hashtable
            ## holds the validation and / or type restrictions
            if($parameter -is [Hashtable])
            {
                ## Add their attributes and other information to
                ## the variable holding the parameter block additions
                if($currentParameter -gt 0)
                {
                    $newParamBlockCode += ","
                }
    
                $newParamBlockCode += "`n`n    " +
                    $parameter.Attributes + "`n" +
                    '    $' + $parameter.Name
    
                $parameter = $parameter.Name
            }
            else
            {
                ## If this is a simple parameter name, add it to the list of
                ## parameters. The proxy generation APIs will take care of
                ## adding it to the param() block.
                $newParameter =
                    New-Object System.Management.Automation.ParameterMetadata `
                        $parameter
                $metaData.Parameters.Add($parameter, $newParameter)
            }
    
            $parameterCode = $parameterCode.ToString()
    
            ## Create the template code that invokes their parameter code if
            ## the parameter is selected.
            $templateCode = @"
    
            if(`$PSBoundParameters['$parameter'])
            {
                $parameterCode
    
                ## Replace the __ORIGINAL_COMMAND__ tag with the code
                ## that represents the original command
                `$alteredPipeline = `$newPipeline.ToString()
                `$finalPipeline = `$alteredPipeline.Replace(
                    '__ORIGINAL_COMMAND__', `$finalPipeline)
            }
"@
    
            ## Add the template code to the list of changes we're making
            ## to the begin() section.
            $beginAdditions += $templateCode
            $currentParameter++
        }
    }
    
    ## Generate the param() block
    $parameters = $proxyCommandType::GetParamBlock($metaData)
    if($newParamBlockCode) { $parameters += $newParamBlockCode }
    $proxy = $proxy.Replace('__PARAMETERS__', $parameters)
    
    ## Update the begin, process, and end sections
    $proxy = $proxy.Replace('__CUSTOM_BEGIN__', $Begin)
    $proxy = $proxy.Replace('__CUSTOM_PARAMETER_PROCESSING__', $beginAdditions)
    $proxy = $proxy.Replace('__CUSTOM_PROCESS__', $Process)
    $proxy = $proxy.Replace('__CUSTOM_END__', $End)
    
    ## Save the function wrapper
    Write-Verbose $proxy
    Set-Content function:\GLOBAL:$NAME $proxy
    
    ## If we were wrapping a cmdlet, hide it so that it doesn't conflict with
    ## Get-Help and Get-Command
    if($commandType -eq "Cmdlet")
    {
        $originalCommand.Visibility = "Private"
    }
}

function New-DynamicVariable
{
    ##############################################################################
    ##
    ## New-DynamicVariable
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Creates a variable that supports scripted actions for its getter and setter
    
    .EXAMPLE
    
    PS > .\New-DynamicVariable GLOBAL:WindowTitle `
         -Getter { $host.UI.RawUI.WindowTitle } `
         -Setter { $host.UI.RawUI.WindowTitle = $args[0] }
    
    PS > $windowTitle
    Administrator: C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe
    PS > $windowTitle = "Test"
    PS > $windowTitle
    Test
    
    #>
    
    param(
        ## The name for the dynamic variable
        [Parameter(Mandatory = $true)]
        $Name,
    
        ## The scriptblock to invoke when getting the value of the variable
        [Parameter(Mandatory = $true)]
        [ScriptBlock] $Getter,
    
        ## The scriptblock to invoke when setting the value of the variable
        [ScriptBlock] $Setter
    )
    
    Set-StrictMode -Version 3
    
    Add-Type @"
    using System;
    using System.Collections.ObjectModel;
    using System.Management.Automation;
    
    namespace Lee.Holmes
    {
        public class DynamicVariable : PSVariable
        {
            public DynamicVariable(
                string name,
                ScriptBlock scriptGetter,
                ScriptBlock scriptSetter)
                    : base(name, null, ScopedItemOptions.AllScope)
            {
                getter = scriptGetter;
                setter = scriptSetter;
            }
            private ScriptBlock getter;
            private ScriptBlock setter;
    
            public override object Value
            {
                get
                {
                    if(getter != null)
                    {
                        Collection<PSObject> results = getter.Invoke();
                        if(results.Count == 1)
                        {
                            return results[0];
                        }
                        else
                        {
                            PSObject[] returnResults =
                                new PSObject[results.Count];
                            results.CopyTo(returnResults, 0);
                            return returnResults;
                        }
                    }
                    else { return null; }
                }
                set
                {
                    if(setter != null) { setter.Invoke(value); }
                }
            }
        }
    }
"@
    
    ## If we've already defined the variable, remove it.
    if(Test-Path variable:\$name)
    {
        Remove-Item variable:\$name -Force
    }
    
    ## Set the new variable, along with its getter and setter.
    $executioncontext.SessionState.PSVariable.Set(
        (New-Object Lee.Holmes.DynamicVariable $name,$getter,$setter))
}

function New-FilesystemHardLink
{
    ##############################################################################
    ##
    ## New-FileSystemHardLink
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Create a new hard link, which allows you to create a new name by which you
    can access an existing file. Windows only deletes the actual file once
    you delete all hard links that point to it.
    
    .EXAMPLE
    
    PS > "Hello" > test.txt
    PS > dir test* | select name
    
    Name
    ----
    test.txt
    
    PS > .\New-FilesystemHardLink.ps1 test.txt test2.txt
    PS > type test2.txt
    Hello
    PS > dir test* | select name
    
    Name
    ----
    test.txt
    test2.txt
    
    #>
    
    param(
        ## The existing file that you want the new name to point to
        [string] $Path,
    
        ## The new filename you want to create
        [string] $Destination
    )
    
    Set-StrictMode -Version 3
    
    ## Ensure that the provided names are absolute paths
    $filename = $executionContext.SessionState.`
        Path.GetUnresolvedProviderPathFromPSPath($destination)
    $existingFilename = Resolve-Path $path
    
    ## Prepare the parameter types and parameters for the CreateHardLink function
    $parameterTypes = [string], [string], [IntPtr]
    $parameters = [string] $filename, [string] $existingFilename, [IntPtr]::Zero
    
    ## Call the CreateHardLink method in the Kernel32 DLL
    $currentDirectory = Split-Path $myInvocation.MyCommand.Path
    $invokeWindowsApiCommand = Join-Path $currentDirectory Invoke-WindowsApi.ps1
    $result = & $invokeWindowsApiCommand "kernel32" `
        ([bool]) "CreateHardLink" $parameterTypes $parameters
    
    ## Provide an error message if the call fails
    if(-not $result)
    {
        $message = "Could not create hard link of $filename to " +
            "existing file $existingFilename"
        Write-Error $message
    }
}

function New-GenericObject
{
    ##############################################################################
    ##
    ## New-GenericObject
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Creates an object of a generic type. If using PowerShell version three,
    use this syntax:
    
    PS > $r = New-Object "System.Collections.Generic.Dictionary[String, Int32]"
    
    .EXAMPLE
    
    PS > New-GenericObject System.Collections.ObjectModel.Collection System.Int32
    Creates a simple generic collection
    
    .EXAMPLE
    
    PS > New-GenericObject System.Collections.Generic.Dictionary `
          System.String,System.Int32
    Creates a generic dictionary with two types
    
    .EXAMPLE
    
    PS > $secondType = New-GenericObject System.Collections.Generic.List Int32
    PS > New-GenericObject System.Collections.Generic.Dictionary `
          System.String,$secondType.GetType()
    Creates a generic list as the second type to a generic dictionary
    
    .EXAMPLE
    
    PS > New-GenericObject System.Collections.Generic.LinkedListNode `
          System.String "Hi"
    Creates a generic type with a non-default constructor
    
    #>
    
    param(
        ## The generic type to create
        [Parameter(Mandatory = $true)]
        [string] $TypeName,
    
        ## The types that should be applied to the generic object
        [Parameter(Mandatory = $true)]
        [string[]] $TypeParameters,
    
        ## Arguments to be passed to the constructor
        [object[]] $ConstructorParameters
    )
    
    Set-StrictMode -Version 2
    
    ## Create the generic type name
    $genericTypeName = $typeName + '`' + $typeParameters.Count
    $genericType = [Type] $genericTypeName
    
    if(-not $genericType)
    {
        throw "Could not find generic type $genericTypeName"
    }
    
    ## Bind the type arguments to it
    [type[]] $typedParameters = $typeParameters
    $closedType = $genericType.MakeGenericType($typedParameters)
    if(-not $closedType)
    {
        throw "Could not make closed type $genericType"
    }
    
    ## Create the closed version of the generic type
    ,[Activator]::CreateInstance($closedType, $constructorParameters)
}

function New-SelfSignedCertificate
{
    ##############################################################################
    ##
    ## New-SelfSignedCertificate
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Generate a new self-signed certificate. The certificate generated by these
    commands allow you to sign scripts on your own computer for protection
    from tampering. Files signed with this signature are not valid on other
    computers.
    
    .EXAMPLE
    
    PS > New-SelfSignedCertificate.ps1
    Creates a new self-signed certificate
    
    #>
    
    Set-StrictMode -Version 3
    
    ## Ensure we can find makecert.exe
    if(-not (Get-Command makecert.exe -ErrorAction SilentlyContinue))
    {
        $errorMessage = "Could not find makecert.exe. " +
            "This tool is available as part of Visual Studio, or the Windows SDK."
    
        Write-Error $errorMessage
        return
    }
    
    $keyPath = Join-Path ([IO.Path]::GetTempPath()) "root.pvk"
    
    ## Generate the local certification authority
    makecert -n "CN=PowerShell Local Certificate Root" -a sha1 `
        -eku 1.3.6.1.5.5.7.3.3 -r -sv $keyPath root.cer `
        -ss Root -sr localMachine
    
    ## Use the local certification authority to generate a self-signed
    ## certificate
    makecert -pe -n "CN=PowerShell User" -ss MY -a sha1 `
        -eku 1.3.6.1.5.5.7.3.3 -iv $keyPath -ic root.cer
    
    ## Remove the private key from the filesystem.
    Remove-Item $keyPath
    
    ## Retrieve the certificate
    Get-ChildItem cert:\currentuser\my -codesign |
        Where-Object { $_.Subject -match "PowerShell User" }
}

function New-ZipFile
{
    ##############################################################################
    ##
    ## New-ZipFile
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Create a Zip file from any files piped in.
    
    .EXAMPLE
    
    PS > dir *.ps1 | New-ZipFile scripts.zip
    Copies all PS1 files in the current directory to scripts.zip
    
    .EXAMPLE
    
    PS > "readme.txt" | New-ZipFile docs.zip
    Copies readme.txt to docs.zip
    
    #>
    
    param(
        ## The name of the zip archive to create
        $Path = $(throw "Specify a zip file name"),
    
        ## Switch to delete the zip archive if it already exists.
        [Switch] $Force
    )
    
    Set-StrictMode -Version 3
    
    ## Create the Zip File
    $zipName = $executionContext.SessionState.`
        Path.GetUnresolvedProviderPathFromPSPath($Path)
    
    ## Check if the file exists already. If it does, check
    ## for -Force - generate an error if not specified.
    if(Test-Path $zipName)
    {
        if($Force)
        {
            Remove-Item $zipName -Force
        }
        else
        {
            throw "Item with specified name $zipName already exists."
        }
    }
    
    ## Add the DLL that helps with file compression
    Add-Type -Assembly System.IO.Compression.FileSystem
    
    try
    {
        ## Open the Zip archive
        $archive = [System.IO.Compression.ZipFile]::Open($zipName, "Create")
    
        ## Go through each file in the input, adding it to the Zip file
        ## specified
        foreach($file in $input)
        {
            ## Skip the current file if it is the zip file itself
            if($file.FullName -eq $zipName)
            {
                continue
            }
    
            ## Skip directories
            if($file.PSIsContainer)
            {
                continue
            }
    
            $item = $file | Get-Item
            $null = [System.IO.Compression.ZipFileExtensions]::CreateEntryFromFile(
                $archive, $item.FullName, $item.Name)
        }
    }
    finally
    {
        ## Close the file
        $archive.Dispose()
        $archive = $null
    }
}

function Read-HostWithPrompt
{
    #############################################################################
    ##
    ## Read-HostWithPrompt
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Read user input, with choices restricted to the list of options you
    provide.
    
    .EXAMPLE
    
    PS > $caption = "Please specify a task"
    PS > $message = "Specify a task to run"
    PS > $option = "&Clean Temporary Files","&Defragment Hard Drive"
    PS > $helptext = "Clean the temporary files from the computer",
    >>              "Run the defragment task"
    >>
    PS > $default = 1
    PS > Read-HostWithPrompt $caption $message $option $helptext $default
    
    Please specify a task
    Specify a task to run
    [C] Clean Temporary Files  [D] Defragment Hard Drive  [?] Help
    (default is "D"):?
    C - Clean the temporary files from the computer
    D - Run the defragment task
    [C] Clean Temporary Files  [D] Defragment Hard Drive  [?] Help
    (default is "D"):C
    0
    
    #>
    
    param(
        ## The caption for the prompt
        $Caption = $null,
    
        ## The message to display in the prompt
        $Message = $null,
    
        ## Options to provide in the prompt
        [Parameter(Mandatory = $true)]
        $Option,
    
        ## Any help text to provide
        $HelpText = $null,
    
        ## The default choice
        $Default = 0
    )
    
    Set-StrictMode -Version 3
    
    ## Create the list of choices
    $choices = New-Object `
        Collections.ObjectModel.Collection[Management.Automation.Host.ChoiceDescription]
    
    ## Go through each of the options, and add them to the choice collection
    for($counter = 0; $counter -lt $option.Length; $counter++)
    {
        $choice = New-Object Management.Automation.Host.ChoiceDescription `
            $option[$counter]
    
        if($helpText -and $helpText[$counter])
        {
            $choice.HelpMessage = $helpText[$counter]
        }
    
        $choices.Add($choice)
    }
    
    ## Prompt for the choice, returning the item the user selected
    $host.UI.PromptForChoice($caption, $message, $choices, $default)
}

function Read-InputBox
{
    ##############################################################################
    ##
    ## Read-InputBox
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Read user input from a visual InputBox
    
    .EXAMPLE
    
    PS > $caption = "Please enter your name"
    PS > $name = Read-InputBox $caption
    
    #>
    
    param(
        ## The title of the dialog when displayed
        [string] $Title = "Input Dialog"
    )
    
    Set-StrictMode -Version 3
    
    ## Load the Windows Forms assembly
    Add-Type -Assembly System.Windows.Forms
    
    ## Create the main form
    $form = New-Object Windows.Forms.Form
    $form.Size = New-Object Drawing.Size @(400,100)
    $form.FormBorderStyle = "FixedToolWindow"
    
    ## Create the listbox to hold the items from the pipeline
    $textbox = New-Object Windows.Forms.TextBox
    $textbox.Top = 5
    $textbox.Left = 5
    $textBox.Width = 380
    $textbox.Anchor = "Left","Right"
    $form.Text = $Title
    
    ## Create the button panel to hold the OK and Cancel buttons
    $buttonPanel = New-Object Windows.Forms.Panel
    $buttonPanel.Size = New-Object Drawing.Size @(400,40)
    $buttonPanel.Dock = "Bottom"
    
    ## Create the Cancel button, which will anchor to the bottom right
    $cancelButton = New-Object Windows.Forms.Button
    $cancelButton.Text = "Cancel"
    $cancelButton.DialogResult = "Cancel"
    $cancelButton.Top = $buttonPanel.Height - $cancelButton.Height - 10
    $cancelButton.Left = $buttonPanel.Width - $cancelButton.Width - 10
    $cancelButton.Anchor = "Right"
    
    ## Create the OK button, which will anchor to the left of Cancel
    $okButton = New-Object Windows.Forms.Button
    $okButton.Text = "Ok"
    $okButton.DialogResult = "Ok"
    $okButton.Top = $cancelButton.Top
    $okButton.Left = $cancelButton.Left - $okButton.Width - 5
    $okButton.Anchor = "Right"
    
    ## Add the buttons to the button panel
    $buttonPanel.Controls.Add($okButton)
    $buttonPanel.Controls.Add($cancelButton)
    
    ## Add the button panel and list box to the form, and also set
    ## the actions for the buttons
    $form.Controls.Add($buttonPanel)
    $form.Controls.Add($textbox)
    $form.AcceptButton = $okButton
    $form.CancelButton = $cancelButton
    $form.Add_Shown( { $form.Activate(); $textbox.Focus() } )
    
    ## Show the form, and wait for the response
    $result = $form.ShowDialog()
    
    ## If they pressed OK (or Enter,) go through all the
    ## checked items and send the corresponding object down the pipeline
    if($result -eq "OK")
    {
        $textbox.Text
    }
}

function Register-TemporaryEvent
{
    ##############################################################################
    ##
    ## Register-TemporaryEvent
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Registers an event action for an object, and automatically unregisters
    itself afterward. In PowerShell version three, use the -MaxTriggerCount
    parameter of the Register-*Event cmdlets.
    
    .EXAMPLE
    
    PS > $timer = New-Object Timers.Timer
    PS > Register-TemporaryEvent $timer Disposed { [Console]::Beep(100,100) }
    PS > $timer.Dispose()
    PS > Get-EventSubscriber
    PS > Get-Job
    
    #>
    
    param(
        ## The object that generates the event
        $Object,
    
        ## The event to subscribe to
        $Event,
    
        ## The action to invoke when the event arrives
        [ScriptBlock] $Action
    )
    
    Set-StrictMode -Version 2
    
    $actionText = $action.ToString()
    $actionText += @'
    
    $eventSubscriber | Unregister-Event
    $eventSubscriber.Action | Remove-Job
'@
    
    $eventAction = [ScriptBlock]::Create($actionText)
    $null = Register-ObjectEvent $object $event -Action $eventAction
}

function Resolve-Error
{
    #############################################################################
    ##
    ## Resolve-Error
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Displays detailed information about an error and its context.
    
    #>
    
    param(
        ## The error to resolve
        $ErrorRecord = ($error[0])
    )
    
    Set-StrictMode -Off
    
    ""
    "If this is an error in a script you wrote, use the Set-PsBreakpoint cmdlet"
    "to diagnose it."
    ""
    
    'Error details ($error[0] | Format-List * -Force)'
    "-"*80
    $errorRecord | Format-List * -Force
    
    'Information about the command that caused this error ' +
        '($error[0].InvocationInfo | Format-List *)'
    "-"*80
    $errorRecord.InvocationInfo | Format-List *
    
    'Information about the error''s target ' +
        '($error[0].TargetObject | Format-List *)'
    "-"*80
    $errorRecord.TargetObject | Format-List *
    
    'Exception details ($error[0].Exception | Format-List * -Force)'
    "-"*80
    
    $exception = $errorRecord.Exception
    
    for ($i = 0; $exception; $i++, ($exception = $exception.InnerException))
    {
        "$i" * 80
        $exception | Format-List * -Force
    }
}

function Search-Bing
{
    ##############################################################################
    ##
    ## Search-Bing
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Search Bing for a given term
    
    .EXAMPLE
    
    PS > Search-Bing PowerShell
    Searches Bing for the term "PowerShell"
    
    #>
    
    param(
        ## The term to search for
        $Pattern = "PowerShell"
    )
    
    Set-StrictMode -Version 3
    
    ## Create the URL that contains the Twitter search results
    Add-Type -Assembly System.Web
    $queryUrl = 'http://www.bing.com/search?q={0}'
    $queryUrl = $queryUrl -f ([System.Web.HttpUtility]::UrlEncode($pattern))
    
    ## Download the web page
    $results = [string] (Invoke-WebRequest $queryUrl)
    
    ## Extract the text of the results, which are contained in
    ## segments that look like "<div class="sb_tlst">...</div>"
    $matches = $results |
        Select-String -Pattern '(?s)<div[^>]*sb_tlst[^>]*>.*?</div>' -AllMatches
    
    foreach($match in $matches.Matches)
    {
        ## Extract the URL, keeping only the text inside the quotes
        ## of the HREF
        $url = $match.Value -replace '.*href="(.*?)".*','$1'
        $url = [System.Web.HttpUtility]::UrlDecode($url)
    
        ## Extract the page name,  replace anything in angle
        ## brackets with an empty string.
        $item = $match.Value -replace '<[^>]*>', ''
    
        ## Output the item
        [PSCustomObject] @{ Item = $item; Url = $url }
    }
}

function Search-CertificateStore
{
    ##############################################################################
    ##
    ## Search-CertificateStore
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Search the certificate provider for certificates that match the specified
    Enhanced Key Usage (EKU.)
    
    .EXAMPLE
    
    PS > Search-CertificateStore "Encrypting File System"
    Searches the certificate store for Encrypting File System certificates
    
    #>
    
    param(
        ## The friendly name of an Enhanced Key Usage
        ## (such as 'Code Signing')
        [Parameter(Mandatory = $true)]
        $EkuName
    )
    
    Set-StrictMode -Off
    
    ## Go through every certificate in the current user's "My" store
    foreach($cert in Get-ChildItem cert:\CurrentUser\My)
    {
        ## For each of those, go through its extensions
        foreach($extension in $cert.Extensions)
        {
            ## For each extension, go through its Enhanced Key Usages
            foreach($certEku in $extension.EnhancedKeyUsages)
            {
                ## If the friendly name matches, output that certificate
                if($certEku.FriendlyName -eq $ekuName)
                {
                    $cert
                }
            }
        }
    }
}

function Search-Help
{
    ##############################################################################
    ##
    ## Search-Help
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Search the PowerShell help documentation for a given keyword or regular
    expression. For simple keyword searches in PowerShell version two or three,
    simply use "Get-Help <keyword>"
    
    .EXAMPLE
    
    PS > Search-Help hashtable
    Searches help for the term 'hashtable'
    
    .EXAMPLE
    
    PS > Search-Help "(datetime|ticks)"
    Searches help for the term datetime or ticks, using the regular expression
    syntax.
    
    #>
    
    param(
        ## The pattern to search for
        [Parameter(Mandatory = $true)]
        $Pattern
    )
    
    $helpNames = $(Get-Help * | Where-Object { $_.Category -ne "Alias" })
    
    ## Go through all of the help topics
    foreach($helpTopic in $helpNames)
    {
        ## Get their text content, and
        $content = Get-Help -Full $helpTopic.Name | Out-String
        if($content -match "(.{0,30}$pattern.{0,30})")
        {
            $helpTopic | Add-Member NoteProperty Match $matches[0].Trim()
            $helpTopic | Select-Object Name,Match
        }
    }
}

function Search-Registry
{
    ##############################################################################
    ##
    ## Search-Registry
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Search the registry for keys or properties that match a specific value.
    
    .EXAMPLE
    
    PS > Set-Location HKCU:\Software\Microsoft\
    PS > Search-Registry Run
    
    #>
    
    param(
        ## The text to search for
        [Parameter(Mandatory = $true)]
        [string] $Pattern
    )
    
    Set-StrictMode -Off
    
    ## Helper function to create a new object that represents
    ## a registry match from this script
    function New-RegistryMatch
    {
        param( $matchType, $keyName, $propertyName, $line )
    
        $registryMatch = New-Object PsObject -Property @{
            MatchType = $matchType;
            KeyName = $keyName;
            PropertyName = $propertyName;
            Line = $line
        }
    
        $registryMatch
    }
    
    ## Go through each item in the registry
    foreach($item in Get-ChildItem -Recurse -ErrorAction SilentlyContinue)
    {
        ## Check if the key name matches
        if($item.Name -match $pattern)
        {
            New-RegistryMatch "Key" $item.Name $null $item.Name
        }
    
        ## Check if a key property matches
        foreach($property in (Get-ItemProperty $item.PsPath).PsObject.Properties)
        {
            ## Skip the property if it was one PowerShell added
            if(($property.Name -eq "PSPath") -or
                ($property.Name -eq "PSChildName"))
            {
                continue
            }
    
            ## Search the text of the property
            $propertyText = "$($property.Name)=$($property.Value)"
            if($propertyText -match $pattern)
            {
                New-RegistryMatch "Property" $item.Name `
                    property.Name $propertyText
            }
        }
    }
}

function Search-StackOverflow
{
    ##############################################################################
    ##
    ## Search-StackOverflow
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Searches Stack Overflow for PowerShell questions that relate to your
    search term, and provides the link to the accepted answer.
    
    
    .EXAMPLE
    
    PS > Search-StackOverflow upload ftp
    Searches StackOverflow for questions about how to upload FTP files
    
    .EXAMPLE
    
    PS > $answers = Search-StackOverflow.ps1 upload ftp
    PS > $answers | Out-GridView -PassThru | Foreach-Object { start $_ }
    
    Launches Out-GridView with the answers from a search. Select the URLs
    that you want to launch, and then press OK. PowerShell then launches
    your default web brower for those URLs.
    
    #>
    
    Set-StrictMode -Off
    Add-Type -Assembly System.Web
    
    $query = ($args | Foreach-Object { '"' + $_ + '"' }) -join " "
    $query = [System.Web.HttpUtility]::UrlEncode($query)
    
    ## Use the StackOverflow API to retrieve the answer for a question
    $url = "https://api.stackexchange.com/2.0/search?order=desc&sort=relevance" +
        "&pagesize=5&tagged=powershell&intitle=$query&site=stackoverflow"
    $question = Invoke-RestMethod $url
    
    ## Now go through and show the questions and answers
    $question.Items | Where accepted_answer_id | Foreach-Object {
            "Question: " + $_.Title
            "http://www.stackoverflow.com/questions/$($_.accepted_answer_id)"
            ""
    }
}

function Search-StartMenu
{
    ##############################################################################
    ##
    ## Search-StartMenu
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/blog)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Search the Start Menu for items that match the provided text. This script
    searches both the name (as displayed on the Start Menu itself,) and the
    destination of the link.
    
    .EXAMPLE
    
    PS > Search-StartMenu "Character Map" | Invoke-Item
    Searches for the "Character Map" appication, and then runs it
    
    PS > Search-StartMenu PowerShell | Select-FilteredObject | Invoke-Item
    Searches for anything with "PowerShell" in the application name, lets you
    pick which one to launch, and then launches it.
    
    #>
    
    param(
        ## The pattern to match
        [Parameter(Mandatory = $true)]
        $Pattern
    )
    
    Set-StrictMode -Version 3
    
    ## Get the locations of the start menu paths
    $myStartMenu = [Environment]::GetFolderPath("StartMenu")
    $shell = New-Object -Com WScript.Shell
    $allStartMenu = $shell.SpecialFolders.Item("AllUsersStartMenu")
    
    ## Escape their search term, so that any regular expression
    ## characters don't affect the search
    $escapedMatch = [Regex]::Escape($pattern)
    
    ## Search in "my start menu" for text in the link name or link destination
    dir $myStartMenu *.lnk -rec | Where-Object {
        ($_.Name -match "$escapedMatch") -or
        ($_ | Select-String "\\[^\\]*$escapedMatch\." -Quiet)
    }
    
    ## Search in "all start menu" for text in the link name or link destination
    dir $allStartMenu *.lnk -rec | Where-Object {
        ($_.Name -match "$escapedMatch") -or
        ($_ | Select-String "\\[^\\]*$escapedMatch\." -Quiet)
    }
}

function Search-WmiNamespace
{
    ##############################################################################
    ##
    ## Search-WmiNamespace
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Search the WMI classes installed on the system for the provided match text.
    
    .EXAMPLE
    
    PS > Search-WmiNamespace Registry
    Searches WMI for any classes or descriptions that mention "Registry"
    
    .EXAMPLE
    
    Search-WmiNamespace Process ClassName,PropertyName
    Searchs WMI for any classes or properties that mention "Process"
    
    .EXAMPLE
    
    Search-WmiNamespace CPU -Detailed
    Searches WMI for any class names, descriptions, or properties that mention
    "CPU"
    
    #>
    
    param(
        ## The pattern to search for
        [Parameter(Mandatory = $true)]
        [string] $Pattern,
    
        ## Switch parameter to look for class names, descriptions, or properties
        [switch] $Detailed,
    
        ## Switch parameter to look for class names, descriptions, properties, and
        ## property description.
        [switch] $Full,
    
        ## Custom match options.
        ## Supports any or all of the following match options:
        ## ClassName, ClassDescription, PropertyName, PropertyDescription
        [string[]] $MatchOptions = ("ClassName","ClassDescription")
    )
    
    Set-StrictMode -Off
    
    ## Helper function to create a new object that represents
    ## a Wmi match from this script
    function New-WmiMatch
    {
        param( $matchType, $className, $propertyName, $line )
    
        $wmiMatch = New-Object PsObject -Property @{
            MatchType = $matchType;
            ClassName = $className;
            PropertyName = $propertyName;
            Line = $line
        }
    
        $wmiMatch
    }
    
    ## If they've specified the -detailed or -full options, update
    ## the match options to provide them an appropriate amount of detail
    if($detailed)
    {
        $matchOptions = "ClassName","ClassDescription","PropertyName"
    }
    
    if($full)
    {
        $matchOptions =
            "ClassName","ClassDescription","PropertyName","PropertyDescription"
    }
    
    ## Verify that they specified only valid match options
    foreach($matchOption in $matchOptions)
    {
        $fullMatchOptions =
            "ClassName","ClassDescription","PropertyName","PropertyDescription"
    
        if($fullMatchOptions -notcontains $matchOption)
        {
            $error = "Cannot convert value {0} to a match option. " +
                "Specify one of the following values and try again. " +
                "The possible values are ""{1}""."
            $ofs = ", "
            throw ($error -f $matchOption, ([string] $fullMatchOptions))
        }
    }
    
    ## Go through all of the available classes on the computer
    foreach($class in Get-WmiObject -List -Rec)
    {
        ## Provide explicit get options, so that we get back descriptios
        ## as well
        $managementOptions = New-Object System.Management.ObjectGetOptions
        $managementOptions.UseAmendedQualifiers = $true
        $managementClass =
            New-Object Management.ManagementClass $class.Name,$managementOptions
    
        ## If they want us to match on class names, check if their text
        ## matches the class name
        if($matchOptions -contains "ClassName")
        {
            if($managementClass.Name -match $pattern)
            {
                New-WmiMatch "ClassName" `
                    $managementClass.Name $null $managementClass.__PATH
            }
        }
    
        ## If they want us to match on class descriptions, check if their text
        ## matches the class description
        if($matchOptions -contains "ClassDescription")
        {
            $description =
                $managementClass.Qualifiers |
                    foreach { if($_.Name -eq "Description") { $_.Value } }
            if($description -match $pattern)
            {
                New-WmiMatch "ClassDescription" `
                    $managementClass.Name $null $description
            }
        }
    
        ## Go through the properties of the class
        foreach($property in $managementClass.Properties)
        {
            ## If they want us to match on property names, check if their text
            ## matches the property name
            if($matchOptions -contains "PropertyName")
            {
                if($property.Name -match $pattern)
                {
                    New-WmiMatch "PropertyName" `
                        $managementClass.Name $property.Name $property.Name
                }
            }
    
            ## If they want us to match on property descriptions, check if
            ## their text matches the property name
            if($matchOptions -contains "PropertyDescription")
            {
                $propertyDescription =
                    $property.Qualifiers |
                        foreach { if($_.Name -eq "Description") { $_.Value } }
                if($propertyDescription -match $pattern)
                {
                    New-WmiMatch "PropertyDescription" `
                        $managementClass.Name $property.Name $propertyDescription
                }
            }
        }
    }
}

function Select-FilteredObject
{
    ##############################################################################
    ##
    ## Select-FilteredObject
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Provides an inteactive window to help you select complex sets of objects.
    To do this, it takes all the input from the pipeline, and presents it in a
    notepad window.  Keep any lines that represent objects you want to retain,
    delete the rest, then save the file and exit notepad.
    
    The script then passes the original objects that you kept along the
    pipeline.
    
    .EXAMPLE
    
    PS > Get-Process | Select-FilteredObject | Stop-Process -WhatIf
    Gets all of the processes running on the system, and displays them to you.
    After you've selected the ones you want to stop, it pipes those into the
    Stop-Process cmdlet.
    
    #>
    
    ## PowerShell runs your "begin" script block before it passes you any of the
    ## items in the pipeline.
    begin
    {
        Set-StrictMode -Version 3
    
        ## Create a temporary file
        $filename = [System.IO.Path]::GetTempFileName()
    
        ## Define a header in a "here-string" that explains how to interact with
        ## the file
        $header = @"
    ############################################################
    ## Keep any lines that represent obects you want to retain,
    ## and delete the rest.
    ##
    ## Once you finish selecting objects, save this file and
    ## exit.
    ############################################################
    
"@
    
        ## Place the instructions into the file
        $header > $filename
    
        ## Initialize the variables that will hold our list of objects, and
        ## a counter to help us keep track of the objects coming down the
        ## pipeline
        $objectList = @()
        $counter = 0
    }
    
    ## PowerShell runs your "process" script block for each item it passes down
    ## the pipeline. In this block, the "$_" variable represents the current
    ## pipeline object
    process
    {
        ## Add a line to the file, using PowerShell's format (-f) operator.
        ## When provided the ouput of Get-Process, for example, these lines look
        ## like:
        ## 30: System.Diagnostics.Process (powershell)
        "{0}: {1}" -f $counter,$_.ToString() >> $filename
    
        ## Add the object to the list of objects, and increment our counter.
        $objectList += $_
        $counter++
    }
    
    ## PowerShell runs your "end" script block once it completes passing all
    ## objects down the pipeline.
    end
    {
        ## Start notepad, then call the process's WaitForExit() method to
        ## pause the script until the user exits notepad.
        $process = Start-Process Notepad -Args $filename -PassThru
        $process.WaitForExit()
    
        ## Go over each line of the file
        foreach($line in (Get-Content $filename))
        {
            ## Check if the line is of the special format: numbers, followed by
            ## a colon, followed by extra text.
            if($line -match "^(\d+?):.*")
            {
                ## If it did match the format, then $matches[1] represents the
                ## number -- a counter into the list of objects we saved during
                ## the "process" section.
                ## So, we output that object from our list of saved objects.
                $objectList[$matches[1]]
            }
        }
    
        ## Finally, clean up the temporary file.
        Remove-Item $filename
    }
}

function Select-GraphicalFilteredObject
{
    ##############################################################################
    ##
    ## Select-GraphicalFilteredObject
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Display a Windows Form to help the user select a list of items piped in.
    Any selected items get passed along the pipeline.
    
    .EXAMPLE
    
    PS > dir | Select-GraphicalFilteredObject
    
      Directory: C:\
    
    Mode                LastWriteTime     Length Name
    ----                -------------     ------ ----
    d----         10/7/2006   4:30 PM            Documents and Settings
    d----         3/18/2007   7:56 PM            Windows
    
    #>
    
    Set-StrictMode -Version 2
    
    $objectArray = @($input)
    
    ## Ensure that they've piped information into the script
    if($objectArray.Count -eq 0)
    {
        Write-Error "This script requires pipeline input."
        return
    }
    
    ## Load the Windows Forms assembly
    Add-Type -Assembly System.Windows.Forms
    
    ## Create the main form
    $form = New-Object Windows.Forms.Form
    $form.Size = New-Object Drawing.Size @(600,600)
    
    ## Create the listbox to hold the items from the pipeline
    $listbox = New-Object Windows.Forms.CheckedListBox
    $listbox.CheckOnClick = $true
    $listbox.Dock = "Fill"
    $form.Text = "Select the list of objects you wish to pass down the pipeline"
    $listBox.Items.AddRange($objectArray)
    
    ## Create the button panel to hold the OK and Cancel buttons
    $buttonPanel = New-Object Windows.Forms.Panel
    $buttonPanel.Size = New-Object Drawing.Size @(600,30)
    $buttonPanel.Dock = "Bottom"
    
    ## Create the Cancel button, which will anchor to the bottom right
    $cancelButton = New-Object Windows.Forms.Button
    $cancelButton.Text = "Cancel"
    $cancelButton.DialogResult = "Cancel"
    $cancelButton.Top = $buttonPanel.Height - $cancelButton.Height - 5
    $cancelButton.Left = $buttonPanel.Width - $cancelButton.Width - 10
    $cancelButton.Anchor = "Right"
    
    ## Create the OK button, which will anchor to the left of Cancel
    $okButton = New-Object Windows.Forms.Button
    $okButton.Text = "Ok"
    $okButton.DialogResult = "Ok"
    $okButton.Top = $cancelButton.Top
    $okButton.Left = $cancelButton.Left - $okButton.Width - 5
    $okButton.Anchor = "Right"
    
    ## Add the buttons to the button panel
    $buttonPanel.Controls.Add($okButton)
    $buttonPanel.Controls.Add($cancelButton)
    
    ## Add the button panel and list box to the form, and also set
    ## the actions for the buttons
    $form.Controls.Add($listBox)
    $form.Controls.Add($buttonPanel)
    $form.AcceptButton = $okButton
    $form.CancelButton = $cancelButton
    $form.Add_Shown( { $form.Activate() } )
    
    ## Show the form, and wait for the response
    $result = $form.ShowDialog()
    
    ## If they pressed OK (or Enter,) go through all the
    ## checked items and send the corresponding object down the pipeline
    if($result -eq "OK")
    {
        foreach($index in $listBox.CheckedIndices)
        {
            $objectArray[$index]
        }
    }
}

function Select-TextOutput
{
    ##############################################################################
    ##
    ## Select-TextOutput
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Searches the textual output of a command for a pattern.
    
    .EXAMPLE
    
    PS > Get-Service | Select-TextOutput audio
    Finds all references to "Audio" in the output of Get-Service
    
    #>
    
    param(
        ## The pattern to search for
        $Pattern
    )
    
    Set-StrictMode -Version 3
    $input | Out-String -Stream | Select-String $pattern
}

function Send-File
{
    ##############################################################################
    ##
    ## Send-File
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Sends a file to a remote session.
    
    .EXAMPLE
    
    PS > $session = New-PsSession leeholmes1c23
    PS > Send-File c:\temp\test.exe c:\temp\test.exe $session
    
    #>
    
    param(
        ## The path on the local computer
        [Parameter(Mandatory = $true)]
        $Source,
    
        ## The target path on the remote computer
        [Parameter(Mandatory = $true)]
        $Destination,
    
        ## The session that represents the remote computer
        [Parameter(Mandatory = $true)]
        [System.Management.Automation.Runspaces.PSSession] $Session
    )
    
    Set-StrictMode -Version 3
    
    $remoteScript = {
        param($destination, $bytes)
    
        ## Convert the destination path to a full filesystem path (to support
        ## relative paths)
        $Destination = $executionContext.SessionState.`
            Path.GetUnresolvedProviderPathFromPSPath($Destination)
    
        ## Write the content to the new file
        $file = [IO.File]::Open($Destination, "OpenOrCreate")
        $null = $file.Seek(0, "End")
        $null = $file.Write($bytes, 0, $bytes.Length)
        $file.Close()
    }
    
    ## Get the source file, and then start reading its content
    $sourceFile = Get-Item $source
    
    ## Delete the previously-existing file if it exists
    Invoke-Command -Session $session {
        if(Test-Path $args[0]) { Remove-Item $args[0] }
    } -ArgumentList $Destination
    
    ## Now break it into chunks to stream
    Write-Progress -Activity "Sending $Source" -Status "Preparing file"
    
    $streamSize = 1MB
    $position = 0
    $rawBytes = New-Object byte[] $streamSize
    $file = [IO.File]::OpenRead($sourceFile.FullName)
    
    while(($read = $file.Read($rawBytes, 0, $streamSize)) -gt 0)
    {
        Write-Progress -Activity "Writing $Destination" `
            -Status "Sending file" `
            -PercentComplete ($position / $sourceFile.Length * 100)
    
        ## Ensure that our array is the same size as what we read
        ## from disk
        if($read -ne $rawBytes.Length)
        {
            [Array]::Resize( [ref] $rawBytes, $read)
        }
    
        ## And send that array to the remote system
        Invoke-Command -Session $session $remoteScript `
            -ArgumentList $destination,$rawBytes
    
        ## Ensure that our array is the same size as what we read
        ## from disk
        if($rawBytes.Length -ne $streamSize)
        {
            [Array]::Resize( [ref] $rawBytes, $streamSize)
        }
        
        [GC]::Collect()
        $position += $read
    }
    
    $file.Close()
    
    ## Show the result
    Invoke-Command -Session $session { Get-Item $args[0] } -ArgumentList $Destination
}

function Send-MailMessage
{
    ##############################################################################
    ##
    ## Send-MailMessage
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ## Illustrate the techniques used to send an email in PowerShell.
    ## In PowerShell version two, use the Send-MailMessage cmdlet.
    ##
    ## Example:
    ##
    ## PS > $body = @"
    ## >> Hi from another satisfied customer of The PowerShell Cookbook!
## >> "@
    ## >>
    ## PS > $to = "guide_feedback@leeholmes.com"
    ## PS > $subject = "Thanks for all of the scripts."
    ## PS > $mailHost = "mail.leeholmes.com"
    ## PS > Send-MailMessage $to $subject $body $mailHost
    ##
    ##############################################################################
    
    param(
        ## The recipient of the mail message
        [string[]] $To = $(throw "Please specify the destination mail address"),
    
        ## The subjecty of the message
        [string] $Subject = "<No Subject>",
    
        ## The body of the message
        [string] $Body = $(throw "Please specify the message content"),
    
        ## The SMTP host that will transmit the message
        [string] $SmtpHost = $(throw "Please specify a mail server."),
    
        ## The sender of the message
        [string] $From = "$($env:UserName)@example.com",
    
        ## Any credentials to supply
        $Credential,
    
        ## Determine whether an SSL connection should be used
        [Switch] $UseSSL
    )
    
    ## Create the mail message
    $email = New-Object System.Net.Mail.MailMessage
    
    ## Populate its fields
    foreach($mailTo in $to)
    {
        $email.To.Add($mailTo)
    }
    
    $email.From = $from
    $email.Subject = $subject
    $email.Body = $body
    
    ## Send the mail
    $client = New-Object System.Net.Mail.SmtpClient $smtpHost
    
    if(-not $Credential)
    {
        $client.UseDefaultCredentials = $true
    }
    else
    {
        $actualCred = Get-Credential $Credential
        $networkCred = New-Object System.Net.NetworkCredential
        $networkCred.Username = $actualCred.Username
    
        $bstr = [System.Runtime.InteropServices.Marshal]::SecureStringToBSTR($actualCred.Password)
        $password = [System.Runtime.InteropServices.Marshal]::PtrToStringAuto($bstr)
        [System.Runtime.InteropServices.Marshal]::ZeroFreeBstr($bstr)
    
        $networkCred.Password = $password
        $client.Credentials = $networkCred
    }
    
    if($UseSSL)
    {
        $client.EnableSSL = $true
    }
    
    $client.Send($email)
}

function Send-TcpRequest
{
    ##############################################################################
    ##
    ## Send-TcpRequest
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Send a TCP request to a remote computer, and return the response.
    If you do not supply input to this script (via either the pipeline, or the
    -InputObject parameter,) the script operates in interactive mode.
    
    .EXAMPLE
    
    PS > $http = @"
      GET / HTTP/1.1
      Host:bing.com
      `n`n
"@
    
    $http | Send-TcpRequest bing.com 80
    
    #>
    
    param(
        ## The computer to connect to
        [string] $ComputerName = "localhost",
    
        ## A switch to determine if you just want to test the connection
        [switch] $Test,
    
        ## The port to use
        [int] $Port = 80,
    
        ## A switch to determine if the connection should be made using SSL
        [switch] $UseSSL,
    
        ## The input string to send to the remote host
        [string] $InputObject,
    
        ## The delay, in milliseconds, to wait between commands
        [int] $Delay = 100
    )
    
    Set-StrictMode -Version 3
    
    [string] $SCRIPT:output = ""
    
    ## Store the input into an array that we can scan over. If there was no input,
    ## then we will be in interactive mode.
    $currentInput = $inputObject
    if(-not $currentInput)
    {
        $currentInput = @($input)
    }
    $scriptedMode = ([bool] $currentInput) -or $test
    
    function Main
    {
        ## Open the socket, and connect to the computer on the specified port
        if(-not $scriptedMode)
        {
            write-host "Connecting to $computerName on port $port"
        }
    
        try
        {
            $socket = New-Object Net.Sockets.TcpClient($computerName, $port)
        }
        catch
        {
            if($test) { $false }
            else { Write-Error "Could not connect to remote computer: $_" }
    
            return
        }
    
        ## If we're just testing the connection, we've made the connection
        ## successfully, so just return $true
        if($test) { $true; return }
    
        ## If this is interactive mode, supply the prompt
        if(-not $scriptedMode)
        {
            write-host "Connected.  Press ^D followed by [ENTER] to exit.`n"
        }
    
        $stream = $socket.GetStream()
    
        ## If we wanted to use SSL, set up that portion of the connection
        if($UseSSL)
        {
            $sslStream = New-Object System.Net.Security.SslStream $stream,$false
            $sslStream.AuthenticateAsClient($computerName)
            $stream = $sslStream
        }
    
        $writer = new-object System.IO.StreamWriter $stream
    
        while($true)
        {
            ## Receive the output that has buffered so far
            $SCRIPT:output += GetOutput
    
            ## If we're in scripted mode, send the commands,
            ## receive the output, and exit.
            if($scriptedMode)
            {
                foreach($line in $currentInput)
                {
                    $writer.WriteLine($line)
                    $writer.Flush()
                    Start-Sleep -m $Delay
                    $SCRIPT:output += GetOutput
                }
    
                break
            }
            ## If we're in interactive mode, write the buffered
            ## output, and respond to input.
            else
            {
                if($output)
                {
                    foreach($line in $output.Split("`n"))
                    {
                        write-host $line
                    }
                    $SCRIPT:output = ""
                }
    
                ## Read the user's command, quitting if they hit ^D
                $command = read-host
                if($command -eq ([char] 4)) { break; }
    
                ## Otherwise, Write their command to the remote host
                $writer.WriteLine($command)
                $writer.Flush()
            }
        }
    
        ## Close the streams
        $writer.Close()
        $stream.Close()
    
        ## If we're in scripted mode, return the output
        if($scriptedMode)
        {
            $output
        }
    }
    
    ## Read output from a remote host
    function GetOutput
    {
        ## Create a buffer to receive the response
        $buffer = new-object System.Byte[] 1024
        $encoding = new-object System.Text.AsciiEncoding
    
        $outputBuffer = ""
        $foundMore = $false
    
        ## Read all the data available from the stream, writing it to the
        ## output buffer when done.
        do
        {
            ## Allow data to buffer for a bit
            start-sleep -m 1000
    
            ## Read what data is available
            $foundmore = $false
            $stream.ReadTimeout = 1000
    
            do
            {
                try
                {
                    $read = $stream.Read($buffer, 0, 1024)
    
                    if($read -gt 0)
                    {
                        $foundmore = $true
                        $outputBuffer += ($encoding.GetString($buffer, 0, $read))
                    }
                } catch { $foundMore = $false; $read = 0 }
            } while($read -gt 0)
        } while($foundmore)
    
        $outputBuffer
    }
    
    . Main
}

function Set-Clipboard
{
    #############################################################################
    ##
    ## Set-Clipboard
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Sends the given input to the Windows clipboard.
    
    .EXAMPLE
    
    PS > dir | Set-Clipboard
    This example sends the view of a directory listing to the clipboard
    
    .EXAMPLE
    
    PS > Set-Clipboard "Hello World"
    This example sets the clipboard to the string, "Hello World".
    
    #>
    
    param(
        ## The input to send to the clipboard
        [Parameter(ValueFromPipeline = $true)]
        [object[]] $InputObject
    )
    
    begin
    {
        Set-StrictMode -Version 3
        $objectsToProcess = @()
    }
    
    process
    {
        ## Collect everything sent to the script either through
        ## pipeline input, or direct input.
        $objectsToProcess += $inputObject
    }
    
    end
    {
        ## Convert the input objects to text
        $clipText = ($objectsToProcess | Out-String -Stream) -join "`r`n"
    
        ## And finally set the clipboard text
        Add-Type -Assembly PresentationCore
        [Windows.Clipboard]::SetText($clipText)
    }
}

function Set-ConsoleProperties
{
    ##############################################################################
    ##
    ## Set-ConsoleProperties
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Configures PowerShell windows launched through Start | Run to have the same
    appearance as those launched through the Start Menu. On Windows 8, this is not
    required.
    
    #>
    
    Set-StrictMode -Version 3
    
    Push-Location
    Set-Location HKCU:\Console
    New-Item '.\%SystemRoot%_system32_WindowsPowerShell_v1.0_powershell.exe'
    Set-Location '.\%SystemRoot%_system32_WindowsPowerShell_v1.0_powershell.exe'
    
    New-ItemProperty . ColorTable00 -type DWORD -value 0x00562401
    New-ItemProperty . ColorTable07 -type DWORD -value 0x00f0edee
    New-ItemProperty . FaceName -type STRING -value "Lucida Console"
    New-ItemProperty . FontFamily -type DWORD -value 0x00000036
    New-ItemProperty . FontSize -type DWORD -value 0x000c0000
    New-ItemProperty . FontWeight -type DWORD -value 0x00000190
    New-ItemProperty . HistoryNoDup -type DWORD -value 0x00000000
    New-ItemProperty . QuickEdit -type DWORD -value 0x00000001
    New-ItemProperty . ScreenBufferSize -type DWORD -value 0x0bb80078
    New-ItemProperty . WindowSize -type DWORD -value 0x00320078
    Pop-Location
}

function Set-PsBreakPointLastError
{
    Set-StrictMode -Version 3
    
    $lastError = $error[0]
    Set-PsBreakpoint $lastError.InvocationInfo.ScriptName `
        $lastError.InvocationInfo.ScriptLineNumber
}

function Set-RemoteRegistryKeyProperty
{
    ##############################################################################
    ##
    ## Set-RemoteRegistryKeyProperty
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Set the value of a remote registry key property
    
    .EXAMPLE
    
    PS >$registryPath =
        "HKLM:\software\Microsoft\PowerShell\1\ShellIds\Microsoft.PowerShell"
    PS >Set-RemoteRegistryKeyProperty LEE-DESK $registryPath `
          "ExecutionPolicy" "RemoteSigned"
    
    #>
    
    param(
        ## The computer to connect to
        [Parameter(Mandatory = $true)]
        $ComputerName,
    
        ## The registry path to modify
        [Parameter(Mandatory = $true)]
        $Path,
    
        ## The property to modify
        [Parameter(Mandatory = $true)]
        $PropertyName,
    
        ## The value to set on the property
        [Parameter(Mandatory = $true)]
        $PropertyValue
    )
    
    Set-StrictMode -Version 3
    
    ## Validate and extract out the registry key
    if($path -match "^HKLM:\\(.*)")
    {
        $baseKey = [Microsoft.Win32.RegistryKey]::OpenRemoteBaseKey(
            "LocalMachine", $computername)
    }
    elseif($path -match "^HKCU:\\(.*)")
    {
        $baseKey = [Microsoft.Win32.RegistryKey]::OpenRemoteBaseKey(
            "CurrentUser", $computername)
    }
    else
    {
        Write-Error ("Please specify a fully-qualified registry path " +
            "(i.e.: HKLM:\Software) of the registry key to open.")
        return
    }
    
    ## Open the key and set its value
    $key = $baseKey.OpenSubKey($matches[1], $true)
    $key.SetValue($propertyName, $propertyValue)
    
    ## Close the key and base keys
    $key.Close()
    $baseKey.Close()
}

function Show-ColorizedContent
{
    ##############################################################################
    ##
    ## Show-ColorizedContent
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Displays syntax highlighting, line numbering, and range highlighting for
    PowerShell scripts.
    
    .EXAMPLE
    
    PS > Show-ColorizedContent Invoke-MyScript.ps1
    
    001 | function Write-Greeting
    002 | {
    003 |     param($greeting)
    004 |     Write-Host "$greeting World"
    005 | }
    006 |
    007 | Write-Greeting "Hello"
    
    .EXAMPLE
    
    PS > Show-ColorizedContent Invoke-MyScript.ps1 -highlightRange (1..3+7)
    
    001 > function Write-Greeting
    002 > {
    003 >     param($greeting)
    004 |     Write-Host "$greeting World"
    005 | }
    006 |
    007 > Write-Greeting "Hello"
    
    #>
    
    param(
        ## The path to colorize
        [Parameter(Mandatory = $true)]
        $Path,
    
        ## The range of lines to highlight
        $HighlightRange = @(),
    
        ## Switch to exclude line numbers
        [Switch] $ExcludeLineNumbers
    )
    
    Set-StrictMode -Version 3
    
    ## Colors to use for the different script tokens.
    ## To pick your own colors:
    ## [Enum]::GetValues($host.UI.RawUI.ForegroundColor.GetType()) |
    ##     Foreach-Object { Write-Host -Fore $_ "$_" }
    $replacementColours = @{
        'Attribute' = 'DarkCyan'
        'Command' = 'Blue'
        'CommandArgument' = 'Magenta'
        'CommandParameter' = 'DarkBlue'
        'Comment' = 'DarkGreen'
        'GroupEnd' = 'Black'
        'GroupStart' = 'Black'
        'Keyword' = 'DarkBlue'
        'LineContinuation' = 'Black'
        'LoopLabel' = 'DarkBlue'
        'Member' = 'Black'
        'NewLine' = 'Black'
        'Number' = 'Magenta'
        'Operator' = 'DarkGray'
        'Position' = 'Black'
        'StatementSeparator' = 'Black'
        'String' = 'DarkRed'
        'Type' = 'DarkCyan'
        'Unknown' = 'Black'
        'Variable' = 'Red'
    }
    
    $highlightColor = "Red"
    $highlightCharacter = ">"
    $highlightWidth = 6
    if($excludeLineNumbers) { $highlightWidth = 0 }
    
    ## Read the text of the file, and tokenize it
    $content = Get-Content $Path -Raw
    $parsed = [System.Management.Automation.PsParser]::Tokenize(
        $content, [ref] $null) | Sort StartLine,StartColumn
    
    ## Write a formatted line -- in the format of:
    ## <Line Number> <Separator Character> <Text>
    function WriteFormattedLine($formatString, [int] $line)
    {
        if($excludeLineNumbers) { return }
    
        ## By default, write the line number in gray, and use
        ## a simple pipe as the separator
        $hColor = "DarkGray"
        $separator = "|"
    
        ## If we need to highlight the line, use the highlight
        ## color and highlight separator as the separator
        if($highlightRange -contains $line)
        {
            $hColor = $highlightColor
            $separator = $highlightCharacter
        }
    
        ## Write the formatted line
        $text = $formatString -f $line,$separator
        Write-Host -NoNewLine -Fore $hColor -Back White $text
    }
    
    ## Complete the current line with filler cells
    function CompleteLine($column)
    {
        ## Figure how much space is remaining
        $lineRemaining = $host.UI.RawUI.WindowSize.Width -
            $column - $highlightWidth + 1
    
        ## If we have less than 0 remaining, we've wrapped onto the
        ## next line. Add another buffer width worth of filler
        if($lineRemaining -lt 0)
        {
            $lineRemaining += $host.UI.RawUI.WindowSize.Width
        }
    
        Write-Host -NoNewLine -Back White (" " * $lineRemaining)
    }
    
    
    ## Write the first line of context information (line number,
    ## highlight character.)
    Write-Host
    WriteFormattedLine "{0:D3} {1} " 1
    
    ## Now, go through each of the tokens in the input
    ## script
    $column = 1
    foreach($token in $parsed)
    {
        $color = "Gray"
    
        ## Determine the highlighting colour for that token by looking
        ## in the hashtable that maps token types to their color
        $color = $replacementColours[[string]$token.Type]
        if(-not $color) { $color = "Gray" }
    
        ## If it's a newline token, write the next line of context
        ## information
        if(($token.Type -eq "NewLine") -or ($token.Type -eq "LineContinuation"))
        {
            CompleteLine $column
            WriteFormattedLine "{0:D3} {1} " ($token.StartLine + 1)
            $column = 1
        }
        else
        {
            ## Do any indenting
            if($column -lt $token.StartColumn)
            {
                $text = " " * ($token.StartColumn - $column)
                Write-Host -Back White -NoNewLine $text
                $column = $token.StartColumn
            }
    
            ## See where the token ends
            $tokenEnd = $token.Start + $token.Length - 1
    
            ## Handle the line numbering for multi-line strings and comments
            if(
                (($token.Type -eq "String") -or
                ($token.Type -eq "Comment")) -and
                ($token.EndLine -gt $token.StartLine))
            {
                ## Store which line we've started at
                $lineCounter = $token.StartLine
    
                ## Split the content of this token into its lines
                ## We use the start and end of the tokens to determine
                ## the position of the content, but use the content
                ## itself (rather than the token values) for manipulation.
                $stringLines = $(
                    -join $content[$token.Start..$tokenEnd] -split "`n")
    
                ## Go through each of the lines in the content
                foreach($stringLine in $stringLines)
                {
                    $stringLine = $stringLine.Trim()
    
                    ## If we're on a new line, fill the right hand
                    ## side of the line with spaces, and write the header
                    ## for the new line.
                    if($lineCounter -gt $token.StartLine)
                    {
                        CompleteLine $column
                        WriteFormattedLine "{0:D3} {1} " $lineCounter
                        $column = 1
                    }
    
                    ## Now write the text of the current line
                    Write-Host -NoNewLine -Fore $color -Back White $stringLine
                    $column += $stringLine.Length
                    $lineCounter++
                }
            }
            ## Write out a regular token
            else
            {
                ## We use the start and end of the tokens to determine
                ## the position of the content, but use the content
                ## itself (rather than the token values) for manipulation.
                $text = (-join $content[$token.Start..$tokenEnd])
                Write-Host -NoNewLine -Fore $color -Back White $text
            }
    
            ## Update our position in the column
            $column = $token.EndColumn
        }
    }
    
    CompleteLine $column
    Write-Host
}

function Show-Object
{
    #############################################################################
    ##
    ## Show-Object
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Provides a graphical interface to let you explore and navigate an object.
    
    
    .EXAMPLE
    
    PS > $ps = { Get-Process -ID $pid }.Ast
    PS > Show-Object $ps
    
    #>
    
    param(
        ## The object to examine
        [Parameter(ValueFromPipeline = $true)]
        $InputObject
    )
    
    Set-StrictMode -Version 3
    
    Add-Type -Assembly System.Windows.Forms
    
    ## Figure out the variable name to use when displaying the
    ## object navigation syntax. To do this, we look through all
    ## of the variables for the one with the same object identifier.
    $rootVariableName = dir variable:\* -Exclude InputObject,Args |
        Where-Object {
            $_.Value -and
            ($_.Value.GetType() -eq $InputObject.GetType()) -and
            ($_.Value.GetHashCode() -eq $InputObject.GetHashCode())
    }
    
    ## If we got multiple, pick the first
    $rootVariableName = $rootVariableName| % Name | Select -First 1
    
    ## If we didn't find one, use a default name
    if(-not $rootVariableName)
    {
        $rootVariableName = "InputObject"
    }
    
    ## A function to add an object to the display tree
    function PopulateNode($node, $object)
    {
        ## If we've been asked to add a NULL object, just return
        if(-not $object) { return }
    
        ## If the object is a collection, then we need to add multiple
        ## children to the node
        if([System.Management.Automation.LanguagePrimitives]::GetEnumerator($object))
        {
            ## Some very rare collections don't support indexing (i.e.: $foo[0]).
            ## In this situation, PowerShell returns the parent object back when you
            ## try to access the [0] property.
            $isOnlyEnumerable = $object.GetHashCode() -eq $object[0].GetHashCode()
    
            ## Go through all the items
            $count = 0
            foreach($childObjectValue in $object)
            {
                ## Create the new node to add, with the node text of the item and
                ## value, along with its type
    	        $newChildNode = New-Object Windows.Forms.TreeNode
                $newChildNode.Text = "$($node.Name)[$count] = $childObjectValue"
                $newChildNode.ToolTipText = $childObjectValue.GetType()
                   
                ## Use the node name to keep track of the actual property name
                ## and syntax to access that property.
                ## If we can't use the index operator to access children, add
                ## a special tag that we'll handle specially when displaying
                ## the node names.
                if($isOnlyEnumerable)
                {
                    $newChildNode.Name = "@"
                }
    
                $newChildNode.Name += "[$count]"
    	        $null = $node.Nodes.Add($newChildNode)               
    
                ## If this node has children or properties, add a placeholder
                ## node underneath so that the node shows a '+' sign to be
                ## expanded.
                AddPlaceholderIfRequired $newChildNode $childObjectValue
    
                $count++
            }
        }
        else
        {
            ## If the item was not a collection, then go through its
            ## properties
            foreach($child in $object.PSObject.Properties)
            {
                ## Figure out the value of the property, along with
                ## its type.
    	        $childObject = $child.Value
                $childObjectType = $null
                if($childObject)
                {
                    $childObjectType = $childObject.GetType()
                }
    
                ## Create the new node to add, with the node text of the item and
                ## value, along with its type
    	        $childNode = New-Object Windows.Forms.TreeNode
                $childNode.Text = $child.Name + " = $childObject"
                $childNode.ToolTipText = $childObjectType
                if([System.Management.Automation.LanguagePrimitives]::GetEnumerator($childObject))
                {
                    $childNode.ToolTipText += "[]"
                }
                
                $childNode.Name = $child.Name
    	        $null = $node.Nodes.Add($childNode)
    
                ## If this node has children or properties, add a placeholder
                ## node underneath so that the node shows a '+' sign to be
                ## expanded.
                AddPlaceholderIfRequired $childNode $childObject
            }
        }
    }
    
    ## A function to add a placeholder if required to a node.
    ## If there are any properties or children for this object, make a temporary
    ## node with the text "..." so that the node shows a '+' sign to be
    ## expanded.
    function AddPlaceholderIfRequired($node, $object)
    {
        if(-not $object) { return }
    
        if([System.Management.Automation.LanguagePrimitives]::GetEnumerator($object) -or
            @($object.PSObject.Properties))
        {
            $null = $node.Nodes.Add( (New-Object Windows.Forms.TreeNode "...") )
        }
    }
    
    ## A function invoked when a node is selected.
    function OnAfterSelect
    {
        param($Sender, $TreeViewEventArgs)
    
        ## Determine the selected node
        $nodeSelected = $Sender.SelectedNode
    
        ## Walk through its parents, creating the virtual
        ## PowerShell syntax to access this property.
        $nodePath = GetPathForNode $nodeSelected
    
        ## Now, invoke that PowerShell syntax to retrieve
        ## the value of the property.
        $resultObject = Invoke-Expression $nodePath
        $outputPane.Text = $nodePath
    
        ## If we got some output, put the object's member
        ## information in the text box.
        if($resultObject)
        {
            $members = Get-Member -InputObject $resultObject | Out-String       
            $outputPane.Text += "`n" + $members
        }
    }
    
    ## A function invoked when the user is about to expand a node
    function OnBeforeExpand
    {
        param($Sender, $TreeViewCancelEventArgs)
    
        ## Determine the selected node
        $selectedNode = $TreeViewCancelEventArgs.Node
    
        ## If it has a child node that is the placeholder, clear
        ## the placehoder node.
        if($selectedNode.FirstNode -and
            ($selectedNode.FirstNode.Text -eq "..."))
        {
            $selectedNode.Nodes.Clear()
        }
        else
        {
            return
        }
    
        ## Walk through its parents, creating the virtual
        ## PowerShell syntax to access this property.
        $nodePath = GetPathForNode $selectedNode 
    
        ## Now, invoke that PowerShell syntax to retrieve
        ## the value of the property.
        Invoke-Expression "`$resultObject = $nodePath"
    
        ## And populate the node with the result object.
        PopulateNode $selectedNode $resultObject
    }
    
    ## A function to handle key presses on the tree view.
    ## In this case, we capture ^C to copy the path of
    ## the object property that we're currently viewing.
    function OnTreeViewKeyPress
    {
        param($Sender, $KeyPressEventArgs)
    
        ## [Char] 3 = Control-C
        if($KeyPressEventArgs.KeyChar -eq 3)
        {
            $KeyPressEventArgs.Handled = $true
    
            ## Get the object path, and set it on the clipboard
            $node = $Sender.SelectedNode
            $nodePath = GetPathForNode $node
            [System.Windows.Forms.Clipboard]::SetText($nodePath)
    
            $form.Close()
        }
        elseif([System.Windows.Forms.Control]::ModifierKeys -eq "Control")
        {
            if($KeyPressEventArgs.KeyChar -eq '+')
            {
                $SCRIPT:currentFontSize++
                UpdateFonts $SCRIPT:currentFontSize
            
                $KeyPressEventArgs.Handled = $true
            }
            elseif($KeyPressEventArgs.KeyChar -eq '-')
            {
                $SCRIPT:currentFontSize--
                if($SCRIPT:currentFontSize -lt 1) { $SCRIPT:currentFontSize = 1 }
                UpdateFonts $SCRIPT:currentFontSize
            
                $KeyPressEventArgs.Handled = $true
            }
        }
    }

    ## A function to handle key presses on the form.
    ## In this case, we handle Ctrl-Plus and Ctrl-Minus
    ## to adjust font size.
    function OnKeyUp
    {
        param($Sender, $KeyUpEventArgs)

        if([System.Windows.Forms.Control]::ModifierKeys -eq "Control")
        {
            if($KeyUpEventArgs.KeyCode -in 'Add','OemPlus')
            {
                $SCRIPT:currentFontSize++
                UpdateFonts $SCRIPT:currentFontSize
            
                $KeyUpEventArgs.Handled = $true
            }
            elseif($KeyUpEventArgs.KeyCode -in 'Subtract','OemMinus')
            {
                $SCRIPT:currentFontSize--
                if($SCRIPT:currentFontSize -lt 1) { $SCRIPT:currentFontSize = 1 }
                UpdateFonts $SCRIPT:currentFontSize
            
                $KeyUpEventArgs.Handled = $true
            }
            elseif($KeyUpEventArgs.KeyCode -eq 'D0')
            {
                $SCRIPT:currentFontSize = 12
                UpdateFonts $SCRIPT:currentFontSize
            
                $KeyUpEventArgs.Handled = $true
            }
        }
    }

    ## A function to handle mouse wheel scrolling.
    ## In this case, we translate Ctrl-Wheel to zoom.
    function OnMouseWheel
    {
        param($Sender, $MouseEventArgs)
    
        if(
            ([System.Windows.Forms.Control]::ModifierKeys -eq "Control") -and
            ($MouseEventArgs.Delta -ne 0))
        {
            $SCRIPT:currentFontSize += ($MouseEventArgs.Delta / 120)
            if($SCRIPT:currentFontSize -lt 1) { $SCRIPT:currentFontSize = 1 }

            UpdateFonts $SCRIPT:currentFontSize
            $MouseEventArgs.Handled = $true
        }
    }
    
    ## A function to walk through the parents of a node,
    ## creating virtual PowerShell syntax to access this property.
    function GetPathForNode
    {
        param($Node)
    
        $nodeElements = @()
    
        ## Go through all the parents, adding them so that
        ## $nodeElements is in order.
        while($Node)
        {
            $nodeElements = ,$Node + $nodeElements
            $Node = $Node.Parent
        }
    
        ## Now go through the node elements
        $nodePath = ""
        foreach($Node in $nodeElements)
        {
            $nodeName = $Node.Name
    
            ## If it was a node that PowerShell is able to enumerate
            ## (but not index), wrap it in the array cast operator.
        if($nodeName.StartsWith('@'))
            {
                $nodeName = $nodeName.Substring(1)
            $nodePath = "@(" + $nodePath + ")"
            }
            elseif($nodeName.StartsWith('['))
            {
                ## If it's a child index, we don't need to
                ## add the dot for property access
            }
            elseif($nodePath)
            {
                ## Otherwise, we're accessing a property. Add a dot.
                $nodePath += "."
            }
    
            ## Append the node name to the path
            $nodePath += $nodeName
        }
    
        ## And return the result
        $nodePath
    }

    function UpdateFonts
    {
        param($fontSize)
	
        $treeView.Font = New-Object System.Drawing.Font "Consolas",$fontSize
        $outputPane.Font = New-Object System.Drawing.Font "Consolas",$fontSize
    }
    
    $SCRIPT:currentFontSize = 12

    ## Create the TreeView, which will hold our object navigation
    ## area.
    $treeView = New-Object Windows.Forms.TreeView
    $treeView.Dock = "Top"
    $treeView.Height = 500
    $treeView.PathSeparator = "."
    $treeView.ShowNodeToolTips = $true
    $treeView.Add_AfterSelect( { OnAfterSelect @args } )
    $treeView.Add_BeforeExpand( { OnBeforeExpand @args } )
    $treeView.Add_KeyPress( { OnTreeViewKeyPress @args } )
    
    ## Create the output pane, which will hold our object
    ## member information.
    $outputPane = New-Object System.Windows.Forms.TextBox
    $outputPane.Multiline = $true
    $outputPane.WordWrap = $false
    $outputPane.ScrollBars = "Both"
    $outputPane.Dock = "Fill"

    ## Create the root node, which represents the object
    ## we are trying to show.
    $root = New-Object Windows.Forms.TreeNode
    $root.ToolTipText = $InputObject.GetType()
    $root.Text = $InputObject
    $root.Name = '$' + $rootVariableName
    $root.Expand()
    $null = $treeView.Nodes.Add($root)

    UpdateFonts $currentFontSize
    
    ## And populate the initial information into the tree
    ## view.
    PopulateNode $root $InputObject
    
    ## Finally, create the main form and show it.
    $form = New-Object Windows.Forms.Form
    $form.Text = "Browsing " + $root.Text
    $form.Width = 1000
    $form.Height = 800
    $form.Controls.Add($outputPane)
    $form.Controls.Add($treeView)
    $form.Add_MouseWheel( { OnMouseWheel @args } )
    $treeView.Add_KeyUp( { OnKeyUp @args } )
    $treeView.Select()
    $null = $form.ShowDialog()
    $form.Dispose()
}

function Start-ProcessAsUser
{
    ##############################################################################
    ##
    ## Start-ProcessAsUser
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Launch a process under alternate credentials, providing functionality
    similar to runas.exe.
    
    .EXAMPLE
    
    PS > $file = Join-Path ([Environment]::GetFolderPath("System")) certmgr.msc
    PS > Start-ProcessAsUser Administrator mmc $file
    
    #>
    
    param(
        ## The credential to launch the process under
        $Credential = (Get-Credential),
    
        ## The process to start
        [Parameter(Mandatory = $true)]
        [string] $Process,
    
        ## Any arguments to pass to the process
        [string] $ArgumentList = ""
    )
    
    Set-StrictMode -Version 3
    
    ## Create a real credential if they supplied a username
    $credential = Get-Credential $credential
    
    ## Exit if they canceled out of the credential dialog
    if(-not ($credential -is "System.Management.Automation.PsCredential"))
    {
        return
    }
    
    ## Prepare the startup information (including username and password)
    $startInfo = New-Object Diagnostics.ProcessStartInfo
    $startInfo.Filename = $process
    $startInfo.Arguments = $argumentList
    
    ## If we're launching as ourselves, set the "runas" verb
    if(($credential.Username -eq "$ENV:Username") -or
        ($credential.Username -eq "\$ENV:Username"))
    {
        $startInfo.Verb = "runas"
    }
    else
    {
        $startInfo.UserName = $credential.Username
        $startInfo.Password = $credential.Password
        $startInfo.UseShellExecute = $false
    }
    
    ## Start the process
    [Diagnostics.Process]::Start($startInfo)
}

function Test-Uri
{
    ##############################################################################
    ##
    ## Test-Uri
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Connects to a given URI and returns status about it: URI, response code,
    and time taken.
    
    .EXAMPLE
    
    PS > Test-Uri bing.com
    
    Uri               : bing.com
    StatusCode        : 200
    StatusDescription : OK
    ResponseLength    : 34001
    TimeTaken         : 459.0009
    
    #>
    
    param(
        ## The URI to test
        $Uri
    )
    
    $request = $null
    $time = try
    {
        ## Request the URI, and measure how long the response took.
    	$result = Measure-Command { $request = Invoke-WebRequest -Uri $uri }
        $result.TotalMilliseconds
    }
    catch
    {
        ## If the request generated an exception (i.e.: 500 server
        ## error or 404 not found), we can pull the status code from the
        ## Exception.Response property
        $request = $_.Exception.Response
        $time = -1
    }
    
    $result = [PSCustomObject] @{
        Time = Get-Date;
        Uri = $uri;
        StatusCode = [int] $request.StatusCode;
        StatusDescription = $request.StatusDescription;
        ResponseLength = $request.RawContentLength;
        TimeTaken = $time;
    }
    
    $result
}

function Use-Culture
{
    #############################################################################
    ##
    ## Use-Culture
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    #############################################################################
    
    <#
    
    .SYNOPSIS
    
    Invoke a scriptblock under the given culture
    
    .EXAMPLE
    
    PS > Use-Culture fr-FR { Get-Date -Date "25/12/2007" }
    mardi 25 decembre 2007 00:00:00
    
    #>
    
    param(
        ## The culture in which to evaluate the given script block
        [Parameter(Mandatory = $true)]
        [System.Globalization.CultureInfo] $Culture,
    
        ## The code to invoke in the context of the given culture
        [Parameter(Mandatory = $true)]
        [ScriptBlock] $ScriptBlock
    )
    
    Set-StrictMode -Version 3
    
    ## A helper function to set the current culture
    function Set-Culture([System.Globalization.CultureInfo] $culture)
    {
        [System.Threading.Thread]::CurrentThread.CurrentUICulture = $culture
        [System.Threading.Thread]::CurrentThread.CurrentCulture = $culture
    }
    
    ## Remember the original culture information
    $oldCulture = [System.Threading.Thread]::CurrentThread.CurrentUICulture
    
    ## Restore the original culture information if
    ## the user's script encounters errors.
    trap { Set-Culture $oldCulture }
    
    ## Set the current culture to the user's provided
    ## culture.
    Set-Culture $culture
    
    ## Invoke the user's scriptblock
    & $ScriptBlock
    
    ## Restore the original culture information.
    Set-Culture $oldCulture
}

function Watch-Command
{
    ##############################################################################
    ##
    ## Watch-Command
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Watches the result of a command invocation, alerting you when the output
    either matches a specified string, lacks a specified string, or has simply
    changed.
    
    .EXAMPLE
    
    PS > Watch-Command { Get-Process -Name Notepad | Measure } -UntilChanged
    Monitors Notepad processes until you start or stop one.
    
    .EXAMPLE
    
    PS > Watch-Command { Get-Process -Name Notepad | Measure } -Until "Count    : 1"
    Monitors Notepad processes until there is exactly one open.
    
    .EXAMPLE
    
    PS > Watch-Command { Get-Process -Name Notepad | Measure } -While 'Count    : \d\s*\n'
    Monitors Notepad processes while there are between 0 and 9 open
    (once number after the colon).
    
    #>
    
    
    [CmdletBinding(DefaultParameterSetName = "Forever")]
    param(
        ## The scriptblock to invoke while monitoring
        [Parameter(Mandatory = $true, Position = 0)]
        [ScriptBlock] $ScriptBlock,
    
        ## The delay, in seconds, between monitoring attempts
        [Parameter()]
        [Double] $DelaySeconds = 1,
    
        ## Specifies that the alert sound should not be played
        [Parameter()]
        [Switch] $Quiet,
    
        ## Monitoring continues only until while the output of the
        ## command remains the same.
        [Parameter(ParameterSetName = "UntilChanged", Mandatory = $false)]
        [Switch] $UntilChanged,
    
        ## The regular expression to search for. Monitoring continues
        ## until this expression is found.
        [Parameter(ParameterSetName = "Until", Mandatory = $false)]
        [String] $Until,
    
        ## The regular expression to search for. Monitoring continues
        ## until this expression is not found.
        [Parameter(ParameterSetName = "While", Mandatory = $false)]
        [String] $While
    )
    
    Set-StrictMode -Version 3
    
    $initialOutput = ""
    
    ## Start a continuous loop
    while($true)
    {
        ## Run the provided script block
        $r = & $ScriptBlock
    
        ## Clear the screen and display the results
        Clear-Host
        $ScriptBlock.ToString().Trim()
        ""
        $textOutput = $r | Out-String
        $textOutput
    
        ## Remember the initial output, if we haven't
        ## stored it yet
        if(-not $initialOutput)
        {
            $initialOutput = $textOutput
        }
    
        ## If we are just looking for any change,
        ## see if the text has changed.
        if($UntilChanged)
        {
            if($initialOutput -ne $textOutput)
            {
                break
            }
        }
    
        ## If we need to ensure some text is found,
        ## break if we didn't find it.
        if($While)
        {
            if($textOutput -notmatch $While)
            {
                break
            }
        }
    
        ## If we need to wait for some text to be found,
        ## break if we find it.
        if($Until)
        {
            if($textOutput -match $Until)
            {
                break
            }
        }
    
        ## Delay
        Start-Sleep -Seconds $DelaySeconds
    }
    
    ## Notify the user
    if(-not $Quiet)
    {
        [Console]::Beep(1000, 1000)
    }
}

function Watch-DebugExpression
{
    #############################################################################
    ##
    ## Watch-DebugExpression
    ##
    ## From Windows PowerShell Cookbook (O'Reilly)
    ## by Lee Holmes (http://www.leeholmes.com/guide)
    ##
    ##############################################################################
    
    <#
    
    .SYNOPSIS
    
    Updates your prompt to display the values of information you want to track.
    
    .EXAMPLE
    
    PS > Watch-DebugExpression { (Get-History).Count }
    
    Expression          Value
    ----------          -----
    (Get-History).Count     3
    
    PS > Watch-DebugExpression { $count }
    
    Expression          Value
    ----------          -----
    (Get-History).Count     4
    $count
    
    PS > $count = 100
    
    Expression          Value
    ----------          -----
    (Get-History).Count     5
    $count                100
    
    PS > Watch-DebugExpression -Reset
    PS >
    
    #>
    
    param(
        ## The expression to track
        [ScriptBlock] $ScriptBlock,
    
        ## Switch to no longer watch an expression
        [Switch] $Reset
    )
    
    Set-StrictMode -Version 3
    
    if($Reset)
    {
        Set-Item function:\prompt ([ScriptBlock]::Create($oldPrompt))
    
        Remove-Item variable:\expressionWatch
        Remove-Item variable:\oldPrompt
    
        return
    }
    
    ## Create the variableWatch variable if it doesn't yet exist
    if(-not (Test-Path variable:\expressionWatch))
    {
        $GLOBAL:expressionWatch = @()
    }
    
    ## Add the current variable name to the watch list
    $GLOBAL:expressionWatch += $scriptBlock
    
    ## Update the prompt to display the expression values,
    ## if needed.
    if(-not (Test-Path variable:\oldPrompt))
    {
        $GLOBAL:oldPrompt = Get-Content function:\prompt
    }
    
    if($oldPrompt -notlike '*$expressionWatch*')
    {
        $newPrompt = @'
            $results = foreach($expression in $expressionWatch)
            {
                New-Object PSObject -Property @{
                    Expression = $expression.ToString().Trim();
                    Value = & $expression
                } | Select Expression,Value
            }
            Write-Host "`n"
            Write-Host ($results | Format-Table -Auto | Out-String).Trim()
            Write-Host "`n"
    
'@
    
        $newPrompt += $oldPrompt
    
        Set-Item function:\prompt ([ScriptBlock]::Create($newPrompt))
    }
}