El Blog de Gualtrysoft

Windows 2000/2003/2008, Active Directory, VBScript, Hyper-V, PowerShell y todo aquello interesante a la hora de usar, configurar y administrar Windows Server. También tenemos longanizas…

PowerShell: Cmdlet para obtener los miembros de un grupo

Posted by urpiano en Miércoles 20 \20\UTC julio \20\UTC 2011

Esta función recibe como parámetro el nombre distinguido de un grupo de Active Directory y devuelve los usuarios que pertenecen a dicho grupo. La devolución consiste en objetos DirectoryEntry, lo que permite recorrerla para leer o escribir determinados atributos según necesidades detectadas.

Los usuarios devueltos son aquellos cuya membresía es directa, los que tienen el grupo como su grupo primario y los que son miembros de forma heredada (que pertenecen a otro grupo que pertenece al original o incluso a uno que pertenece a otro que pertenece al original).

El Cmdlet incluye ayuda, pego a continuación la ayuda con modificador -Detailed (esta ayuda se basa en la prestación de ayuda basada en comentarios de PowerShell 2.0 ¿Qué todavía tienes la versión 1.0 y no la 2.0? ¿A qué esperas para instalarla si es mucho mejor?):

NOMBRE
    Get-GroupMember

SINOPSIS
    Devuelve los usuarios que pertenecen a un grupo.

SINTAXIS
    Get-GroupMember [[-Group] <String>] [[-User] <String>] [[-Password] <String>] [-ShowUsers] [-ShowContacts] [-ShowCo
    mputers] [-ShowGroups] [-ShowAll] [<CommonParameters>]

DESCRIPCIÓN
    Esta función recibe como parámetro el nombre distinguido de un grupo de
    Active Directory y devuelve los usuarios que pertenecen a dicho grupo. La
    devolución consiste en objetos DirectoryEntry, lo que permite recorrerla
    para leer o escribir determinados atributos según necesidades detectadas.
    Los usuarios devueltos son aquellos cuya membresía es directa y los que
    son miembros de forma heredada (que pertenecen a otro grupo que
    pertenece al original o incluso a uno que pertenece a otro que pertenece
    al original). Para hacer esto realiza llamadas recursivas con los
    miembros que son grupos. Para evitar referencias circulares y enumerar
    más de una vez un usuario, el script crea en ejecución un array que va
    poblando con los miembros, sean del tipo que sean, y evita aquellos que
    ya son miembros de dicho array. Al finalizar la ejecución este array es
    destruido.
    Una referencia circular se produce cuando se encadenan membresías de
    grupo de manera que un grupo sea miembro de otro y este otro sea miembro
    del otro grupo que es miembro del primero; en un caso así las llamadas
    recursivas entrarían en un bucle infinito, de ahí la necesidad de que la
    función controle si ya ha sido encontrado un grupo anteriormente. Veamos
    un ejemplo:
    Tenemos el grupo A que tiene entre sus miembros al grupo B. Por su parte
    el grupo B tiene entre sus miembros al grupo C. Por último, el grupo C
    tiene entre sus miembros al grupo A. Si no se estableciera el control de
    elementos ya encontrados, al llamar a la función pasando el grupo A,
    ésta realizaría una llamada recursiva con el grupo B, por ser miembro de
    A. En la llamada recursiva con B se encontraría como miembro a C y se
    realizaría una llamada recursiva con el grupo C. En esta llamada con C
    se encontraría como miembro al grupo A y se realizaría una llamada con
    A, lo que originaría una llamada con B, lo que originaría una llamada
    con C, lo que originaría una llamada con A, lo que..., en fin, que así se
    quedaría hasta el infinito y más allá :oP. Estableciendo el control de ya
    encontrados, en la llamada con A se agregaría al array a A y a B, en la
    llamada a B se agregaría a C y en la llamada a C no se agregaría a A ni,
    por tanto, se realizaría esta llamada, con lo que se rompe la referencia
    circular.

