[ADSI] récuperer un nom de domaine

bonjour @ tous.

Actuellement, je developpe une classe me permettant de diaoguer via le protocole LDAP avec un serveur d'annuaire. Pour récupérer le nom de domaine sous la forme d'un DN (Distinguished Name), je dois interroger l'entrée rootDsequi contient toutes les informations sur le serveur.

Pour se faire, je me suis inspiré de cet exemple dans lequel il faut utiliser les interfaces ADSI.

Seulement, la fonction VariantInit et le type variant utilisé sont assez complexe. Quelq'un aurait-il deja mis en place ceci ?

Merci

voila l'exemple en C de la MSDN :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
IADs *pads;
hr = ADsGetObject(  L"LDAP://rootDSE",
                    IID_IADs, 
                    (void**)&pads);
 
if(SUCCEEDED(hr))
{
    VARIANT var;
 
    VariantInit(&var);
    
    hr = pads->Get(CComBSTR("defaultNamingContext"), &var);
    if(SUCCEEDED(hr))
    {
        if(VT_BSTR == var.vt)
        {
            wprintf(var.bstrVal);
        }
 
        VariantClear(&var);
    }
 
    pads->Release();
}

le problème c'est que cet exemple fait intervenir la fonction VariantInit et je ne sais pas ou elle est definie et que le type variant est monstreux :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
typedef struct tagVARIANT VARIANT;
typedef struct tagVARIANT VARIANTARG;
struct tagVARIANT
    {
    union 
        {
        struct __tagVARIANT
            {
            VARTYPE vt;
            WORD wReserved1;
            WORD wReserved2;
            WORD wReserved3;
            union 
                {
                LONGLONG llVal;
                LONG lVal;
                BYTE bVal;
                SHORT iVal;
                FLOAT fltVal;
                DOUBLE dblVal;
                VARIANT_BOOL boolVal;
                _VARIANT_BOOL bool;
                SCODE scode;
                CY cyVal;
                DATE date;
                BSTR bstrVal;
                IUnknown *punkVal;
                IDispatch *pdispVal;
                SAFEARRAY *parray;
                BYTE *pbVal;
                SHORT *piVal;
                LONG *plVal;
                LONGLONG *pllVal;
                FLOAT *pfltVal;
                DOUBLE *pdblVal;
                VARIANT_BOOL *pboolVal;
                _VARIANT_BOOL *pbool;
                SCODE *pscode;
                CY *pcyVal;
                DATE *pdate;
                BSTR *pbstrVal;
                IUnknown **ppunkVal;
                IDispatch **ppdispVal;
                SAFEARRAY **pparray;
                VARIANT *pvarVal;
                PVOID byref;
                CHAR cVal;
                USHORT uiVal;
                ULONG ulVal;
                ULONGLONG ullVal;
                INT intVal;
                UINT uintVal;
                DECIMAL *pdecVal;
                CHAR *pcVal;
                USHORT *puiVal;
                ULONG *pulVal;
                ULONGLONG *pullVal;
                INT *pintVal;
                UINT *puintVal;
                struct __tagBRECORD
                    {
                    PVOID pvRecord;
                    IRecordInfo *pRecInfo;
                    }    __VARIANT_NAME_4;
                }    __VARIANT_NAME_3;
            }    __VARIANT_NAME_2;
        DECIMAL decVal;
        }    __VARIANT_NAME_1;
struct tagVARIANT  
   {
    union 
       {
       struct __tagVARIANT
       {
          VARTYPE vt;
          WORD wReserved1;
          WORD wReserved2;
          WORD wReserved3;
   union {
      LONGLONG                llval;             // VT_I8. 
      LONG                    lVal;              // VT_I4.
      BYTE                    bVal;              // VT_UI1.
      SHORT                   iVal;              // VT_I2.
      FLOAT                   fltVal;            // VT_R4.
      DOUBLE                  dblVal;            // VT_R8.
      VARIANT_BOOL            boolVal;           // VT_BOOL.
      _VARIANT_BOOL           bool;
      SCODE                   scode;             // VT_ERROR.
      CY                      cyVal;             // VT_CY.
      DATE                    date;              // VT_DATE.
      BSTR                    bstrVal;           // VT_BSTR.
      IUnknown                * punkVal;         // VT_UNKNOWN.
      IDispatch               * pdispVal;        // VT_DISPATCH.
      SAFEARRAY               * parray;          // VT_ARRAY|*.
      BYTE                    * pbVal;           // VT_BYREF|VT_UI1.
      SHORT                   * piVal;           // VT_BYREF|VT_I2.
      LONG                    * plVal;           // VT_BYREF|VT_I4.
      LONGLONG                * pllVal;          // VT_BYREF|VT_I8.
      FLOAT                   * pfltVal;         // VT_BYREF|VT_R4.
      DOUBLE                  * pdblVal;         // VT_BYREF|VT_R8.
      VARIANT_BOOL            * pboolVal;        // VT_BYREF|VT_BOOL.
      _VARIANT_BOOL           * pbool;
      SCODE                   * pscode;          // VT_BYREF|VT_ERROR.
      CY                      * pcyVal;          // VT_BYREF|VT_CY.
      DATE                    * pdate;           // VT_BYREF|VT_DATE.
      BSTR                    * pbstrVal;        // VT_BYREF|VT_BSTR.
      IUnknown                ** ppunkVal;       // VT_BYREF|VT_UNKNOWN.
      IDispatch               ** ppdispVal;      // VT_BYREF|VT_DISPATCH.
      SAFEARRAY               ** pparray;        // VT_ARRAY|*.
      VARIANT                 * pvarVal;         // VT_BYREF|VT_VARIANT.
      PVOID                   * byref;           // Generic ByRef.
      CHAR                    cVal;              // VT_I1.
      USHORT                  uiVal;             // VT_UI2.
      ULONG                   ulVal;             // VT_UI4.
      ULONGLONG               ullVal;            // VT_UI8.
      INT                     intVal;            // VT_INT.
      UINT                    uintVal;           // VT_UINT.
      DECIMAL                 * pdecVal          // VT_BYREF|VT_DECIMAL.
      CHAR                    * pcVal;           // VT_BYREF|VT_I1.
      USHORT                  * puiVal;          // VT_BYREF|VT_UI2.
      ULONG                   * pulVal;          // VT_BYREF|VT_UI4.
      ULONGLONG               * pullVal;         // VT_BYREF|VT_UI8.
      INT                     * pintVal;         // VT_BYREF|VT_INT.
      UINT                    * puintVal;        // VT_BYREF|VT_UINT.
      struct __tagBRECORD
      {
      PVOID                   pvRecord;
      IRecordInfo             *pRecInfo;
      }    __VARIANT_NAME_4;
   }    __VARIANT_NAME_3;
  }    __VARIANT_NAME_2;
  DECIMAL decVal;
}    __VARIANT_NAME_1;
 
   };
};

perso je ne sais pas faire les unions en delphi !

Citation:

VariantInit et je ne sais pas ou elle est definie
Code:

1 2 uses VarUtils; procedure VariantInit(var V: TVarData); stdcall;
Citation:

type variant est monstreux

Ouf, Borland l'a déjà traduit en Delphi... Inclus Variants dans tes clauses uses, pour voir.

Citation:

perso je ne sais pas faire les unions en delphi !

Et bien moi siiiii, heu, la la la la lère...

:salut: :idea:

Salut, voici comment, avec delphi, je fais pour recuperer le nom complet du domaine par defaut :
Code:

1 2 3 4 5 6 7 8 9 10 11 // var AdsInfo:IADs; DomStr:String; Try ADsGetObject('LDAP://rootDSE', IID_IADs, AdsInfo); DomStr:= AdsInfo.Get('defaultNamingContext'); Except //... end; edt_DCname.Text:=DomStr; // ex: DC=local,DC=domain ...
necessite la librairie ADSI.

@+ ! :D