?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r14279: Fix coverity #86, 87, 88, 89:
[Samba/nascimento.git] / source3 / rpc_parse / parse_lsa.c
blobd285f5d36b18b9b64f5a2c25bd6d35786e4176f9
1 /*
2 * Unix SMB/CIFS implementation.
3 * RPC Pipe client / server routines
4 * Copyright (C) Andrew Tridgell 1992-1997,
5 * Copyright (C) Luke Kenneth Casson Leighton 1996-1997,
6 * Copyright (C) Paul Ashton 1997,
7 * Copyright (C) Andrew Bartlett 2002,
8 * Copyright (C) Jim McDonough <jmcd@us.ibm.com> 2002.
9 * Copyright (C) Gerald )Jerry) Carter 2005
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 */
25
26 #include "includes.h"
27
28 #undef DBGC_CLASS
29 #define DBGC_CLASS DBGC_RPC_PARSE
30
31 static BOOL lsa_io_trans_names(const char *desc, LSA_TRANS_NAME_ENUM *trn, prs_struct *ps, int depth);
32 static BOOL lsa_io_trans_names2(const char *desc, LSA_TRANS_NAME_ENUM2 *trn, prs_struct *ps, int depth);
33
34 /*******************************************************************
35 Inits a LSA_TRANS_NAME structure.
36 ********************************************************************/
37
38 void init_lsa_trans_name(LSA_TRANS_NAME *trn, UNISTR2 *uni_name,
39 uint16 sid_name_use, const char *name, uint32 idx)
40 {
41 trn->sid_name_use = sid_name_use;
42 init_unistr2(uni_name, name, UNI_FLAGS_NONE);
43 init_uni_hdr(&trn->hdr_name, uni_name);
44 trn->domain_idx = idx;
45 }
46
47 /*******************************************************************
48 Reads or writes a LSA_TRANS_NAME structure.
49 ********************************************************************/
50
51 static BOOL lsa_io_trans_name(const char *desc, LSA_TRANS_NAME *trn, prs_struct *ps,
52 int depth)
53 {
54 prs_debug(ps, depth, desc, "lsa_io_trans_name");
55 depth++;
56
57 if(!prs_align(ps))
58 return False;
59
60 if(!prs_uint16("sid_name_use", ps, depth, &trn->sid_name_use))
61 return False;
62 if(!prs_align(ps))
63 return False;
64
65 if(!smb_io_unihdr ("hdr_name", &trn->hdr_name, ps, depth))
66 return False;
67 if(!prs_uint32("domain_idx ", ps, depth, &trn->domain_idx))
68 return False;
69
70 return True;
71 }
72
73 /*******************************************************************
74 Inits a LSA_TRANS_NAME2 structure.
75 ********************************************************************/
76
77 void init_lsa_trans_name2(LSA_TRANS_NAME2 *trn, UNISTR2 *uni_name,
78 uint16 sid_name_use, const char *name, uint32 idx)
79 {
80 trn->sid_name_use = sid_name_use;
81 init_unistr2(uni_name, name, UNI_FLAGS_NONE);
82 init_uni_hdr(&trn->hdr_name, uni_name);
83 trn->domain_idx = idx;
84 trn->unknown = 0;
85 }
86
87 /*******************************************************************
88 Reads or writes a LSA_TRANS_NAME2 structure.
89 ********************************************************************/
90
91 static BOOL lsa_io_trans_name2(const char *desc, LSA_TRANS_NAME2 *trn, prs_struct *ps,
92 int depth)
93 {
94 prs_debug(ps, depth, desc, "lsa_io_trans_name2");
95 depth++;
96
97 if(!prs_align(ps))
98 return False;
99
100 if(!prs_uint16("sid_name_use", ps, depth, &trn->sid_name_use))
101 return False;
102 if(!prs_align(ps))
103 return False;
104
105 if(!smb_io_unihdr ("hdr_name", &trn->hdr_name, ps, depth))
106 return False;
107 if(!prs_uint32("domain_idx ", ps, depth, &trn->domain_idx))
108 return False;
109 if(!prs_uint32("unknown ", ps, depth, &trn->unknown))
110 return False;
111
112 return True;
113 }
114
115 /*******************************************************************
116 Reads or writes a DOM_R_REF structure.
117 ********************************************************************/
118
119 static BOOL lsa_io_dom_r_ref(const char *desc, DOM_R_REF *dom, prs_struct *ps, int depth)
120 {
121 unsigned int i;
122
123 prs_debug(ps, depth, desc, "lsa_io_dom_r_ref");
124 depth++;
125
126 if(!prs_align(ps))
127 return False;
128
129 if(!prs_uint32("num_ref_doms_1", ps, depth, &dom->num_ref_doms_1)) /* num referenced domains? */
130 return False;
131 if(!prs_uint32("ptr_ref_dom ", ps, depth, &dom->ptr_ref_dom)) /* undocumented buffer pointer. */
132 return False;
133 if(!prs_uint32("max_entries ", ps, depth, &dom->max_entries)) /* 32 - max number of entries */
134 return False;
135
136 SMB_ASSERT_ARRAY(dom->hdr_ref_dom, dom->num_ref_doms_1);
137
138 if (dom->ptr_ref_dom != 0) {
139
140 if(!prs_uint32("num_ref_doms_2", ps, depth, &dom->num_ref_doms_2)) /* 4 - num referenced domains? */
141 return False;
142
143 SMB_ASSERT_ARRAY(dom->ref_dom, dom->num_ref_doms_2);
144
145 for (i = 0; i < dom->num_ref_doms_1; i++) {
146 fstring t;
147
148 slprintf(t, sizeof(t) - 1, "dom_ref[%d] ", i);
149 if(!smb_io_unihdr(t, &dom->hdr_ref_dom[i].hdr_dom_name, ps, depth))
150 return False;
151
152 slprintf(t, sizeof(t) - 1, "sid_ptr[%d] ", i);
153 if(!prs_uint32(t, ps, depth, &dom->hdr_ref_dom[i].ptr_dom_sid))
154 return False;
155 }
156
157 for (i = 0; i < dom->num_ref_doms_2; i++) {
158 fstring t;
159
160 if (dom->hdr_ref_dom[i].hdr_dom_name.buffer != 0) {
161 slprintf(t, sizeof(t) - 1, "dom_ref[%d] ", i);
162 if(!smb_io_unistr2(t, &dom->ref_dom[i].uni_dom_name, True, ps, depth)) /* domain name unicode string */
163 return False;
164 if(!prs_align(ps))
165 return False;
166 }
167
168 if (dom->hdr_ref_dom[i].ptr_dom_sid != 0) {
169 slprintf(t, sizeof(t) - 1, "sid_ptr[%d] ", i);
170 if(!smb_io_dom_sid2(t, &dom->ref_dom[i].ref_dom, ps, depth)) /* referenced domain SIDs */
171 return False;
172 }
173 }
174 }
175
176 return True;
177 }
178
179 /*******************************************************************
180 Inits an LSA_SEC_QOS structure.
181 ********************************************************************/
182
183 void init_lsa_sec_qos(LSA_SEC_QOS *qos, uint16 imp_lev, uint8 ctxt, uint8 eff)
184 {
185 DEBUG(5, ("init_lsa_sec_qos\n"));
186
187 qos->len = 0x0c; /* length of quality of service block, in bytes */
188 qos->sec_imp_level = imp_lev;
189 qos->sec_ctxt_mode = ctxt;
190 qos->effective_only = eff;
191 }
192
193 /*******************************************************************
194 Reads or writes an LSA_SEC_QOS structure.
195 ********************************************************************/
196
197 static BOOL lsa_io_sec_qos(const char *desc, LSA_SEC_QOS *qos, prs_struct *ps,
198 int depth)
199 {
200 uint32 start;
201
202 prs_debug(ps, depth, desc, "lsa_io_obj_qos");
203 depth++;
204
205 if(!prs_align(ps))
206 return False;
207
208 start = prs_offset(ps);
209
210 /* these pointers had _better_ be zero, because we don't know
211 what they point to!
212 */
213 if(!prs_uint32("len ", ps, depth, &qos->len)) /* 0x18 - length (in bytes) inc. the length field. */
214 return False;
215 if(!prs_uint16("sec_imp_level ", ps, depth, &qos->sec_imp_level ))
216 return False;
217 if(!prs_uint8 ("sec_ctxt_mode ", ps, depth, &qos->sec_ctxt_mode ))
218 return False;
219 if(!prs_uint8 ("effective_only", ps, depth, &qos->effective_only))
220 return False;
221
222 if (qos->len != prs_offset(ps) - start) {
223 DEBUG(3,("lsa_io_sec_qos: length %x does not match size %x\n",
224 qos->len, prs_offset(ps) - start));
225 }
226
227 return True;
228 }
229
230 /*******************************************************************
231 Inits an LSA_OBJ_ATTR structure.
232 ********************************************************************/
233
234 static void init_lsa_obj_attr(LSA_OBJ_ATTR *attr, uint32 attributes, LSA_SEC_QOS *qos)
235 {
236 DEBUG(5, ("init_lsa_obj_attr\n"));
237
238 attr->len = 0x18; /* length of object attribute block, in bytes */
239 attr->ptr_root_dir = 0;
240 attr->ptr_obj_name = 0;
241 attr->attributes = attributes;
242 attr->ptr_sec_desc = 0;
243
244 if (qos != NULL) {
245 attr->ptr_sec_qos = 1;
246 attr->sec_qos = qos;
247 } else {
248 attr->ptr_sec_qos = 0;
249 attr->sec_qos = NULL;
250 }
251 }
252
253 /*******************************************************************
254 Reads or writes an LSA_OBJ_ATTR structure.
255 ********************************************************************/
256
257 static BOOL lsa_io_obj_attr(const char *desc, LSA_OBJ_ATTR *attr, prs_struct *ps,
258 int depth)
259 {
260 prs_debug(ps, depth, desc, "lsa_io_obj_attr");
261 depth++;
262
263 if(!prs_align(ps))
264 return False;
265
266 /* these pointers had _better_ be zero, because we don't know
267 what they point to!
268 */
269 if(!prs_uint32("len ", ps, depth, &attr->len)) /* 0x18 - length (in bytes) inc. the length field. */
270 return False;
271 if(!prs_uint32("ptr_root_dir", ps, depth, &attr->ptr_root_dir)) /* 0 - root directory (pointer) */
272 return False;
273 if(!prs_uint32("ptr_obj_name", ps, depth, &attr->ptr_obj_name)) /* 0 - object name (pointer) */
274 return False;
275 if(!prs_uint32("attributes ", ps, depth, &attr->attributes)) /* 0 - attributes (undocumented) */
276 return False;
277 if(!prs_uint32("ptr_sec_desc", ps, depth, &attr->ptr_sec_desc)) /* 0 - security descriptior (pointer) */
278 return False;
279 if(!prs_uint32("ptr_sec_qos ", ps, depth, &attr->ptr_sec_qos )) /* security quality of service (pointer) */
280 return False;
281
282 if (attr->ptr_sec_qos != 0) {
283 if (UNMARSHALLING(ps))
284 if (!(attr->sec_qos = PRS_ALLOC_MEM(ps,LSA_SEC_QOS,1)))
285 return False;
286
287 if(!lsa_io_sec_qos("sec_qos", attr->sec_qos, ps, depth))
288 return False;
289 }
290
291 return True;
292 }
293
294
295 /*******************************************************************
296 Inits an LSA_Q_OPEN_POL structure.
297 ********************************************************************/
298
299 void init_q_open_pol(LSA_Q_OPEN_POL *in, uint16 system_name,
300 uint32 attributes, uint32 desired_access,
301 LSA_SEC_QOS *qos)
302 {
303 DEBUG(5, ("init_open_pol: attr:%d da:%d\n", attributes,
304 desired_access));
305
306 in->ptr = 1; /* undocumented pointer */
307
308 in->des_access = desired_access;
309
310 in->system_name = system_name;
311 init_lsa_obj_attr(&in->attr, attributes, qos);
312 }
313
314 /*******************************************************************
315 Reads or writes an LSA_Q_OPEN_POL structure.
316 ********************************************************************/
317
318 BOOL lsa_io_q_open_pol(const char *desc, LSA_Q_OPEN_POL *in, prs_struct *ps,
319 int depth)
320 {
321 prs_debug(ps, depth, desc, "lsa_io_q_open_pol");
322 depth++;
323
324 if(!prs_uint32("ptr ", ps, depth, &in->ptr))
325 return False;
326 if(!prs_uint16("system_name", ps, depth, &in->system_name))
327 return False;
328 if(!prs_align( ps ))
329 return False;
330
331 if(!lsa_io_obj_attr("", &in->attr, ps, depth))
332 return False;
333
334 if(!prs_uint32("des_access", ps, depth, &in->des_access))
335 return False;
336
337 return True;
338 }
339
340 /*******************************************************************
341 Reads or writes an LSA_R_OPEN_POL structure.
342 ********************************************************************/
343
344 BOOL lsa_io_r_open_pol(const char *desc, LSA_R_OPEN_POL *out, prs_struct *ps,
345 int depth)
346 {
347 prs_debug(ps, depth, desc, "lsa_io_r_open_pol");
348 depth++;
349
350 if(!smb_io_pol_hnd("", &out->pol, ps, depth))
351 return False;
352
353 if(!prs_ntstatus("status", ps, depth, &out->status))
354 return False;
355
356 return True;
357 }
358
359 /*******************************************************************
360 Inits an LSA_Q_OPEN_POL2 structure.
361 ********************************************************************/
362
363 void init_q_open_pol2(LSA_Q_OPEN_POL2 *in, const char *server_name,
364 uint32 attributes, uint32 desired_access,
365 LSA_SEC_QOS *qos)
366 {
367 DEBUG(5, ("init_q_open_pol2: attr:%d da:%d\n", attributes,
368 desired_access));
369
370 in->ptr = 1; /* undocumented pointer */
371
372 in->des_access = desired_access;
373
374 init_unistr2(&in->uni_server_name, server_name, UNI_STR_TERMINATE);
375
376 init_lsa_obj_attr(&in->attr, attributes, qos);
377 }
378
379 /*******************************************************************
380 Reads or writes an LSA_Q_OPEN_POL2 structure.
381 ********************************************************************/
382
383 BOOL lsa_io_q_open_pol2(const char *desc, LSA_Q_OPEN_POL2 *in, prs_struct *ps,
384 int depth)
385 {
386 prs_debug(ps, depth, desc, "lsa_io_q_open_pol2");
387 depth++;
388
389 if(!prs_uint32("ptr ", ps, depth, &in->ptr))
390 return False;
391
392 if(!smb_io_unistr2 ("", &in->uni_server_name, in->ptr, ps, depth))
393 return False;
394 if(!lsa_io_obj_attr("", &in->attr, ps, depth))
395 return False;
396
397 if(!prs_uint32("des_access", ps, depth, &in->des_access))
398 return False;
399
400 return True;
401 }
402
403 /*******************************************************************
404 Reads or writes an LSA_R_OPEN_POL2 structure.
405 ********************************************************************/
406
407 BOOL lsa_io_r_open_pol2(const char *desc, LSA_R_OPEN_POL2 *out, prs_struct *ps,
408 int depth)
409 {
410 prs_debug(ps, depth, desc, "lsa_io_r_open_pol2");
411 depth++;
412
413 if(!smb_io_pol_hnd("", &out->pol, ps, depth))
414 return False;
415
416 if(!prs_ntstatus("status", ps, depth, &out->status))
417 return False;
418
419 return True;
420 }
421
422 /*******************************************************************
423 makes an LSA_Q_QUERY_SEC_OBJ structure.
424 ********************************************************************/
425
426 void init_q_query_sec_obj(LSA_Q_QUERY_SEC_OBJ *in, const POLICY_HND *hnd,
427 uint32 sec_info)
428 {
429 DEBUG(5, ("init_q_query_sec_obj\n"));
430
431 in->pol = *hnd;
432 in->sec_info = sec_info;
433
434 return;
435 }
436
437 /*******************************************************************
438 Reads or writes an LSA_Q_QUERY_SEC_OBJ structure.
439 ********************************************************************/
440
441 BOOL lsa_io_q_query_sec_obj(const char *desc, LSA_Q_QUERY_SEC_OBJ *in,
442 prs_struct *ps, int depth)
443 {
444 prs_debug(ps, depth, desc, "lsa_io_q_query_sec_obj");
445 depth++;
446
447 if (!smb_io_pol_hnd("", &in->pol, ps, depth))
448 return False;
449
450 if (!prs_uint32("sec_info", ps, depth, &in->sec_info))
451 return False;
452
453 return True;
454 }
455
456 /*******************************************************************
457 Reads or writes a LSA_R_QUERY_SEC_OBJ structure.
458 ********************************************************************/
459
460 BOOL lsa_io_r_query_sec_obj(const char *desc, LSA_R_QUERY_SEC_OBJ *out, prs_struct *ps, int depth)
461 {
462 prs_debug(ps, depth, desc, "lsa_io_r_query_sec_obj");
463 depth++;
464
465 if (!prs_align(ps))
466 return False;
467
468 if (!prs_uint32("ptr", ps, depth, &out->ptr))
469 return False;
470
471 if (out->ptr != 0) {
472 if (!sec_io_desc_buf("sec", &out->buf, ps, depth))
473 return False;
474 }
475
476 if (!prs_ntstatus("status", ps, depth, &out->status))
477 return False;
478
479 return True;
480 }
481
482 /*******************************************************************
483 Inits an LSA_Q_QUERY_INFO structure.
484 ********************************************************************/
485
486 void init_q_query(LSA_Q_QUERY_INFO *in, POLICY_HND *hnd, uint16 info_class)
487 {
488 DEBUG(5, ("init_q_query\n"));
489
490 memcpy(&in->pol, hnd, sizeof(in->pol));
491
492 in->info_class = info_class;
493 }
494
495 /*******************************************************************
496 Reads or writes an LSA_Q_QUERY_INFO structure.
497 ********************************************************************/
498
499 BOOL lsa_io_q_query(const char *desc, LSA_Q_QUERY_INFO *in, prs_struct *ps,
500 int depth)
501 {
502 prs_debug(ps, depth, desc, "lsa_io_q_query");
503 depth++;
504
505 if(!smb_io_pol_hnd("", &in->pol, ps, depth))
506 return False;
507
508 if(!prs_uint16("info_class", ps, depth, &in->info_class))
509 return False;
510
511 return True;
512 }
513
514 /*******************************************************************
515 makes an LSA_Q_ENUM_TRUST_DOM structure.
516 ********************************************************************/
517 BOOL init_q_enum_trust_dom(LSA_Q_ENUM_TRUST_DOM * q_e, POLICY_HND *pol,
518 uint32 enum_context, uint32 preferred_len)
519 {
520 DEBUG(5, ("init_q_enum_trust_dom\n"));
521
522 q_e->pol = *pol;
523 q_e->enum_context = enum_context;
524 q_e->preferred_len = preferred_len;
525
526 return True;
527 }
528
529 /*******************************************************************
530 Reads or writes an LSA_Q_ENUM_TRUST_DOM structure.
531 ********************************************************************/
532
533 BOOL lsa_io_q_enum_trust_dom(const char *desc, LSA_Q_ENUM_TRUST_DOM *q_e,
534 prs_struct *ps, int depth)
535 {
536 prs_debug(ps, depth, desc, "lsa_io_q_enum_trust_dom");
537 depth++;
538
539 if(!smb_io_pol_hnd("", &q_e->pol, ps, depth))
540 return False;
541
542 if(!prs_uint32("enum_context ", ps, depth, &q_e->enum_context))
543 return False;
544 if(!prs_uint32("preferred_len", ps, depth, &q_e->preferred_len))
545 return False;
546
547 return True;
548 }
549
550 /*******************************************************************
551 Inits an LSA_R_ENUM_TRUST_DOM structure.
552 ********************************************************************/
553
554 void init_r_enum_trust_dom(TALLOC_CTX *ctx, LSA_R_ENUM_TRUST_DOM *out,
555 uint32 enum_context, uint32 num_domains,
556 struct trustdom_info **td)
557 {
558 unsigned int i;
559
560 DEBUG(5, ("init_r_enum_trust_dom\n"));
561
562 out->enum_context = enum_context;
563 out->count = num_domains;
564
565 if ( num_domains != 0 ) {
566
567 /* allocate container memory */
568
569 out->domlist = TALLOC_P( ctx, DOMAIN_LIST );
570
571 if ( !out->domlist ) {
572 out->status = NT_STATUS_NO_MEMORY;
573 return;
574 }
575
576 out->domlist->domains = TALLOC_ARRAY( ctx, DOMAIN_INFO,
577 out->count );
578
579 if ( !out->domlist->domains ) {
580 out->status = NT_STATUS_NO_MEMORY;
581 return;
582 }
583
584 out->domlist->count = out->count;
585
586 /* initialize the list of domains and their sid */
587
588 for (i = 0; i < num_domains; i++) {
589 smb_ucs2_t *name;
590 if ( !(out->domlist->domains[i].sid =
591 TALLOC_P(ctx, DOM_SID2)) ) {
592 out->status = NT_STATUS_NO_MEMORY;
593 return;
594 }
595
596 init_dom_sid2(out->domlist->domains[i].sid,
597 &(td[i])->sid);
598 if (push_ucs2_talloc(ctx, &name, (td[i])->name) < 0){
599 out->status = NT_STATUS_NO_MEMORY;
600 return;
601 }
602 init_unistr4_w(ctx, &out->domlist->domains[i].name,
603 name);
604 }
605 }
606
607 }
608
609 /*******************************************************************
610 ********************************************************************/
611
612 BOOL lsa_io_domain_list( const char *desc, prs_struct *ps, int depth, DOMAIN_LIST *domlist )
613 {
614 int i;
615
616 prs_debug(ps, depth, desc, "lsa_io_domain_list");
617 depth++;
618
619 if(!prs_uint32("count", ps, depth, &domlist->count))
620 return False;
621
622 if ( domlist->count == 0 )
623 return True;
624
625 if ( UNMARSHALLING(ps) ) {
626 if ( !(domlist->domains = PRS_ALLOC_MEM( ps, DOMAIN_INFO, domlist->count )) )
627 return False;
628 }
629
630 /* headers */
631
632 for ( i=0; i<domlist->count; i++ ) {
633 if ( !prs_unistr4_hdr("name_header", ps, depth, &domlist->domains[i].name) )
634 return False;
635 if ( !smb_io_dom_sid2_p("sid_header", ps, depth, &domlist->domains[i].sid) )
636 return False;
637 }
638
639 /* data */
640
641 for ( i=0; i<domlist->count; i++ ) {
642 if ( !prs_unistr4_str("name", ps, depth, &domlist->domains[i].name) )
643 return False;
644 if( !smb_io_dom_sid2("sid", domlist->domains[i].sid, ps, depth) )
645 return False;
646 }
647
648 return True;
649 }
650
651 /*******************************************************************
652 Reads or writes an LSA_R_ENUM_TRUST_DOM structure.
653 ********************************************************************/
654
655 BOOL lsa_io_r_enum_trust_dom(const char *desc, LSA_R_ENUM_TRUST_DOM *out,
656 prs_struct *ps, int depth)
657 {
658 prs_debug(ps, depth, desc, "lsa_io_r_enum_trust_dom");
659 depth++;
660
661 if(!prs_uint32("enum_context", ps, depth, &out->enum_context))
662 return False;
663
664 if(!prs_uint32("count", ps, depth, &out->count))
665 return False;
666
667 if ( !prs_pointer("trusted_domains", ps, depth, (void**)&out->domlist, sizeof(DOMAIN_LIST), (PRS_POINTER_CAST)lsa_io_domain_list))
668 return False;
669
670 if(!prs_ntstatus("status", ps, depth, &out->status))
671 return False;
672
673 return True;
674 }
675
676 /*******************************************************************
677 reads or writes a dom query structure.
678 ********************************************************************/
679
680 static BOOL lsa_io_dom_query(const char *desc, DOM_QUERY *d_q, prs_struct *ps, int depth)
681 {
682 if (d_q == NULL)
683 return False;
684
685 prs_debug(ps, depth, desc, "lsa_io_dom_query");
686 depth++;
687
688 if(!prs_align(ps))
689 return False;
690
691 if(!prs_uint16("uni_dom_max_len", ps, depth, &d_q->uni_dom_max_len)) /* domain name string length * 2 */
692 return False;
693 if(!prs_uint16("uni_dom_str_len", ps, depth, &d_q->uni_dom_str_len)) /* domain name string length * 2 */
694 return False;
695
696 if(!prs_uint32("buffer_dom_name", ps, depth, &d_q->buffer_dom_name)) /* undocumented domain name string buffer pointer */
697 return False;
698 if(!prs_uint32("buffer_dom_sid ", ps, depth, &d_q->buffer_dom_sid)) /* undocumented domain SID string buffer pointer */
699 return False;
700
701 if(!smb_io_unistr2("unistr2", &d_q->uni_domain_name, d_q->buffer_dom_name, ps, depth)) /* domain name (unicode string) */
702 return False;
703
704 if(!prs_align(ps))
705 return False;
706
707 if (d_q->buffer_dom_sid != 0) {
708 if(!smb_io_dom_sid2("", &d_q->dom_sid, ps, depth)) /* domain SID */
709 return False;
710 } else {
711 memset((char *)&d_q->dom_sid, '\0', sizeof(d_q->dom_sid));
712 }
713
714 return True;
715 }
716
717 /*******************************************************************
718 reads or writes a structure.
719 ********************************************************************/
720
721 static BOOL lsa_io_dom_query_2(const char *desc, DOM_QUERY_2 *d_q, prs_struct *ps, int depth)
722 {
723 uint32 ptr = 1;
724
725 if (d_q == NULL)
726 return False;
727
728 prs_debug(ps, depth, desc, "lsa_io_dom_query_2");
729 depth++;
730
731 if (!prs_align(ps))
732 return False;
733
734 if (!prs_uint32("auditing_enabled", ps, depth, &d_q->auditing_enabled))
735 return False;
736 if (!prs_uint32("ptr ", ps, depth, &ptr))
737 return False;
738 if (!prs_uint32("count1", ps, depth, &d_q->count1))
739 return False;
740 if (!prs_uint32("count2", ps, depth, &d_q->count2))
741 return False;
742
743 if (UNMARSHALLING(ps)) {
744 d_q->auditsettings = TALLOC_ZERO_ARRAY(ps->mem_ctx, uint32, d_q->count2);
745 }
746
747 if (d_q->auditsettings == NULL) {
748 DEBUG(1, ("lsa_io_dom_query_2: NULL auditsettings!\n"));
749 return False;
750 }
751
752 if (!prs_uint32s(False, "auditsettings", ps, depth, d_q->auditsettings, d_q->count2))
753 return False;
754
755 return True;
756 }
757
758 /*******************************************************************
759 Reads or writes a dom query structure.
760 ********************************************************************/
761
762 static BOOL lsa_io_dom_query_3(const char *desc, DOM_QUERY_3 *d_q, prs_struct *ps, int depth)
763 {
764 return lsa_io_dom_query("", d_q, ps, depth);
765 }
766
767 /*******************************************************************
768 Reads or writes a dom query structure.
769 ********************************************************************/
770
771 static BOOL lsa_io_dom_query_5(const char *desc, DOM_QUERY_5 *d_q, prs_struct *ps, int depth)
772 {
773 return lsa_io_dom_query("", d_q, ps, depth);
774 }
775
776 /*******************************************************************
777 Reads or writes a dom query structure.
778 ********************************************************************/
779
780 static BOOL lsa_io_dom_query_6(const char *desc, DOM_QUERY_6 *d_q, prs_struct *ps, int depth)
781 {
782 if (d_q == NULL)
783 return False;
784
785 prs_debug(ps, depth, desc, "lsa_io_dom_query_6");
786 depth++;
787
788 if (!prs_uint16("server_role", ps, depth, &d_q->server_role))
789 return False;
790
791 return True;
792 }
793
794 /*******************************************************************
795 Reads or writes an LSA_R_QUERY_INFO structure.
796 ********************************************************************/
797
798 BOOL lsa_io_r_query(const char *desc, LSA_R_QUERY_INFO *out, prs_struct *ps, int depth)
799 {
800 prs_debug(ps, depth, desc, "lsa_io_r_query");
801 depth++;
802
803 if(!prs_uint32("undoc_buffer", ps, depth, &out->undoc_buffer))
804 return False;
805
806 if (out->undoc_buffer != 0) {
807 if(!prs_uint16("info_class", ps, depth, &out->info_class))
808 return False;
809
810 if(!prs_align(ps))
811 return False;
812
813 switch (out->info_class) {
814 case 2:
815 if(!lsa_io_dom_query_2("", &out->dom.id2, ps, depth))
816 return False;
817 break;
818 case 3:
819 if(!lsa_io_dom_query_3("", &out->dom.id3, ps, depth))
820 return False;
821 break;
822 case 5:
823 if(!lsa_io_dom_query_5("", &out->dom.id5, ps, depth))
824 return False;
825 break;
826 case 6:
827 if(!lsa_io_dom_query_6("", &out->dom.id6, ps, depth))
828 return False;
829 break;
830 default:
831 /* PANIC! */
832 break;
833 }
834 }
835
836 if(!prs_align(ps))
837 return False;
838
839 if(!prs_ntstatus("status", ps, depth, &out->status))
840 return False;
841
842 return True;
843 }
844
845 /*******************************************************************
846 Inits a LSA_SID_ENUM structure.
847 ********************************************************************/
848
849 static void init_lsa_sid_enum(TALLOC_CTX *mem_ctx, LSA_SID_ENUM *sen,
850 int num_entries, const DOM_SID *sids)
851 {
852 int i;
853
854 DEBUG(5, ("init_lsa_sid_enum\n"));
855
856 sen->num_entries = num_entries;
857 sen->ptr_sid_enum = (num_entries != 0);
858 sen->num_entries2 = num_entries;
859
860 /* Allocate memory for sids and sid pointers */
861
862 if (num_entries == 0) return;
863
864 if ((sen->ptr_sid = TALLOC_ZERO_ARRAY(mem_ctx, uint32, num_entries )) == NULL) {
865 DEBUG(3, ("init_lsa_sid_enum(): out of memory for ptr_sid\n"));
866 return;
867 }
868
869 if ((sen->sid = TALLOC_ZERO_ARRAY(mem_ctx, DOM_SID2, num_entries)) == NULL) {
870 DEBUG(3, ("init_lsa_sid_enum(): out of memory for sids\n"));
871 return;
872 }
873
874 /* Copy across SIDs and SID pointers */
875
876 for (i = 0; i < num_entries; i++) {
877 sen->ptr_sid[i] = 1;
878 init_dom_sid2(&sen->sid[i], &sids[i]);
879 }
880 }
881
882 /*******************************************************************
883 Reads or writes a LSA_SID_ENUM structure.
884 ********************************************************************/
885
886 static BOOL lsa_io_sid_enum(const char *desc, LSA_SID_ENUM *sen, prs_struct *ps,
887 int depth)
888 {
889 unsigned int i;
890
891 prs_debug(ps, depth, desc, "lsa_io_sid_enum");
892 depth++;
893
894 if(!prs_align(ps))
895 return False;
896
897 if(!prs_uint32("num_entries ", ps, depth, &sen->num_entries))
898 return False;
899 if(!prs_uint32("ptr_sid_enum", ps, depth, &sen->ptr_sid_enum))
900 return False;
901
902 /*
903 if the ptr is NULL, leave here. checked from a real w2k trace.
904 JFM, 11/23/2001
905 */
906
907 if (sen->ptr_sid_enum==0)
908 return True;
909
910 if(!prs_uint32("num_entries2", ps, depth, &sen->num_entries2))
911 return False;
912
913 /* Mallocate memory if we're unpacking from the wire */
914
915 if (UNMARSHALLING(ps)) {
916 if ((sen->ptr_sid = PRS_ALLOC_MEM( ps, uint32, sen->num_entries)) == NULL) {
917 DEBUG(3, ("init_lsa_sid_enum(): out of memory for "
918 "ptr_sid\n"));
919 return False;
920 }
921
922 if ((sen->sid = PRS_ALLOC_MEM( ps, DOM_SID2, sen->num_entries)) == NULL) {
923 DEBUG(3, ("init_lsa_sid_enum(): out of memory for "
924 "sids\n"));
925 return False;
926 }
927 }
928
929 for (i = 0; i < sen->num_entries; i++) {
930 fstring temp;
931
932 slprintf(temp, sizeof(temp) - 1, "ptr_sid[%d]", i);
933 if(!prs_uint32(temp, ps, depth, &sen->ptr_sid[i])) {
934 return False;
935 }
936 }
937
938 for (i = 0; i < sen->num_entries; i++) {
939 fstring temp;
940
941 slprintf(temp, sizeof(temp) - 1, "sid[%d]", i);
942 if(!smb_io_dom_sid2(temp, &sen->sid[i], ps, depth)) {
943 return False;
944 }
945 }
946
947 return True;
948 }
949
950 /*******************************************************************
951 Inits an LSA_R_ENUM_TRUST_DOM structure.
952 ********************************************************************/
953
954 void init_q_lookup_sids(TALLOC_CTX *mem_ctx, LSA_Q_LOOKUP_SIDS *q_l,
955 POLICY_HND *hnd, int num_sids, const DOM_SID *sids,
956 uint16 level)
957 {
958 DEBUG(5, ("init_q_lookup_sids\n"));
959
960 ZERO_STRUCTP(q_l);
961
962 memcpy(&q_l->pol, hnd, sizeof(q_l->pol));
963 init_lsa_sid_enum(mem_ctx, &q_l->sids, num_sids, sids);
964
965 q_l->level = level;
966 }
967
968 /*******************************************************************
969 Reads or writes a LSA_Q_LOOKUP_SIDS structure.
970 ********************************************************************/
971
972 BOOL lsa_io_q_lookup_sids(const char *desc, LSA_Q_LOOKUP_SIDS *q_s, prs_struct *ps,
973 int depth)
974 {
975 prs_debug(ps, depth, desc, "lsa_io_q_lookup_sids");
976 depth++;
977
978 if(!prs_align(ps))
979 return False;
980
981 if(!smb_io_pol_hnd("pol_hnd", &q_s->pol, ps, depth)) /* policy handle */
982 return False;
983 if(!lsa_io_sid_enum("sids ", &q_s->sids, ps, depth)) /* sids to be looked up */
984 return False;
985 if(!lsa_io_trans_names("names ", &q_s->names, ps, depth)) /* translated names */
986 return False;
987
988 if(!prs_uint16("level", ps, depth, &q_s->level)) /* lookup level */
989 return False;
990 if(!prs_align(ps))
991 return False;
992
993 if(!prs_uint32("mapped_count", ps, depth, &q_s->mapped_count))
994 return False;
995
996 return True;
997 }
998
999 /*******************************************************************
1000 Reads or writes a LSA_Q_LOOKUP_SIDS2 structure.
1001 ********************************************************************/
1002
1003 BOOL lsa_io_q_lookup_sids2(const char *desc, LSA_Q_LOOKUP_SIDS2 *q_s, prs_struct *ps,
1004 int depth)
1005 {
1006 prs_debug(ps, depth, desc, "lsa_io_q_lookup_sids2");
1007 depth++;
1008
1009 if(!prs_align(ps))
1010 return False;
1011
1012 if(!smb_io_pol_hnd("pol_hnd", &q_s->pol, ps, depth)) /* policy handle */
1013 return False;
1014 if(!lsa_io_sid_enum("sids ", &q_s->sids, ps, depth)) /* sids to be looked up */
1015 return False;
1016 if(!lsa_io_trans_names2("names ", &q_s->names, ps, depth)) /* translated names */
1017 return False;
1018
1019 if(!prs_uint16("level", ps, depth, &q_s->level)) /* lookup level */
1020 return False;
1021 if(!prs_align(ps))
1022 return False;
1023
1024 if(!prs_uint32("mapped_count", ps, depth, &q_s->mapped_count))
1025 return False;
1026 if(!prs_uint32("unknown1", ps, depth, &q_s->unknown1))
1027 return False;
1028 if(!prs_uint32("unknown2", ps, depth, &q_s->unknown2))
1029 return False;
1030
1031 return True;
1032 }
1033
1034 /*******************************************************************
1035 Reads or writes a LSA_Q_LOOKUP_SIDS3 structure.
1036 ********************************************************************/
1037
1038 BOOL lsa_io_q_lookup_sids3(const char *desc, LSA_Q_LOOKUP_SIDS3 *q_s, prs_struct *ps,
1039 int depth)
1040 {
1041 prs_debug(ps, depth, desc, "lsa_io_q_lookup_sids3");
1042 depth++;
1043
1044 if(!prs_align(ps))
1045 return False;
1046
1047 if(!lsa_io_sid_enum("sids ", &q_s->sids, ps, depth)) /* sids to be looked up */
1048 return False;
1049 if(!lsa_io_trans_names2("names ", &q_s->names, ps, depth)) /* translated names */
1050 return False;
1051
1052 if(!prs_uint16("level", ps, depth, &q_s->level)) /* lookup level */
1053 return False;
1054 if(!prs_align(ps))
1055 return False;
1056
1057 if(!prs_uint32("mapped_count", ps, depth, &q_s->mapped_count))
1058 return False;
1059 if(!prs_uint32("unknown1", ps, depth, &q_s->unknown1))
1060 return False;
1061 if(!prs_uint32("unknown2", ps, depth, &q_s->unknown2))
1062 return False;
1063
1064 return True;
1065 }
1066
1067
1068 /*******************************************************************
1069 Reads or writes a structure.
1070 ********************************************************************/
1071
1072 static BOOL lsa_io_trans_names(const char *desc, LSA_TRANS_NAME_ENUM *trn,
1073 prs_struct *ps, int depth)
1074 {
1075 unsigned int i;
1076
1077 prs_debug(ps, depth, desc, "lsa_io_trans_names");
1078 depth++;
1079
1080 if(!prs_align(ps))
1081 return False;
1082
1083 if(!prs_uint32("num_entries ", ps, depth, &trn->num_entries))
1084 return False;
1085 if(!prs_uint32("ptr_trans_names", ps, depth, &trn->ptr_trans_names))
1086 return False;
1087
1088 if (trn->ptr_trans_names != 0) {
1089 if(!prs_uint32("num_entries2 ", ps, depth,
1090 &trn->num_entries2))
1091 return False;
1092
1093 if (UNMARSHALLING(ps)) {
1094 if ((trn->name = PRS_ALLOC_MEM(ps, LSA_TRANS_NAME, trn->num_entries)) == NULL) {
1095 return False;
1096 }
1097
1098 if ((trn->uni_name = PRS_ALLOC_MEM(ps, UNISTR2, trn->num_entries)) == NULL) {
1099 return False;
1100 }
1101 }
1102
1103 for (i = 0; i < trn->num_entries2; i++) {
1104 fstring t;
1105 slprintf(t, sizeof(t) - 1, "name[%d] ", i);
1106
1107 if(!lsa_io_trans_name(t, &trn->name[i], ps, depth)) /* translated name */
1108 return False;
1109 }
1110
1111 for (i = 0; i < trn->num_entries2; i++) {
1112 fstring t;
1113 slprintf(t, sizeof(t) - 1, "name[%d] ", i);
1114
1115 if(!smb_io_unistr2(t, &trn->uni_name[i], trn->name[i].hdr_name.buffer, ps, depth))
1116 return False;
1117 if(!prs_align(ps))
1118 return False;
1119 }
1120 }
1121
1122 return True;
1123 }
1124
1125 /*******************************************************************
1126 Reads or writes a structure.
1127 ********************************************************************/
1128
1129 static BOOL lsa_io_trans_names2(const char *desc, LSA_TRANS_NAME_ENUM2 *trn,
1130 prs_struct *ps, int depth)
1131 {
1132 unsigned int i;
1133
1134 prs_debug(ps, depth, desc, "lsa_io_trans_names2");
1135 depth++;
1136
1137 if(!prs_align(ps))
1138 return False;
1139
1140 if(!prs_uint32("num_entries ", ps, depth, &trn->num_entries))
1141 return False;
1142 if(!prs_uint32("ptr_trans_names", ps, depth, &trn->ptr_trans_names))
1143 return False;
1144
1145 if (trn->ptr_trans_names != 0) {
1146 if(!prs_uint32("num_entries2 ", ps, depth,
1147 &trn->num_entries2))
1148 return False;
1149
1150 if (UNMARSHALLING(ps)) {
1151 if ((trn->name = PRS_ALLOC_MEM(ps, LSA_TRANS_NAME2, trn->num_entries)) == NULL) {
1152 return False;
1153 }
1154
1155 if ((trn->uni_name = PRS_ALLOC_MEM(ps, UNISTR2, trn->num_entries)) == NULL) {
1156 return False;
1157 }
1158 }
1159
1160 for (i = 0; i < trn->num_entries2; i++) {
1161 fstring t;
1162 slprintf(t, sizeof(t) - 1, "name[%d] ", i);
1163
1164 if(!lsa_io_trans_name2(t, &trn->name[i], ps, depth)) /* translated name */
1165 return False;
1166 }
1167
1168 for (i = 0; i < trn->num_entries2; i++) {
1169 fstring t;
1170 slprintf(t, sizeof(t) - 1, "name[%d] ", i);
1171
1172 if(!smb_io_unistr2(t, &trn->uni_name[i], trn->name[i].hdr_name.buffer, ps, depth))
1173 return False;
1174 if(!prs_align(ps))
1175 return False;
1176 }
1177 }
1178
1179 return True;
1180 }
1181
1182
1183 /*******************************************************************
1184 Reads or writes a structure.
1185 ********************************************************************/
1186
1187 BOOL lsa_io_r_lookup_sids(const char *desc, LSA_R_LOOKUP_SIDS *r_s,
1188 prs_struct *ps, int depth)
1189 {
1190 prs_debug(ps, depth, desc, "lsa_io_r_lookup_sids");
1191 depth++;
1192
1193 if(!prs_align(ps))
1194 return False;
1195
1196 if(!prs_uint32("ptr_dom_ref", ps, depth, &r_s->ptr_dom_ref))
1197 return False;
1198
1199 if (r_s->ptr_dom_ref != 0)
1200 if(!lsa_io_dom_r_ref ("dom_ref", r_s->dom_ref, ps, depth)) /* domain reference info */
1201 return False;
1202
1203 if(!lsa_io_trans_names("names ", r_s->names, ps, depth)) /* translated names */
1204 return False;
1205
1206 if(!prs_align(ps))
1207 return False;
1208
1209 if(!prs_uint32("mapped_count", ps, depth, &r_s->mapped_count))
1210 return False;
1211
1212 if(!prs_ntstatus("status ", ps, depth, &r_s->status))
1213 return False;
1214
1215 return True;
1216 }
1217
1218 /*******************************************************************
1219 Reads or writes a structure.
1220 ********************************************************************/
1221
1222 BOOL lsa_io_r_lookup_sids2(const char *desc, LSA_R_LOOKUP_SIDS2 *r_s,
1223 prs_struct *ps, int depth)
1224 {
1225 prs_debug(ps, depth, desc, "lsa_io_r_lookup_sids2");
1226 depth++;
1227
1228 if(!prs_align(ps))
1229 return False;
1230
1231 if(!prs_uint32("ptr_dom_ref", ps, depth, &r_s->ptr_dom_ref))
1232 return False;
1233
1234 if (r_s->ptr_dom_ref != 0)
1235 if(!lsa_io_dom_r_ref ("dom_ref", r_s->dom_ref, ps, depth)) /* domain reference info */
1236 return False;
1237
1238 if(!lsa_io_trans_names2("names ", r_s->names, ps, depth)) /* translated names */
1239 return False;
1240
1241 if(!prs_align(ps))
1242 return False;
1243
1244 if(!prs_uint32("mapped_count", ps, depth, &r_s->mapped_count))
1245 return False;
1246
1247 if(!prs_ntstatus("status ", ps, depth, &r_s->status))
1248 return False;
1249
1250 return True;
1251 }
1252
1253
1254 /*******************************************************************
1255 Reads or writes a structure.
1256 ********************************************************************/
1257
1258 BOOL lsa_io_r_lookup_sids3(const char *desc, LSA_R_LOOKUP_SIDS3 *r_s,
1259 prs_struct *ps, int depth)
1260 {
1261 prs_debug(ps, depth, desc, "lsa_io_r_lookup_sids3");
1262 depth++;
1263
1264 if(!prs_align(ps))
1265 return False;
1266
1267 if(!prs_uint32("ptr_dom_ref", ps, depth, &r_s->ptr_dom_ref))
1268 return False;
1269
1270 if (r_s->ptr_dom_ref != 0)
1271 if(!lsa_io_dom_r_ref ("dom_ref", r_s->dom_ref, ps, depth)) /* domain reference info */
1272 return False;
1273
1274 if(!lsa_io_trans_names2("names ", r_s->names, ps, depth)) /* translated names */
1275 return False;
1276
1277 if(!prs_align(ps))
1278 return False;
1279
1280 if(!prs_uint32("mapped_count", ps, depth, &r_s->mapped_count))
1281 return False;
1282
1283 if(!prs_ntstatus("status ", ps, depth, &r_s->status))
1284 return False;
1285
1286 return True;
1287 }
1288
1289 /*******************************************************************
1290 makes a structure.
1291 ********************************************************************/
1292
1293 void init_q_lookup_names(TALLOC_CTX *mem_ctx, LSA_Q_LOOKUP_NAMES *q_l,
1294 POLICY_HND *hnd, int num_names, const char **names)
1295 {
1296 unsigned int i;
1297
1298 DEBUG(5, ("init_q_lookup_names\n"));
1299
1300 ZERO_STRUCTP(q_l);
1301
1302 q_l->pol = *hnd;
1303 q_l->num_entries = num_names;
1304 q_l->num_entries2 = num_names;
1305 q_l->lookup_level = 1;
1306
1307 if ((q_l->uni_name = TALLOC_ZERO_ARRAY(mem_ctx, UNISTR2, num_names)) == NULL) {
1308 DEBUG(3, ("init_q_lookup_names(): out of memory\n"));
1309 return;
1310 }
1311
1312 if ((q_l->hdr_name = TALLOC_ZERO_ARRAY(mem_ctx, UNIHDR, num_names)) == NULL) {
1313 DEBUG(3, ("init_q_lookup_names(): out of memory\n"));
1314 return;
1315 }
1316
1317 for (i = 0; i < num_names; i++) {
1318 init_unistr2(&q_l->uni_name[i], names[i], UNI_FLAGS_NONE);
1319 init_uni_hdr(&q_l->hdr_name[i], &q_l->uni_name[i]);
1320 }
1321 }
1322
1323 /*******************************************************************
1324 reads or writes a structure.
1325 ********************************************************************/
1326
1327 BOOL lsa_io_q_lookup_names(const char *desc, LSA_Q_LOOKUP_NAMES *q_r,
1328 prs_struct *ps, int depth)
1329 {
1330 unsigned int i;
1331
1332 prs_debug(ps, depth, desc, "lsa_io_q_lookup_names");
1333 depth++;
1334
1335 if(!prs_align(ps))
1336 return False;
1337
1338 if(!smb_io_pol_hnd("", &q_r->pol, ps, depth)) /* policy handle */
1339 return False;
1340
1341 if(!prs_align(ps))
1342 return False;
1343 if(!prs_uint32("num_entries ", ps, depth, &q_r->num_entries))
1344 return False;
1345 if(!prs_uint32("num_entries2 ", ps, depth, &q_r->num_entries2))
1346 return False;
1347
1348 if (UNMARSHALLING(ps)) {
1349 if (q_r->num_entries) {
1350 if ((q_r->hdr_name = PRS_ALLOC_MEM(ps, UNIHDR, q_r->num_entries)) == NULL)
1351 return False;
1352 if ((q_r->uni_name = PRS_ALLOC_MEM(ps, UNISTR2, q_r->num_entries)) == NULL)
1353 return False;
1354 }
1355 }
1356
1357 for (i = 0; i < q_r->num_entries; i++) {
1358 if(!prs_align(ps))
1359 return False;
1360 if(!smb_io_unihdr("hdr_name", &q_r->hdr_name[i], ps, depth)) /* pointer names */
1361 return False;
1362 }
1363
1364 for (i = 0; i < q_r->num_entries; i++) {
1365 if(!prs_align(ps))
1366 return False;
1367 if(!smb_io_unistr2("dom_name", &q_r->uni_name[i], q_r->hdr_name[i].buffer, ps, depth)) /* names to be looked up */
1368 return False;
1369 }
1370
1371 if(!prs_align(ps))
1372 return False;
1373 if(!prs_uint32("num_trans_entries ", ps, depth, &q_r->num_trans_entries))
1374 return False;
1375 if(!prs_uint32("ptr_trans_sids ", ps, depth, &q_r->ptr_trans_sids))
1376 return False;
1377 if(!prs_uint16("lookup_level ", ps, depth, &q_r->lookup_level))
1378 return False;
1379 if(!prs_align(ps))
1380 return False;
1381 if(!prs_uint32("mapped_count ", ps, depth, &q_r->mapped_count))
1382 return False;
1383
1384 return True;
1385 }
1386
1387 /*******************************************************************
1388 reads or writes a structure.
1389 ********************************************************************/
1390
1391 BOOL lsa_io_r_lookup_names(const char *desc, LSA_R_LOOKUP_NAMES *out, prs_struct *ps, int depth)
1392 {
1393 unsigned int i;
1394
1395 prs_debug(ps, depth, desc, "lsa_io_r_lookup_names");
1396 depth++;
1397
1398 if(!prs_align(ps))
1399 return False;
1400
1401 if(!prs_uint32("ptr_dom_ref", ps, depth, &out->ptr_dom_ref))
1402 return False;
1403
1404 if (out->ptr_dom_ref != 0)
1405 if(!lsa_io_dom_r_ref("", out->dom_ref, ps, depth))
1406 return False;
1407
1408 if(!prs_uint32("num_entries", ps, depth, &out->num_entries))
1409 return False;
1410 if(!prs_uint32("ptr_entries", ps, depth, &out->ptr_entries))
1411 return False;
1412
1413 if (out->ptr_entries != 0) {
1414 if(!prs_uint32("num_entries2", ps, depth, &out->num_entries2))
1415 return False;
1416
1417 if (out->num_entries2 != out->num_entries) {
1418 /* RPC fault */
1419 return False;
1420 }
1421
1422 if (UNMARSHALLING(ps)) {
1423 if ((out->dom_rid = PRS_ALLOC_MEM(ps, DOM_RID, out->num_entries2))
1424 == NULL) {
1425 DEBUG(3, ("lsa_io_r_lookup_names(): out of memory\n"));
1426 return False;
1427 }
1428 }
1429
1430 for (i = 0; i < out->num_entries2; i++)
1431 if(!smb_io_dom_rid("", &out->dom_rid[i], ps, depth)) /* domain RIDs being looked up */
1432 return False;
1433 }
1434
1435 if(!prs_uint32("mapped_count", ps, depth, &out->mapped_count))
1436 return False;
1437
1438 if(!prs_ntstatus("status ", ps, depth, &out->status))
1439 return False;
1440
1441 return True;
1442 }
1443
1444 /*******************************************************************
1445 reads or writes a structure.
1446 ********************************************************************/
1447
1448 BOOL lsa_io_q_lookup_names2(const char *desc, LSA_Q_LOOKUP_NAMES2 *q_r,
1449 prs_struct *ps, int depth)
1450 {
1451 unsigned int i;
1452
1453 prs_debug(ps, depth, desc, "lsa_io_q_lookup_names2");
1454 depth++;
1455
1456 if(!prs_align(ps))
1457 return False;
1458
1459 if(!smb_io_pol_hnd("", &q_r->pol, ps, depth)) /* policy handle */
1460 return False;
1461
1462 if(!prs_align(ps))
1463 return False;
1464 if(!prs_uint32("num_entries ", ps, depth, &q_r->num_entries))
1465 return False;
1466 if(!prs_uint32("num_entries2 ", ps, depth, &q_r->num_entries2))
1467 return False;
1468
1469 if (UNMARSHALLING(ps)) {
1470 if (q_r->num_entries) {
1471 if ((q_r->hdr_name = PRS_ALLOC_MEM(ps, UNIHDR, q_r->num_entries)) == NULL)
1472 return False;
1473 if ((q_r->uni_name = PRS_ALLOC_MEM(ps, UNISTR2, q_r->num_entries)) == NULL)
1474 return False;
1475 }
1476 }
1477
1478 for (i = 0; i < q_r->num_entries; i++) {
1479 if(!prs_align(ps))
1480 return False;
1481 if(!smb_io_unihdr("hdr_name", &q_r->hdr_name[i], ps, depth)) /* pointer names */
1482 return False;
1483 }
1484
1485 for (i = 0; i < q_r->num_entries; i++) {
1486 if(!prs_align(ps))
1487 return False;
1488 if(!smb_io_unistr2("dom_name", &q_r->uni_name[i], q_r->hdr_name[i].buffer, ps, depth)) /* names to be looked up */
1489 return False;
1490 }
1491
1492 if(!prs_align(ps))
1493 return False;
1494 if(!prs_uint32("num_trans_entries ", ps, depth, &q_r->num_trans_entries))
1495 return False;
1496 if(!prs_uint32("ptr_trans_sids ", ps, depth, &q_r->ptr_trans_sids))
1497 return False;
1498 if(!prs_uint16("lookup_level ", ps, depth, &q_r->lookup_level))
1499 return False;
1500 if(!prs_align(ps))
1501 return False;
1502 if(!prs_uint32("mapped_count ", ps, depth, &q_r->mapped_count))
1503 return False;
1504 if(!prs_uint32("unknown1 ", ps, depth, &q_r->unknown1))
1505 return False;
1506 if(!prs_uint32("unknown2 ", ps, depth, &q_r->unknown2))
1507 return False;
1508
1509 return True;
1510 }
1511
1512 /*******************************************************************
1513 reads or writes a structure.
1514 ********************************************************************/
1515
1516 BOOL lsa_io_r_lookup_names2(const char *desc, LSA_R_LOOKUP_NAMES2 *out, prs_struct *ps, int depth)
1517 {
1518 unsigned int i;
1519
1520 prs_debug(ps, depth, desc, "lsa_io_r_lookup_names2");
1521 depth++;
1522
1523 if(!prs_align(ps))
1524 return False;
1525
1526 if(!prs_uint32("ptr_dom_ref", ps, depth, &out->ptr_dom_ref))
1527 return False;
1528
1529 if (out->ptr_dom_ref != 0)
1530 if(!lsa_io_dom_r_ref("", out->dom_ref, ps, depth))
1531 return False;
1532
1533 if(!prs_uint32("num_entries", ps, depth, &out->num_entries))
1534 return False;
1535 if(!prs_uint32("ptr_entries", ps, depth, &out->ptr_entries))
1536 return False;
1537
1538 if (out->ptr_entries != 0) {
1539 if(!prs_uint32("num_entries2", ps, depth, &out->num_entries2))
1540 return False;
1541
1542 if (out->num_entries2 != out->num_entries) {
1543 /* RPC fault */
1544 return False;
1545 }
1546
1547 if (UNMARSHALLING(ps)) {
1548 if ((out->dom_rid = PRS_ALLOC_MEM(ps, DOM_RID2, out->num_entries2))
1549 == NULL) {
1550 DEBUG(3, ("lsa_io_r_lookup_names2(): out of memory\n"));
1551 return False;
1552 }
1553 }
1554
1555 for (i = 0; i < out->num_entries2; i++)
1556 if(!smb_io_dom_rid2("", &out->dom_rid[i], ps, depth)) /* domain RIDs being looked up */
1557 return False;
1558 }
1559
1560 if(!prs_uint32("mapped_count", ps, depth, &out->mapped_count))
1561 return False;
1562
1563 if(!prs_ntstatus("status ", ps, depth, &out->status))
1564 return False;
1565
1566 return True;
1567 }
1568
1569 /*******************************************************************
1570 Internal lsa data type io.
1571 Following pass must read DOM_SID2 types.
1572 ********************************************************************/
1573
1574 BOOL smb_io_lsa_translated_sids3(const char *desc, LSA_TRANSLATED_SID3 *q_r,
1575 prs_struct *ps, int depth)
1576 {
1577 prs_debug(ps, depth, desc, "smb_io_lsa_translated_sids3");
1578 depth++;
1579
1580 if(!prs_align(ps))
1581 return False;
1582 if(!prs_uint8 ("sid_type ", ps, depth, &q_r->sid_type ))
1583 return False;
1584 if(!prs_align(ps))
1585 return False;
1586 /* Second pass will read/write these. */
1587 if (!smb_io_dom_sid2_p("sid_header", ps, depth, &q_r->sid2))
1588 return False;
1589 if(!prs_uint32("sid_idx ", ps, depth, &q_r->sid_idx ))
1590 return False;
1591 if(!prs_uint32("unknown ", ps, depth, &q_r->unknown ))
1592 return False;
1593
1594 return True;
1595 }
1596
1597 /*******************************************************************
1598 Identical to lsa_io_q_lookup_names2.
1599 ********************************************************************/
1600
1601 BOOL lsa_io_q_lookup_names3(const char *desc, LSA_Q_LOOKUP_NAMES3 *q_r,
1602 prs_struct *ps, int depth)
1603 {
1604 unsigned int i;
1605
1606 prs_debug(ps, depth, desc, "lsa_io_q_lookup_names3");
1607 depth++;
1608
1609 if(!prs_align(ps))
1610 return False;
1611
1612 if(!smb_io_pol_hnd("", &q_r->pol, ps, depth)) /* policy handle */
1613 return False;
1614
1615 if(!prs_align(ps))
1616 return False;
1617 if(!prs_uint32("num_entries ", ps, depth, &q_r->num_entries))
1618 return False;
1619 if(!prs_uint32("num_entries2 ", ps, depth, &q_r->num_entries2))
1620 return False;
1621
1622 if (UNMARSHALLING(ps)) {
1623 if (q_r->num_entries) {
1624 if ((q_r->hdr_name = PRS_ALLOC_MEM(ps, UNIHDR, q_r->num_entries)) == NULL)
1625 return False;
1626 if ((q_r->uni_name = PRS_ALLOC_MEM(ps, UNISTR2, q_r->num_entries)) == NULL)
1627 return False;
1628 }
1629 }
1630
1631 for (i = 0; i < q_r->num_entries; i++) {
1632 if(!prs_align(ps))
1633 return False;
1634 if(!smb_io_unihdr("hdr_name", &q_r->hdr_name[i], ps, depth)) /* pointer names */
1635 return False;
1636 }
1637
1638 for (i = 0; i < q_r->num_entries; i++) {
1639 if(!prs_align(ps))
1640 return False;
1641 if(!smb_io_unistr2("dom_name", &q_r->uni_name[i], q_r->hdr_name[i].buffer, ps, depth)) /* names to be looked up */
1642 return False;
1643 }
1644
1645 if(!prs_align(ps))
1646 return False;
1647 if(!prs_uint32("num_trans_entries ", ps, depth, &q_r->num_trans_entries))
1648 return False;
1649 if(!prs_uint32("ptr_trans_sids ", ps, depth, &q_r->ptr_trans_sids))
1650 return False;
1651 if(!prs_uint16("lookup_level ", ps, depth, &q_r->lookup_level))
1652 return False;
1653 if(!prs_align(ps))
1654 return False;
1655 if(!prs_uint32("mapped_count ", ps, depth, &q_r->mapped_count))
1656 return False;
1657 if(!prs_uint32("unknown1 ", ps, depth, &q_r->unknown1))
1658 return False;
1659 if(!prs_uint32("unknown2 ", ps, depth, &q_r->unknown2))
1660 return False;
1661
1662 return True;
1663 }
1664
1665 /*******************************************************************
1666 reads or writes a structure.
1667 ********************************************************************/
1668
1669 BOOL lsa_io_r_lookup_names3(const char *desc, LSA_R_LOOKUP_NAMES3 *out, prs_struct *ps, int depth)
1670 {
1671 unsigned int i;
1672
1673 prs_debug(ps, depth, desc, "lsa_io_r_lookup_names3");
1674 depth++;
1675
1676 if(!prs_align(ps))
1677 return False;
1678
1679 if(!prs_uint32("ptr_dom_ref", ps, depth, &out->ptr_dom_ref))
1680 return False;
1681
1682 if (out->ptr_dom_ref != 0)
1683 if(!lsa_io_dom_r_ref("", out->dom_ref, ps, depth))
1684 return False;
1685
1686 if(!prs_uint32("num_entries", ps, depth, &out->num_entries))
1687 return False;
1688 if(!prs_uint32("ptr_entries", ps, depth, &out->ptr_entries))
1689 return False;
1690
1691 if (out->ptr_entries != 0) {
1692 if(!prs_uint32("num_entries2", ps, depth, &out->num_entries2))
1693 return False;
1694
1695 if (out->num_entries2 != out->num_entries) {
1696 /* RPC fault */
1697 return False;
1698 }
1699
1700 if (UNMARSHALLING(ps)) {
1701 if ((out->trans_sids = PRS_ALLOC_MEM(ps, LSA_TRANSLATED_SID3, out->num_entries2))
1702 == NULL) {
1703 DEBUG(3, ("lsa_io_r_lookup_names3(): out of memory\n"));
1704 return False;
1705 }
1706 }
1707
1708 for (i = 0; i < out->num_entries2; i++) {
1709 if(!smb_io_lsa_translated_sids3("", &out->trans_sids[i], ps, depth)) {
1710 return False;
1711 }
1712 }
1713 /* Now process the DOM_SID2 entries. */
1714 for (i = 0; i < out->num_entries2; i++) {
1715 if (out->trans_sids[i].sid2) {
1716 if( !smb_io_dom_sid2("sid2", out->trans_sids[i].sid2, ps, depth) ) {
1717 return False;
1718 }
1719 }
1720 }
1721 }
1722
1723 if(!prs_uint32("mapped_count", ps, depth, &out->mapped_count))
1724 return False;
1725
1726 if(!prs_ntstatus("status ", ps, depth, &out->status))
1727 return False;
1728
1729 return True;
1730 }
1731
1732 /*******************************************************************
1733 ********************************************************************/
1734
1735 BOOL lsa_io_q_lookup_names4(const char *desc, LSA_Q_LOOKUP_NAMES4 *q_r,
1736 prs_struct *ps, int depth)
1737 {
1738 unsigned int i;
1739
1740 prs_debug(ps, depth, desc, "lsa_io_q_lookup_names4");
1741 depth++;
1742
1743 if(!prs_align(ps))
1744 return False;
1745
1746 if(!prs_uint32("num_entries ", ps, depth, &q_r->num_entries))
1747 return False;
1748 if(!prs_uint32("num_entries2 ", ps, depth, &q_r->num_entries2))
1749 return False;
1750
1751 if (UNMARSHALLING(ps)) {
1752 if (q_r->num_entries) {
1753 if ((q_r->hdr_name = PRS_ALLOC_MEM(ps, UNIHDR, q_r->num_entries)) == NULL)
1754 return False;
1755 if ((q_r->uni_name = PRS_ALLOC_MEM(ps, UNISTR2, q_r->num_entries)) == NULL)
1756 return False;
1757 }
1758 }
1759
1760 for (i = 0; i < q_r->num_entries; i++) {
1761 if(!prs_align(ps))
1762 return False;
1763 if(!smb_io_unihdr("hdr_name", &q_r->hdr_name[i], ps, depth)) /* pointer names */
1764 return False;
1765 }
1766
1767 for (i = 0; i < q_r->num_entries; i++) {
1768 if(!prs_align(ps))
1769 return False;
1770 if(!smb_io_unistr2("dom_name", &q_r->uni_name[i], q_r->hdr_name[i].buffer, ps, depth)) /* names to be looked up */
1771 return False;
1772 }
1773
1774 if(!prs_align(ps))
1775 return False;
1776 if(!prs_uint32("num_trans_entries ", ps, depth, &q_r->num_trans_entries))
1777 return False;
1778 if(!prs_uint32("ptr_trans_sids ", ps, depth, &q_r->ptr_trans_sids))
1779 return False;
1780 if(!prs_uint16("lookup_level ", ps, depth, &q_r->lookup_level))
1781 return False;
1782 if(!prs_align(ps))
1783 return False;
1784 if(!prs_uint32("mapped_count ", ps, depth, &q_r->mapped_count))
1785 return False;
1786 if(!prs_uint32("unknown1 ", ps, depth, &q_r->unknown1))
1787 return False;
1788 if(!prs_uint32("unknown2 ", ps, depth, &q_r->unknown2))
1789 return False;
1790
1791 return True;
1792 }
1793
1794 /*******************************************************************
1795 Identical to lsa_io_r_lookup_names3.
1796 ********************************************************************/
1797
1798 BOOL lsa_io_r_lookup_names4(const char *desc, LSA_R_LOOKUP_NAMES4 *out, prs_struct *ps, int depth)
1799 {
1800 unsigned int i;
1801
1802 prs_debug(ps, depth, desc, "lsa_io_r_lookup_names4");
1803 depth++;
1804
1805 if(!prs_align(ps))
1806 return False;
1807
1808 if(!prs_uint32("ptr_dom_ref", ps, depth, &out->ptr_dom_ref))
1809 return False;
1810
1811 if (out->ptr_dom_ref != 0)
1812 if(!lsa_io_dom_r_ref("", out->dom_ref, ps, depth))
1813 return False;
1814
1815 if(!prs_uint32("num_entries", ps, depth, &out->num_entries))
1816 return False;
1817 if(!prs_uint32("ptr_entries", ps, depth, &out->ptr_entries))
1818 return False;
1819
1820 if (out->ptr_entries != 0) {
1821 if(!prs_uint32("num_entries2", ps, depth, &out->num_entries2))
1822 return False;
1823
1824 if (out->num_entries2 != out->num_entries) {
1825 /* RPC fault */
1826 return False;
1827 }
1828
1829 if (UNMARSHALLING(ps)) {
1830 if ((out->trans_sids = PRS_ALLOC_MEM(ps, LSA_TRANSLATED_SID3, out->num_entries2))
1831 == NULL) {
1832 DEBUG(3, ("lsa_io_r_lookup_names4(): out of memory\n"));
1833 return False;
1834 }
1835 }
1836
1837 for (i = 0; i < out->num_entries2; i++) {
1838 if(!smb_io_lsa_translated_sids3("", &out->trans_sids[i], ps, depth)) {
1839 return False;
1840 }
1841 }
1842 /* Now process the DOM_SID2 entries. */
1843 for (i = 0; i < out->num_entries2; i++) {
1844 if (out->trans_sids[i].sid2) {
1845 if( !smb_io_dom_sid2("sid2", out->trans_sids[i].sid2, ps, depth) ) {
1846 return False;
1847 }
1848 }
1849 }
1850 }
1851
1852 if(!prs_uint32("mapped_count", ps, depth, &out->mapped_count))
1853 return False;
1854
1855 if(!prs_ntstatus("status ", ps, depth, &out->status))
1856 return False;
1857
1858 return True;
1859 }
1860
1861 /*******************************************************************
1862 Inits an LSA_Q_CLOSE structure.
1863 ********************************************************************/
1864
1865 void init_lsa_q_close(LSA_Q_CLOSE *in, POLICY_HND *hnd)
1866 {
1867 DEBUG(5, ("init_lsa_q_close\n"));
1868
1869 memcpy(&in->pol, hnd, sizeof(in->pol));
1870 }
1871
1872 /*******************************************************************
1873 Reads or writes an LSA_Q_CLOSE structure.
1874 ********************************************************************/
1875
1876 BOOL lsa_io_q_close(const char *desc, LSA_Q_CLOSE *in, prs_struct *ps, int depth)
1877 {
1878 prs_debug(ps, depth, desc, "lsa_io_q_close");
1879 depth++;
1880
1881 if(!smb_io_pol_hnd("", &in->pol, ps, depth))
1882 return False;
1883
1884 return True;
1885 }
1886
1887 /*******************************************************************
1888 Reads or writes an LSA_R_CLOSE structure.
1889 ********************************************************************/
1890
1891 BOOL lsa_io_r_close(const char *desc, LSA_R_CLOSE *out, prs_struct *ps, int depth)
1892 {
1893 prs_debug(ps, depth, desc, "lsa_io_r_close");
1894 depth++;
1895
1896 if(!smb_io_pol_hnd("", &out->pol, ps, depth))
1897 return False;
1898
1899 if(!prs_ntstatus("status", ps, depth, &out->status))
1900 return False;
1901
1902 return True;
1903 }
1904
1905 /*******************************************************************
1906 Reads or writes an LSA_Q_OPEN_SECRET structure.
1907 ********************************************************************/
1908
1909 BOOL lsa_io_q_open_secret(const char *desc, LSA_Q_OPEN_SECRET *in, prs_struct *ps, int depth)
1910 {
1911 prs_debug(ps, depth, desc, "lsa_io_q_open_secret");
1912 depth++;
1913
1914 if(!prs_align(ps))
1915 return False;
1916
1917 if(!smb_io_pol_hnd("", &in->handle, ps, depth))
1918 return False;
1919
1920 if(!prs_unistr4 ("secretname", ps, depth, &in->secretname))
1921 return False;
1922 if(!prs_align(ps))
1923 return False;
1924
1925 if(!prs_uint32("access", ps, depth, &in->access))
1926 return False;
1927
1928 return True;
1929 }
1930
1931 /*******************************************************************
1932 Reads or writes an LSA_R_OPEN_SECRET structure.
1933 ********************************************************************/
1934
1935 BOOL lsa_io_r_open_secret(const char *desc, LSA_R_OPEN_SECRET *out, prs_struct *ps, int depth)
1936 {
1937 prs_debug(ps, depth, desc, "lsa_io_r_open_secret");
1938 depth++;
1939
1940 if(!prs_align(ps))
1941 return False;
1942
1943 if(!smb_io_pol_hnd("", &out->handle, ps, depth))
1944 return False;
1945
1946 if(!prs_ntstatus("status", ps, depth, &out->status))
1947 return False;
1948
1949 return True;
1950 }
1951
1952 /*******************************************************************
1953 Inits an LSA_Q_ENUM_PRIVS structure.
1954 ********************************************************************/
1955
1956 void init_q_enum_privs(LSA_Q_ENUM_PRIVS *in, POLICY_HND *hnd, uint32 enum_context, uint32 pref_max_length)
1957 {
1958 DEBUG(5, ("init_q_enum_privs\n"));
1959
1960 memcpy(&in->pol, hnd, sizeof(in->pol));
1961
1962 in->enum_context = enum_context;
1963 in->pref_max_length = pref_max_length;
1964 }
1965
1966 /*******************************************************************
1967 reads or writes a structure.
1968 ********************************************************************/
1969 BOOL lsa_io_q_enum_privs(const char *desc, LSA_Q_ENUM_PRIVS *in, prs_struct *ps, int depth)
1970 {
1971 if (in == NULL)
1972 return False;
1973
1974 prs_debug(ps, depth, desc, "lsa_io_q_enum_privs");
1975 depth++;
1976
1977 if (!smb_io_pol_hnd("", &in->pol, ps, depth))
1978 return False;
1979
1980 if(!prs_uint32("enum_context ", ps, depth, &in->enum_context))
1981 return False;
1982 if(!prs_uint32("pref_max_length", ps, depth, &in->pref_max_length))
1983 return False;
1984
1985 return True;
1986 }
1987
1988 /*******************************************************************
1989 reads or writes a structure.
1990 ********************************************************************/
1991 static BOOL lsa_io_priv_entries(const char *desc, LSA_PRIV_ENTRY *entries, uint32 count, prs_struct *ps, int depth)
1992 {
1993 uint32 i;
1994
1995 if (entries == NULL)
1996 return False;
1997
1998 prs_debug(ps, depth, desc, "lsa_io_priv_entries");
1999 depth++;
2000
2001 if(!prs_align(ps))
2002 return False;
2003
2004 for (i = 0; i < count; i++) {
2005 if (!smb_io_unihdr("", &entries[i].hdr_name, ps, depth))
2006 return False;
2007 if(!prs_uint32("luid_low ", ps, depth, &entries[i].luid_low))
2008 return False;
2009 if(!prs_uint32("luid_high", ps, depth, &entries[i].luid_high))
2010 return False;
2011 }
2012
2013 for (i = 0; i < count; i++)
2014 if (!smb_io_unistr2("", &entries[i].name, entries[i].hdr_name.buffer, ps, depth))
2015 return False;
2016
2017 return True;
2018 }
2019
2020 /*******************************************************************
2021 Inits an LSA_R_ENUM_PRIVS structure.
2022 ********************************************************************/
2023
2024 void init_lsa_r_enum_privs(LSA_R_ENUM_PRIVS *out, uint32 enum_context,
2025 uint32 count, LSA_PRIV_ENTRY *entries)
2026 {
2027 DEBUG(5, ("init_lsa_r_enum_privs\n"));
2028
2029 out->enum_context=enum_context;
2030 out->count=count;
2031
2032 if (entries!=NULL) {
2033 out->ptr=1;
2034 out->count1=count;
2035 out->privs=entries;
2036 } else {
2037 out->ptr=0;
2038 out->count1=0;
2039 out->privs=NULL;
2040 }
2041 }
2042
2043 /*******************************************************************
2044 reads or writes a structure.
2045 ********************************************************************/
2046 BOOL lsa_io_r_enum_privs(const char *desc, LSA_R_ENUM_PRIVS *out, prs_struct *ps, int depth)
2047 {
2048 if (out == NULL)
2049 return False;
2050
2051 prs_debug(ps, depth, desc, "lsa_io_r_enum_privs");
2052 depth++;
2053
2054 if(!prs_align(ps))
2055 return False;
2056
2057 if(!prs_uint32("enum_context", ps, depth, &out->enum_context))
2058 return False;
2059 if(!prs_uint32("count", ps, depth, &out->count))
2060 return False;
2061 if(!prs_uint32("ptr", ps, depth, &out->ptr))
2062 return False;
2063
2064 if (out->ptr) {
2065 if(!prs_uint32("count1", ps, depth, &out->count1))
2066 return False;
2067
2068 if (UNMARSHALLING(ps))
2069 if (!(out->privs = PRS_ALLOC_MEM(ps, LSA_PRIV_ENTRY, out->count1)))
2070 return False;
2071
2072 if (!lsa_io_priv_entries("", out->privs, out->count1, ps, depth))
2073 return False;
2074 }
2075
2076 if(!prs_align(ps))
2077 return False;
2078
2079 if(!prs_ntstatus("status", ps, depth, &out->status))
2080 return False;
2081
2082 return True;
2083 }
2084
2085 void init_lsa_priv_get_dispname(LSA_Q_PRIV_GET_DISPNAME *trn, POLICY_HND *hnd, const char *name, uint16 lang_id, uint16 lang_id_sys)
2086 {
2087 memcpy(&trn->pol, hnd, sizeof(trn->pol));
2088
2089 init_unistr2(&trn->name, name, UNI_FLAGS_NONE);
2090 init_uni_hdr(&trn->hdr_name, &trn->name);
2091 trn->lang_id = lang_id;
2092 trn->lang_id_sys = lang_id_sys;
2093 }
2094
2095 /*******************************************************************
2096 reads or writes a structure.
2097 ********************************************************************/
2098 BOOL lsa_io_q_priv_get_dispname(const char *desc, LSA_Q_PRIV_GET_DISPNAME *in, prs_struct *ps, int depth)
2099 {
2100 if (in == NULL)
2101 return False;
2102
2103 prs_debug(ps, depth, desc, "lsa_io_q_priv_get_dispname");
2104 depth++;
2105
2106 if(!prs_align(ps))
2107 return False;
2108
2109 if (!smb_io_pol_hnd("", &in->pol, ps, depth))
2110 return False;
2111
2112 if (!smb_io_unihdr("hdr_name", &in->hdr_name, ps, depth))
2113 return False;
2114
2115 if (!smb_io_unistr2("name", &in->name, in->hdr_name.buffer, ps, depth))
2116 return False;
2117
2118 if(!prs_uint16("lang_id ", ps, depth, &in->lang_id))
2119 return False;
2120 if(!prs_uint16("lang_id_sys", ps, depth, &in->lang_id_sys))
2121 return False;
2122
2123 return True;
2124 }
2125
2126 /*******************************************************************
2127 reads or writes a structure.
2128 ********************************************************************/
2129 BOOL lsa_io_r_priv_get_dispname(const char *desc, LSA_R_PRIV_GET_DISPNAME *out, prs_struct *ps, int depth)
2130 {
2131 if (out == NULL)
2132 return False;
2133
2134 prs_debug(ps, depth, desc, "lsa_io_r_priv_get_dispname");
2135 depth++;
2136
2137 if (!prs_align(ps))
2138 return False;
2139
2140 if (!prs_uint32("ptr_info", ps, depth, &out->ptr_info))
2141 return False;
2142
2143 if (out->ptr_info){
2144 if (!smb_io_unihdr("hdr_name", &out->hdr_desc, ps, depth))
2145 return False;
2146
2147 if (!smb_io_unistr2("desc", &out->desc, out->hdr_desc.buffer, ps, depth))
2148 return False;
2149 }
2150 /*
2151 if(!prs_align(ps))
2152 return False;
2153 */
2154 if(!prs_uint16("lang_id", ps, depth, &out->lang_id))
2155 return False;
2156
2157 if(!prs_align(ps))
2158 return False;
2159 if(!prs_ntstatus("status", ps, depth, &out->status))
2160 return False;
2161
2162 return True;
2163 }
2164
2165 /*
2166 initialise a LSA_Q_ENUM_ACCOUNTS structure
2167 */
2168 void init_lsa_q_enum_accounts(LSA_Q_ENUM_ACCOUNTS *trn, POLICY_HND *hnd, uint32 enum_context, uint32 pref_max_length)
2169 {
2170 memcpy(&trn->pol, hnd, sizeof(trn->pol));
2171
2172 trn->enum_context = enum_context;
2173 trn->pref_max_length = pref_max_length;
2174 }
2175
2176 /*******************************************************************
2177 reads or writes a structure.
2178 ********************************************************************/
2179 BOOL lsa_io_q_enum_accounts(const char *desc, LSA_Q_ENUM_ACCOUNTS *in, prs_struct *ps, int depth)
2180 {
2181 if (in == NULL)
2182 return False;
2183
2184 prs_debug(ps, depth, desc, "lsa_io_q_enum_accounts");
2185 depth++;
2186
2187 if (!smb_io_pol_hnd("", &in->pol, ps, depth))
2188 return False;
2189
2190 if(!prs_uint32("enum_context ", ps, depth, &in->enum_context))
2191 return False;
2192 if(!prs_uint32("pref_max_length", ps, depth, &in->pref_max_length))
2193 return False;
2194
2195 return True;
2196 }
2197
2198
2199 /*******************************************************************
2200 Inits an LSA_R_ENUM_PRIVS structure.
2201 ********************************************************************/
2202
2203 void init_lsa_r_enum_accounts(LSA_R_ENUM_ACCOUNTS *out, uint32 enum_context)
2204 {
2205 DEBUG(5, ("init_lsa_r_enum_accounts\n"));
2206
2207 out->enum_context=enum_context;
2208 if (out->enum_context!=0) {
2209 out->sids.num_entries=enum_context;
2210 out->sids.ptr_sid_enum=1;
2211 out->sids.num_entries2=enum_context;
2212 } else {
2213 out->sids.num_entries=0;
2214 out->sids.ptr_sid_enum=0;
2215 out->sids.num_entries2=0;
2216 }
2217 }
2218
2219 /*******************************************************************
2220 reads or writes a structure.
2221 ********************************************************************/
2222 BOOL lsa_io_r_enum_accounts(const char *desc, LSA_R_ENUM_ACCOUNTS *out, prs_struct *ps, int depth)
2223 {
2224 if (out == NULL)
2225 return False;
2226
2227 prs_debug(ps, depth, desc, "lsa_io_r_enum_accounts");
2228 depth++;
2229
2230 if (!prs_align(ps))
2231 return False;
2232
2233 if(!prs_uint32("enum_context", ps, depth, &out->enum_context))
2234 return False;
2235
2236 if (!lsa_io_sid_enum("sids", &out->sids, ps, depth))
2237 return False;
2238
2239 if (!prs_align(ps))
2240 return False;
2241
2242 if(!prs_ntstatus("status", ps, depth, &out->status))
2243 return False;
2244
2245 return True;
2246 }
2247
2248
2249 /*******************************************************************
2250 Reads or writes an LSA_Q_UNK_GET_CONNUSER structure.
2251 ********************************************************************/
2252
2253 BOOL lsa_io_q_unk_get_connuser(const char *desc, LSA_Q_UNK_GET_CONNUSER *in, prs_struct *ps, int depth)
2254 {
2255 prs_debug(ps, depth, desc, "lsa_io_q_unk_get_connuser");
2256 depth++;
2257
2258 if(!prs_align(ps))
2259 return False;
2260
2261 if(!prs_uint32("ptr_srvname", ps, depth, &in->ptr_srvname))
2262 return False;
2263
2264 if(!smb_io_unistr2("uni2_srvname", &in->uni2_srvname, in->ptr_srvname, ps, depth)) /* server name to be looked up */
2265 return False;
2266
2267 if (!prs_align(ps))
2268 return False;
2269
2270 if(!prs_uint32("unk1", ps, depth, &in->unk1))
2271 return False;
2272 if(!prs_uint32("unk2", ps, depth, &in->unk2))
2273 return False;
2274 if(!prs_uint32("unk3", ps, depth, &in->unk3))
2275 return False;
2276
2277 /* Don't bother to read or write at present... */
2278 return True;
2279 }
2280
2281 /*******************************************************************
2282 Reads or writes an LSA_R_UNK_GET_CONNUSER structure.
2283 ********************************************************************/
2284
2285 BOOL lsa_io_r_unk_get_connuser(const char *desc, LSA_R_UNK_GET_CONNUSER *out, prs_struct *ps, int depth)
2286 {
2287 prs_debug(ps, depth, desc, "lsa_io_r_unk_get_connuser");
2288 depth++;
2289
2290 if(!prs_align(ps))
2291 return False;
2292
2293 if(!prs_uint32("ptr_user_name", ps, depth, &out->ptr_user_name))
2294 return False;
2295 if(!smb_io_unihdr("hdr_user_name", &out->hdr_user_name, ps, depth))
2296 return False;
2297 if(!smb_io_unistr2("uni2_user_name", &out->uni2_user_name, out->ptr_user_name, ps, depth))
2298 return False;
2299
2300 if (!prs_align(ps))
2301 return False;
2302
2303 if(!prs_uint32("unk1", ps, depth, &out->unk1))
2304 return False;
2305
2306 if(!prs_uint32("ptr_dom_name", ps, depth, &out->ptr_dom_name))
2307 return False;
2308 if(!smb_io_unihdr("hdr_dom_name", &out->hdr_dom_name, ps, depth))
2309 return False;
2310 if(!smb_io_unistr2("uni2_dom_name", &out->uni2_dom_name, out->ptr_dom_name, ps, depth))
2311 return False;
2312
2313 if (!prs_align(ps))
2314 return False;
2315
2316 if(!prs_ntstatus("status", ps, depth, &out->status))
2317 return False;
2318
2319 return True;
2320 }
2321
2322 void init_lsa_q_create_account(LSA_Q_CREATEACCOUNT *trn, POLICY_HND *hnd, DOM_SID *sid, uint32 desired_access)
2323 {
2324 memcpy(&trn->pol, hnd, sizeof(trn->pol));
2325
2326 init_dom_sid2(&trn->sid, sid);
2327 trn->access = desired_access;
2328 }
2329
2330
2331 /*******************************************************************
2332 Reads or writes an LSA_Q_CREATEACCOUNT structure.
2333 ********************************************************************/
2334
2335 BOOL lsa_io_q_create_account(const char *desc, LSA_Q_CREATEACCOUNT *out, prs_struct *ps, int depth)
2336 {
2337 prs_debug(ps, depth, desc, "lsa_io_q_create_account");
2338 depth++;
2339
2340 if(!prs_align(ps))
2341 return False;
2342
2343 if(!smb_io_pol_hnd("pol", &out->pol, ps, depth))
2344 return False;
2345
2346 if(!smb_io_dom_sid2("sid", &out->sid, ps, depth)) /* domain SID */
2347 return False;
2348
2349 if(!prs_uint32("access", ps, depth, &out->access))
2350 return False;
2351
2352 return True;
2353 }
2354
2355 /*******************************************************************
2356 Reads or writes an LSA_R_CREATEACCOUNT structure.
2357 ********************************************************************/
2358
2359 BOOL lsa_io_r_create_account(const char *desc, LSA_R_CREATEACCOUNT *out, prs_struct *ps, int depth)
2360 {
2361 prs_debug(ps, depth, desc, "lsa_io_r_open_account");
2362 depth++;
2363
2364 if(!prs_align(ps))
2365 return False;
2366
2367 if(!smb_io_pol_hnd("pol", &out->pol, ps, depth))
2368 return False;
2369
2370 if(!prs_ntstatus("status", ps, depth, &out->status))
2371 return False;
2372
2373 return True;
2374 }
2375
2376
2377 void init_lsa_q_open_account(LSA_Q_OPENACCOUNT *trn, POLICY_HND *hnd, DOM_SID *sid, uint32 desired_access)
2378 {
2379 memcpy(&trn->pol, hnd, sizeof(trn->pol));
2380
2381 init_dom_sid2(&trn->sid, sid);
2382 trn->access = desired_access;
2383 }
2384
2385 /*******************************************************************
2386 Reads or writes an LSA_Q_OPENACCOUNT structure.
2387 ********************************************************************/
2388
2389 BOOL lsa_io_q_open_account(const char *desc, LSA_Q_OPENACCOUNT *out, prs_struct *ps, int depth)
2390 {
2391 prs_debug(ps, depth, desc, "lsa_io_q_open_account");
2392 depth++;
2393
2394 if(!prs_align(ps))
2395 return False;
2396
2397 if(!smb_io_pol_hnd("pol", &out->pol, ps, depth))
2398 return False;
2399
2400 if(!smb_io_dom_sid2("sid", &out->sid, ps, depth)) /* domain SID */
2401 return False;
2402
2403 if(!prs_uint32("access", ps, depth, &out->access))
2404 return False;
2405
2406 return True;
2407 }
2408
2409 /*******************************************************************
2410 Reads or writes an LSA_R_OPENACCOUNT structure.
2411 ********************************************************************/
2412
2413 BOOL lsa_io_r_open_account(const char *desc, LSA_R_OPENACCOUNT *out, prs_struct *ps, int depth)
2414 {
2415 prs_debug(ps, depth, desc, "lsa_io_r_open_account");
2416 depth++;
2417
2418 if(!prs_align(ps))
2419 return False;
2420
2421 if(!smb_io_pol_hnd("pol", &out->pol, ps, depth))
2422 return False;
2423
2424 if(!prs_ntstatus("status", ps, depth, &out->status))
2425 return False;
2426
2427 return True;
2428 }
2429
2430
2431 void init_lsa_q_enum_privsaccount(LSA_Q_ENUMPRIVSACCOUNT *trn, POLICY_HND *hnd)
2432 {
2433 memcpy(&trn->pol, hnd, sizeof(trn->pol));
2434
2435 }
2436
2437 /*******************************************************************
2438 Reads or writes an LSA_Q_ENUMPRIVSACCOUNT structure.
2439 ********************************************************************/
2440
2441 BOOL lsa_io_q_enum_privsaccount(const char *desc, LSA_Q_ENUMPRIVSACCOUNT *out, prs_struct *ps, int depth)
2442 {
2443 prs_debug(ps, depth, desc, "lsa_io_q_enum_privsaccount");
2444 depth++;
2445
2446 if(!prs_align(ps))
2447 return False;
2448
2449 if(!smb_io_pol_hnd("pol", &out->pol, ps, depth))
2450 return False;
2451
2452 return True;
2453 }
2454
2455 /*******************************************************************
2456 Reads or writes an LUID structure.
2457 ********************************************************************/
2458
2459 static BOOL lsa_io_luid(const char *desc, LUID *out, prs_struct *ps, int depth)
2460 {
2461 prs_debug(ps, depth, desc, "lsa_io_luid");
2462 depth++;
2463
2464 if(!prs_align(ps))
2465 return False;
2466
2467 if(!prs_uint32("low", ps, depth, &out->low))
2468 return False;
2469
2470 if(!prs_uint32("high", ps, depth, &out->high))
2471 return False;
2472
2473 return True;
2474 }
2475
2476 /*******************************************************************
2477 Reads or writes an LUID_ATTR structure.
2478 ********************************************************************/
2479
2480 static BOOL lsa_io_luid_attr(const char *desc, LUID_ATTR *out, prs_struct *ps, int depth)
2481 {
2482 prs_debug(ps, depth, desc, "lsa_io_luid_attr");
2483 depth++;
2484
2485 if(!prs_align(ps))
2486 return False;
2487
2488 if (!lsa_io_luid(desc, &out->luid, ps, depth))
2489 return False;
2490
2491 if(!prs_uint32("attr", ps, depth, &out->attr))
2492 return False;
2493
2494 return True;
2495 }
2496
2497 /*******************************************************************
2498 Reads or writes an PRIVILEGE_SET structure.
2499 ********************************************************************/
2500
2501 static BOOL lsa_io_privilege_set(const char *desc, PRIVILEGE_SET *out, prs_struct *ps, int depth)
2502 {
2503 uint32 i;
2504
2505 prs_debug(ps, depth, desc, "lsa_io_privilege_set");
2506 depth++;
2507
2508 if(!prs_align(ps))
2509 return False;
2510
2511 if(!prs_uint32("count", ps, depth, &out->count))
2512 return False;
2513 if(!prs_uint32("control", ps, depth, &out->control))
2514 return False;
2515
2516 for (i=0; i<out->count; i++) {
2517 if (!lsa_io_luid_attr(desc, &out->set[i], ps, depth))
2518 return False;
2519 }
2520
2521 return True;
2522 }
2523
2524 NTSTATUS init_lsa_r_enum_privsaccount(TALLOC_CTX *mem_ctx, LSA_R_ENUMPRIVSACCOUNT *out, LUID_ATTR *set, uint32 count, uint32 control)
2525 {
2526 NTSTATUS ret = NT_STATUS_OK;
2527
2528 out->ptr = 1;
2529 out->count = count;
2530
2531 if ( !NT_STATUS_IS_OK(ret = privilege_set_init_by_ctx(mem_ctx, &(out->set))) )
2532 return ret;
2533
2534 out->set.count = count;
2535
2536 if (!NT_STATUS_IS_OK(ret = dup_luid_attr(out->set.mem_ctx, &(out->set.set), set, count)))
2537 return ret;
2538
2539 DEBUG(10,("init_lsa_r_enum_privsaccount: %d privileges\n", out->count));
2540
2541 return ret;
2542 }
2543
2544 /*******************************************************************
2545 Reads or writes an LSA_R_ENUMPRIVSACCOUNT structure.
2546 ********************************************************************/
2547
2548 BOOL lsa_io_r_enum_privsaccount(const char *desc, LSA_R_ENUMPRIVSACCOUNT *out, prs_struct *ps, int depth)
2549 {
2550 prs_debug(ps, depth, desc, "lsa_io_r_enum_privsaccount");
2551 depth++;
2552
2553 if(!prs_align(ps))
2554 return False;
2555
2556 if(!prs_uint32("ptr", ps, depth, &out->ptr))
2557 return False;
2558
2559 if (out->ptr!=0) {
2560 if(!prs_uint32("count", ps, depth, &out->count))
2561 return False;
2562
2563 /* malloc memory if unmarshalling here */
2564
2565 if (UNMARSHALLING(ps) && out->count != 0) {
2566 if (!NT_STATUS_IS_OK(privilege_set_init_by_ctx(ps->mem_ctx, &(out->set))))
2567 return False;
2568
2569 if (!(out->set.set = PRS_ALLOC_MEM(ps,LUID_ATTR,out->count)))
2570 return False;
2571
2572 }
2573
2574 if(!lsa_io_privilege_set(desc, &out->set, ps, depth))
2575 return False;
2576 }
2577
2578 if(!prs_ntstatus("status", ps, depth, &out->status))
2579 return False;
2580
2581 return True;
2582 }
2583
2584
2585
2586 /*******************************************************************
2587 Reads or writes an LSA_Q_GETSYSTEMACCOUNTstructure.
2588 ********************************************************************/
2589
2590 BOOL lsa_io_q_getsystemaccount(const char *desc, LSA_Q_GETSYSTEMACCOUNT *out, prs_struct *ps, int depth)
2591 {
2592 prs_debug(ps, depth, desc, "lsa_io_q_getsystemaccount");
2593 depth++;
2594
2595 if(!prs_align(ps))
2596 return False;
2597
2598 if(!smb_io_pol_hnd("pol", &out->pol, ps, depth))
2599 return False;
2600
2601 return True;
2602 }
2603
2604 /*******************************************************************
2605 Reads or writes an LSA_R_GETSYSTEMACCOUNTstructure.
2606 ********************************************************************/
2607
2608 BOOL lsa_io_r_getsystemaccount(const char *desc, LSA_R_GETSYSTEMACCOUNT *out, prs_struct *ps, int depth)
2609 {
2610 prs_debug(ps, depth, desc, "lsa_io_r_getsystemaccount");
2611 depth++;
2612
2613 if(!prs_align(ps))
2614 return False;
2615
2616 if(!prs_uint32("access", ps, depth, &out->access))
2617 return False;
2618
2619 if(!prs_ntstatus("status", ps, depth, &out->status))
2620 return False;
2621
2622 return True;
2623 }
2624
2625
2626 /*******************************************************************
2627 Reads or writes an LSA_Q_SETSYSTEMACCOUNT structure.
2628 ********************************************************************/
2629
2630 BOOL lsa_io_q_setsystemaccount(const char *desc, LSA_Q_SETSYSTEMACCOUNT *out, prs_struct *ps, int depth)
2631 {
2632 prs_debug(ps, depth, desc, "lsa_io_q_setsystemaccount");
2633 depth++;
2634
2635 if(!prs_align(ps))
2636 return False;
2637
2638 if(!smb_io_pol_hnd("pol", &out->pol, ps, depth))
2639 return False;
2640
2641 if(!prs_uint32("access", ps, depth, &out->access))
2642 return False;
2643
2644 return True;
2645 }
2646
2647 /*******************************************************************
2648 Reads or writes an LSA_R_SETSYSTEMACCOUNT structure.
2649 ********************************************************************/
2650
2651 BOOL lsa_io_r_setsystemaccount(const char *desc, LSA_R_SETSYSTEMACCOUNT *out, prs_struct *ps, int depth)
2652 {
2653 prs_debug(ps, depth, desc, "lsa_io_r_setsystemaccount");
2654 depth++;
2655
2656 if(!prs_align(ps))
2657 return False;
2658
2659 if(!prs_ntstatus("status", ps, depth, &out->status))
2660 return False;
2661
2662 return True;
2663 }
2664
2665
2666 static void init_lsa_string( LSA_STRING *uni, const char *string )
2667 {
2668 init_unistr2(&uni->unistring, string, UNI_FLAGS_NONE);
2669 init_uni_hdr(&uni->hdr, &uni->unistring);
2670 }
2671
2672 void init_lsa_q_lookup_priv_value(LSA_Q_LOOKUP_PRIV_VALUE *q_u, POLICY_HND *hnd, const char *name)
2673 {
2674 memcpy(&q_u->pol, hnd, sizeof(q_u->pol));
2675 init_lsa_string( &q_u->privname, name );
2676 }
2677
2678 BOOL smb_io_lsa_string( const char *desc, LSA_STRING *string, prs_struct *ps, int depth )
2679 {
2680 prs_debug(ps, depth, desc, "smb_io_lsa_string");
2681 depth++;
2682
2683 if(!smb_io_unihdr ("hdr", &string->hdr, ps, depth))
2684 return False;
2685 if(!smb_io_unistr2("unistring", &string->unistring, string->hdr.buffer, ps, depth))
2686 return False;
2687
2688 return True;
2689 }
2690
2691 /*******************************************************************
2692 Reads or writes an LSA_Q_LOOKUP_PRIV_VALUE structure.
2693 ********************************************************************/
2694
2695 BOOL lsa_io_q_lookup_priv_value(const char *desc, LSA_Q_LOOKUP_PRIV_VALUE *out, prs_struct *ps, int depth)
2696 {
2697 prs_debug(ps, depth, desc, "lsa_io_q_lookup_priv_value");
2698 depth++;
2699
2700 if(!prs_align(ps))
2701 return False;
2702
2703 if(!smb_io_pol_hnd("pol", &out->pol, ps, depth))
2704 return False;
2705 if(!smb_io_lsa_string("privname", &out->privname, ps, depth))
2706 return False;
2707
2708 return True;
2709 }
2710
2711 /*******************************************************************
2712 Reads or writes an LSA_R_LOOKUP_PRIV_VALUE structure.
2713 ********************************************************************/
2714
2715 BOOL lsa_io_r_lookup_priv_value(const char *desc, LSA_R_LOOKUP_PRIV_VALUE *out, prs_struct *ps, int depth)
2716 {
2717 prs_debug(ps, depth, desc, "lsa_io_r_lookup_priv_value");
2718 depth++;
2719
2720 if(!prs_align(ps))
2721 return False;
2722
2723 if(!lsa_io_luid("luid", &out->luid, ps, depth))
2724 return False;
2725
2726 if(!prs_ntstatus("status", ps, depth, &out->status))
2727 return False;
2728
2729 return True;
2730 }
2731
2732
2733 /*******************************************************************
2734 Reads or writes an LSA_Q_ADDPRIVS structure.
2735 ********************************************************************/
2736
2737 BOOL lsa_io_q_addprivs(const char *desc, LSA_Q_ADDPRIVS *out, prs_struct *ps, int depth)
2738 {
2739 prs_debug(ps, depth, desc, "lsa_io_q_addprivs");
2740 depth++;
2741
2742 if(!prs_align(ps))
2743 return False;
2744
2745 if(!smb_io_pol_hnd("pol", &out->pol, ps, depth))
2746 return False;
2747
2748 if(!prs_uint32("count", ps, depth, &out->count))
2749 return False;
2750
2751 if (UNMARSHALLING(ps) && out->count!=0) {
2752 if (!NT_STATUS_IS_OK(privilege_set_init_by_ctx(ps->mem_ctx, &(out->set))))
2753 return False;
2754
2755 if (!(out->set.set = PRS_ALLOC_MEM(ps, LUID_ATTR, out->count)))
2756 return False;
2757 }
2758
2759 if(!lsa_io_privilege_set(desc, &out->set, ps, depth))
2760 return False;
2761
2762 return True;
2763 }
2764
2765 /*******************************************************************
2766 Reads or writes an LSA_R_ADDPRIVS structure.
2767 ********************************************************************/
2768
2769 BOOL lsa_io_r_addprivs(const char *desc, LSA_R_ADDPRIVS *out, prs_struct *ps, int depth)
2770 {
2771 prs_debug(ps, depth, desc, "lsa_io_r_addprivs");
2772 depth++;
2773
2774 if(!prs_align(ps))
2775 return False;
2776
2777 if(!prs_ntstatus("status", ps, depth, &out->status))
2778 return False;
2779
2780 return True;
2781 }
2782
2783 /*******************************************************************
2784 Reads or writes an LSA_Q_REMOVEPRIVS structure.
2785 ********************************************************************/
2786
2787 BOOL lsa_io_q_removeprivs(const char *desc, LSA_Q_REMOVEPRIVS *out, prs_struct *ps, int depth)
2788 {
2789 prs_debug(ps, depth, desc, "lsa_io_q_removeprivs");
2790 depth++;
2791
2792 if(!prs_align(ps))
2793 return False;
2794
2795 if(!smb_io_pol_hnd("pol", &out->pol, ps, depth))
2796 return False;
2797
2798 if(!prs_uint32("allrights", ps, depth, &out->allrights))
2799 return False;
2800
2801 if(!prs_uint32("ptr", ps, depth, &out->ptr))
2802 return False;
2803
2804 /*
2805 * JFM: I'm not sure at all if the count is inside the ptr
2806 * never seen one with ptr=0
2807 */
2808
2809 if (out->ptr!=0) {
2810 if(!prs_uint32("count", ps, depth, &out->count))
2811 return False;
2812
2813 if (UNMARSHALLING(ps) && out->count!=0) {
2814 if (!NT_STATUS_IS_OK(privilege_set_init_by_ctx(ps->mem_ctx, &(out->set))))
2815 return False;
2816
2817 if (!(out->set.set = PRS_ALLOC_MEM(ps, LUID_ATTR, out->count)))
2818 return False;
2819 }
2820
2821 if(!lsa_io_privilege_set(desc, &out->set, ps, depth))
2822 return False;
2823 }
2824
2825 return True;
2826 }
2827
2828 /*******************************************************************
2829 Reads or writes an LSA_R_REMOVEPRIVS structure.
2830 ********************************************************************/
2831
2832 BOOL lsa_io_r_removeprivs(const char *desc, LSA_R_REMOVEPRIVS *out, prs_struct *ps, int depth)
2833 {
2834 prs_debug(ps, depth, desc, "lsa_io_r_removeprivs");
2835 depth++;
2836
2837 if(!prs_align(ps))
2838 return False;
2839
2840 if(!prs_ntstatus("status", ps, depth, &out->status))
2841 return False;
2842
2843 return True;
2844 }
2845
2846 BOOL policy_handle_is_valid(const POLICY_HND *hnd)
2847 {
2848 POLICY_HND zero_pol;
2849
2850 ZERO_STRUCT(zero_pol);
2851 return ((memcmp(&zero_pol, hnd, sizeof(POLICY_HND)) == 0) ? False : True );
2852 }
2853
2854 /*******************************************************************
2855 Reads or writes an LSA_DNS_DOM_INFO structure.
2856 ********************************************************************/
2857
2858 BOOL lsa_io_dns_dom_info(const char *desc, LSA_DNS_DOM_INFO *info,
2859 prs_struct *ps, int depth)
2860 {
2861 prs_debug(ps, depth, desc, "lsa_io_dns_dom_info");
2862 depth++;
2863
2864 if(!prs_align(ps))
2865 return False;
2866 if(!smb_io_unihdr("nb_name", &info->hdr_nb_dom_name, ps, depth))
2867 return False;
2868 if(!smb_io_unihdr("dns_name", &info->hdr_dns_dom_name, ps, depth))
2869 return False;
2870 if(!smb_io_unihdr("forest", &info->hdr_forest_name, ps, depth))
2871 return False;
2872
2873 if(!prs_align(ps))
2874 return False;
2875 if ( !smb_io_uuid("dom_guid", &info->dom_guid, ps, depth) )
2876 return False;
2877
2878 if(!prs_align(ps))
2879 return False;
2880 if(!prs_uint32("dom_sid", ps, depth, &info->ptr_dom_sid))
2881 return False;
2882
2883 if(!smb_io_unistr2("nb_name", &info->uni_nb_dom_name,
2884 info->hdr_nb_dom_name.buffer, ps, depth))
2885 return False;
2886 if(!smb_io_unistr2("dns_name", &info->uni_dns_dom_name,
2887 info->hdr_dns_dom_name.buffer, ps, depth))
2888 return False;
2889 if(!smb_io_unistr2("forest", &info->uni_forest_name,
2890 info->hdr_forest_name.buffer, ps, depth))
2891 return False;
2892
2893 if(!smb_io_dom_sid2("dom_sid", &info->dom_sid, ps, depth))
2894 return False;
2895
2896 return True;
2897
2898 }
2899
2900 /*******************************************************************
2901 Inits an LSA_Q_QUERY_INFO2 structure.
2902 ********************************************************************/
2903
2904 void init_q_query2(LSA_Q_QUERY_INFO2 *in, POLICY_HND *hnd, uint16 info_class)
2905 {
2906 DEBUG(5, ("init_q_query2\n"));
2907
2908 memcpy(&in->pol, hnd, sizeof(in->pol));
2909
2910 in->info_class = info_class;
2911 }
2912
2913 /*******************************************************************
2914 Reads or writes an LSA_Q_QUERY_DNSDOMINFO structure.
2915 ********************************************************************/
2916
2917 BOOL lsa_io_q_query_info2(const char *desc, LSA_Q_QUERY_INFO2 *in, prs_struct *ps, int depth)
2918 {
2919 prs_debug(ps, depth, desc, "lsa_io_q_query_info2");
2920 depth++;
2921
2922 if(!prs_align(ps))
2923 return False;
2924
2925 if(!smb_io_pol_hnd("pol", &in->pol, ps, depth))
2926 return False;
2927
2928 if(!prs_uint16("info_class", ps, depth, &in->info_class))
2929 return False;
2930
2931 return True;
2932 }
2933
2934 /*******************************************************************
2935 Reads or writes an LSA_R_QUERY_DNSDOMINFO structure.
2936 ********************************************************************/
2937
2938 BOOL lsa_io_r_query_info2(const char *desc, LSA_R_QUERY_INFO2 *out,
2939 prs_struct *ps, int depth)
2940 {
2941 prs_debug(ps, depth, desc, "lsa_io_r_query_info2");
2942 depth++;
2943
2944 if(!prs_align(ps))
2945 return False;
2946
2947 if(!prs_uint32("ptr", ps, depth, &out->ptr))
2948 return False;
2949 if(!prs_uint16("info_class", ps, depth, &out->info_class))
2950 return False;
2951 switch(out->info_class) {
2952 case 0x000c:
2953 if (!lsa_io_dns_dom_info("info12", &out->info.dns_dom_info,
2954 ps, depth))
2955 return False;
2956 break;
2957 default:
2958 DEBUG(0,("lsa_io_r_query_info2: unknown info class %d\n",
2959 out->info_class));
2960 return False;
2961 }
2962
2963 if(!prs_align(ps))
2964 return False;
2965 if(!prs_ntstatus("status", ps, depth, &out->status))
2966 return False;
2967
2968 return True;
2969 }
2970
2971 /*******************************************************************
2972 Inits an LSA_Q_ENUM_ACCT_RIGHTS structure.
2973 ********************************************************************/
2974 void init_q_enum_acct_rights(LSA_Q_ENUM_ACCT_RIGHTS *in,
2975 POLICY_HND *hnd,
2976 uint32 count,
2977 DOM_SID *sid)
2978 {
2979 DEBUG(5, ("init_q_enum_acct_rights\n"));
2980
2981 in->pol = *hnd;
2982 init_dom_sid2(&in->sid, sid);
2983 }
2984
2985 /*******************************************************************
2986 ********************************************************************/
2987 NTSTATUS init_r_enum_acct_rights( LSA_R_ENUM_ACCT_RIGHTS *out, PRIVILEGE_SET *privileges )
2988 {
2989 uint32 i;
2990 char *privname;
2991 const char **privname_array = NULL;
2992 int num_priv = 0;
2993
2994 for ( i=0; i<privileges->count; i++ ) {
2995 privname = luid_to_privilege_name( &privileges->set[i].luid );
2996 if ( privname ) {
2997 if ( !add_string_to_array( get_talloc_ctx(), privname, &privname_array, &num_priv ) )
2998 return NT_STATUS_NO_MEMORY;
2999 }
3000 }
3001
3002 if ( num_priv ) {
3003 out->rights = TALLOC_P( get_talloc_ctx(), UNISTR4_ARRAY );
3004
3005 if ( !init_unistr4_array( out->rights, num_priv, privname_array ) )
3006 return NT_STATUS_NO_MEMORY;
3007
3008 out->count = num_priv;
3009 }
3010
3011 return NT_STATUS_OK;
3012 }
3013
3014 /*******************************************************************
3015 reads or writes a LSA_Q_ENUM_ACCT_RIGHTS structure.
3016 ********************************************************************/
3017 BOOL lsa_io_q_enum_acct_rights(const char *desc, LSA_Q_ENUM_ACCT_RIGHTS *in, prs_struct *ps, int depth)
3018 {
3019
3020 if (in == NULL)
3021 return False;
3022
3023 prs_debug(ps, depth, desc, "lsa_io_q_enum_acct_rights");
3024 depth++;
3025
3026 if (!smb_io_pol_hnd("", &in->pol, ps, depth))
3027 return False;
3028
3029 if(!smb_io_dom_sid2("sid", &in->sid, ps, depth))
3030 return False;
3031
3032 return True;
3033 }
3034
3035
3036 /*******************************************************************
3037 reads or writes a LSA_R_ENUM_ACCT_RIGHTS structure.
3038 ********************************************************************/
3039 BOOL lsa_io_r_enum_acct_rights(const char *desc, LSA_R_ENUM_ACCT_RIGHTS *out, prs_struct *ps, int depth)
3040 {
3041 prs_debug(ps, depth, desc, "lsa_io_r_enum_acct_rights");
3042 depth++;
3043
3044 if(!prs_uint32("count ", ps, depth, &out->count))
3045 return False;
3046
3047 if ( !prs_pointer("rights", ps, depth, (void**)&out->rights, sizeof(UNISTR4_ARRAY), (PRS_POINTER_CAST)prs_unistr4_array) )
3048 return False;
3049
3050 if(!prs_align(ps))
3051 return False;
3052
3053 if(!prs_ntstatus("status", ps, depth, &out->status))
3054 return False;
3055
3056 return True;
3057 }
3058
3059
3060 /*******************************************************************
3061 Inits an LSA_Q_ADD_ACCT_RIGHTS structure.
3062 ********************************************************************/
3063 void init_q_add_acct_rights( LSA_Q_ADD_ACCT_RIGHTS *in, POLICY_HND *hnd,
3064 DOM_SID *sid, uint32 count, const char **rights )
3065 {
3066 DEBUG(5, ("init_q_add_acct_rights\n"));
3067
3068 in->pol = *hnd;
3069 init_dom_sid2(&in->sid, sid);
3070
3071 in->rights = TALLOC_P( get_talloc_ctx(), UNISTR4_ARRAY );
3072 init_unistr4_array( in->rights, count, rights );
3073
3074 in->count = count;
3075 }
3076
3077
3078 /*******************************************************************
3079 reads or writes a LSA_Q_ADD_ACCT_RIGHTS structure.
3080 ********************************************************************/
3081 BOOL lsa_io_q_add_acct_rights(const char *desc, LSA_Q_ADD_ACCT_RIGHTS *in, prs_struct *ps, int depth)
3082 {
3083 prs_debug(ps, depth, desc, "lsa_io_q_add_acct_rights");
3084 depth++;
3085
3086 if (!smb_io_pol_hnd("", &in->pol, ps, depth))
3087 return False;
3088
3089 if(!smb_io_dom_sid2("sid", &in->sid, ps, depth))
3090 return False;
3091
3092 if(!prs_uint32("count", ps, depth, &in->count))
3093 return False;
3094
3095 if ( !prs_pointer("rights", ps, depth, (void**)&in->rights, sizeof(UNISTR4_ARRAY), (PRS_POINTER_CAST)prs_unistr4_array) )
3096 return False;
3097
3098 return True;
3099 }
3100
3101 /*******************************************************************
3102 reads or writes a LSA_R_ENUM_ACCT_RIGHTS structure.
3103 ********************************************************************/
3104 BOOL lsa_io_r_add_acct_rights(const char *desc, LSA_R_ADD_ACCT_RIGHTS *out, prs_struct *ps, int depth)
3105 {
3106 prs_debug(ps, depth, desc, "lsa_io_r_add_acct_rights");
3107 depth++;
3108
3109 if(!prs_ntstatus("status", ps, depth, &out->status))
3110 return False;
3111
3112 return True;
3113 }
3114
3115
3116 /*******************************************************************
3117 Inits an LSA_Q_REMOVE_ACCT_RIGHTS structure.
3118 ********************************************************************/
3119 void init_q_remove_acct_rights(LSA_Q_REMOVE_ACCT_RIGHTS *in,
3120 POLICY_HND *hnd,
3121 DOM_SID *sid,
3122 uint32 removeall,
3123 uint32 count,
3124 const char **rights)
3125 {
3126 DEBUG(5, ("init_q_remove_acct_rights\n"));
3127
3128 in->pol = *hnd;
3129
3130 init_dom_sid2(&in->sid, sid);
3131
3132 in->removeall = removeall;
3133 in->count = count;
3134
3135 in->rights = TALLOC_P( get_talloc_ctx(), UNISTR4_ARRAY );
3136 init_unistr4_array( in->rights, count, rights );
3137 }
3138
3139
3140 /*******************************************************************
3141 reads or writes a LSA_Q_REMOVE_ACCT_RIGHTS structure.
3142 ********************************************************************/
3143 BOOL lsa_io_q_remove_acct_rights(const char *desc, LSA_Q_REMOVE_ACCT_RIGHTS *in, prs_struct *ps, int depth)
3144 {
3145 prs_debug(ps, depth, desc, "lsa_io_q_remove_acct_rights");
3146 depth++;
3147
3148 if (!smb_io_pol_hnd("", &in->pol, ps, depth))
3149 return False;
3150
3151 if(!smb_io_dom_sid2("sid", &in->sid, ps, depth))
3152 return False;
3153
3154 if(!prs_uint32("removeall", ps, depth, &in->removeall))
3155 return False;
3156
3157 if(!prs_uint32("count", ps, depth, &in->count))
3158 return False;
3159
3160 if ( !prs_pointer("rights", ps, depth, (void**)&in->rights, sizeof(UNISTR4_ARRAY), (PRS_POINTER_CAST)prs_unistr4_array) )
3161 return False;
3162
3163 return True;
3164 }
3165
3166 /*******************************************************************
3167 reads or writes a LSA_R_ENUM_ACCT_RIGHTS structure.
3168 ********************************************************************/
3169 BOOL lsa_io_r_remove_acct_rights(const char *desc, LSA_R_REMOVE_ACCT_RIGHTS *out, prs_struct *ps, int depth)
3170 {
3171 prs_debug(ps, depth, desc, "lsa_io_r_remove_acct_rights");
3172 depth++;
3173
3174 if(!prs_ntstatus("status", ps, depth, &out->status))
3175 return False;
3176
3177 return True;
3178 }
3179
3180 /*******************************************************************
3181 Inits an LSA_Q_OPEN_TRUSTED_DOMAIN structure.
3182 ********************************************************************/
3183
3184 void init_lsa_q_open_trusted_domain(LSA_Q_OPEN_TRUSTED_DOMAIN *q, POLICY_HND *hnd, DOM_SID *sid, uint32 desired_access)
3185 {
3186 memcpy(&q->pol, hnd, sizeof(q->pol));
3187
3188 init_dom_sid2(&q->sid, sid);
3189 q->access_mask = desired_access;
3190 }
3191
3192 /*******************************************************************
3193 ********************************************************************/
3194
3195 #if 0 /* jerry, I think this not correct - gd */
3196 BOOL lsa_io_q_open_trusted_domain(const char *desc, LSA_Q_OPEN_TRUSTED_DOMAIN *in, prs_struct *ps, int depth)
3197 {
3198 prs_debug(ps, depth, desc, "lsa_io_q_open_trusted_domain");
3199 depth++;
3200
3201 if(!prs_align(ps))
3202 return False;
3203
3204 if (!smb_io_pol_hnd("", &in->handle, ps, depth))
3205 return False;
3206
3207 if(!prs_uint32("count", ps, depth, &in->count))
3208 return False;
3209
3210 if(!smb_io_dom_sid("sid", &in->sid, ps, depth))
3211 return False;
3212
3213 return True;
3214 }
3215 #endif
3216
3217
3218 /*******************************************************************
3219 Inits an LSA_Q_OPEN_TRUSTED_DOMAIN_BY_NAME structure.
3220 ********************************************************************/
3221
3222 void init_lsa_q_open_trusted_domain_by_name(LSA_Q_OPEN_TRUSTED_DOMAIN_BY_NAME *q,
3223 POLICY_HND *hnd,
3224 const char *name,
3225 uint32 desired_access)
3226 {
3227 memcpy(&q->pol, hnd, sizeof(q->pol));
3228
3229 init_lsa_string(&q->name, name);
3230 q->access_mask = desired_access;
3231 }
3232
3233 /*******************************************************************
3234 ********************************************************************/
3235
3236
3237 /*******************************************************************
3238 Reads or writes an LSA_Q_OPEN_TRUSTED_DOMAIN_BY_NAME structure.
3239 ********************************************************************/
3240
3241 BOOL lsa_io_q_open_trusted_domain_by_name(const char *desc, LSA_Q_OPEN_TRUSTED_DOMAIN_BY_NAME *q_o, prs_struct *ps, int depth)
3242 {
3243 prs_debug(ps, depth, desc, "lsa_io_q_open_trusted_domain_by_name");
3244 depth++;
3245
3246 if(!prs_align(ps))
3247 return False;
3248
3249 if(!smb_io_pol_hnd("pol", &q_o->pol, ps, depth))
3250 return False;
3251
3252 if(!prs_align(ps))
3253 return False;
3254
3255 if(!smb_io_lsa_string("name", &q_o->name, ps, depth))
3256 return False;
3257
3258 if(!prs_align(ps))
3259 return False;
3260
3261 if(!prs_uint32("access", ps, depth, &q_o->access_mask))
3262 return False;
3263
3264 return True;
3265 }
3266
3267 /*******************************************************************
3268 Reads or writes an LSA_R_OPEN_TRUSTED_DOMAIN_BY_NAME structure.
3269 ********************************************************************/
3270
3271 BOOL lsa_io_r_open_trusted_domain_by_name(const char *desc, LSA_R_OPEN_TRUSTED_DOMAIN_BY_NAME *out, prs_struct *ps, int depth)
3272 {
3273 prs_debug(ps, depth, desc, "lsa_io_r_open_trusted_domain_by_name");
3274 depth++;
3275
3276 if(!prs_align(ps))
3277 return False;
3278
3279 if (!smb_io_pol_hnd("handle", &out->handle, ps, depth))
3280 return False;
3281
3282 if(!prs_ntstatus("status", ps, depth, &out->status))
3283 return False;
3284
3285 return True;
3286 }
3287
3288 /*******************************************************************
3289 ********************************************************************/
3290
3291 BOOL lsa_io_q_open_trusted_domain(const char *desc, LSA_Q_OPEN_TRUSTED_DOMAIN *q_o, prs_struct *ps, int depth)
3292 {
3293 prs_debug(ps, depth, desc, "lsa_io_q_open_trusted_domain");
3294 depth++;
3295
3296 if(!prs_align(ps))
3297 return False;
3298
3299 if(!smb_io_pol_hnd("pol", &q_o->pol, ps, depth))
3300 return False;
3301
3302 if(!smb_io_dom_sid2("sid", &q_o->sid, ps, depth))
3303 return False;
3304
3305 if(!prs_uint32("access", ps, depth, &q_o->access_mask))
3306 return False;
3307
3308 return True;
3309 }
3310
3311 /*******************************************************************
3312 Reads or writes an LSA_R_OPEN_TRUSTED_DOMAIN structure.
3313 ********************************************************************/
3314
3315 BOOL lsa_io_r_open_trusted_domain(const char *desc, LSA_R_OPEN_TRUSTED_DOMAIN *out, prs_struct *ps, int depth)
3316 {
3317 prs_debug(ps, depth, desc, "lsa_io_r_open_trusted_domain");
3318 depth++;
3319
3320 if(!prs_align(ps))
3321 return False;
3322
3323 if (!smb_io_pol_hnd("handle", &out->handle, ps, depth))
3324 return False;
3325
3326 if(!prs_ntstatus("status", ps, depth, &out->status))
3327 return False;
3328
3329 return True;
3330 }
3331
3332 /*******************************************************************
3333 ********************************************************************/
3334
3335 BOOL lsa_io_q_create_trusted_domain(const char *desc, LSA_Q_CREATE_TRUSTED_DOMAIN *in, prs_struct *ps, int depth)
3336 {
3337 prs_debug(ps, depth, desc, "lsa_io_q_create_trusted_domain");
3338 depth++;
3339
3340 if(!prs_align(ps))
3341 return False;
3342
3343 if(!smb_io_pol_hnd("", &in->handle, ps, depth))
3344 return False;
3345
3346 if(!prs_unistr4 ("secretname", ps, depth, &in->secretname))
3347 return False;
3348 if(!prs_align(ps))
3349 return False;
3350
3351 if(!prs_uint32("access", ps, depth, &in->access))
3352 return False;
3353
3354 return True;
3355 }
3356
3357 /*******************************************************************
3358 ********************************************************************/
3359
3360 BOOL lsa_io_r_create_trusted_domain(const char *desc, LSA_R_CREATE_TRUSTED_DOMAIN *out, prs_struct *ps, int depth)
3361 {
3362 prs_debug(ps, depth, desc, "lsa_io_r_create_trusted_domain");
3363 depth++;
3364
3365 if(!prs_align(ps))
3366 return False;
3367
3368 if (!smb_io_pol_hnd("", &out->handle, ps, depth))
3369 return False;
3370
3371 if(!prs_ntstatus("status", ps, depth, &out->status))
3372 return False;
3373
3374 return True;
3375 }
3376
3377 /*******************************************************************
3378 ********************************************************************/
3379
3380 BOOL lsa_io_q_create_secret(const char *desc, LSA_Q_CREATE_SECRET *in, prs_struct *ps, int depth)
3381 {
3382 prs_debug(ps, depth, desc, "lsa_io_q_create_secret");
3383 depth++;
3384
3385 if(!prs_align(ps))
3386 return False;
3387
3388 if(!smb_io_pol_hnd("", &in->handle, ps, depth))
3389 return False;
3390
3391 if(!prs_unistr4 ("secretname", ps, depth, &in->secretname))
3392 return False;
3393 if(!prs_align(ps))
3394 return False;
3395
3396 if(!prs_uint32("access", ps, depth, &in->access))
3397 return False;
3398
3399 return True;
3400 }
3401
3402 /*******************************************************************
3403 ********************************************************************/
3404
3405 BOOL lsa_io_r_create_secret(const char *desc, LSA_R_CREATE_SECRET *out, prs_struct *ps, int depth)
3406 {
3407 prs_debug(ps, depth, desc, "lsa_io_r_create_secret");
3408 depth++;
3409
3410 if(!prs_align(ps))
3411 return False;
3412
3413 if (!smb_io_pol_hnd("", &out->handle, ps, depth))
3414 return False;
3415
3416 if(!prs_ntstatus("status", ps, depth, &out->status))
3417 return False;
3418
3419 return True;
3420 }
3421
3422
3423
3424 /*******************************************************************
3425 ********************************************************************/
3426
3427 static BOOL lsa_io_data_blob( const char *desc, prs_struct *ps, int depth, LSA_DATA_BLOB *blob )
3428 {
3429 prs_debug(ps, depth, desc, "lsa_io_data_blob");
3430 depth++;
3431
3432 if ( !prs_uint32("size", ps, depth, &blob->size) )
3433 return False;
3434 if ( !prs_uint32("size", ps, depth, &blob->size) )
3435 return False;
3436
3437 if ( !prs_io_unistr2_p(desc, ps, depth, &blob->data) )
3438 return False;
3439
3440 return True;
3441 }
3442
3443 /*******************************************************************
3444 ********************************************************************/
3445
3446 BOOL lsa_io_q_set_secret(const char *desc, LSA_Q_SET_SECRET *in, prs_struct *ps, int depth)
3447 {
3448 prs_debug(ps, depth, desc, "lsa_io_q_set_secret");
3449 depth++;
3450
3451 if ( !prs_align(ps) )
3452 return False;
3453
3454 if ( !smb_io_pol_hnd("", &in->handle, ps, depth) )
3455 return False;
3456
3457 if ( !prs_pointer( "old_value", ps, depth, (void*)&in->old_value, sizeof(LSA_DATA_BLOB), (PRS_POINTER_CAST)lsa_io_data_blob ))
3458 return False;
3459
3460 if( !prs_align(ps) )
3461 return False;
3462 if ( !prs_pointer( "old_value", ps, depth, (void*)&in->old_value, sizeof(LSA_DATA_BLOB), (PRS_POINTER_CAST)lsa_io_data_blob ))
3463 return False;
3464
3465
3466 return True;
3467 }
3468
3469 /*******************************************************************
3470 ********************************************************************/
3471
3472 BOOL lsa_io_r_set_secret(const char *desc, LSA_R_SET_SECRET *out, prs_struct *ps, int depth)
3473 {
3474 prs_debug(ps, depth, desc, "lsa_io_r_set_secret");
3475 depth++;
3476
3477 if(!prs_ntstatus("status", ps, depth, &out->status))
3478 return False;
3479
3480 return True;
3481 }
3482
3483 /*******************************************************************
3484 ********************************************************************/
3485
3486 BOOL lsa_io_q_delete_object(const char *desc, LSA_Q_DELETE_OBJECT *in, prs_struct *ps, int depth)
3487 {
3488 prs_debug(ps, depth, desc, "lsa_io_q_delete_object");
3489 depth++;
3490
3491 if(!prs_align(ps))
3492 return False;
3493
3494 if(!smb_io_pol_hnd("", &in->handle, ps, depth))
3495 return False;
3496
3497 return True;
3498 }
3499
3500 /*******************************************************************
3501 ********************************************************************/
3502
3503 BOOL lsa_io_r_delete_object(const char *desc, LSA_R_DELETE_OBJECT *out, prs_struct *ps, int depth)
3504 {
3505 prs_debug(ps, depth, desc, "lsa_io_r_delete_object");
3506 depth++;
3507
3508 if(!prs_ntstatus("status", ps, depth, &out->status))
3509 return False;
3510
3511 return True;
3512 }
3513
3514 /*******************************************************************
3515 Inits an LSA_Q_QUERY_TRUSTED_DOMAIN_INFO structure.
3516 ********************************************************************/
3517
3518 void init_q_query_trusted_domain_info(LSA_Q_QUERY_TRUSTED_DOMAIN_INFO *q,
3519 POLICY_HND *hnd, uint16 info_class)
3520 {
3521 DEBUG(5, ("init_q_query_trusted_domain_info\n"));
3522
3523 q->pol = *hnd;
3524 q->info_class = info_class;
3525 }
3526
3527 /*******************************************************************
3528 Inits an LSA_Q_QUERY_TRUSTED_DOMAIN_INFO_BY_NAME structure.
3529 ********************************************************************/
3530
3531 void init_q_query_trusted_domain_info_by_name(LSA_Q_QUERY_TRUSTED_DOMAIN_INFO_BY_NAME *q,
3532 POLICY_HND *hnd, uint16 info_class,
3533 const char *dom_name)
3534 {
3535 DEBUG(5, ("init_q_query_trusted_domain_info_by_name\n"));
3536
3537 q->pol = *hnd;
3538 init_lsa_string(&q->domain_name, dom_name );
3539 q->info_class = info_class;
3540 }
3541
3542 /*******************************************************************
3543 Inits an LSA_Q_QUERY_TRUSTED_DOMAIN_INFO_BY_SID structure.
3544 ********************************************************************/
3545
3546 void init_q_query_trusted_domain_info_by_sid(LSA_Q_QUERY_TRUSTED_DOMAIN_INFO_BY_SID *q,
3547 POLICY_HND *hnd, uint16 info_class,
3548 DOM_SID *dom_sid)
3549 {
3550 DEBUG(5, ("init_q_query_trusted_domain_info_by_sid\n"));
3551
3552 q->pol = *hnd;
3553 init_dom_sid2(&q->dom_sid, dom_sid);
3554 q->info_class = info_class;
3555 }
3556
3557 /*******************************************************************
3558 Reads or writes an LSA_Q_QUERY_TRUSTED_DOMAIN_INFO structure.
3559 ********************************************************************/
3560
3561 BOOL lsa_io_q_query_trusted_domain_info(const char *desc,
3562 LSA_Q_QUERY_TRUSTED_DOMAIN_INFO *q_q,
3563 prs_struct *ps, int depth)
3564 {
3565 prs_debug(ps, depth, desc, "lsa_io_q_query_trusted_domain_info");
3566 depth++;
3567
3568 if(!prs_align(ps))
3569 return False;
3570
3571 if(!smb_io_pol_hnd("pol", &q_q->pol, ps, depth))
3572 return False;
3573
3574 if(!prs_uint16("info_class", ps, depth, &q_q->info_class))
3575 return False;
3576
3577 return True;
3578 }
3579
3580
3581 /*******************************************************************
3582 Reads or writes an LSA_Q_QUERY_TRUSTED_DOMAIN_INFO_BY_SID structure.
3583 ********************************************************************/
3584
3585 BOOL lsa_io_q_query_trusted_domain_info_by_sid(const char *desc,
3586 LSA_Q_QUERY_TRUSTED_DOMAIN_INFO_BY_SID *q_q,
3587 prs_struct *ps, int depth)
3588 {
3589 prs_debug(ps, depth, desc, "lsa_io_q_query_trusted_domain_info_by_sid");
3590 depth++;
3591
3592 if(!prs_align(ps))
3593 return False;
3594
3595 if(!smb_io_pol_hnd("pol", &q_q->pol, ps, depth))
3596 return False;
3597
3598 if(!prs_align(ps))
3599 return False;
3600
3601 if(!smb_io_dom_sid2("dom_sid", &q_q->dom_sid, ps, depth))
3602 return False;
3603
3604 if(!prs_uint16("info_class", ps, depth, &q_q->info_class))
3605 return False;
3606
3607 return True;
3608 }
3609
3610 /*******************************************************************
3611 Reads or writes an LSA_Q_QUERY_TRUSTED_DOMAIN_INFO_BY_NAME structure.
3612 ********************************************************************/
3613
3614 BOOL lsa_io_q_query_trusted_domain_info_by_name(const char *desc,
3615 LSA_Q_QUERY_TRUSTED_DOMAIN_INFO_BY_NAME *q_q,
3616 prs_struct *ps, int depth)
3617 {
3618 prs_debug(ps, depth, desc, "lsa_io_q_query_trusted_domain_info_by_name");
3619 depth++;
3620
3621 if(!prs_align(ps))
3622 return False;
3623
3624 if(!smb_io_pol_hnd("pol", &q_q->pol, ps, depth))
3625 return False;
3626
3627 if(!prs_align(ps))
3628 return False;
3629
3630 if(!smb_io_lsa_string("domain_name", &q_q->domain_name, ps, depth))
3631 return False;
3632
3633 if(!prs_uint16("info_class", ps, depth, &q_q->info_class))
3634 return False;
3635
3636 return True;
3637 }
3638
3639 /*******************************************************************
3640 ********************************************************************/
3641
3642 static BOOL smb_io_lsa_data_buf_hdr(const char *desc, LSA_DATA_BUF_HDR *buf_hdr,
3643 prs_struct *ps, int depth)
3644 {
3645 prs_debug(ps, depth, desc, "smb_io_lsa_data_buf_hdr");
3646 depth++;
3647
3648 if(!prs_align(ps))
3649 return False;
3650
3651 if(!prs_uint32("length", ps, depth, &buf_hdr->length))
3652 return False;
3653
3654 if(!prs_uint32("size", ps, depth, &buf_hdr->size))
3655 return False;
3656
3657 if (!prs_uint32("data_ptr", ps, depth, &buf_hdr->data_ptr))
3658 return False;
3659
3660 return True;
3661 }
3662
3663 /*******************************************************************
3664 ********************************************************************/
3665
3666 static BOOL smb_io_lsa_data_buf(const char *desc, LSA_DATA_BUF *buf,
3667 prs_struct *ps, int depth, int length, int size)
3668 {
3669 prs_debug(ps, depth, desc, "smb_io_lsa_data_buf");
3670 depth++;
3671
3672 if ( UNMARSHALLING(ps) ) {
3673 if ( !(buf->data = PRS_ALLOC_MEM( ps, uint8, length )) )
3674 return False;
3675 }
3676
3677 if (!prs_uint32("size", ps, depth, &buf->size))
3678 return False;
3679
3680 if (!prs_uint32("offset", ps, depth, &buf->offset))
3681 return False;
3682
3683 if (!prs_uint32("length", ps, depth, &buf->length))
3684 return False;
3685
3686 if(!prs_uint8s(False, "data", ps, depth, buf->data, size))
3687 return False;
3688
3689 return True;
3690 }
3691
3692 /*******************************************************************
3693 ********************************************************************/
3694
3695 static BOOL lsa_io_trustdom_query_1(const char *desc, TRUSTED_DOMAIN_INFO_NAME *name,
3696 prs_struct *ps, int depth)
3697 {
3698 if (!smb_io_lsa_string("netbios_name", &name->netbios_name, ps, depth))
3699 return False;
3700
3701 return True;
3702 }
3703
3704 /*******************************************************************
3705 ********************************************************************/
3706
3707 static BOOL lsa_io_trustdom_query_3(const char *desc, TRUSTED_DOMAIN_INFO_POSIX_OFFSET *posix,
3708 prs_struct *ps, int depth)
3709 {
3710 if(!prs_uint32("posix_offset", ps, depth, &posix->posix_offset))
3711 return False;
3712
3713 return True;
3714 }
3715
3716 /*******************************************************************
3717 ********************************************************************/
3718
3719 static BOOL lsa_io_trustdom_query_4(const char *desc, TRUSTED_DOMAIN_INFO_PASSWORD *password,
3720 prs_struct *ps, int depth)
3721 {
3722 if(!prs_align(ps))
3723 return False;
3724
3725 if(!prs_uint32("ptr_password", ps, depth, &password->ptr_password))
3726 return False;
3727
3728 if(!prs_uint32("ptr_old_password", ps, depth, &password->ptr_old_password))
3729 return False;
3730
3731 if (&password->ptr_password) {
3732
3733 if (!smb_io_lsa_data_buf_hdr("password_hdr", &password->password_hdr, ps, depth))
3734 return False;
3735
3736 if (!smb_io_lsa_data_buf("password", &password->password, ps, depth,
3737 password->password_hdr.length, password->password_hdr.size))
3738 return False;
3739 }
3740
3741 if (&password->ptr_old_password) {
3742
3743 if (!smb_io_lsa_data_buf_hdr("old_password_hdr", &password->old_password_hdr, ps, depth))
3744 return False;
3745
3746 if (!smb_io_lsa_data_buf("old_password", &password->old_password, ps, depth,
3747 password->old_password_hdr.length, password->old_password_hdr.size))
3748 return False;
3749 }
3750
3751 return True;
3752 }
3753
3754 /*******************************************************************
3755 ********************************************************************/
3756
3757 static BOOL lsa_io_trustdom_query_6(const char *desc, TRUSTED_DOMAIN_INFO_EX *info_ex,
3758 prs_struct *ps, int depth)
3759 {
3760 uint32 dom_sid_ptr;
3761
3762 if (!smb_io_unihdr("domain_name_hdr", &info_ex->domain_name.hdr, ps, depth))
3763 return False;
3764
3765 if (!smb_io_unihdr("netbios_name_hdr", &info_ex->netbios_name.hdr, ps, depth))
3766 return False;
3767
3768 if (!prs_uint32("dom_sid_ptr", ps, depth, &dom_sid_ptr))
3769 return False;
3770
3771 if (!prs_uint32("trust_direction", ps, depth, &info_ex->trust_direction))
3772 return False;
3773
3774 if (!prs_uint32("trust_type", ps, depth, &info_ex->trust_type))
3775 return False;
3776
3777 if (!prs_uint32("trust_attributes", ps, depth, &info_ex->trust_attributes))
3778 return False;
3779
3780 if (!smb_io_unistr2("domain_name_unistring", &info_ex->domain_name.unistring, info_ex->domain_name.hdr.buffer, ps, depth))
3781 return False;
3782
3783 if (!smb_io_unistr2("netbios_name_unistring", &info_ex->netbios_name.unistring, info_ex->netbios_name.hdr.buffer, ps, depth))
3784 return False;
3785
3786 if (!smb_io_dom_sid2("sid", &info_ex->sid, ps, depth))
3787 return False;
3788
3789 return True;
3790 }
3791
3792 /*******************************************************************
3793 ********************************************************************/
3794
3795 static BOOL lsa_io_trustdom_query(const char *desc, prs_struct *ps, int depth, LSA_TRUSTED_DOMAIN_INFO *info)
3796 {
3797 prs_debug(ps, depth, desc, "lsa_io_trustdom_query");
3798 depth++;
3799
3800 if(!prs_uint16("info_class", ps, depth, &info->info_class))
3801 return False;
3802
3803 if(!prs_align(ps))
3804 return False;
3805
3806 switch (info->info_class) {
3807 case 1:
3808 if(!lsa_io_trustdom_query_1("name", &info->name, ps, depth))
3809 return False;
3810 break;
3811 case 3:
3812 if(!lsa_io_trustdom_query_3("posix_offset", &info->posix_offset, ps, depth))
3813 return False;
3814 break;
3815 case 4:
3816 if(!lsa_io_trustdom_query_4("password", &info->password, ps, depth))
3817 return False;
3818 break;
3819 case 6:
3820 if(!lsa_io_trustdom_query_6("info_ex", &info->info_ex, ps, depth))
3821 return False;
3822 break;
3823 default:
3824 DEBUG(0,("unsupported info-level: %d\n", info->info_class));
3825 return False;
3826 }
3827
3828 return True;
3829 }
3830
3831 /*******************************************************************
3832 Reads or writes an LSA_R_QUERY_TRUSTED_DOMAIN_INFO structure.
3833 ********************************************************************/
3834
3835 BOOL lsa_io_r_query_trusted_domain_info(const char *desc,
3836 LSA_R_QUERY_TRUSTED_DOMAIN_INFO *r_q,
3837 prs_struct *ps, int depth)
3838 {
3839 if (r_q == NULL)
3840 return False;
3841
3842 prs_debug(ps, depth, desc, "lsa_io_r_query_trusted_domain_info");
3843 depth++;
3844
3845 if (!prs_pointer("trustdom", ps, depth, (void**)&r_q->info,
3846 sizeof(LSA_TRUSTED_DOMAIN_INFO),
3847 (PRS_POINTER_CAST)lsa_io_trustdom_query) )
3848 return False;
3849
3850 if(!prs_align(ps))
3851 return False;
3852
3853 if(!prs_ntstatus("status", ps, depth, &r_q->status))
3854 return False;
3855
3856 return True;
3857 }
3858
3859 /*******************************************************************
3860 Inits an LSA_Q_QUERY_DOM_INFO_POLICY structure.
3861 ********************************************************************/
3862
3863 void init_q_query_dom_info(LSA_Q_QUERY_DOM_INFO_POLICY *in, POLICY_HND *hnd, uint16 info_class)
3864 {
3865 DEBUG(5, ("init_q_query_dom_info\n"));
3866
3867 memcpy(&in->pol, hnd, sizeof(in->pol));
3868
3869 in->info_class = info_class;
3870 }
3871
3872 /*******************************************************************
3873 Reads or writes an LSA_Q_QUERY_DOM_INFO_POLICY structure.
3874 ********************************************************************/
3875
3876 BOOL lsa_io_q_query_dom_info(const char *desc, LSA_Q_QUERY_DOM_INFO_POLICY *in, prs_struct *ps, int depth)
3877 {
3878 prs_debug(ps, depth, desc, "lsa_io_q_query_dom_info");
3879 depth++;
3880
3881 if(!prs_align(ps))
3882 return False;
3883
3884 if(!smb_io_pol_hnd("pol", &in->pol, ps, depth))
3885 return False;
3886
3887 if(!prs_uint16("info_class", ps, depth, &in->info_class))
3888 return False;
3889
3890 return True;
3891 }
3892
3893 /*******************************************************************
3894 Reads or writes an LSA_R_QUERY_DOM_INFO_POLICY structure.
3895 ********************************************************************/
3896
3897 static BOOL lsa_io_dominfo_query_3(const char *desc, LSA_DOM_INFO_POLICY_KERBEROS *krb_policy,
3898 prs_struct *ps, int depth)
3899 {
3900 if (!prs_align_uint64(ps))
3901 return False;
3902
3903 if (!prs_align(ps))
3904 return False;
3905
3906 if (!prs_uint32("enforce_restrictions", ps, depth, &krb_policy->enforce_restrictions))
3907 return False;
3908
3909 if (!prs_align_uint64(ps))
3910 return False;
3911
3912 if (!smb_io_nttime("service_tkt_lifetime", ps, depth, &krb_policy->service_tkt_lifetime))
3913 return False;
3914
3915 if (!prs_align_uint64(ps))
3916 return False;
3917
3918 if (!smb_io_nttime("user_tkt_lifetime", ps, depth, &krb_policy->user_tkt_lifetime))
3919 return False;
3920
3921 if (!prs_align_uint64(ps))
3922 return False;
3923
3924 if (!smb_io_nttime("user_tkt_renewaltime", ps, depth, &krb_policy->user_tkt_renewaltime))
3925 return False;
3926
3927 if (!prs_align_uint64(ps))
3928 return False;
3929
3930 if (!smb_io_nttime("clock_skew", ps, depth, &krb_policy->clock_skew))
3931 return False;
3932
3933 if (!prs_align_uint64(ps))
3934 return False;
3935
3936 if (!smb_io_nttime("unknown6", ps, depth, &krb_policy->unknown6))
3937 return False;
3938
3939 return True;
3940 }
3941
3942 static BOOL lsa_io_dom_info_query(const char *desc, prs_struct *ps, int depth, LSA_DOM_INFO_UNION *info)
3943 {
3944 prs_debug(ps, depth, desc, "lsa_io_dom_info_query");
3945 depth++;
3946
3947 if(!prs_align_uint16(ps))
3948 return False;
3949
3950 if(!prs_uint16("info_class", ps, depth, &info->info_class))
3951 return False;
3952
3953 switch (info->info_class) {
3954 case 3:
3955 if (!lsa_io_dominfo_query_3("krb_policy", &info->krb_policy, ps, depth))
3956 return False;
3957 break;
3958 default:
3959 DEBUG(0,("unsupported info-level: %d\n", info->info_class));
3960 return False;
3961 break;
3962 }
3963
3964 return True;
3965 }
3966
3967
3968 BOOL lsa_io_r_query_dom_info(const char *desc, LSA_R_QUERY_DOM_INFO_POLICY *out,
3969 prs_struct *ps, int depth)
3970 {
3971 prs_debug(ps, depth, desc, "lsa_io_r_query_dom_info");
3972 depth++;
3973
3974 if (!prs_pointer("dominfo", ps, depth, (void**)&out->info,
3975 sizeof(LSA_DOM_INFO_UNION),
3976 (PRS_POINTER_CAST)lsa_io_dom_info_query) )
3977 return False;
3978
3979 if(!prs_ntstatus("status", ps, depth, &out->status))
3980 return False;
3981
3982 return True;
3983 }