Comment spécifier des valeurs de comparaison

Article
06/13/2023

Chaque type d’attribut a une syntaxe qui détermine le type de valeurs de comparaison que vous pouvez spécifier dans un filtre de recherche pour cet attribut.

Les sections suivantes décrivent les conditions requises pour chaque syntaxe d’attribut. Pour plus d’informations sur les syntaxes d’attributs, consultez Syntaxes des attributs dans services de domaine Active Directory.

Boolean

La valeur spécifiée dans un filtre doit être une valeur de chaîne qui est « TRUE » ou « FALSE ». Les exemples suivants montrent comment spécifier une chaîne de comparaison booléenne.

L’exemple suivant recherche les objets dont la valeur showInAdvancedViewOnly estdéfinie sur TRUE :

(showInAdvancedViewOnly=TRUE)

L’exemple suivant recherche les objets dont la valeur showInAdvancedViewOnly est définie sur FALSE :

(showInAdvancedViewOnly=FALSE)

Entier et énumération

La valeur spécifiée dans un filtre doit être un entier décimal. Les valeurs hexadécimales doivent être converties en décimales. Une chaîne de comparaison de valeurs prend la forme suivante :

<attribute name>:<value>

«< nom de l’attribut> » est le lDAPDisplayName de l’attribut et «< value> » est la valeur à utiliser pour la comparaison.

L’exemple de code suivant montre un filtre qui recherche les objets qui ont une valeur groupType égale à l’indicateur ADS_GROUP_TYPE_UNIVERSAL_GROUP (8) et à l’indicateur ADS_GROUP_TYPE_SECURITY_ENABLED (0x80000000). Les deux indicateurs combinés sont 0x80000008, ce qui est converti en décimal est 2147483656.

(groupType=2147483656)

Les opérateurs de règle de correspondance LDAP peuvent également être utilisés pour effectuer des comparaisons au niveau du bit. Pour plus d’informations sur les règles de correspondance, consultez Syntaxe de filtre de recherche. L’exemple de code suivant montre un filtre qui recherche les objets qui ont un groupType avec le ADS_GROUP_TYPE_SECURITY_ENABLED (0x80000000 = 2147483648) défini.

(groupType:1.2.840.113556.1.4.803:=2147483648))

OctetString

La valeur spécifiée dans un filtre correspond aux données à trouver. Les données doivent être représentées sous la forme d’une chaîne d’octets encodée à deux caractères, où chaque octet est précédé d’une barre oblique inverse (\). Par exemple, la valeur 0x05 s’affiche dans la chaîne sous la forme « \05 ».

La fonction ADsEncodeBinaryData peut être utilisée pour créer une représentation sous forme de chaîne codée de données binaires. La fonction ADsEncodeBinaryData n’encode pas les valeurs d’octet qui représentent des caractères alphanumériques. À la place, il place le caractère dans la chaîne sans l’encoder. Il en résulte que la chaîne contient un mélange de caractères encodés et non codés. Par exemple, si les données binaires sont 0x05|0x1A|0x1B|0x43|0x32, la chaîne encodée contiendra « \05\1A\1BC2 ». Cela n’a aucun effet sur le filtre et les filtres de recherche fonctionnent correctement avec ces types de chaînes.

Les caractères génériques sont acceptés.

L’exemple de code suivant montre un filtre qui contient une chaîne encodée pour schemaIDGUID avec la valeur GUID « {BF967ABA-0DE6-11D0-A285-00AA003049E2} » :

(schemaidguid=\BA\7A\96\BF\E6\0D\D0\11\A2\85\00\AA\00\30\49\E2)

Sid

La valeur spécifiée dans un filtre est la représentation de chaîne d’octets encodée du SID. Pour plus d’informations sur les chaînes d’octets encodées, consultez la section précédente de cette rubrique qui traite de la syntaxe OctetString.

L’exemple de code suivant montre un filtre qui contient une chaîne encodée pour objectSid avec la valeur de chaîne SID « S-1-5-21-1935655697-308236825-1417001333 » :

(ObjectSid=\01\04\00\00\00\00\00\05\15\00\00\00\11\C3\5Fs\19R\5F\12u\B9uT)

DN

Le nom unique entier, à mettre en correspondance, doit être fourni.

Les caractères génériques ne sont pas acceptés.

N’oubliez pas que l’attribut objectCategory vous permet également de spécifier le lDAPDisplayName de la classe définie sur l’attribut.

L’exemple suivant montre un filtre qui spécifie un membre qui contient « CN=TestUser,DC=Fabrikam,DC=COM » :

(member=CN=TestUser,DC=Fabrikam,DC=COM)

INTEGER8

La valeur spécifiée dans un filtre doit être un entier décimal. Convertissez des valeurs hexadécimales en décimales.

L’exemple de code suivant montre un filtre qui spécifie un creationTime défini sur un FILETIME de « 1999-12-31 23:59:59 (UTC/GMT) » :

(creationTime=125911583990000000)