PARÁMETROS
    -Group <String>
        Nombre distinguido del grupo del que se quiere obtener sus usuarios
        miembro.

    -User <String>
        Nombre del usuario con el que se conectará a Active Directory, si se
        omite la conexión se establecerá con el usuario que lanza la función.

    -Password <String>
        Contraseña del usuario con el que se conectará a Active Directory. Será
        ignorado si no se ha pasado también el parámetro User.

    -ShowUsers [<SwitchParameter>]
        Al pasarse este modificador se devolverán todos los miembros del grupo,
        que sean del tipo usuario. Si se omite  y son omitidos los parámetros
        ShowComputers, ShowGroups y ShowContacs, la función también devolverá
        todos los tipos de objetos que sean miembros del grupo. Su uso no es
        excluyente, lo que quiere decir que si se pasa otro modificador de tipo
        de objeto a devolver se devolverán ambos tipos de objetos. Este
        modificador será ignorado si se pasa el modificador ShowAll.

    -ShowContacts [<SwitchParameter>]
        Al pasarse este modificador se devolverán todos los miembros del grupo,
        que sean del tipo contacto. Si se omite  y son omitidos los parámetros
        ShowUsers, ShowGroups y ShowComputers, la función también devolverá
        todos los tipos de objetos que sean miembros del grupo. Su uso no es
        excluyente, lo que quiere decir que si se pasa otro modificador de tipo
        de objeto a devolver se devolverán ambos tipos de objetos. Este
        modificador será ignorado si se pasa el modificador ShowAll.

    -ShowComputers [<SwitchParameter>]
        Al pasarse este modificador se devolverán todos los miembros del grupo,
        que sean del tipo equipo. Si se omite  y son omitidos los parámetros
        ShowUsers, ShowGroups y ShowContacs, la función también devolverá todos
        los tipos de objetos que sean miembros del grupo. Su uso no es
        excluyente, lo que quiere decir que si se pasa otro modificador de tipo
        de objeto a devolver se devolverán ambos tipos de objetos. Este modificador
        será ignorado si se pasa el modificador ShowAll.

    -ShowGroups [<SwitchParameter>]
        Al pasarse este modificador se devolverán todos los miembros del grupo,
        que sean del tipo grupo. Si se omite  y son omitidos los parámetros
        ShowUsers, ShowComputers y ShowContacs, la función también devolverá
        todos los tipos de objetos que sean miembros del grupo. Su uso no es
        excluyente, lo que quiere decir que si se pasa otro modificador de tipo
        de objeto a devolver se devolverán ambos tipos de objetos. Este
        modificador será ignorado si se pasa el modificador ShowAll.

    -ShowAll [<SwitchParameter>]
        Al pasarse este modificador se devolverán todos los miembros del grupo,
        sean del tipo que sean (usuarios, grupos, etc.). Si se omite  y son
        omitidos los parámetros ShowUsers, ShowGroups, ShowComputers y
        ShowContacs, la función también devolverá todos los tipos de objetos que
        sean miembros del grupo. Si se pasa este modificador, los demás
        modificadores de tipo de objeto a devolver serán ignorados.

    <CommonParameters>
        Este cmdlet admite los parámetros comunes Verbose, Debug,
        ErrorAction, ErrorVariable, WarningAction, WarningVariable,
        OutBuffer y OutVariable. Para obtener más información, escriba:
        "get-help about_commonparameters".

    -------------------------- EJEMPLO 1 --------------------------

    PS C:\>Get-GroupMember -Group "cn=Agentes,cn=Users,dc=tia,dc=org"

    Obtiene todos los miembros del grupo de agentes del dominio tia.org.

    -------------------------- EJEMPLO 2 --------------------------

    PS C:\>Get-GroupMember -Group "cn=Agentes,cn=Users,dc=tia,dc=org" `
                           -User Bacterio -Password -OfeliaFoca

    Obtiene todos los miembros del grupo de agentes del dominio tia.org,
    conectando con el usuario Bacterio y suministrando como contraseña
    OfeliaFoca

    -------------------------- EJEMPLO 3 --------------------------

    PS C:\>Get-GroupMember -Group "cn=Agentes,cn=Users,dc=tia,dc=org" `
                           -ShowUsers

    Obtiene todos los usuarios miembros del grupo de agentes del dominio
    tia.org.

    -------------------------- EJEMPLO 4 --------------------------

    PS C:\>Get-GroupMember -Group "cn=Agentes,cn=Users,dc=tia,dc=org" `
                           -ShowUsers -ShowGroups

    Obtiene todos los grupos y usuarios miembros del grupo de agentes del
    dominio tia.org.

NOTAS
    Para ver los ejemplos, escriba: "get-help Get-GroupMember -examples".
    Para obtener más información, escriba: "get-help Get-GroupMember -detailed".
    Para obtener información técnica, escriba: "get-help Get-GroupMember -full".

Este es el código del Cmdlet:

Function Get-GroupMember([String]   $Group, `
                         [String]   $User = $null, `
                         [String]   $Password = $null, `
                         [Switch]   $ShowUsers, `
                         [Switch]   $ShowContacts, `
                         [Switch]   $ShowComputers, `
                         [Switch]   $ShowGroups, `
                         [Switch]   $ShowAll)
{
    # Necesitamos saber si esta es una llamada recursiva o es la llamada
    # original. Para ello usaremos el siguiente mecanismo: primero establecemos
    # a false una booleana. Después averiguaremos si es o no nula una variable;
    # esta variable será nula en la llamada original, ya que no existe. Esto
    # permite que la creemos EN AMBITO GLOBAL para que así conserve su valor
    # en las llamadas recursivas y que marcemos la booleana como True. El saber
    # si la llamada es la original o no es para poder crear otra variable global
    # que almacena los nombres distinguidos de los objetos encontrados, para no
    # repetir usuarios y que no se produzca ningún bucle infinito con los grupos
    $LlamadaOriginal = $false
    # Si LlamadaRecursiva es nulo quiere decir que estamos en la llamada
    # original, no en una que se produce por recursividad. Creamos el array que
    # guardará los nombres de usuarios y grupos encontrados. Esto permite evitar
    # que se repitan los usuarios y/o grupos que pertenecen a más de un grupo de
    # los encontrados en las sucesivas llamadas que se producirán por
    # recursividad. Además de ésto, y mucho más importante, evitará las posibles
    # referencias circulares que producirían entrar en un bucle infinito (A
    # tiene como miembro a B que tiene como miembro a C que tiene como miembro a
    # A).
    If($LlamadaRecursiva -eq $null)
    {
        # Marcamos que esta es la llamada original
        $LlamadaOriginal = $true
        # Establecemos la variable LlamadaRecursiva como global con valor True
        Set-Variable -Name LlamadaRecursiva -Scope Global -Value $true
        # Creamos el array vacío en el ámbito global
        Set-Variable -Name Miembros -Value @() -Scope Global
        # Agregamos el grupo actual al array, para ello usaremos una variable
        # temporal
        $MiembrosTemp = @()
        $MiembrosTemp += $Group
        Set-Variable -Name Miembros -Value $MiembrosTemp -Scope Global
        Remove-Variable MiembrosTemp
    }
    # Según se haya pasado o no usuario o contraseña deberemos obtener el objeto
    # directory entry del grupo
    If([System.String]::IsNullOrEmpty($User) -eq $true)
    {
        # Como no hay usuario y contraseña, podemos usar la forma breve de
        # obtención del objeto DirectoryEntry. Esto es equivalente a la línea:
        #
        # $Grupo = New-Object system.DirectoryServices.DirectoryEntry `
        #                                                   "LDAP://$Group"
        $Grupo = [ADSI] "LDAP://$Group"
    }
    Else
    {
        # Como sí se ha recibido usuario y contraseña, los pasamos como
        # parámetros al constructor del objeto DirectoryEntry
        $Grupo = New-Object system.DirectoryServices.DirectoryEntry `
                                                            "LDAP://$Group" , `
                                                            $User, `
                                                            $Password
    }
    ################ Inicio del Código de Richard L. Mueller ###################
    # Esta parte del código es cortesía, con ligeras modificaciones y
    # comentarios añadidos, del maestro Richard L. Mueller en el script que se
    # puede encontrar en http://www.rlmueller.net/PowerShell/PSEnumGroup.txt.
    
    # Buscamos ahora aquellos miembros que lo son por tratarse del grupo
    # primario al que pertenece el usuario (típicamente los usuarios pertenecen
    # al grupo "Usuarios del dominio", pero no aparecen en la lista member de
    # este grupo, pues su pertenencia se basa en que es su grupo primario. Para
    # obtener esto, es necesario saber el identificador RID del grupo y realizar
    # un búsqueda de los objetos cuyo grupo primario tenga este RID por valor.
    # Primero obtenemos un array con el SID del grupo
    $arrSID = (($Grupo.objectSid).ToString()).Split()
    $Elementos = $arrSID.Count
    $RID = [Int32]$arrSID[$Elementos - 4] `
        + (256 * [int32]$arrSID[$Elementos - 3]) `
        + (256 * 256 * [Int32]$arrSID[$Elementos - 2]) `
        + (256 * 256 * 256 * [Int32]$arrSID[$Elementos - 1])
    # Una vez conocido el RID, realizaremos una búsqueda LDAP de los objetos
    # que tienen este RID como primaryGroupID. Para ello crearemos un objeto
    # DirectorySearcher que busque en el dominio al que pertenece el grupo.
    
    # Esto no es de Richard :o). Obtenemos el nombre distinguido del dominio a
    # partir del nombre distinguido del grupo
    ($Grupo.distinguishedName).ToString()-split(",") | `
    ForEach{ `
        If($_ -like "dc=*"){$DnDominio = "$DnDominio$_,"}
    }
    # Sobra la coma final; la quitamos
    $DnDominio = $DnDominio.SubString(0,$DnDominio.Length - 1)
    # Ahora creamos un objeto DirectoryEntry del dominio, en función de si se
    # recibió usuario y contraseña lo haremos de manera abreviada o no
    If([System.String]::IsNullOrEmpty($User) -eq $true)
    {
        # Como no hay usuario y contraseña, podemos usar la forma breve de
        # obtención del objeto DirectoryEntry. Esto es equivalente a la línea:
        #
        # $Dominio = New-Object system.DirectoryServices.DirectoryEntry `
        #                                                   "LDAP://$DnDominio"
        $Dominio = [ADSI] "LDAP://$DnDominio"
    }
    Else
    {
        # Como sí se ha recibido usuario y contraseña, los pasamos como
        # parámetros al constructor del objeto DirectoryEntry
        $Dominio = New-Object system.DirectoryServices.DirectoryEntry `
                                                         "LDAP://$DnDominio" , `
                                                         $User, `
                                                         $Password
    }
    # Creamos ahora un objeto DirectorySearcher con base en el dominio
    $Buscador = [System.DirectoryServices.DirectorySearcher]$Dominio
    # Establecemos paginación para que se obtengan más de 1000 resultados
    $Buscador.PageSize = 100
    # Establecemos que se busque en todo el dominio
    $Buscador.SearchScope = "Subtree"
    # Buscaremos aquellos objetos cuyo atributo primaryGroupID sea igual al RID
    # del grupo
    $Buscador.Filter = "(primaryGroupID=$RID)"
    ################## Fin del Código de Richard L. Mueller ####################
    
    # Almacenamos la preferencia de accion ante errores que no interrumpen
    $AccionError = $ErrorActionPreference
    # Obligamos a que los errores que no interrumpen sí lo hagan, para poder
    # así interceptarlos con Try
    $ErrorActionPreference = "Stop"
    Try
    {
        # Recorremos la búsqueda para añadir los objetos que no estén en el array
        ForEach($Resultado In $Buscador.FindAll())
        {
            # Si el objeto no está en la lista de miembros
            If($Miembros -notcontains `
                                    $Resultado.Properties.Item("distinguishedName"))
            {
                # Copiamos el array de miembros en una variable temporal
                $MiembrosTemp = $Miembros
                # Agregamos el miembro actual a la variable temporal
                $MiembrosTemp += $Resultado.Properties.Item("distinguishedName")
                # Asignamos la variable temporal al array de miembros, teniendo en
                # cuenta que hay que hacerlo en el ámbito global
                Set-Variable Miembros -Scope Global -Value $MiembrosTemp
                # Destruimos la variable temporal
                Remove-Variable MiembrosTemp
                
                # Al igual que hicimos con el grupo, la forma de obtener el objeto
                # DirectoryEntry del miembro actual depende de si se ha recibido
                # usuarios y contraseña o no.
                If([System.String]::IsNullOrEmpty($User) -eq $true)
                {
                    $DeMiembro = [ADSI]"$($Resultado.Path -replace "/","\/")"
                }
                Else
                {
                    $Path = $Resultado.Properties.Item("distinguishedName")
                    $Path = "LDAP://$($Path -replace "/","\/")"
                    $DeMiembro = New-Object `
                                          System.DirectoryServices.DirectoryEntry  `
                                                                        $Path, `
                                                                        $User, `
                                                                        $Password
                }
                # A continuación devolveremos el miembro si procede, en función del
                # tipo de objeto y de los modificadores de clase a devolver
                # recibidos
                # En primer lugar, si se recibió el modificador All o no se recibió
                # ningún modificador de clase, se debe devolver el miembro
                # independientemente del tipo de objeto de que se trate
                If(  $ShowAll -eq $true `
                -or ($ShowComputers -or `
                     $ShowContacts -or `
                     $ShowUsers -or `
                     $ShowGroups) -ne $true)
                {
                    $DeMiembro
                }
                # Si se ha establecido el modificador de equipos y se trata de un
                # equipo, hay que devolver el miembro
                ElseIf($ShowComputers -eq $true `
                  -and $DeMiembro.objectClass -contains "computer")
                {
                    $DeMiembro
                }
                # Si se ha establecido el modificador de contactos y se trata de un
                # contacto, hay que devolver el miembro
                ElseIf($ShowContacts -eq $true `
                  -and $DeMiembro.objectClass -contains "contact")
                {
                    $DeMiembro
                }
                # Si se ha establecido el modificador de usuarios y se trata de un
                # usuario, hay que devolver el miembro
                ElseIf($ShowUsers -eq $true `
                  -and $DeMiembro.objectClass -contains "user")
                {
                    $DeMiembro
                }
                # Si se ha establecido el modificador de grupos y se trata de un
                # grupo, hay que devolver el miembro
                ElseIf($ShowGroups -eq $true `
                  -and $DeMiembro.objectClass -contains "group")
                {
                    $DeMiembro
                }
            }
        }
    }
    # Si se ha producido error es debido a que no hay objetos que tengan como 
    # grupo primario el grupo actual. No hacemos nada en este caso
    Catch
    {
        Out-Null
    }
    # Restauramos la acción a realizar ante errores que no interrumpen
    $ErrorActionPreference = $AccionError
    # Recorremos los miembros del grupo
    ForEach($Miembro In $Grupo.member)
    {
        # Solo procesaremos aquellos miembros que no hayan sido antes
        # encontrados
        If($Miembros -notcontains $Miembro)
        {
            # Copiamos el array de miembros en una variable temporal
            $MiembrosTemp = $Miembros
            # Agregamos el miembro actual a la variable temporal
            $MiembrosTemp += $Miembro
            # Asignamos la variable temporal al array de miembros, teniendo en
            # cuenta que hay que hacerlo en el ámbito global
            Set-Variable Miembros -Scope Global -Value $MiembrosTemp
            # Destruimos la variable temporal
            Remove-Variable MiembrosTemp
            
            # Al igual que hicimos con el grupo, la forma de obtener el objeto
            # DirectoryEntry del miembro actual depende de si se ha recibido
            # usuarios y contraseña o no.
            If([System.String]::IsNullOrEmpty($User) -eq $true)
            {
                $DeMiembro = [ADSI]"LDAP://$($Miembro -replace "/","\/")"
            }
            Else
            {
                $DeMiembro = New-Object `
                                       System.DirectoryServices.DirectoryEntry `
                                       "LDAP://$($Miembro -replace "/","\/")", `
                                       $User, `
                                       $Password
            }
            # A continuación devolveremos el miembro si procede, en función del
            # tipo de objeto y de los modificadores de clase a devolver
            # recibidos
            # En primer lugar, si se recibió el modificador All o no se recibió
            # ningún modificador de clase, se debe devolver el miembro
            # independientemente del tipo de objeto de que se trate
            If(  $ShowAll -eq $true `
            -or ($ShowComputers -or `
                 $ShowContacts -or `
                 $ShowUsers -or `
                 $ShowGroups) -ne $true)
            {
                $DeMiembro
            }
            # Si se ha establecido el modificador de equipos y se trata de un
            # equipo, hay que devolver el miembro
            ElseIf($ShowComputers -eq $true `
              -and $DeMiembro.objectClass -contains "computer")
            {
                $DeMiembro
            }
            # Si se ha establecido el modificador de contactos y se trata de un
            # contacto, hay que devolver el miembro
            ElseIf($ShowContacts -eq $true `
              -and $DeMiembro.objectClass -contains "contact")
            {
                $DeMiembro
            }
            # Si se ha establecido el modificador de usuarios y se trata de un
            # usuario, hay que devolver el miembro
            ElseIf($ShowUsers -eq $true `
              -and $DeMiembro.objectClass -contains "user")
            {
                $DeMiembro
            }
            # Si se ha establecido el modificador de grupos y se trata de un
            # grupo, hay que devolver el miembro
            ElseIf($ShowGroups -eq $true `
              -and $DeMiembro.objectClass -contains "group")
            {
                $DeMiembro
            }
            # Comprobamos a continuación si se trata de un grupo, en cuyo caso
            # realizaremos una llamada recursiva para obtener sus miembros
            If($DeMiembro.objectClass -contains "group")
            {
                # Cambiamos el valor de Group al nombre distinguido del grupo
                # actual en los parámetros de la función
                $PSBoundParameters["Group"] = $Miembro -replace "/","\/"
                # Realizamos la llamada recursiva con los parámetros
                # correspondientes, lo que permitirá enumerar los miembros del
                # grupo y de los grupos por el contenidos
                Get-GroupMember @PSBoundParameters
            }
        }
    }
    # Si estamos en la llamada original, podemos ya destruir la variable global
    # con el array de miembros, pues no es deseable que quede en memoria
    If($LlamadaOriginal -eq $true)
    {
        Remove-Variable Miembros -Force -Scope Global
        Remove-Variable LlamadaRecursiva -Force -Scope Global
    }
    
