?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Daily ChangeLog Update
[OpenChange-git-clone.git] / ndr_mapi.c
blob019be78cece05fb66588d242d14cd222fbf2da6e
1 /*
2 OpenChange implementation.
3
4 libndr mapi support
5
6 Copyright (C) Julien Kerihuel 2005-2008
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 #include <libmapi/libmapi.h>
23 #include <ndr.h>
24 #include <gen_ndr/ndr_exchange.h>
25
26
27 static void obfuscate_data(uint8_t *data, uint32_t size, uint8_t salt)
28 {
29 uint32_t i;
30
31 for (i=0; i<size; i++) {
32 data[i] ^= salt;
33 }
34 }
35
36 /*
37 print mapi_request / mapi_response structures
38 */
39
40 void ndr_print_mapi_request(struct ndr_print *ndr, const char *name, const struct mapi_request *r)
41 {
42 uint32_t rlength;
43
44 rlength = r->mapi_len - r->length;
45
46 ndr_print_uint32(ndr, "mapi_len", r->mapi_len);
47 if (r->length && r->length > sizeof(uint16_t)) {
48 uint32_t cntr_mapi_req_0;
49
50 ndr_print_uint16(ndr, "length", r->length);
51 ndr->depth++;
52 for (cntr_mapi_req_0=0; r->mapi_req[cntr_mapi_req_0].opnum; cntr_mapi_req_0++) {
53 char *idx_0 = NULL;
54 int ret;
55
56 ret = asprintf(&idx_0, "[%u]", cntr_mapi_req_0);
57 if (ret != -1 && idx_0) {
58 ndr_print_EcDoRpc_MAPI_REQ(ndr, "mapi_request", &r->mapi_req[cntr_mapi_req_0]);
59 free(idx_0);
60 }
61 }
62 ndr->depth--;
63 }
64
65 if (rlength) {
66 uint32_t i;
67
68 ndr->depth++;
69 ndr->print(ndr, "%-25s: (handles) number=%u", name, rlength / 4);
70 ndr->depth++;
71 for (i = 0; i < (rlength / 4); i++) {
72 ndr_print_uint32(ndr, "handle", r->handles[i]);
73 }
74 ndr->depth--;
75 }
76 }
77
78 void ndr_print_mapi_response(struct ndr_print *ndr, const char *name, const struct mapi_response *r)
79 {
80 uint32_t rlength;
81
82 rlength = r->mapi_len - r->length;
83
84 ndr->print(ndr, "%-25s: length=%u", name, r->length);
85 if (r->length && r->length > sizeof(uint16_t)) {
86 uint32_t cntr_mapi_repl_0;
87
88 ndr->print(ndr, "%s: ARRAY(%d)", name, r->length - 2);
89 ndr->depth++;
90 for (cntr_mapi_repl_0=0; r->mapi_repl[cntr_mapi_repl_0].opnum; cntr_mapi_repl_0++) {
91 ndr_print_EcDoRpc_MAPI_REPL(ndr, "mapi_repl", &r->mapi_repl[cntr_mapi_repl_0]);
92 }
93 ndr->depth--;
94 }
95
96 ndr->print(ndr, "%-25s: (handles) number=%u", name, rlength / 4);
97
98 if (rlength) {
99 uint32_t i;
100
101 ndr->depth++;
102
103 for (i = 0; i < (rlength / 4); i++) {
104 ndr_print_uint32(ndr, "handle id", r->handles[i]);
105 }
106 ndr->depth--;
107 }
108 }
109
110
111 /*
112 push mapi_request / mapi_response onto the wire.
113
114 MAPI length field includes length bytes.
115 But these bytes do not belong to the mapi content in the user
116 context. We have to add them when pushing mapi content length
117 (uint16_t) and next substract when pushing the content blob
118 */
119
120 enum ndr_err_code ndr_push_mapi_request(struct ndr_push *ndr, int ndr_flags, const struct mapi_request *r)
121 {
122 uint32_t cntr_mapi_req_0;
123 uint32_t count;
124
125 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
126 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->length));
127
128 for (count = 0; ndr->offset < r->length - 2; count++) {
129 NDR_CHECK(ndr_push_EcDoRpc_MAPI_REQ(ndr, NDR_SCALARS, &r->mapi_req[count]));
130 }
131
132 count = (r->mapi_len - r->length) / sizeof(uint32_t);
133 for (cntr_mapi_req_0=0; cntr_mapi_req_0 < count; cntr_mapi_req_0++) {
134 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->handles[cntr_mapi_req_0]));
135 }
136
137 obfuscate_data(ndr->data, ndr->offset, 0xA5);
138
139 return NDR_ERR_SUCCESS;
140 }
141
142 enum ndr_err_code ndr_push_mapi_response(struct ndr_push *ndr, int ndr_flags, const struct mapi_response *r)
143 {
144 uint32_t cntr_mapi_repl_0;
145 uint32_t count;
146
147 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
148 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->length));
149
150 if (r->length > sizeof (uint16_t)) {
151 for (count = 0; ndr->offset < r->length - 2; count++) {
152 NDR_CHECK(ndr_push_EcDoRpc_MAPI_REPL(ndr, NDR_SCALARS, &r->mapi_repl[count]));
153 }
154 }
155
156 count = (r->mapi_len - r->length) / sizeof (uint32_t);
157 for (cntr_mapi_repl_0 = 0; cntr_mapi_repl_0 <count; cntr_mapi_repl_0++) {
158 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->handles[cntr_mapi_repl_0]));
159 }
160
161 obfuscate_data(ndr->data, ndr->alloc_size, 0xA5);
162
163 return NDR_ERR_SUCCESS;
164 }
165
166 /*
167 pull mapi_request / mapi_response from the wire
168 */
169
170 enum ndr_err_code ndr_pull_mapi_request(struct ndr_pull *ndr, int ndr_flags, struct mapi_request *r)
171 {
172 uint32_t length,count;
173 uint32_t cntr_mapi_req_0;
174 TALLOC_CTX *_mem_save_mapi_req_0;
175 TALLOC_CTX *_mem_save_handles_0;
176 struct ndr_pull *_ndr_mapi_req;
177
178 obfuscate_data(ndr->data, ndr->data_size, 0xA5);
179
180 if (ndr->flags & LIBNDR_FLAG_REMAINING) {
181 length = ndr->data_size - ndr->offset;
182 } else {
183 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &length));
184 }
185 r->mapi_len = length;
186
187 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->length));
188
189 /* If length equals length field then skipping subcontext */
190 if (r->length > sizeof (uint16_t)) {
191 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_mapi_req, 0, r->length - 2));
192 _mem_save_mapi_req_0 = NDR_PULL_GET_MEM_CTX(_ndr_mapi_req);
193 r->mapi_req = talloc_zero(_mem_save_mapi_req_0, struct EcDoRpc_MAPI_REQ);
194 for (cntr_mapi_req_0 = 0; _ndr_mapi_req->offset < _ndr_mapi_req->data_size - 2; cntr_mapi_req_0++) {
195 NDR_CHECK(ndr_pull_EcDoRpc_MAPI_REQ(_ndr_mapi_req, NDR_SCALARS, &r->mapi_req[cntr_mapi_req_0]));
196 r->mapi_req = talloc_realloc(_mem_save_mapi_req_0, r->mapi_req, struct EcDoRpc_MAPI_REQ, cntr_mapi_req_0 + 2);
197 }
198 r->mapi_req = talloc_realloc(_mem_save_mapi_req_0, r->mapi_req, struct EcDoRpc_MAPI_REQ, cntr_mapi_req_0 + 2);
199 r->mapi_req[cntr_mapi_req_0].opnum = 0;
200
201 if (_ndr_mapi_req->offset != r->length - 2) {
202 return NDR_ERR_BUFSIZE;
203 }
204 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_mapi_req, 4, -1));
205
206 _mem_save_handles_0 = NDR_PULL_GET_MEM_CTX(ndr);
207 count = (r->mapi_len - r->length) / sizeof(uint32_t);
208 r->handles = talloc_array(_mem_save_handles_0, uint32_t, count + 1);
209 for (cntr_mapi_req_0=0; cntr_mapi_req_0 < count; cntr_mapi_req_0++) {
210 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->handles[cntr_mapi_req_0]));
211 }
212 } else {
213 r->handles = NULL;
214 }
215
216 return NDR_ERR_SUCCESS;
217 }
218
219 enum ndr_err_code ndr_pull_mapi_response(struct ndr_pull *ndr, int ndr_flags, struct mapi_response *r)
220 {
221 uint32_t length,count;
222 uint32_t cntr_mapi_repl_0;
223 TALLOC_CTX *_mem_save_mapi_repl_0;
224 TALLOC_CTX *_mem_save_handles_0;
225 struct ndr_pull *_ndr_mapi_repl;
226
227 obfuscate_data(ndr->data, ndr->data_size, 0xA5);
228
229 if (ndr->flags & LIBNDR_FLAG_REMAINING) {
230 length = ndr->data_size - ndr->offset;
231 } else {
232 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &length));
233 }
234 r->mapi_len = length;
235
236 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->length));
237
238 /* If length equals length field then skipping subcontext */
239 if (r->length > sizeof (uint16_t)) {
240 _mem_save_mapi_repl_0 = NDR_PULL_GET_MEM_CTX(ndr);
241 r->mapi_repl = talloc_array(_mem_save_mapi_repl_0, struct EcDoRpc_MAPI_REPL, 2);
242 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_mapi_repl, 0, r->length - 2));
243 for (cntr_mapi_repl_0 = 0; _ndr_mapi_repl->offset < _ndr_mapi_repl->data_size - 2; cntr_mapi_repl_0++) {
244 NDR_CHECK(ndr_pull_EcDoRpc_MAPI_REPL(_ndr_mapi_repl, NDR_SCALARS, &r->mapi_repl[cntr_mapi_repl_0]));
245 r->mapi_repl = talloc_realloc(_ndr_mapi_repl, r->mapi_repl, struct EcDoRpc_MAPI_REPL, cntr_mapi_repl_0 + 2);
246 }
247 r->mapi_repl[cntr_mapi_repl_0].opnum = 0;
248 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_mapi_repl, 4, -1));
249 talloc_free(_ndr_mapi_repl);
250 }
251
252 _mem_save_handles_0 = NDR_PULL_GET_MEM_CTX(ndr);
253 count = (r->mapi_len - r->length) / sizeof(uint32_t);
254 NDR_PULL_ALLOC_N(ndr, r->handles, count + 1);
255
256 for (cntr_mapi_repl_0=0; cntr_mapi_repl_0 < count; cntr_mapi_repl_0++) {
257 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->handles[cntr_mapi_repl_0]));
258 }
259 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handles_0, LIBNDR_FLAG_REF_ALLOC);
260
261 return NDR_ERR_SUCCESS;
262 }
263
264 /*
265 We stop processing the IDL if MAPISTATUS is different from MAPI_E_SUCCESS
266 */
267
268 _PUBLIC_ enum ndr_err_code ndr_push_EcDoRpc_MAPI_REPL(struct ndr_push *ndr, int ndr_flags, const struct EcDoRpc_MAPI_REPL *r)
269 {
270 if (r->opnum != op_MAPI_Release)
271 {
272 uint32_t _flags_save_STRUCT = ndr->flags;
273 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
274 if (ndr_flags & NDR_SCALARS) {
275 NDR_CHECK(ndr_push_align(ndr, 8));
276 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->opnum));
277 if ((r->opnum == op_MAPI_Notify) || (r->opnum == op_MAPI_Pending)) {
278 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->u, r->opnum));
279 NDR_CHECK(ndr_push_EcDoRpc_MAPI_REPL_UNION(ndr, NDR_SCALARS, &r->u));
280 } else {
281 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->handle_idx));
282 NDR_CHECK(ndr_push_MAPISTATUS(ndr, NDR_SCALARS, r->error_code));
283 if (r->error_code == MAPI_E_SUCCESS) {
284 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->u, r->opnum));
285 NDR_CHECK(ndr_push_EcDoRpc_MAPI_REPL_UNION(ndr, NDR_SCALARS, &r->u));
286 } else {
287 switch (r->opnum) {
288 case op_MAPI_Logon: {
289 if (r->error_code == ecWrongServer) {
290 NDR_CHECK(ndr_push_Logon_redirect(ndr, NDR_SCALARS, &(r->us.mapi_Logon)));
291 }
292 break; }
293 default:
294 break;
295 }
296 }
297 }
298 }
299 if (ndr_flags & NDR_BUFFERS) {
300 NDR_CHECK(ndr_push_EcDoRpc_MAPI_REPL_UNION(ndr, NDR_BUFFERS, &r->u));
301 }
302 ndr->flags = _flags_save_STRUCT;
303 }
304 return NDR_ERR_SUCCESS;
305 }
306
307 enum ndr_err_code ndr_pull_EcDoRpc_MAPI_REPL(struct ndr_pull *ndr, int ndr_flags, struct EcDoRpc_MAPI_REPL *r)
308 {
309 {
310 uint32_t _flags_save_STRUCT = ndr->flags;
311 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
312 if (ndr_flags & NDR_SCALARS) {
313 NDR_CHECK(ndr_pull_align(ndr, 8));
314 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->opnum));
315 if ((r->opnum == op_MAPI_Notify) || (r->opnum == op_MAPI_Pending)) {
316 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->u, r->opnum));
317 NDR_CHECK(ndr_pull_EcDoRpc_MAPI_REPL_UNION(ndr, NDR_SCALARS, &r->u));
318 } else {
319 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->handle_idx));
320 NDR_CHECK(ndr_pull_MAPISTATUS(ndr, NDR_SCALARS, &r->error_code));
321 if ( r->error_code == MAPI_E_SUCCESS) {
322 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->u, r->opnum));
323 NDR_CHECK(ndr_pull_EcDoRpc_MAPI_REPL_UNION(ndr, NDR_SCALARS, &r->u));
324 } else {
325 switch (r->opnum) {
326 case op_MAPI_Logon: {
327 if (r->error_code == ecWrongServer) {
328 NDR_CHECK(ndr_pull_Logon_redirect(ndr, NDR_SCALARS, &(r->us.mapi_Logon)));
329 }
330 break;}
331 default:
332 break;
333 }
334 }
335 }
336 }
337 if (ndr_flags & NDR_BUFFERS) {
338 ndr->flags = _flags_save_STRUCT;
339 }
340 }
341 return NDR_ERR_SUCCESS;
342 }
343
344 void ndr_print_EcDoRpc_MAPI_REPL(struct ndr_print *ndr, const char *name, const struct EcDoRpc_MAPI_REPL *r)
345 {
346 ndr_print_struct(ndr, name, "EcDoRpc_MAPI_REPL");
347 {
348 uint32_t _flags_save_STRUCT = ndr->flags;
349 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
350 ndr->depth++;
351 ndr_print_uint8(ndr, "opnum", r->opnum);
352 if ((r->opnum != op_MAPI_Notify) && (r->opnum != op_MAPI_Pending)) {
353 ndr_print_uint8(ndr, "handle_idx", r->handle_idx);
354 ndr_print_MAPISTATUS(ndr, "error_code", r->error_code);
355 if (r->error_code == MAPI_E_SUCCESS) {
356 ndr_print_set_switch_value(ndr, &r->u, r->opnum);
357 ndr_print_EcDoRpc_MAPI_REPL_UNION(ndr, "u", &r->u);
358 } else {
359 switch (r->opnum) {
360 case op_MAPI_Logon: {
361 if (r->error_code == ecWrongServer) {
362 ndr_print_set_switch_value(ndr, &r->us, r->opnum);
363 ndr_print_EcDoRpc_MAPI_REPL_UNION_SPECIAL(ndr, "us", &r->us);
364 }
365 break;}
366 default:
367 break;
368 }
369 }
370 } else {
371 ndr_print_set_switch_value(ndr, &r->u, r->opnum);
372 ndr_print_EcDoRpc_MAPI_REPL_UNION(ndr, "u", &r->u);
373 }
374 ndr->depth--;
375 ndr->flags = _flags_save_STRUCT;
376 }
377 }
378
379 /*
380 We need to pull QueryRows replies on our own:
381 If we have no results, do not push/pull the DATA_BLOB
382 */
383
384 enum ndr_err_code ndr_push_QueryRows_repl(struct ndr_push *ndr, int ndr_flags, const struct QueryRows_repl *r)
385 {
386 {
387 uint32_t _flags_save_STRUCT = ndr->flags;
388 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
389 if (ndr_flags & NDR_SCALARS) {
390 NDR_CHECK(ndr_push_align(ndr, 4));
391 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->Origin));
392 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->RowCount));
393
394 if (r->RowCount) {
395 uint32_t _flags_save_DATA_BLOB = ndr->flags;
396 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
397 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->RowData));
398 ndr->flags = _flags_save_DATA_BLOB;
399 }
400 }
401 if (ndr_flags & NDR_BUFFERS) {
402 }
403 ndr->flags = _flags_save_STRUCT;
404 }
405 return NDR_ERR_SUCCESS;
406 }
407
408 enum ndr_err_code ndr_pull_QueryRows_repl(struct ndr_pull *ndr, int ndr_flags, struct QueryRows_repl *r)
409 {
410 {
411 uint32_t _flags_save_STRUCT = ndr->flags;
412 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
413 if (ndr_flags & NDR_SCALARS) {
414 NDR_CHECK(ndr_pull_align(ndr, 4));
415 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->Origin));
416 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->RowCount));
417
418 if (r->RowCount)
419 {
420 uint32_t _flags_save_DATA_BLOB = ndr->flags;
421
422 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
423 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->RowData));
424 ndr->flags = _flags_save_DATA_BLOB;
425 }
426 }
427 if (ndr_flags & NDR_BUFFERS) {
428 }
429 ndr->flags = _flags_save_STRUCT;
430 }
431 return NDR_ERR_SUCCESS;
432 }
433
434
435 enum ndr_err_code ndr_push_Logon_req(struct ndr_push *ndr, int ndr_flags, const struct Logon_req *r)
436 {
437 {
438 uint32_t _flags_save_STRUCT = ndr->flags;
439 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
440 if (ndr_flags & NDR_SCALARS) {
441 NDR_CHECK(ndr_push_align(ndr, 4));
442 NDR_CHECK(ndr_push_LogonFlags(ndr, NDR_SCALARS, r->LogonFlags));
443 NDR_CHECK(ndr_push_OpenFlags(ndr, NDR_SCALARS, r->OpenFlags));
444 NDR_CHECK(ndr_push_StoreState(ndr, NDR_SCALARS, r->StoreState));
445 if (r->EssDN && r->EssDN[0] != '\0') {
446 uint32_t _flags_save_string = ndr->flags;
447 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_SIZE2);
448 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->EssDN));
449 ndr->flags = _flags_save_string;
450 } else {
451 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 0));
452 }
453 }
454 if (ndr_flags & NDR_BUFFERS) {
455 }
456 ndr->flags = _flags_save_STRUCT;
457 }
458 return NDR_ERR_SUCCESS;
459 }
460
461
462 _PUBLIC_ void ndr_print_SBinary_short(struct ndr_print *ndr, const char *name, const struct SBinary_short *r)
463 {
464 ndr->print(ndr, "%-25s: SBinary_short cb=%u", name, (unsigned)r->cb);
465 {
466 uint32_t _flags_save_STRUCT = ndr->flags;
467 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
468 ndr->depth++;
469 dump_data(0, r->lpb, r->cb);
470 ndr->depth--;
471 ndr->flags = _flags_save_STRUCT;
472 }
473 }
474
475
476 _PUBLIC_ void ndr_print_fuzzyLevel(struct ndr_print *ndr, const char *name, uint32_t r)
477 {
478 ndr_print_uint32(ndr, name, r);
479 ndr->depth++;
480 switch ((r & 0x0000FFFF)) {
481 case FL_FULLSTRING:
482 ndr->print(ndr, "%-25s: FL_FULLSTRING", "lower 16 bits");
483 break;
484 case FL_SUBSTRING:
485 ndr->print(ndr, "%-25s: FL_SUBSTRING", "lower 16 bits");
486 break;
487 case FL_PREFIX:
488 ndr->print(ndr, "%-25s: FL_PREFIX", "lower 16 bits");
489 break;
490 }
491 ndr->print(ndr, "%-25s", "higher 16 bits");
492 ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "FL_IGNORECASE", FL_IGNORECASE, r);
493 ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "FL_IGNORENONSPACE", FL_IGNORENONSPACE, r);
494 ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "FL_LOOSE", FL_LOOSE, r);
495 ndr->depth--;
496 }
497
498 /*
499 * Fake wrapper over mapi_SRestriction. Workaround the no-pointer deep
500 * recursion problem in pidl
501 */
502 enum ndr_err_code ndr_push_mapi_SRestriction_wrap(struct ndr_push *ndr, int ndr_flags, const struct mapi_SRestriction_wrap *r)
503 {
504 return ndr_push_mapi_SRestriction(ndr, NDR_SCALARS, (const struct mapi_SRestriction *)r);
505 }
506
507
508 enum ndr_err_code ndr_pull_mapi_SRestriction_wrap(struct ndr_pull *ndr, int ndr_flags, struct mapi_SRestriction_wrap *r)
509 {
510 return ndr_pull_mapi_SRestriction(ndr, NDR_SCALARS|NDR_BUFFERS, (struct mapi_SRestriction *)r);
511 }
512
513 void ndr_print_mapi_SRestriction_wrap(struct ndr_print *ndr, const char *name, const struct mapi_SRestriction_wrap *r)
514 {
515 ndr_print_mapi_SRestriction(ndr, name, (const struct mapi_SRestriction *)r);
516 }
517
518 /*
519 * Fake wrapper over mapi_SPropValue. Workaround the no-pointer deep
520 * recursion problem in pidl
521 */
522 enum ndr_err_code ndr_push_mapi_SPropValue_wrap(struct ndr_push *ndr, int ndr_flags, const struct mapi_SPropValue_wrap *r)
523 {
524 NDR_CHECK(ndr_push_align(ndr, 8));
525 return ndr_push_mapi_SPropValue(ndr, NDR_SCALARS, (const struct mapi_SPropValue *)r);
526 }
527
528 enum ndr_err_code ndr_pull_mapi_SPropValue_wrap(struct ndr_pull *ndr, int ndr_flags, struct mapi_SPropValue_wrap *r)
529 {
530 return ndr_pull_mapi_SPropValue(ndr, NDR_SCALARS, (struct mapi_SPropValue *)r);
531 }
532
533 void ndr_print_mapi_SPropValue_wrap(struct ndr_print *ndr, const char *name, const struct mapi_SPropValue_wrap *r)
534 {
535 return ndr_print_mapi_SPropValue(ndr, name, (const struct mapi_SPropValue *)r);
536 }
537
538
539 /*
540 * Fake wrapper over mapi_SPropValue_array. Workaround the no-pointer deep
541 * recursion problem in pidl
542 */
543 enum ndr_err_code ndr_push_mapi_SPropValue_array_wrap(struct ndr_push *ndr, int ndr_flags, const struct mapi_SPropValue_array_wrap *r)
544 {
545 NDR_CHECK(ndr_push_align(ndr, 8));
546 return ndr_push_mapi_SPropValue_array(ndr, NDR_SCALARS, (const struct mapi_SPropValue_array *)r);
547 }
548
549 enum ndr_err_code ndr_pull_mapi_SPropValue_array_wrap(struct ndr_pull *ndr, int ndr_flags, struct mapi_SPropValue_array_wrap *r)
550 {
551 return ndr_pull_mapi_SPropValue_array(ndr, NDR_SCALARS, (struct mapi_SPropValue_array *)r);
552 }
553
554 void ndr_print_mapi_SPropValue_array_wrap(struct ndr_print *ndr, const char *name, const struct mapi_SPropValue_array_wrap *r)
555 {
556 return ndr_print_mapi_SPropValue_array(ndr, name, (const struct mapi_SPropValue_array *)r);
557 }
558
559 enum ndr_err_code ndr_push_RestrictionVariable(struct ndr_push *ndr, int ndr_flags, const union RestrictionVariable *r)
560 {
561 {
562 uint32_t _flags_save_STRUCT = ndr->flags;
563 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
564 if (ndr_flags & NDR_SCALARS) {
565 int level = ndr_push_get_switch_value(ndr, r);
566 switch (level) {
567 case 0x0: {
568 break; }
569
570 case 0x1: {
571 NDR_CHECK(ndr_push_mapi_SRestriction_comment(ndr, NDR_SCALARS, &r->res[0]));
572 break; }
573
574 default:
575 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
576 }
577 }
578 if (ndr_flags & NDR_BUFFERS) {
579 int level = ndr_push_get_switch_value(ndr, r);
580 switch (level) {
581 case 0x0:
582 break;
583
584 case 0x1:
585 if (r->res) {
586 NDR_CHECK(ndr_push_mapi_SRestriction_comment(ndr, NDR_BUFFERS, &r->res[0]));
587 }
588 break;
589
590 default:
591 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
592 }
593 }
594 ndr->flags = _flags_save_STRUCT;
595 }
596 return NDR_ERR_SUCCESS;
597 }
598
599 enum ndr_err_code ndr_pull_RestrictionVariable(struct ndr_pull *ndr, int ndr_flags, union RestrictionVariable *r)
600 {
601 int level;
602 TALLOC_CTX *_mem_save_res_0;
603 level = ndr_pull_get_switch_value(ndr, r);
604 {
605 uint32_t _flags_save_STRUCT = ndr->flags;
606 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
607
608 if (ndr_flags & NDR_SCALARS) {
609 switch (level) {
610 case 0x0: {
611 break; }
612
613 case 0x1: {
614 NDR_CHECK(ndr_pull_align(ndr, 4));
615 NDR_PULL_ALLOC_N(ndr, r->res, 1);
616 _mem_save_res_0 = NDR_PULL_GET_MEM_CTX(ndr);
617 NDR_PULL_SET_MEM_CTX(ndr, r->res, 0);
618 NDR_CHECK(ndr_pull_mapi_SRestriction_comment(ndr, NDR_SCALARS, &r->res[0]));
619 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_res_0, 0);
620 break; }
621
622 default:
623 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
624 }
625 }
626 if (ndr_flags & NDR_BUFFERS) {
627 switch (level) {
628 case 0x0:
629 break;
630
631 case 0x1:
632 if (r->res) {
633 _mem_save_res_0 = NDR_PULL_GET_MEM_CTX(ndr);
634 NDR_PULL_SET_MEM_CTX(ndr, r->res, 0);
635 NDR_CHECK(ndr_pull_mapi_SRestriction_comment(ndr, NDR_BUFFERS, &r->res[0]));
636 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_res_0, 0);
637 break; }
638
639 default:
640 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
641 }
642 }
643 ndr->flags = _flags_save_STRUCT;
644 }
645 return NDR_ERR_SUCCESS;
646 }
647
648
649 _PUBLIC_ void ndr_print_RestrictionVariable(struct ndr_print *ndr, const char *name, const union RestrictionVariable *r)
650 {
651 int level;
652 level = ndr_print_get_switch_value(ndr, r);
653 ndr_print_union(ndr, name, level, "RestrictionVariable");
654 switch (level) {
655 case 0x0:
656 break;
657
658 case 0x1:
659 ndr_print_ptr(ndr, "res", r->res);
660 ndr->depth++;
661 if (r->res) {
662 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
663 ndr_print_mapi_SRestriction_comment(ndr, "res", &r->res[0]);
664 }
665 ndr->depth--;
666 break;
667 }
668 }
669
670 enum ndr_err_code ndr_push_Release_req(struct ndr_push *ndr, int ndr_flags, const struct Release_req *r)
671 {
672 return NDR_ERR_SUCCESS;
673 }
674
675 enum ndr_err_code ndr_pull_Release_req(struct ndr_pull *ndr, int ndr_flags, struct Release_req *r)
676 {
677 return NDR_ERR_SUCCESS;
678 }
679
680 enum ndr_err_code ndr_push_Release_repl(struct ndr_push *ndr, int ndr_flags, const struct Release_repl *r)
681 {
682 return NDR_ERR_SUCCESS;
683 }
684
685 enum ndr_err_code ndr_pull_Release_repl(struct ndr_pull *ndr, int ndr_flags, struct Release_repl *r)
686 {
687 return NDR_ERR_SUCCESS;
688 }
From home site: OpenChange aims to provide a portable Open Source implementation of Microsoft Exchange Server and Exchange protocols.