Les fonctions suivantes créent un filtre de correspondance exacte (=) pour un attribut entier volumineux et vérifient l’attribut dans le schéma et sa syntaxe :

//***************************************************************************
//
//  CheckAttribute()
//
//***************************************************************************

HRESULT CheckAttribute(LPOLESTR szAttribute, LPOLESTR szSyntax)
{
    HRESULT hr = E_FAIL;
    BSTR bstr;
    IADsProperty *pObject = NULL;
    LPWSTR szPrefix = L"LDAP://schema/";
    LPWSTR szPath;
     
    if((!szAttribute) || (!szSyntax))
    {
        return E_POINTER;
    }

    // Allocate a buffer large enough to hold the ADsPath of the attribute.
    szPath = new WCHAR[lstrlenW(szPrefix) + lstrlenW(szAttribute) + 1];
    if(NULL == szPath)
    {
        return E_OUTOFMEMORY;
    }
     
    // Create the ADsPath of the attribute.
    wcscpy_s(szPath, szPrefix);
    wcscat_s(szPath, szAttribute);

    hr = ADsOpenObject( szPath,
                        NULL,
                        NULL,
                        ADS_SECURE_AUTHENTICATION, // Use Secure Authentication.
                        IID_IADsProperty,
                        (void**)&pObject);
    if(SUCCEEDED(hr)) 
    {
        hr = pObject->get_Syntax(&bstr);
        if (SUCCEEDED(hr)) 
        {
            if (0==lstrcmpiW(bstr, szSyntax)) 
            {
                hr = S_OK;
            }
            else
            {
                hr = S_FALSE;
            }
        }

        SysFreeString(bstr);
    }
    
    if(pObject)
    {
        pObject->Release();
    }

    delete szPath;
    
    return hr;
}

//***************************************************************************
//
//  CreateExactMatchFilterLargeInteger()
//
//***************************************************************************

HRESULT CreateExactMatchFilterLargeInteger( LPOLESTR szAttribute, 
                                            INT64 liValue, 
                                            LPOLESTR *pszFilter)
{
    HRESULT hr = E_FAIL;
     
    if ((!szAttribute) || (!pszFilter))
    {
        return E_POINTER;
    }
     
    // Verify that the attribute exists and has 
    // Integer8 (Large Integer) syntax.
     
    hr = CheckAttribute(szAttribute, L"Integer8");
    if (S_OK == hr) 
    {
        LPWSTR szFormat = L"%s=%I64d";
        LPWSTR szTempFilter = new WCHAR[lstrlenW(szFormat) + lstrlenW(szAttribute) + 20 + 1];

        if(NULL == szTempFilter)
        {
            return E_OUTOFMEMORY;
        }
        
        swprintf_s(szTempFilter, L"%s=%I64d", szAttribute, liValue);
     
        // Allocate buffer for the filter string.
        // Caller must free the buffer using CoTaskMemFree.
        *pszFilter = (OLECHAR *)CoTaskMemAlloc(sizeof(OLECHAR) * (lstrlenW(szTempFilter) + 1));
        if (*pszFilter) 
        {
            wcscpy_s(*pszFilter, szTempFilter);
            hr = S_OK;
        }
        else
        {
            hr = E_OUTOFMEMORY;
        }

        delete szTempFilter;
    }

    return hr;
}

PrintableString

Les attributs avec ces syntaxes doivent respecter des jeux de caractères spécifiques. Pour plus d’informations, consultez Syntaxes pour les attributs dans services de domaine Active Directory.

Actuellement, services de domaine Active Directory n’appliquez pas ces jeux de caractères.

La valeur spécifiée dans un filtre est une chaîne. La comparaison respecte la casse.

GeneralizedTime

La valeur spécifiée dans un filtre est une chaîne qui représente la date sous la forme suivante :

YYYYMMDDHHMMSS.0Z

« 0Z » indique qu’il n’y a pas de différentiel de temps. N’oubliez pas que le serveur Active Directory stocke la date/heure en tant qu’heure moyenne de Greenwich (GMT). Si un différentiel de temps n’est pas spécifié, la valeur par défaut est GMT.

Si le fuseau horaire local n’est pas GMT, utilisez une valeur différentielle pour spécifier votre fuseau horaire local et appliquez le différentiel à GMT. Le différentiel est basé sur : GMT=Local+différentiel.

Pour spécifier un différentiel, utilisez :

YYYYMMDDHHMMSS.0[+/-]HHMM

L’exemple suivant montre un filtre qui spécifie une heure whenCreated définie sur 23/3/99 8:52:58 PM GMT :

(whenCreated=19990323205258.0Z)

L’exemple suivant montre un filtre qui spécifie une heure whenCreated définie sur 23/3/99 20:52:58 Heure standard de Nouvelle-Zélande (différentielle est de +12 heures) :

(whenCreated=19990323205258.0+1200)

L’exemple de code suivant montre comment calculer le différentiel de fuseau horaire. La fonction retourne le différentiel entre le fuseau horaire local actuel et GMT. La valeur retournée est une chaîne au format suivant :