<#
    .SYNOPSIS
    Devuelve los usuarios que pertenecen a un grupo.

    .DESCRIPTION
        Esta función recibe como parámetro el nombre distinguido de un grupo de
    Active Directory y devuelve los usuarios que pertenecen a dicho grupo. La
    devolución consiste en objetos DirectoryEntry, lo que permite recorrerla
    para leer o escribir determinados atributos según necesidades detectadas.
    Los usuarios devueltos son aquellos cuya membresía es directa y los que
    son miembros de forma heredada (que pertenecen a otro grupo que
    pertenece al original o incluso a uno que pertenece a otro que pertenece
    al original). Para hacer esto realiza llamadas recursivas con los
    miembros que son grupos. Para evitar referencias circulares y enumerar
    más de una vez un usuario, el script crea en ejecución un array que va
    poblando con los miembros, sean del tipo que sean, y evita aquellos que
    ya son miembros de dicho array. Al finalizar la ejecución este array es
    destruido.
    
    Una referencia circular se produce cuando se encadenan membresías de
    grupo de manera que un grupo sea miembro de otro y este otro sea miembro
    del otro grupo que es miembro del primero; en un caso así las llamadas
    recursivas entrarían en un bucle infinito, de ahí la necesidad de que la
    función controle si ya ha sido encontrado un grupo anteriormente. Veamos
    un ejemplo:
    
    Tenemos el grupo A que tiene entre sus miembros al grupo B. Por su parte
    el grupo B tiene entre sus miembros al grupo C. Por último, el grupo C
    tiene entre sus miembros al grupo A. Si no se estableciera el control de
    elementos ya encontrados, al llamar a la función pasando el grupo A,
    ésta realizaría una llamada recursiva con el grupo B, por ser miembro de
    A. En la llamada recursiva con B se encontraría como miembro a C y se
    realizaría una llamada recursiva con el grupo C. En esta llamada con C
    se encontraría como miembro al grupo A y se realizaría una llamada con
    A, lo que originaría una llamada con B, lo que originaría una llamada
    con C, lo que originaría una llamada con A, lo que..., en fin, que así se
    quedaría hasta el infinito y más allá :oP. Estableciendo el control de ya
    encontrados, en la llamada con A se agregaría al array a A y a B, en la
    llamada a B se agregaría a C y en la llamada a C no se agregaría a A ni,
    por tanto, se realizaría esta llamada, con lo que se rompe la referencia
    circular.

    .PARAMETER  Group
        Nombre distinguido del grupo del que se quiere obtener sus usuarios
    miembro.

    .PARAMETER  User
        Nombre del usuario con el que se conectará a Active Directory, si se
    omite la conexión se establecerá con el usuario que lanza la función.

    .PARAMETER  Password
        Contraseña del usuario con el que se conectará a Active Directory. Será
    ignorado si no se ha pasado también el parámetro User.

    .PARAMETER  ShowAll
        Al pasarse este modificador se devolverán todos los miembros del grupo,
    sean del tipo que sean (usuarios, grupos, etc.). Si se omite  y son
    omitidos los parámetros ShowUsers, ShowGroups, ShowComputers y
    ShowContacs, la función también devolverá todos los tipos de objetos que
    sean miembros del grupo. Si se pasa este modificador, los demás
    modificadores de tipo de objeto a devolver serán ignorados.

    .PARAMETER ShowComputers
        Al pasarse este modificador se devolverán todos los miembros del grupo,
    que sean del tipo equipo. Si se omite  y son omitidos los parámetros
    ShowUsers, ShowGroups y ShowContacs, la función también devolverá todos
    los tipos de objetos que sean miembros del grupo. Su uso no es
    excluyente, lo que quiere decir que si se pasa otro modificador de tipo
    de objeto a devolver se devolverán ambos tipos de objetos. Este modificador
    será ignorado si se pasa el modificador ShowAll.

    .PARAMETER  ShowContacts
        Al pasarse este modificador se devolverán todos los miembros del grupo,
    que sean del tipo contacto. Si se omite  y son omitidos los parámetros
    ShowUsers, ShowGroups y ShowComputers, la función también devolverá
    todos los tipos de objetos que sean miembros del grupo. Su uso no es
    excluyente, lo que quiere decir que si se pasa otro modificador de tipo
    de objeto a devolver se devolverán ambos tipos de objetos. Este
    modificador será ignorado si se pasa el modificador ShowAll.

    .PARAMETER  ShowGroups
        Al pasarse este modificador se devolverán todos los miembros del grupo,
    que sean del tipo grupo. Si se omite  y son omitidos los parámetros
    ShowUsers, ShowComputers y ShowContacs, la función también devolverá
    todos los tipos de objetos que sean miembros del grupo. Su uso no es
    excluyente, lo que quiere decir que si se pasa otro modificador de tipo
    de objeto a devolver se devolverán ambos tipos de objetos. Este
    modificador será ignorado si se pasa el modificador ShowAll.

    .PARAMETER  ShowUsers
        Al pasarse este modificador se devolverán todos los miembros del grupo,
    que sean del tipo usuario. Si se omite  y son omitidos los parámetros
    ShowComputers, ShowGroups y ShowContacs, la función también devolverá
    todos los tipos de objetos que sean miembros del grupo. Su uso no es
    excluyente, lo que quiere decir que si se pasa otro modificador de tipo
    de objeto a devolver se devolverán ambos tipos de objetos. Este
    modificador será ignorado si se pasa el modificador ShowAll.

    .EXAMPLE
        PS C:\> Get-GroupMember -Group "cn=Agentes,cn=Users,dc=tia,dc=org"
    Obtiene todos los miembros del grupo de agentes del dominio tia.org.

    .EXAMPLE
        PS C:\> Get-GroupMember -Group "cn=Agentes,cn=Users,dc=tia,dc=org" -User Bacterio -Password -OfeliaFoca
    Obtiene todos los miembros del grupo de agentes del dominio tia.org,
    conectando con el usuario Bacterio y suministrando como contraseña
    OfeliaFoca

    .EXAMPLE
        PS C:\> Get-GroupMember -Group "cn=Agentes,cn=Users,dc=tia,dc=org" -ShowUsers
    Obtiene todos los usuarios miembros del grupo de agentes del dominio
    tia.org.

    .EXAMPLE
        PS C:\> Get-GroupMember -Group "cn=Agentes,cn=Users,dc=tia,dc=org" -ShowUsers -ShowGroups
    Obtiene todos los grupos y usuarios miembros del grupo de agentes del
    dominio tia.org.

    .INPUTS
        System.String

    .OUTPUTS
        System.DirectoryServices.DirectoryEntry

    .NOTES
        © Fernando Reyes López
    Julio de 2011

    .LINK
        https://urpiano.wordpress.com

    .LINK
        http://freyes.svetlian.com

#>

}

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s

 
A %d blogueros les gusta esto: