idl: Use DRSUAPI_ATTID_ prefix instead of DRSUAPI_ATTRIBUTE_ for ATTID values
[kamenim/samba.git] / librpc / ndr / ndr_drsuapi.c
1 /*
2    Unix SMB/CIFS implementation.
3
4    routines for printing some linked list structs in DRSUAPI
5
6    Copyright (C) Stefan (metze) Metzmacher 2005
7
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 3 of the License, or
11    (at your option) any later version.
12
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17
18    You should have received a copy of the GNU General Public License
19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
20 */
21
22
23 #include "includes.h"
24 #include "librpc/gen_ndr/ndr_drsuapi.h"
25 #include "librpc/gen_ndr/ndr_misc.h"
26 #include "../lib/util/asn1.h"
27 #include "librpc/ndr/ndr_compression.h"
28 /* We don't need multibyte if we're just comparing to 'ff' */
29 #undef strncasecmp
30
31 void ndr_print_drsuapi_DsReplicaObjectListItem(struct ndr_print *ndr, const char *name,
32                                                const struct drsuapi_DsReplicaObjectListItem *r)
33 {
34         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjectListItem");
35         ndr->depth++;
36         ndr_print_ptr(ndr, "next_object", r->next_object);
37         ndr_print_drsuapi_DsReplicaObject(ndr, "object", &r->object);
38         ndr->depth--;
39         if (r->next_object) {
40                 ndr_print_drsuapi_DsReplicaObjectListItem(ndr, "next_object", r->next_object);
41         }
42 }
43
44 void ndr_print_drsuapi_DsReplicaObjectListItemEx(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjectListItemEx *r)
45 {
46         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjectListItemEx");
47         ndr->depth++;
48         ndr_print_ptr(ndr, "next_object", r->next_object);
49         ndr_print_drsuapi_DsReplicaObject(ndr, "object", &r->object);
50         ndr_print_uint32(ndr, "is_nc_prefix", r->is_nc_prefix);
51         ndr_print_ptr(ndr, "parent_object_guid", r->parent_object_guid);
52         ndr->depth++;
53         if (r->parent_object_guid) {
54                 ndr_print_GUID(ndr, "parent_object_guid", r->parent_object_guid);
55         }
56         ndr->depth--;
57         ndr_print_ptr(ndr, "meta_data_ctr", r->meta_data_ctr);
58         ndr->depth++;
59         if (r->meta_data_ctr) {
60                 ndr_print_drsuapi_DsReplicaMetaDataCtr(ndr, "meta_data_ctr", r->meta_data_ctr);
61         }
62         ndr->depth--;
63         ndr->depth--;
64         if (r->next_object) {
65                 ndr_print_drsuapi_DsReplicaObjectListItemEx(ndr, "next_object", r->next_object);
66         }
67 }
68
69 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOID(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOID *r)
70 {
71         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOID");
72         ndr->depth++;
73         ndr_print_uint32(ndr, "length", r->length);
74         ndr->print(ndr, "%-25s: length=%u", "oid", r->length);
75         if (r->binary_oid) {
76                 char *partial_oid = NULL;
77                 DATA_BLOB oid_blob = data_blob_const(r->binary_oid, r->length);
78                 char *hex_str = data_blob_hex_string_upper(ndr, &oid_blob);
79                 ber_read_partial_OID_String(ndr, oid_blob, (const char **)&partial_oid);
80                 ndr->depth++;
81                 ndr->print(ndr, "%-25s: 0x%s (%s)", "binary_oid", hex_str, partial_oid);
82                 ndr->depth--;
83                 talloc_free(hex_str);
84                 talloc_free(partial_oid);
85         }
86         ndr->depth--;
87 }
88
89 static void _print_drsuapi_DsAttributeValue_attid(struct ndr_print *ndr, const char *name,
90                                                   const struct drsuapi_DsAttributeValue *r)
91 {
92         uint32_t v;
93
94         ndr_print_struct(ndr, name, "drsuapi_DsAttributeValue");
95         ndr->depth++;
96         v = IVAL(r->blob->data, 0);
97         ndr_print_uint32(ndr, "attid", v);
98         ndr->depth--;
99 }
100
101 static void _print_drsuapi_DsAttributeValue_str(struct ndr_print *ndr, const char *name,
102                                                 const struct drsuapi_DsAttributeValue *r)
103 {
104         char *str;
105
106         ndr_print_struct(ndr, name, "drsuapi_DsAttributeValue");
107         ndr->depth++;
108         if (!convert_string_talloc(ndr,
109                                    CH_UTF16, CH_UNIX,
110                                    r->blob->data,
111                                    r->blob->length,
112                                    (void **)&str, NULL, false)) {
113                 ndr_print_string(ndr, "string", "INVALID CONVERSION");
114         } else {
115                 ndr_print_string(ndr, "string", str);
116                 talloc_free(str);
117         }
118         ndr->depth--;
119 }
120
121 static void _print_drsuapi_DsAttributeValueCtr(struct ndr_print *ndr,
122                                                const char *name,
123                                                const struct drsuapi_DsAttributeValueCtr *r,
124                                                void (*print_val_fn)(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAttributeValue *r))
125 {
126         uint32_t cntr_values_1;
127         ndr_print_struct(ndr, name, "drsuapi_DsAttributeValueCtr");
128         ndr->depth++;
129         ndr_print_uint32(ndr, "num_values", r->num_values);
130         ndr_print_ptr(ndr, "values", r->values);
131         ndr->depth++;
132         if (r->values) {
133                 ndr->print(ndr, "%s: ARRAY(%d)", "values", (int)r->num_values);
134                 ndr->depth++;
135                 for (cntr_values_1=0;cntr_values_1<r->num_values;cntr_values_1++) {
136                         char *idx_1=NULL;
137                         if (asprintf(&idx_1, "[%d]", cntr_values_1) != -1) {
138                                 //ndr_print_drsuapi_DsAttributeValue(ndr, "values", &r->values[cntr_values_1]);
139                                 print_val_fn(ndr, "values", &r->values[cntr_values_1]);
140                                 free(idx_1);
141                         }
142                 }
143                 ndr->depth--;
144         }
145         ndr->depth--;
146         ndr->depth--;
147 }
148
149 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttribute(struct ndr_print *ndr,
150                                                    const char *name,
151                                                    const struct drsuapi_DsReplicaAttribute *r)
152 {
153         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttribute");
154         ndr->depth++;
155         ndr_print_drsuapi_DsAttributeId(ndr, "attid", r->attid);
156         switch (r->attid) {
157         case DRSUAPI_ATTID_objectClass:
158         case DRSUAPI_ATTID_possSuperiors:
159         case DRSUAPI_ATTID_subClassOf:
160         case DRSUAPI_ATTID_governsID:
161         case DRSUAPI_ATTID_mustContain:
162         case DRSUAPI_ATTID_mayContain:
163         case DRSUAPI_ATTID_rDNAttId:
164         case DRSUAPI_ATTID_attributeID:
165         case DRSUAPI_ATTID_attributeSyntax:
166         case DRSUAPI_ATTID_auxiliaryClass:
167         case DRSUAPI_ATTID_systemPossSuperiors:
168         case DRSUAPI_ATTID_systemMayContain:
169         case DRSUAPI_ATTID_systemMustContain:
170         case DRSUAPI_ATTID_systemAuxiliaryClass:
171         case DRSUAPI_ATTID_transportAddressAttribute:
172                 /* ATTIDs for classSchema and attributeSchema */
173                 _print_drsuapi_DsAttributeValueCtr(ndr, "value_ctr", &r->value_ctr,
174                                                    _print_drsuapi_DsAttributeValue_attid);
175                 break;
176         case DRSUAPI_ATTID_cn:
177         case DRSUAPI_ATTID_ou:
178         case DRSUAPI_ATTID_description:
179         case DRSUAPI_ATTID_displayName:
180         case DRSUAPI_ATTID_dMDLocation:
181         case DRSUAPI_ATTID_adminDisplayName:
182         case DRSUAPI_ATTID_adminDescription:
183         case DRSUAPI_ATTID_lDAPDisplayName:
184         case DRSUAPI_ATTID_name:
185                 _print_drsuapi_DsAttributeValueCtr(ndr, "value_ctr", &r->value_ctr,
186                                                    _print_drsuapi_DsAttributeValue_str);
187                 break;
188         default:
189                 _print_drsuapi_DsAttributeValueCtr(ndr, "value_ctr", &r->value_ctr,
190                                                    ndr_print_drsuapi_DsAttributeValue);
191                 break;
192         }
193         ndr->depth--;
194 }
195
196 enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesMSZIPCtr1 *r)
197 {
198         if (ndr_flags & NDR_SCALARS) {
199                 uint32_t decompressed_length = 0;
200                 uint32_t compressed_length = 0;
201                 if (r->ts) {
202                         {
203                                 struct ndr_push *_ndr_ts;
204                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_ts, 4, -1));
205                                 {
206                                         struct ndr_push *_ndr_ts_compressed;
207                                         NDR_CHECK(ndr_push_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_MSZIP, -1));
208                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr1TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
209                                         decompressed_length = _ndr_ts_compressed->offset;
210                                         NDR_CHECK(ndr_push_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_MSZIP, -1));
211                                 }
212                                 compressed_length = _ndr_ts->offset;
213                                 talloc_free(_ndr_ts);
214                         }
215                 }
216                 NDR_CHECK(ndr_push_align(ndr, 4));
217                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, decompressed_length));
218                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, compressed_length));
219                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ts));
220         }
221         if (ndr_flags & NDR_BUFFERS) {
222                 if (r->ts) {
223                         {
224                                 struct ndr_push *_ndr_ts;
225                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_ts, 4, -1));
226                                 {
227                                         struct ndr_push *_ndr_ts_compressed;
228                                         NDR_CHECK(ndr_push_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_MSZIP, -1));
229                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr1TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
230                                         NDR_CHECK(ndr_push_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_MSZIP, -1));
231                                 }
232                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_ts, 4, -1));
233                         }
234                 }
235         }
236         return NDR_ERR_SUCCESS;
237 }
238
239 enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesMSZIPCtr6(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesMSZIPCtr6 *r)
240 {
241         if (ndr_flags & NDR_SCALARS) {
242                 uint32_t decompressed_length = 0;
243                 uint32_t compressed_length = 0;
244                 if (r->ts) {
245                         {
246                                 struct ndr_push *_ndr_ts;
247                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_ts, 4, -1));
248                                 {
249                                         struct ndr_push *_ndr_ts_compressed;
250                                         NDR_CHECK(ndr_push_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_MSZIP, -1));
251                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr6TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
252                                         decompressed_length = _ndr_ts_compressed->offset;
253                                         NDR_CHECK(ndr_push_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_MSZIP, -1));
254                                 }
255                                 compressed_length = _ndr_ts->offset;
256                                 talloc_free(_ndr_ts);
257                         }
258                 }
259                 NDR_CHECK(ndr_push_align(ndr, 4));
260                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, decompressed_length));
261                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, compressed_length));
262                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ts));
263         }
264         if (ndr_flags & NDR_BUFFERS) {
265                 if (r->ts) {
266                         {
267                                 struct ndr_push *_ndr_ts;
268                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_ts, 4, -1));
269                                 {
270                                         struct ndr_push *_ndr_ts_compressed;
271                                         NDR_CHECK(ndr_push_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_MSZIP, -1));
272                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr6TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
273                                         NDR_CHECK(ndr_push_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_MSZIP, -1));
274                                 }
275                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_ts, 4, -1));
276                         }
277                 }
278         }
279         return NDR_ERR_SUCCESS;
280 }
281
282 enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesXPRESSCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesXPRESSCtr1 *r)
283 {
284         if (ndr_flags & NDR_SCALARS) {
285                 uint32_t decompressed_length = 0;
286                 uint32_t compressed_length = 0;
287                 if (r->ts) {
288                         {
289                                 struct ndr_push *_ndr_ts;
290                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_ts, 4, -1));
291                                 {
292                                         struct ndr_push *_ndr_ts_compressed;
293                                         NDR_CHECK(ndr_push_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_XPRESS, -1));
294                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr1TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
295                                         decompressed_length = _ndr_ts_compressed->offset;
296                                         NDR_CHECK(ndr_push_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_XPRESS, -1));
297                                 }
298                                 compressed_length = _ndr_ts->offset;
299                                 talloc_free(_ndr_ts);
300                         }
301                 }
302                 NDR_CHECK(ndr_push_align(ndr, 4));
303                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, decompressed_length));
304                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, compressed_length));
305                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ts));
306         }
307         if (ndr_flags & NDR_BUFFERS) {
308                 if (r->ts) {
309                         {
310                                 struct ndr_push *_ndr_ts;
311                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_ts, 4, -1));
312                                 {
313                                         struct ndr_push *_ndr_ts_compressed;
314                                         NDR_CHECK(ndr_push_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_XPRESS, -1));
315                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr1TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
316                                         NDR_CHECK(ndr_push_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_XPRESS, -1));
317                                 }
318                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_ts, 4, -1));
319                         }
320                 }
321         }
322         return NDR_ERR_SUCCESS;
323 }
324
325 enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesXPRESSCtr6(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesXPRESSCtr6 *r)
326 {
327         if (ndr_flags & NDR_SCALARS) {
328                 uint32_t decompressed_length = 0;
329                 uint32_t compressed_length = 0;
330                 if (r->ts) {
331                         {
332                                 struct ndr_push *_ndr_ts;
333                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_ts, 4, -1));
334                                 {
335                                         struct ndr_push *_ndr_ts_compressed;
336                                         NDR_CHECK(ndr_push_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_XPRESS, -1));
337                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr6TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
338                                         decompressed_length = _ndr_ts_compressed->offset;
339                                         NDR_CHECK(ndr_push_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_XPRESS, -1));
340                                 }
341                                 compressed_length = _ndr_ts->offset;
342                                 talloc_free(_ndr_ts);
343                         }
344                 }
345                 NDR_CHECK(ndr_push_align(ndr, 4));
346                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, decompressed_length));
347                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, compressed_length));
348                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ts));
349         }
350         if (ndr_flags & NDR_BUFFERS) {
351                 if (r->ts) {
352                         {
353                                 struct ndr_push *_ndr_ts;
354                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_ts, 4, -1));
355                                 {
356                                         struct ndr_push *_ndr_ts_compressed;
357                                         NDR_CHECK(ndr_push_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_XPRESS, -1));
358                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr6TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
359                                         NDR_CHECK(ndr_push_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_XPRESS, -1));
360                                 }
361                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_ts, 4, -1));
362                         }
363                 }
364         }
365         return NDR_ERR_SUCCESS;
366 }
367
368 _PUBLIC_ size_t ndr_size_drsuapi_DsReplicaObjectIdentifier3Binary_without_Binary(const struct drsuapi_DsReplicaObjectIdentifier3Binary *r, int flags)
369 {
370         return ndr_size_struct((const struct drsuapi_DsReplicaObjectIdentifier3 *)r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
371 }
372
373 _PUBLIC_ void ndr_print_drsuapi_SecBufferType(struct ndr_print *ndr, const char *name, enum drsuapi_SecBufferType r)
374 {
375         const char *val = NULL;
376
377         switch (r & 0x00000007) {
378                 case DRSUAPI_SECBUFFER_EMPTY: val = "DRSUAPI_SECBUFFER_EMPTY"; break;
379                 case DRSUAPI_SECBUFFER_DATA: val = "DRSUAPI_SECBUFFER_DATA"; break;
380                 case DRSUAPI_SECBUFFER_TOKEN: val = "DRSUAPI_SECBUFFER_TOKEN"; break;
381                 case DRSUAPI_SECBUFFER_PKG_PARAMS: val = "DRSUAPI_SECBUFFER_PKG_PARAMS"; break;
382                 case DRSUAPI_SECBUFFER_MISSING: val = "DRSUAPI_SECBUFFER_MISSING"; break;
383                 case DRSUAPI_SECBUFFER_EXTRA: val = "DRSUAPI_SECBUFFER_EXTRA"; break;
384                 case DRSUAPI_SECBUFFER_STREAM_TRAILER: val = "DRSUAPI_SECBUFFER_STREAM_TRAILER"; break;
385                 case DRSUAPI_SECBUFFER_STREAM_HEADER: val = "DRSUAPI_SECBUFFER_STREAM_HEADER"; break;
386         }
387
388         if (r & DRSUAPI_SECBUFFER_READONLY) {
389                 char *v = talloc_asprintf(ndr, "DRSUAPI_SECBUFFER_READONLY | %s", val);
390                 ndr_print_enum(ndr, name, "ENUM", v, r);
391         } else {
392                 ndr_print_enum(ndr, name, "ENUM", val, r);
393         }
394 }
395
396 _PUBLIC_ void ndr_print_drsuapi_DsAddEntry_AttrErrListItem_V1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntry_AttrErrListItem_V1 *r)
397 {
398         ndr_print_struct(ndr, name, "drsuapi_DsAddEntry_AttrErrListItem_V1");
399         ndr->depth++;
400         ndr_print_ptr(ndr, "next", r->next);
401         ndr_print_drsuapi_DsAddEntry_AttrErr_V1(ndr, "err_data", &r->err_data);
402         ndr->depth--;
403         if (r->next) {
404                 ndr_print_drsuapi_DsAddEntry_AttrErrListItem_V1(ndr, "next", r->next);
405         }
406 }