[+/-]HHMM

Par exemple, l’heure standard du Pacifique est de -0800.

//***************************************************************************
//
//  GetLocalTimeZoneDifferential()
//
//***************************************************************************

HRESULT GetLocalTimeZoneDifferential(LPOLESTR *pszDifferential)
{
    if(NULL == pszDifferential)
    {
        return E_INVALIDARG;
    }
    
    HRESULT hr = E_FAIL;
    DWORD dwReturn;
    TIME_ZONE_INFORMATION timezoneinfo;
    LONG lTimeDifferential;
    LONG lHours;
    LONG lMinutes;
    
    dwReturn  = GetTimeZoneInformation(&timezoneinfo);

    switch (dwReturn)
    {
    case TIME_ZONE_ID_STANDARD:
        lTimeDifferential = timezoneinfo.Bias + timezoneinfo.StandardBias;
        
        // Bias is in minutes. Calculate the hours for HHMM format.
        lHours = -(lTimeDifferential/60);
        
        // Bias is in minutes. Calculate the minutes for HHMM format.
        lMinutes = lTimeDifferential%60L;

        hr = S_OK;
        break;

    case TIME_ZONE_ID_DAYLIGHT:
        lTimeDifferential = timezoneinfo.Bias + timezoneinfo.DaylightBias;
        
        // Bias is in minutes. Calculate the hours for HHMM format.
        // Apply the additive inverse.
        // Bias is based on GMT=Local+Bias.
        // A differential, based on GMT=Local-Bias, is required.
        lHours = -(lTimeDifferential/60);
        
        // Bias is in minutes. Calculate the minutes for HHMM format.
        lMinutes = lTimeDifferential%60L;
        
        hr = S_OK;
        break;

    case TIME_ZONE_ID_INVALID:
    default:
        hr = E_FAIL;
        break;
    }
     
    if (SUCCEEDED(hr))
    {
        // The caller must free the memory using CoTaskMemFree.
        *pszDifferential = (OLECHAR *)CoTaskMemAlloc(sizeof(OLECHAR) * (3 + 2 + 1));
        if (*pszDifferential)
        {
            swprintf_s(*pszDifferential, L"%+03d%02d", lHours, lMinutes);
            
            hr = S_OK;
        }
        else
        {
            hr = E_OUTOFMEMORY;
        }
    }
     
    return hr;
}

UTCTime

La valeur spécifiée dans un filtre est une chaîne qui représente la date sous la forme suivante :

YYMMDDHHMMSSZ

Z indique qu’il n’y a pas de différentiel horaire. N’oubliez pas que le serveur Active Directory stocke la date et l’heure en tant qu’heure GMT. Si un différentiel d’heure n’est pas spécifié, GMT est la valeur par défaut.

La valeur secondes (« SS ») est facultative.

Si GMT n’est pas le fuseau horaire local, appliquez une valeur différentielle locale pour spécifier votre fuseau horaire local. Le différentiel est : GMT=Local+differential.

Pour spécifier un différentiel, utilisez la forme suivante :

YYMMDDHHMMSS[+/-]HHMM

L’exemple suivant montre un filtre qui spécifie une heure myTimeAttrib définie sur 23/3/99 8:52:58 PM GMT :

(myTimeAttrib=990323205258Z)

L’exemple suivant montre un filtre qui spécifie une heure myTimeAttrib définie sur 23/3/99 8:52:58 PM sans secondes spécifiées :

(myTimeAttrib=9903232052Z)

L’exemple suivant montre un filtre qui spécifie une heure myTimeAttrib définie sur 3/23/99 8:52:58 PM Heure standard de Nouvelle-Zélande (différentielle est de 12 heures). Cela équivaut au 23/03/99 8:52:58 AM GMT.

(myTimeAttrib=990323205258+1200)

DirectoryString

La valeur spécifiée dans un filtre est une chaîne. DirectoryString peut contenir des caractères Unicode. La comparaison respecte la casse.

OID

L’ensemble de l’OID à mettre en correspondance doit être fourni.

Les caractères génériques ne sont pas acceptés.

L’attribut objectCategory vous permet de spécifier le lDAPDisplayName du jeu de classes pour l’attribut.

L’exemple suivant montre un filtre qui spécifie governsID pour la classe de volume :

(governsID=1.2.840.113556.1.5.36)

Deux filtres équivalents qui spécifient l’attribut systemMustContain contenant uNCName, qui a un OID de 1.2.840.113556.1.4.137 :

(SystemMustContain=uNCName)
 
(SystemMustContain=1.2.840.113556.1.4.137)

Autres syntaxes

Les syntaxes suivantes sont évaluées dans un filtre similaire à une chaîne d’octets :

ObjectSecurityDescriptor
AccessPointDN
PresentationAddresses
ReplicaLink
DNWithString
DNWithOctetString
ORName

Partager via

Comment spécifier des valeurs de comparaison

Commentaires

Ressources supplémentaires