d7ef923be94e623bc6cd2ae03380b3dff01b0464
[ira/wip.git] / source3 / rpc_parse / parse_lsa.c
1 /* 
2  *  Unix SMB/Netbios implementation.
3  *  Version 1.9.
4  *  RPC Pipe client / server routines
5  *  Copyright (C) Andrew Tridgell              1992-1997,
6  *  Copyright (C) Luke Kenneth Casson Leighton 1996-1997,
7  *  Copyright (C) Paul Ashton                       1997.
8  *  
9  *  This program is free software; you can redistribute it and/or modify
10  *  it under the terms of the GNU General Public License as published by
11  *  the Free Software Foundation; either version 2 of the License, or
12  *  (at your option) any later version.
13  *  
14  *  This program is distributed in the hope that it will be useful,
15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  *  GNU General Public License for more details.
18  *  
19  *  You should have received a copy of the GNU General Public License
20  *  along with this program; if not, write to the Free Software
21  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22  */
23
24 #include "includes.h"
25
26 static BOOL lsa_io_trans_names(char *desc, LSA_TRANS_NAME_ENUM *trn, prs_struct *ps, int depth);
27
28 /*******************************************************************
29  Inits a LSA_TRANS_NAME structure.
30 ********************************************************************/
31
32 void init_lsa_trans_name(LSA_TRANS_NAME *trn, UNISTR2 *uni_name,
33                          uint16 sid_name_use, char *name, uint32 idx)
34 {
35         int len_name = strlen(name);
36
37         if(len_name == 0)
38                 len_name = 1;
39
40         trn->sid_name_use = sid_name_use;
41         init_uni_hdr(&trn->hdr_name, len_name);
42         init_unistr2(uni_name, name, len_name);
43         trn->domain_idx = idx;
44 }
45
46 /*******************************************************************
47  Reads or writes a LSA_TRANS_NAME structure.
48 ********************************************************************/
49
50 static BOOL lsa_io_trans_name(char *desc, LSA_TRANS_NAME *trn, prs_struct *ps, 
51                               int depth)
52 {
53         prs_debug(ps, depth, desc, "lsa_io_trans_name");
54         depth++;
55
56         if(!prs_align(ps))
57                 return False;
58         
59         if(!prs_uint16("sid_name_use", ps, depth, &trn->sid_name_use))
60                 return False;
61         if(!prs_align(ps))
62                 return False;
63         
64         if(!smb_io_unihdr ("hdr_name", &trn->hdr_name, ps, depth))
65                 return False;
66         if(!prs_uint32("domain_idx  ", ps, depth, &trn->domain_idx))
67                 return False;
68
69         return True;
70 }
71
72 /*******************************************************************
73  Reads or writes a DOM_R_REF structure.
74 ********************************************************************/
75
76 static BOOL lsa_io_dom_r_ref(char *desc, DOM_R_REF *r_r, prs_struct *ps, 
77                              int depth)
78 {
79         int i;
80
81         prs_debug(ps, depth, desc, "lsa_io_dom_r_ref");
82         depth++;
83
84         if(!prs_align(ps))
85                 return False;
86         
87         if(!prs_uint32("num_ref_doms_1", ps, depth, &r_r->num_ref_doms_1)) /* num referenced domains? */
88                 return False;
89         if(!prs_uint32("ptr_ref_dom   ", ps, depth, &r_r->ptr_ref_dom)) /* undocumented buffer pointer. */
90                 return False;
91         if(!prs_uint32("max_entries   ", ps, depth, &r_r->max_entries)) /* 32 - max number of entries */
92                 return False;
93
94         SMB_ASSERT_ARRAY(r_r->hdr_ref_dom, r_r->num_ref_doms_1);
95
96         if (r_r->ptr_ref_dom != 0) {
97
98                 if(!prs_uint32("num_ref_doms_2", ps, depth, &r_r->num_ref_doms_2)) /* 4 - num referenced domains? */
99                         return False;
100
101                 SMB_ASSERT_ARRAY(r_r->ref_dom, r_r->num_ref_doms_2);
102
103                 for (i = 0; i < r_r->num_ref_doms_1; i++) {
104                         fstring t;
105
106                         slprintf(t, sizeof(t) - 1, "dom_ref[%d] ", i);
107                         if(!smb_io_unihdr(t, &r_r->hdr_ref_dom[i].hdr_dom_name, ps, depth))
108                                 return False;
109
110                         slprintf(t, sizeof(t) - 1, "sid_ptr[%d] ", i);
111                         if(!prs_uint32(t, ps, depth, &r_r->hdr_ref_dom[i].ptr_dom_sid))
112                                 return False;
113                 }
114
115                 for (i = 0; i < r_r->num_ref_doms_2; i++) {
116                         fstring t;
117
118                         if (r_r->hdr_ref_dom[i].hdr_dom_name.buffer != 0) {
119                                 slprintf(t, sizeof(t) - 1, "dom_ref[%d] ", i);
120                                 if(!smb_io_unistr2(t, &r_r->ref_dom[i].uni_dom_name, True, ps, depth)) /* domain name unicode string */
121                                         return False;
122                                 if(!prs_align(ps))
123                                         return False;
124                         }
125
126                         if (r_r->hdr_ref_dom[i].ptr_dom_sid != 0) {
127                                 slprintf(t, sizeof(t) - 1, "sid_ptr[%d] ", i);
128                                 if(!smb_io_dom_sid2(t, &r_r->ref_dom[i].ref_dom, ps, depth)) /* referenced domain SIDs */
129                                         return False;
130                         }
131                 }
132         }
133
134         return True;
135 }
136
137 /*******************************************************************
138  Inits an LSA_SEC_QOS structure.
139 ********************************************************************/
140
141 void init_lsa_sec_qos(LSA_SEC_QOS *qos, uint16 imp_lev, uint8 ctxt, uint8 eff,
142                       uint32 unknown)
143 {
144         DEBUG(5, ("init_lsa_sec_qos\n"));
145
146         qos->len = 0x0c; /* length of quality of service block, in bytes */
147         qos->sec_imp_level = imp_lev;
148         qos->sec_ctxt_mode = ctxt;
149         qos->effective_only = eff;
150         qos->unknown = unknown;
151 }
152
153 /*******************************************************************
154  Reads or writes an LSA_SEC_QOS structure.
155 ********************************************************************/
156
157 static BOOL lsa_io_sec_qos(char *desc,  LSA_SEC_QOS *qos, prs_struct *ps, 
158                            int depth)
159 {
160         uint32 start;
161
162         prs_debug(ps, depth, desc, "lsa_io_obj_qos");
163         depth++;
164
165         if(!prs_align(ps))
166                 return False;
167         
168         start = prs_offset(ps);
169
170         /* these pointers had _better_ be zero, because we don't know
171            what they point to!
172          */
173         if(!prs_uint32("len           ", ps, depth, &qos->len)) /* 0x18 - length (in bytes) inc. the length field. */
174                 return False;
175         if(!prs_uint16("sec_imp_level ", ps, depth, &qos->sec_imp_level ))
176                 return False;
177         if(!prs_uint8 ("sec_ctxt_mode ", ps, depth, &qos->sec_ctxt_mode ))
178                 return False;
179         if(!prs_uint8 ("effective_only", ps, depth, &qos->effective_only))
180                 return False;
181         if(!prs_uint32("unknown       ", ps, depth, &qos->unknown))
182                 return False;
183
184         if (qos->len != prs_offset(ps) - start) {
185                 DEBUG(3,("lsa_io_sec_qos: length %x does not match size %x\n",
186                          qos->len, prs_offset(ps) - start));
187                 return False;
188         }
189
190         return True;
191 }
192
193 /*******************************************************************
194  Inits an LSA_OBJ_ATTR structure.
195 ********************************************************************/
196
197 void init_lsa_obj_attr(LSA_OBJ_ATTR *attr, uint32 attributes, LSA_SEC_QOS *qos)
198 {
199         DEBUG(5, ("init_lsa_obj_attr\n"));
200
201         attr->len = 0x18; /* length of object attribute block, in bytes */
202         attr->ptr_root_dir = 0;
203         attr->ptr_obj_name = 0;
204         attr->attributes = attributes;
205         attr->ptr_sec_desc = 0;
206         
207         if (qos != NULL) {
208                 attr->ptr_sec_qos = 1;
209                 attr->sec_qos = qos;
210         } else {
211                 attr->ptr_sec_qos = 0;
212                 attr->sec_qos = NULL;
213         }
214 }
215
216 /*******************************************************************
217  Reads or writes an LSA_OBJ_ATTR structure.
218 ********************************************************************/
219
220 static BOOL lsa_io_obj_attr(char *desc, LSA_OBJ_ATTR *attr, prs_struct *ps, 
221                             int depth)
222 {
223         uint32 start;
224
225         prs_debug(ps, depth, desc, "lsa_io_obj_attr");
226         depth++;
227
228         if(!prs_align(ps))
229                 return False;
230         
231         start = prs_offset(ps);
232
233         /* these pointers had _better_ be zero, because we don't know
234            what they point to!
235          */
236         if(!prs_uint32("len         ", ps, depth, &attr->len)) /* 0x18 - length (in bytes) inc. the length field. */
237                 return False;
238         if(!prs_uint32("ptr_root_dir", ps, depth, &attr->ptr_root_dir)) /* 0 - root directory (pointer) */
239                 return False;
240         if(!prs_uint32("ptr_obj_name", ps, depth, &attr->ptr_obj_name)) /* 0 - object name (pointer) */
241                 return False;
242         if(!prs_uint32("attributes  ", ps, depth, &attr->attributes)) /* 0 - attributes (undocumented) */
243                 return False;
244         if(!prs_uint32("ptr_sec_desc", ps, depth, &attr->ptr_sec_desc)) /* 0 - security descriptior (pointer) */
245                 return False;
246         if(!prs_uint32("ptr_sec_qos ", ps, depth, &attr->ptr_sec_qos )) /* security quality of service (pointer) */
247                 return False;
248
249         /* code commented out as it's not necessary true (tested with hyena). JFM, 11/22/2001 */
250 #if 0
251         if (attr->len != prs_offset(ps) - start) {
252                 DEBUG(3,("lsa_io_obj_attr: length %x does not match size %x\n",
253                          attr->len, prs_offset(ps) - start));
254                 return False;
255         }
256 #endif
257
258         if (attr->ptr_sec_qos != 0 && attr->sec_qos != NULL) {
259                 if(!lsa_io_sec_qos("sec_qos", attr->sec_qos, ps, depth))
260                         return False;
261         }
262
263         return True;
264 }
265
266
267 /*******************************************************************
268  Inits an LSA_Q_OPEN_POL structure.
269 ********************************************************************/
270
271 void init_q_open_pol(LSA_Q_OPEN_POL *r_q, uint16 system_name,
272                      uint32 attributes, uint32 desired_access,
273                      LSA_SEC_QOS *qos)
274 {
275         DEBUG(5, ("init_open_pol: attr:%d da:%d\n", attributes, 
276                   desired_access));
277
278         r_q->ptr = 1; /* undocumented pointer */
279
280         if (qos == NULL)
281                 r_q->des_access = desired_access;
282
283         r_q->system_name = system_name;
284         init_lsa_obj_attr(&r_q->attr, attributes, qos);
285 }
286
287 /*******************************************************************
288  Reads or writes an LSA_Q_OPEN_POL structure.
289 ********************************************************************/
290
291 BOOL lsa_io_q_open_pol(char *desc, LSA_Q_OPEN_POL *r_q, prs_struct *ps, 
292                        int depth)
293 {
294         prs_debug(ps, depth, desc, "lsa_io_q_open_pol");
295         depth++;
296
297         if(!prs_uint32("ptr       ", ps, depth, &r_q->ptr))
298                 return False;
299         if(!prs_uint16("system_name", ps, depth, &r_q->system_name))
300                 return False;
301         if(!prs_align( ps ))
302                 return False;
303
304         if(!lsa_io_obj_attr("", &r_q->attr, ps, depth))
305                 return False;
306
307         if (r_q->attr.ptr_sec_qos == 0) {
308                 if(!prs_uint32("des_access", ps, depth, &r_q->des_access))
309                         return False;
310         }
311
312         return True;
313 }
314
315 /*******************************************************************
316  Reads or writes an LSA_R_OPEN_POL structure.
317 ********************************************************************/
318
319 BOOL lsa_io_r_open_pol(char *desc, LSA_R_OPEN_POL *r_p, prs_struct *ps, 
320                        int depth)
321 {
322         prs_debug(ps, depth, desc, "lsa_io_r_open_pol");
323         depth++;
324
325         if(!smb_io_pol_hnd("", &r_p->pol, ps, depth))
326                 return False;
327
328         if(!prs_ntstatus("status", ps, depth, &r_p->status))
329                 return False;
330
331         return True;
332 }
333
334 /*******************************************************************
335  Inits an LSA_Q_OPEN_POL2 structure.
336 ********************************************************************/
337
338 void init_q_open_pol2(LSA_Q_OPEN_POL2 *r_q, char *server_name,
339                         uint32 attributes, uint32 desired_access,
340                         LSA_SEC_QOS *qos)
341 {
342         DEBUG(5, ("init_q_open_pol2: attr:%d da:%d\n", attributes, 
343                   desired_access));
344
345         r_q->ptr = 1; /* undocumented pointer */
346
347         if (qos == NULL)
348                 r_q->des_access = desired_access;
349
350         init_unistr2(&r_q->uni_server_name, server_name, 
351                      strlen(server_name) + 1);
352
353         init_lsa_obj_attr(&r_q->attr, attributes, qos);
354 }
355
356 /*******************************************************************
357  Reads or writes an LSA_Q_OPEN_POL2 structure.
358 ********************************************************************/
359
360 BOOL lsa_io_q_open_pol2(char *desc, LSA_Q_OPEN_POL2 *r_q, prs_struct *ps, 
361                         int depth)
362 {
363         prs_debug(ps, depth, desc, "lsa_io_q_open_pol2");
364         depth++;
365
366         if(!prs_uint32("ptr       ", ps, depth, &r_q->ptr))
367                 return False;
368
369         if(!smb_io_unistr2 ("", &r_q->uni_server_name, r_q->ptr, ps, depth))
370                 return False;
371         if(!lsa_io_obj_attr("", &r_q->attr, ps, depth))
372                 return False;
373
374         if (r_q->attr.ptr_sec_qos == 0) {
375                 if(!prs_uint32("des_access", ps, depth, &r_q->des_access))
376                         return False;
377         }
378
379         return True;
380 }
381
382 /*******************************************************************
383  Reads or writes an LSA_R_OPEN_POL2 structure.
384 ********************************************************************/
385
386 BOOL lsa_io_r_open_pol2(char *desc, LSA_R_OPEN_POL2 *r_p, prs_struct *ps, 
387                         int depth)
388 {
389         prs_debug(ps, depth, desc, "lsa_io_r_open_pol2");
390         depth++;
391
392         if(!smb_io_pol_hnd("", &r_p->pol, ps, depth))
393                 return False;
394
395         if(!prs_ntstatus("status", ps, depth, &r_p->status))
396                 return False;
397
398         return True;
399 }
400
401 /*******************************************************************
402 makes an LSA_Q_QUERY_SEC_OBJ structure.
403 ********************************************************************/
404
405 void init_q_query_sec_obj(LSA_Q_QUERY_SEC_OBJ *q_q, const POLICY_HND *hnd, 
406                           uint32 sec_info)
407 {
408         DEBUG(5, ("init_q_query_sec_obj\n"));
409
410         q_q->pol = *hnd;
411         q_q->sec_info = sec_info;
412
413         return;
414 }
415
416 /*******************************************************************
417  Reads or writes an LSA_Q_QUERY_SEC_OBJ structure.
418 ********************************************************************/
419
420 BOOL lsa_io_q_query_sec_obj(char *desc, LSA_Q_QUERY_SEC_OBJ *q_q, 
421                             prs_struct *ps, int depth)
422 {
423         prs_debug(ps, depth, desc, "lsa_io_q_query_sec_obj");
424         depth++;
425
426         if (!smb_io_pol_hnd("", &q_q->pol, ps, depth))
427                 return False;
428
429         if (!prs_uint32("sec_info", ps, depth, &q_q->sec_info))
430                 return False;
431
432         return True;
433
434
435 /*******************************************************************
436  Reads or writes a LSA_R_QUERY_SEC_OBJ structure.
437 ********************************************************************/
438
439 BOOL lsa_io_r_query_sec_obj(char *desc, LSA_R_QUERY_SEC_OBJ *r_u, 
440                             prs_struct *ps, int depth)
441 {
442         prs_debug(ps, depth, desc, "lsa_io_r_query_sec_obj");
443         depth++;
444
445         if (!prs_align(ps))
446                 return False;
447
448         if (!prs_uint32("ptr", ps, depth, &r_u->ptr))
449                 return False;
450
451         if (r_u->ptr != 0) {
452                 if (!sec_io_desc_buf("sec", &r_u->buf, ps, depth))
453                         return False;
454         }
455
456         if (!prs_ntstatus("status", ps, depth, &r_u->status))
457                 return False;
458
459         return True;
460 }
461
462 /*******************************************************************
463  Inits an LSA_Q_QUERY_INFO structure.
464 ********************************************************************/
465
466 void init_q_query(LSA_Q_QUERY_INFO *q_q, POLICY_HND *hnd, uint16 info_class)
467 {
468         DEBUG(5, ("init_q_query\n"));
469
470         memcpy(&q_q->pol, hnd, sizeof(q_q->pol));
471
472         q_q->info_class = info_class;
473 }
474
475 /*******************************************************************
476  Reads or writes an LSA_Q_QUERY_INFO structure.
477 ********************************************************************/
478
479 BOOL lsa_io_q_query(char *desc, LSA_Q_QUERY_INFO *q_q, prs_struct *ps, 
480                     int depth)
481 {
482         prs_debug(ps, depth, desc, "lsa_io_q_query");
483         depth++;
484
485         if(!smb_io_pol_hnd("", &q_q->pol, ps, depth))
486                 return False;
487
488         if(!prs_uint16("info_class", ps, depth, &q_q->info_class))
489                 return False;
490
491         return True;
492 }
493
494 /*******************************************************************
495 makes an LSA_Q_ENUM_TRUST_DOM structure.
496 ********************************************************************/
497 BOOL init_q_enum_trust_dom(LSA_Q_ENUM_TRUST_DOM * q_e, POLICY_HND *pol,
498                            uint32 enum_context, uint32 preferred_len)
499 {
500         DEBUG(5, ("init_q_enum_trust_dom\n"));
501
502         q_e->pol = *pol;
503         q_e->enum_context = enum_context;
504         q_e->preferred_len = preferred_len;
505
506         return True;
507 }
508
509 /*******************************************************************
510  Reads or writes an LSA_Q_ENUM_TRUST_DOM structure.
511 ********************************************************************/
512
513 BOOL lsa_io_q_enum_trust_dom(char *desc, LSA_Q_ENUM_TRUST_DOM *q_e, 
514                              prs_struct *ps, int depth)
515 {
516         prs_debug(ps, depth, desc, "lsa_io_q_enum_trust_dom");
517         depth++;
518
519         if(!smb_io_pol_hnd("", &q_e->pol, ps, depth))
520                 return False;
521
522         if(!prs_uint32("enum_context ", ps, depth, &q_e->enum_context))
523                 return False;
524         if(!prs_uint32("preferred_len", ps, depth, &q_e->preferred_len))
525                 return False;
526
527         return True;
528 }
529
530 /*******************************************************************
531  Inits an LSA_R_ENUM_TRUST_DOM structure.
532 ********************************************************************/
533
534 void init_r_enum_trust_dom(TALLOC_CTX *ctx, LSA_R_ENUM_TRUST_DOM *r_e, uint32 enum_context, 
535                            char *domain_name, DOM_SID *domain_sid,
536                            NTSTATUS status)
537 {
538         DEBUG(5, ("init_r_enum_trust_dom\n"));
539         
540         r_e->enum_context = enum_context;
541         
542         if (NT_STATUS_IS_OK(status)) {
543                 int len_domain_name = strlen(domain_name) + 1;
544                 
545                 r_e->num_domains  = 1;
546                 r_e->ptr_enum_domains = 1;
547                 r_e->num_domains2 = 1;
548                 
549                 if (!(r_e->hdr_domain_name = (UNIHDR2 *)talloc(ctx,sizeof(UNIHDR2))))
550                         return;
551
552                 if (!(r_e->uni_domain_name = (UNISTR2 *)talloc(ctx,sizeof(UNISTR2))))
553                         return;
554
555                 if (!(r_e->domain_sid = (DOM_SID2 *)talloc(ctx,sizeof(DOM_SID2))))
556                         return;
557
558                 init_uni_hdr2(&r_e->hdr_domain_name[0], len_domain_name);
559                 init_unistr2 (&r_e->uni_domain_name[0], domain_name, 
560                               len_domain_name);
561                 init_dom_sid2(&r_e->domain_sid[0], domain_sid);
562         } else {
563                 r_e->num_domains = 0;
564                 r_e->ptr_enum_domains = 0;
565         }
566         
567         r_e->status = status;
568 }
569
570 /*******************************************************************
571  Reads or writes an LSA_R_ENUM_TRUST_DOM structure.
572 ********************************************************************/
573
574 BOOL lsa_io_r_enum_trust_dom(char *desc, LSA_R_ENUM_TRUST_DOM *r_e, 
575                              prs_struct *ps, int depth)
576 {
577         prs_debug(ps, depth, desc, "lsa_io_r_enum_trust_dom");
578         depth++;
579
580         if(!prs_uint32("enum_context    ", ps, depth, &r_e->enum_context))
581                 return False;
582         if(!prs_uint32("num_domains     ", ps, depth, &r_e->num_domains))
583                 return False;
584         if(!prs_uint32("ptr_enum_domains", ps, depth, &r_e->ptr_enum_domains))
585                 return False;
586
587         if (r_e->ptr_enum_domains) {
588                 int i, num_domains;
589
590                 if(!prs_uint32("num_domains2", ps, depth, &r_e->num_domains2))
591                         return False;
592
593                 num_domains = r_e->num_domains2;
594
595                 if (UNMARSHALLING(ps)) {
596                         if (!(r_e->hdr_domain_name = (UNIHDR2 *)prs_alloc_mem(ps,sizeof(UNIHDR2) * num_domains)))
597                                 return False;
598
599                         if (!(r_e->uni_domain_name = (UNISTR2 *)prs_alloc_mem(ps,sizeof(UNISTR2) * num_domains)))
600                                 return False;
601
602                         if (!(r_e->domain_sid = (DOM_SID2 *)prs_alloc_mem(ps,sizeof(DOM_SID2) * num_domains)))
603                                 return False;
604                 }
605
606                 for (i = 0; i < num_domains; i++) {
607                         if(!smb_io_unihdr2 ("", &r_e->hdr_domain_name[i], ps, 
608                                             depth))
609                                 return False;
610                 }
611                 
612                 for (i = 0; i < num_domains; i++) {
613                         if(!smb_io_unistr2 ("", &r_e->uni_domain_name[i],
614                                             r_e->hdr_domain_name[i].buffer, 
615                                             ps, depth))
616                                 return False;
617                         if(!smb_io_dom_sid2("", &r_e->domain_sid[i], ps, 
618                                             depth))
619                                 return False;
620                 }
621         }
622
623         if(!prs_ntstatus("status", ps, depth, &r_e->status))
624                 return False;
625
626         return True;
627 }
628
629 /*******************************************************************
630 reads or writes a dom query structure.
631 ********************************************************************/
632
633 static BOOL lsa_io_dom_query(char *desc, DOM_QUERY *d_q, prs_struct *ps, int depth)
634 {
635         if (d_q == NULL)
636                 return False;
637
638         prs_debug(ps, depth, desc, "lsa_io_dom_query");
639         depth++;
640
641         if(!prs_align(ps))
642                 return False;
643
644         if(!prs_uint16("uni_dom_max_len", ps, depth, &d_q->uni_dom_max_len)) /* domain name string length * 2 */
645                 return False;
646         if(!prs_uint16("uni_dom_str_len", ps, depth, &d_q->uni_dom_str_len)) /* domain name string length * 2 */
647                 return False;
648
649         if(!prs_uint32("buffer_dom_name", ps, depth, &d_q->buffer_dom_name)) /* undocumented domain name string buffer pointer */
650                 return False;
651         if(!prs_uint32("buffer_dom_sid ", ps, depth, &d_q->buffer_dom_sid)) /* undocumented domain SID string buffer pointer */
652                 return False;
653
654         if(!smb_io_unistr2("unistr2", &d_q->uni_domain_name, d_q->buffer_dom_name, ps, depth)) /* domain name (unicode string) */
655                 return False;
656
657         if(!prs_align(ps))
658                 return False;
659
660         if (d_q->buffer_dom_sid != 0) {
661                 if(!smb_io_dom_sid2("", &d_q->dom_sid, ps, depth)) /* domain SID */
662                         return False;
663         } else {
664                 memset((char *)&d_q->dom_sid, '\0', sizeof(d_q->dom_sid));
665         }
666
667         return True;
668 }
669
670 /*******************************************************************
671 reads or writes a structure.
672 ********************************************************************/
673
674 static BOOL lsa_io_dom_query_2(char *desc, DOM_QUERY_2 *d_q, prs_struct *ps, int depth)
675 {
676         uint32 ptr = 1;
677
678         if (d_q == NULL)
679                 return False;
680
681         prs_debug(ps, depth, desc, "lsa_io_dom_query_2");
682         depth++;
683
684         if (!prs_align(ps))
685                 return False;
686
687         if (!prs_uint32("auditing_enabled", ps, depth, &d_q->auditing_enabled))
688                 return False;
689         if (!prs_uint32("ptr   ", ps, depth, &ptr))
690                 return False;
691         if (!prs_uint32("count1", ps, depth, &d_q->count1))
692                 return False;
693         if (!prs_uint32("count2", ps, depth, &d_q->count2))
694                 return False;
695
696         if (UNMARSHALLING(ps)) {
697                 d_q->auditsettings = (uint32 *)talloc_zero(ps->mem_ctx, d_q->count2 * sizeof(uint32));
698         }
699
700         if (d_q->auditsettings == NULL) {
701                 DEBUG(1, ("lsa_io_dom_query_2: NULL auditsettings!\n"));
702                 return False;
703         }
704
705         if (!prs_uint32s(False, "auditsettings", ps, depth, d_q->auditsettings, d_q->count2))
706                 return False;
707
708     return True;
709 }
710
711 /*******************************************************************
712  Reads or writes a dom query structure.
713 ********************************************************************/
714
715 static BOOL lsa_io_dom_query_3(char *desc, DOM_QUERY_3 *d_q, prs_struct *ps, int depth)
716 {
717         return lsa_io_dom_query("", d_q, ps, depth);
718 }
719
720 /*******************************************************************
721  Reads or writes a dom query structure.
722 ********************************************************************/
723
724 BOOL lsa_io_dom_query_5(char *desc, DOM_QUERY_5 *d_q, prs_struct *ps, int depth)
725 {
726         return lsa_io_dom_query("", d_q, ps, depth);
727 }
728
729 /*******************************************************************
730  Reads or writes a dom query structure.
731 ********************************************************************/
732
733 static BOOL lsa_io_dom_query_6(char *desc, DOM_QUERY_6 *d_q, prs_struct *ps, int depth)
734 {
735         if (d_q == NULL)
736                 return False;
737
738         prs_debug(ps, depth, desc, "lsa_io_dom_query_6");
739         depth++;
740
741         if (!prs_uint16("server_role", ps, depth, &d_q->server_role))
742                 return False;
743
744         return True;
745 }
746
747 /*******************************************************************
748  Reads or writes an LSA_R_QUERY_INFO structure.
749 ********************************************************************/
750
751 BOOL lsa_io_r_query(char *desc, LSA_R_QUERY_INFO *r_q, prs_struct *ps,
752                     int depth)
753 {
754         prs_debug(ps, depth, desc, "lsa_io_r_query");
755         depth++;
756
757         if(!prs_uint32("undoc_buffer", ps, depth, &r_q->undoc_buffer))
758                 return False;
759
760         if (r_q->undoc_buffer != 0) {
761                 if(!prs_uint16("info_class", ps, depth, &r_q->info_class))
762                         return False;
763
764                 if(!prs_align(ps))
765                         return False;
766
767                 switch (r_q->info_class) {
768                 case 2:
769                         if(!lsa_io_dom_query_2("", &r_q->dom.id2, ps, depth))
770                                 return False;
771                         break;
772                 case 3:
773                         if(!lsa_io_dom_query_3("", &r_q->dom.id3, ps, depth))
774                                 return False;
775                         break;
776                 case 5:
777                         if(!lsa_io_dom_query_5("", &r_q->dom.id5, ps, depth))
778                                 return False;
779                         break;
780                 case 6:
781                         if(!lsa_io_dom_query_6("", &r_q->dom.id6, ps, depth))
782                                 return False;
783                         break;
784                 default:
785                         /* PANIC! */
786                         break;
787                 }
788         }
789
790         if(!prs_align(ps))
791                 return False;
792
793         if(!prs_ntstatus("status", ps, depth, &r_q->status))
794                 return False;
795
796         return True;
797 }
798
799 /*******************************************************************
800  Inits a LSA_SID_ENUM structure.
801 ********************************************************************/
802
803 void init_lsa_sid_enum(TALLOC_CTX *mem_ctx, LSA_SID_ENUM *sen, 
804                        int num_entries, DOM_SID *sids)
805 {
806         int i;
807
808         DEBUG(5, ("init_lsa_sid_enum\n"));
809
810         sen->num_entries  = num_entries;
811         sen->ptr_sid_enum = (num_entries != 0);
812         sen->num_entries2 = num_entries;
813
814         /* Allocate memory for sids and sid pointers */
815
816         if (num_entries == 0) return;
817
818         if ((sen->ptr_sid = (uint32 *)talloc_zero(mem_ctx, num_entries * 
819                                              sizeof(uint32))) == NULL) {
820                 DEBUG(3, ("init_lsa_sid_enum(): out of memory for ptr_sid\n"));
821                 return;
822         }
823
824         if ((sen->sid = (DOM_SID2 *)talloc_zero(mem_ctx, num_entries * 
825                                            sizeof(DOM_SID2))) == NULL) {
826                 DEBUG(3, ("init_lsa_sid_enum(): out of memory for sids\n"));
827                 return;
828         }
829
830         /* Copy across SIDs and SID pointers */
831
832         for (i = 0; i < num_entries; i++) {
833                 sen->ptr_sid[i] = 1;
834                 init_dom_sid2(&sen->sid[i], &sids[i]);
835         }
836 }
837
838 /*******************************************************************
839  Reads or writes a LSA_SID_ENUM structure.
840 ********************************************************************/
841
842 static BOOL lsa_io_sid_enum(char *desc, LSA_SID_ENUM *sen, prs_struct *ps, 
843                             int depth)
844 {
845         int i;
846
847         prs_debug(ps, depth, desc, "lsa_io_sid_enum");
848         depth++;
849
850         if(!prs_align(ps))
851                 return False;
852         
853         if(!prs_uint32("num_entries ", ps, depth, &sen->num_entries))
854                 return False;
855         if(!prs_uint32("ptr_sid_enum", ps, depth, &sen->ptr_sid_enum))
856                 return False;
857
858         /*
859            if the ptr is NULL, leave here. checked from a real w2k trace.
860            JFM, 11/23/2001
861          */
862         
863         if (sen->ptr_sid_enum==0)
864                 return True;
865
866         if(!prs_uint32("num_entries2", ps, depth, &sen->num_entries2))
867                 return False;
868
869         /* Mallocate memory if we're unpacking from the wire */
870
871         if (UNMARSHALLING(ps)) {
872                 if ((sen->ptr_sid = (uint32 *)prs_alloc_mem( ps,
873                         sen->num_entries * sizeof(uint32))) == NULL) {
874                         DEBUG(3, ("init_lsa_sid_enum(): out of memory for "
875                                   "ptr_sid\n"));
876                         return False;
877                 }
878
879                 if ((sen->sid = (DOM_SID2 *)prs_alloc_mem( ps,
880                         sen->num_entries * sizeof(DOM_SID2))) == NULL) {
881                         DEBUG(3, ("init_lsa_sid_enum(): out of memory for "
882                                   "sids\n"));
883                         return False;
884                 }
885         }
886
887         for (i = 0; i < sen->num_entries; i++) {        
888                 fstring temp;
889
890                 slprintf(temp, sizeof(temp) - 1, "ptr_sid[%d]", i);
891                 if(!prs_uint32(temp, ps, depth, &sen->ptr_sid[i])) {
892                         return False;
893                 }
894         }
895
896         for (i = 0; i < sen->num_entries; i++) {
897                 fstring temp;
898
899                 slprintf(temp, sizeof(temp) - 1, "sid[%d]", i);
900                 if(!smb_io_dom_sid2(temp, &sen->sid[i], ps, depth)) {
901                         return False;
902                 }
903         }
904
905         return True;
906 }
907
908 /*******************************************************************
909  Inits an LSA_R_ENUM_TRUST_DOM structure.
910 ********************************************************************/
911
912 void init_q_lookup_sids(TALLOC_CTX *mem_ctx, LSA_Q_LOOKUP_SIDS *q_l, 
913                         POLICY_HND *hnd, int num_sids, DOM_SID *sids,
914                         uint16 level)
915 {
916         DEBUG(5, ("init_r_enum_trust_dom\n"));
917
918         ZERO_STRUCTP(q_l);
919
920         memcpy(&q_l->pol, hnd, sizeof(q_l->pol));
921         init_lsa_sid_enum(mem_ctx, &q_l->sids, num_sids, sids);
922         
923         q_l->level.value = level;
924 }
925
926 /*******************************************************************
927  Reads or writes a LSA_Q_LOOKUP_SIDS structure.
928 ********************************************************************/
929
930 BOOL lsa_io_q_lookup_sids(char *desc, LSA_Q_LOOKUP_SIDS *q_s, prs_struct *ps,
931                           int depth)
932 {
933         prs_debug(ps, depth, desc, "lsa_io_q_lookup_sids");
934         depth++;
935
936         if(!prs_align(ps))
937                 return False;
938         
939         if(!smb_io_pol_hnd("pol_hnd", &q_s->pol, ps, depth)) /* policy handle */
940                 return False;
941         if(!lsa_io_sid_enum("sids   ", &q_s->sids, ps, depth)) /* sids to be looked up */
942                 return False;
943         if(!lsa_io_trans_names("names  ", &q_s->names, ps, depth)) /* translated names */
944                 return False;
945         if(!smb_io_lookup_level("switch ", &q_s->level, ps, depth)) /* lookup level */
946                 return False;
947
948         if(!prs_uint32("mapped_count", ps, depth, &q_s->mapped_count))
949                 return False;
950
951         return True;
952 }
953
954 /*******************************************************************
955  Reads or writes a structure.
956 ********************************************************************/
957
958 static BOOL lsa_io_trans_names(char *desc, LSA_TRANS_NAME_ENUM *trn,
959                 prs_struct *ps, int depth)
960 {
961         int i;
962
963         prs_debug(ps, depth, desc, "lsa_io_trans_names");
964         depth++;
965
966         if(!prs_align(ps))
967                 return False;
968    
969         if(!prs_uint32("num_entries    ", ps, depth, &trn->num_entries))
970                 return False;
971         if(!prs_uint32("ptr_trans_names", ps, depth, &trn->ptr_trans_names))
972                 return False;
973
974         if (trn->ptr_trans_names != 0) {
975                 if(!prs_uint32("num_entries2   ", ps, depth, 
976                                &trn->num_entries2))
977                         return False;
978
979                 if (UNMARSHALLING(ps)) {
980                         if ((trn->name = (LSA_TRANS_NAME *)
981                              prs_alloc_mem(ps, trn->num_entries * 
982                                     sizeof(LSA_TRANS_NAME))) == NULL) {
983                                 return False;
984                         }
985
986                         if ((trn->uni_name = (UNISTR2 *)
987                              prs_alloc_mem(ps, trn->num_entries *
988                                     sizeof(UNISTR2))) == NULL) {
989                                 return False;
990                         }
991                 }
992
993                 for (i = 0; i < trn->num_entries2; i++) {
994                         fstring t;
995                         slprintf(t, sizeof(t) - 1, "name[%d] ", i);
996
997                         if(!lsa_io_trans_name(t, &trn->name[i], ps, depth)) /* translated name */
998                                 return False;
999                 }
1000
1001                 for (i = 0; i < trn->num_entries2; i++) {
1002                         fstring t;
1003                         slprintf(t, sizeof(t) - 1, "name[%d] ", i);
1004
1005                         if(!smb_io_unistr2(t, &trn->uni_name[i], trn->name[i].hdr_name.buffer, ps, depth))
1006                                 return False;
1007                         if(!prs_align(ps))
1008                                 return False;
1009                 }
1010         }
1011
1012         return True;
1013 }
1014
1015 /*******************************************************************
1016  Reads or writes a structure.
1017 ********************************************************************/
1018
1019 BOOL lsa_io_r_lookup_sids(char *desc, LSA_R_LOOKUP_SIDS *r_s, 
1020                           prs_struct *ps, int depth)
1021 {
1022         prs_debug(ps, depth, desc, "lsa_io_r_lookup_sids");
1023         depth++;
1024
1025         if(!prs_align(ps))
1026                 return False;
1027         
1028         if(!prs_uint32("ptr_dom_ref", ps, depth, &r_s->ptr_dom_ref))
1029                 return False;
1030
1031         if (r_s->ptr_dom_ref != 0)
1032                 if(!lsa_io_dom_r_ref ("dom_ref", r_s->dom_ref, ps, depth)) /* domain reference info */
1033                         return False;
1034
1035         if(!lsa_io_trans_names("names  ", r_s->names, ps, depth)) /* translated names */
1036                 return False;
1037
1038         if(!prs_align(ps))
1039                 return False;
1040
1041         if(!prs_uint32("mapped_count", ps, depth, &r_s->mapped_count))
1042                 return False;
1043
1044         if(!prs_ntstatus("status      ", ps, depth, &r_s->status))
1045                 return False;
1046
1047         return True;
1048 }
1049
1050 /*******************************************************************
1051 makes a structure.
1052 ********************************************************************/
1053
1054 void init_q_lookup_names(TALLOC_CTX *mem_ctx, LSA_Q_LOOKUP_NAMES *q_l, 
1055                          POLICY_HND *hnd, int num_names, char **names)
1056 {
1057         int i;
1058
1059         DEBUG(5, ("init_q_lookup_names\n"));
1060
1061         ZERO_STRUCTP(q_l);
1062
1063         q_l->pol = *hnd;
1064         q_l->num_entries = num_names;
1065         q_l->num_entries2 = num_names;
1066         q_l->lookup_level = 1;
1067
1068         if ((q_l->uni_name = (UNISTR2 *)talloc_zero(
1069                 mem_ctx, num_names * sizeof(UNISTR2))) == NULL) {
1070                 DEBUG(3, ("init_q_lookup_names(): out of memory\n"));
1071                 return;
1072         }
1073
1074         if ((q_l->hdr_name = (UNIHDR *)talloc_zero(
1075                 mem_ctx, num_names * sizeof(UNIHDR))) == NULL) {
1076                 DEBUG(3, ("init_q_lookup_names(): out of memory\n"));
1077                 return;
1078         }
1079
1080         for (i = 0; i < num_names; i++) {
1081                 char* name = names[i];
1082                 int len = strlen(name);
1083
1084                 init_uni_hdr(&q_l->hdr_name[i], len);
1085                 init_unistr2(&q_l->uni_name[i], name, len);
1086         }
1087 }
1088
1089 /*******************************************************************
1090 reads or writes a structure.
1091 ********************************************************************/
1092
1093 BOOL lsa_io_q_lookup_names(char *desc, LSA_Q_LOOKUP_NAMES *q_r, 
1094                            prs_struct *ps, int depth)
1095 {
1096         int i;
1097
1098         prs_debug(ps, depth, desc, "lsa_io_q_lookup_names");
1099         depth++;
1100
1101         if(!prs_align(ps))
1102                 return False;
1103
1104         if(!smb_io_pol_hnd("", &q_r->pol, ps, depth)) /* policy handle */
1105                 return False;
1106
1107         if(!prs_align(ps))
1108                 return False;
1109         if(!prs_uint32("num_entries    ", ps, depth, &q_r->num_entries))
1110                 return False;
1111         if(!prs_uint32("num_entries2   ", ps, depth, &q_r->num_entries2))
1112                 return False;
1113
1114         if (UNMARSHALLING(ps)) {
1115                 if (q_r->num_entries) {
1116                         if ((q_r->hdr_name = (UNIHDR *)prs_alloc_mem(ps,
1117                                         q_r->num_entries * sizeof(UNIHDR))) == NULL)
1118                                 return False;
1119                         if ((q_r->uni_name = (UNISTR2 *)prs_alloc_mem(ps,
1120                                         q_r->num_entries * sizeof(UNISTR2))) == NULL)
1121                                 return False;
1122                 }
1123         }
1124
1125         for (i = 0; i < q_r->num_entries; i++) {
1126                 if(!prs_align(ps))
1127                         return False;
1128                 if(!smb_io_unihdr("hdr_name", &q_r->hdr_name[i], ps, depth)) /* pointer names */
1129                         return False;
1130         }
1131
1132         for (i = 0; i < q_r->num_entries; i++) {
1133                 if(!prs_align(ps))
1134                         return False;
1135                 if(!smb_io_unistr2("dom_name", &q_r->uni_name[i], q_r->hdr_name[i].buffer, ps, depth)) /* names to be looked up */
1136                         return False;
1137         }
1138
1139         if(!prs_align(ps))
1140                 return False;
1141         if(!prs_uint32("num_trans_entries ", ps, depth, &q_r->num_trans_entries))
1142                 return False;
1143         if(!prs_uint32("ptr_trans_sids ", ps, depth, &q_r->ptr_trans_sids))
1144                 return False;
1145         if(!prs_uint32("lookup_level   ", ps, depth, &q_r->lookup_level))
1146                 return False;
1147         if(!prs_uint32("mapped_count   ", ps, depth, &q_r->mapped_count))
1148                 return False;
1149
1150         return True;
1151 }
1152
1153 /*******************************************************************
1154 reads or writes a structure.
1155 ********************************************************************/
1156
1157 BOOL lsa_io_r_lookup_names(char *desc, LSA_R_LOOKUP_NAMES *r_r, 
1158                            prs_struct *ps, int depth)
1159 {
1160         int i;
1161
1162         prs_debug(ps, depth, desc, "lsa_io_r_lookup_names");
1163         depth++;
1164
1165         if(!prs_align(ps))
1166                 return False;
1167
1168         if(!prs_uint32("ptr_dom_ref", ps, depth, &r_r->ptr_dom_ref))
1169                 return False;
1170
1171         if (r_r->ptr_dom_ref != 0)
1172                 if(!lsa_io_dom_r_ref("", r_r->dom_ref, ps, depth))
1173                         return False;
1174
1175         if(!prs_uint32("num_entries", ps, depth, &r_r->num_entries))
1176                 return False;
1177         if(!prs_uint32("ptr_entries", ps, depth, &r_r->ptr_entries))
1178                 return False;
1179
1180         if (r_r->ptr_entries != 0) {
1181                 if(!prs_uint32("num_entries2", ps, depth, &r_r->num_entries2))
1182                         return False;
1183
1184                 if (r_r->num_entries2 != r_r->num_entries) {
1185                         /* RPC fault */
1186                         return False;
1187                 }
1188
1189                 if (UNMARSHALLING(ps)) {
1190                         if ((r_r->dom_rid = (DOM_RID2 *)prs_alloc_mem(ps, r_r->num_entries2 * sizeof(DOM_RID2)))
1191                             == NULL) {
1192                                 DEBUG(3, ("lsa_io_r_lookup_names(): out of memory\n"));
1193                                 return False;
1194                         }
1195                 }
1196
1197                 for (i = 0; i < r_r->num_entries2; i++)
1198                         if(!smb_io_dom_rid2("", &r_r->dom_rid[i], ps, depth)) /* domain RIDs being looked up */
1199                                 return False;
1200         }
1201
1202         if(!prs_uint32("mapped_count", ps, depth, &r_r->mapped_count))
1203                 return False;
1204
1205         if(!prs_ntstatus("status      ", ps, depth, &r_r->status))
1206                 return False;
1207
1208         return True;
1209 }
1210
1211
1212 /*******************************************************************
1213  Inits an LSA_Q_CLOSE structure.
1214 ********************************************************************/
1215
1216 void init_lsa_q_close(LSA_Q_CLOSE *q_c, POLICY_HND *hnd)
1217 {
1218         DEBUG(5, ("init_lsa_q_close\n"));
1219
1220         memcpy(&q_c->pol, hnd, sizeof(q_c->pol));
1221 }
1222
1223 /*******************************************************************
1224  Reads or writes an LSA_Q_CLOSE structure.
1225 ********************************************************************/
1226
1227 BOOL lsa_io_q_close(char *desc, LSA_Q_CLOSE *q_c, prs_struct *ps, int depth)
1228 {
1229         prs_debug(ps, depth, desc, "lsa_io_q_close");
1230         depth++;
1231
1232         if(!smb_io_pol_hnd("", &q_c->pol, ps, depth))
1233                 return False;
1234
1235         return True;
1236 }
1237
1238 /*******************************************************************
1239  Reads or writes an LSA_R_CLOSE structure.
1240 ********************************************************************/
1241
1242 BOOL lsa_io_r_close(char *desc,  LSA_R_CLOSE *r_c, prs_struct *ps, int depth)
1243 {
1244         prs_debug(ps, depth, desc, "lsa_io_r_close");
1245         depth++;
1246
1247         if(!smb_io_pol_hnd("", &r_c->pol, ps, depth))
1248                 return False;
1249
1250         if(!prs_ntstatus("status", ps, depth, &r_c->status))
1251                 return False;
1252
1253         return True;
1254 }
1255
1256 /*******************************************************************
1257  Reads or writes an LSA_Q_OPEN_SECRET structure.
1258 ********************************************************************/
1259
1260 BOOL lsa_io_q_open_secret(char *desc, LSA_Q_OPEN_SECRET *q_c, prs_struct *ps, int depth)
1261 {
1262         prs_debug(ps, depth, desc, "lsa_io_q_open_secret");
1263         depth++;
1264
1265         /* Don't bother to read or write at present... */
1266         return True;
1267 }
1268
1269 /*******************************************************************
1270  Reads or writes an LSA_R_OPEN_SECRET structure.
1271 ********************************************************************/
1272
1273 BOOL lsa_io_r_open_secret(char *desc, LSA_R_OPEN_SECRET *r_c, prs_struct *ps, int depth)
1274 {
1275         prs_debug(ps, depth, desc, "lsa_io_r_open_secret");
1276         depth++;
1277
1278         if(!prs_align(ps))
1279                 return False;
1280    
1281         if(!prs_uint32("dummy1", ps, depth, &r_c->dummy1))
1282                 return False;
1283         if(!prs_uint32("dummy2", ps, depth, &r_c->dummy2))
1284                 return False;
1285         if(!prs_uint32("dummy3", ps, depth, &r_c->dummy3))
1286                 return False;
1287         if(!prs_uint32("dummy4", ps, depth, &r_c->dummy4))
1288                 return False;
1289         if(!prs_ntstatus("status", ps, depth, &r_c->status))
1290                 return False;
1291
1292         return True;
1293 }
1294
1295 /*******************************************************************
1296  Inits an LSA_Q_ENUM_PRIVS structure.
1297 ********************************************************************/
1298
1299 void init_q_enum_privs(LSA_Q_ENUM_PRIVS *q_q, POLICY_HND *hnd, uint32 enum_context, uint32 pref_max_length)
1300 {
1301         DEBUG(5, ("init_q_enum_privs\n"));
1302
1303         memcpy(&q_q->pol, hnd, sizeof(q_q->pol));
1304
1305         q_q->enum_context = enum_context;
1306         q_q->pref_max_length = pref_max_length;
1307 }
1308
1309 /*******************************************************************
1310 reads or writes a structure.
1311 ********************************************************************/
1312 BOOL lsa_io_q_enum_privs(char *desc, LSA_Q_ENUM_PRIVS *q_q, prs_struct *ps, int depth)
1313 {
1314         if (q_q == NULL)
1315                 return False;
1316
1317         prs_debug(ps, depth, desc, "lsa_io_q_enum_privs");
1318         depth++;
1319
1320         if (!smb_io_pol_hnd("", &q_q->pol, ps, depth))
1321                 return False;
1322
1323         if(!prs_uint32("enum_context   ", ps, depth, &q_q->enum_context))
1324                 return False;
1325         if(!prs_uint32("pref_max_length", ps, depth, &q_q->pref_max_length))
1326                 return False;
1327
1328         return True;
1329 }
1330
1331 /*******************************************************************
1332 reads or writes a structure.
1333 ********************************************************************/
1334 static BOOL lsa_io_priv_entries(char *desc, LSA_PRIV_ENTRY *entries, uint32 count, prs_struct *ps, int depth)
1335 {
1336         uint32 i;
1337
1338         if (entries == NULL)
1339                 return False;
1340
1341         prs_debug(ps, depth, desc, "lsa_io_priv_entries");
1342         depth++;
1343
1344         if(!prs_align(ps))
1345                 return False;
1346
1347         for (i = 0; i < count; i++) {
1348                 if (!smb_io_unihdr("", &entries[i].hdr_name, ps, depth))
1349                         return False;
1350                 if(!prs_uint32("luid_low ", ps, depth, &entries[i].luid_low))
1351                         return False;
1352                 if(!prs_uint32("luid_high", ps, depth, &entries[i].luid_high))
1353                         return False;
1354         }
1355
1356         for (i = 0; i < count; i++)
1357                 if (!smb_io_unistr2("", &entries[i].name, entries[i].hdr_name.buffer, ps, depth))
1358                         return False;
1359
1360         return True;
1361 }
1362
1363 /*******************************************************************
1364  Inits an LSA_R_ENUM_PRIVS structure.
1365 ********************************************************************/
1366
1367 void init_lsa_r_enum_privs(LSA_R_ENUM_PRIVS *r_u, uint32 enum_context,
1368                           uint32 count, LSA_PRIV_ENTRY *entries)
1369 {
1370         DEBUG(5, ("init_lsa_r_enum_privs\n"));
1371
1372         r_u->enum_context=enum_context;
1373         r_u->count=count;
1374         
1375         if (entries!=NULL) {
1376                 r_u->ptr=1;
1377                 r_u->count1=count;
1378                 r_u->privs=entries;
1379         } else {
1380                 r_u->ptr=0;
1381                 r_u->count1=0;
1382                 r_u->privs=NULL;
1383         }               
1384 }
1385
1386 /*******************************************************************
1387 reads or writes a structure.
1388 ********************************************************************/
1389 BOOL lsa_io_r_enum_privs(char *desc, LSA_R_ENUM_PRIVS *r_q, prs_struct *ps, int depth)
1390 {
1391         if (r_q == NULL)
1392                 return False;
1393
1394         prs_debug(ps, depth, desc, "lsa_io_r_enum_privs");
1395         depth++;
1396
1397         if(!prs_align(ps))
1398                 return False;
1399
1400         if(!prs_uint32("enum_context", ps, depth, &r_q->enum_context))
1401                 return False;
1402         if(!prs_uint32("count", ps, depth, &r_q->count))
1403                 return False;
1404         if(!prs_uint32("ptr", ps, depth, &r_q->ptr))
1405                 return False;
1406
1407         if (r_q->ptr) {
1408                 if(!prs_uint32("count1", ps, depth, &r_q->count1))
1409                         return False;
1410
1411                 if (UNMARSHALLING(ps))
1412                         if (!(r_q->privs = (LSA_PRIV_ENTRY *)prs_alloc_mem(ps, sizeof(LSA_PRIV_ENTRY) * r_q->count1)))
1413                                 return False;
1414
1415                 if (!lsa_io_priv_entries("", r_q->privs, r_q->count1, ps, depth))
1416                         return False;
1417         }
1418
1419         if(!prs_align(ps))
1420                 return False;
1421
1422         if(!prs_ntstatus("status", ps, depth, &r_q->status))
1423                 return False;
1424
1425         return True;
1426 }
1427
1428 void init_lsa_priv_get_dispname(LSA_Q_PRIV_GET_DISPNAME *trn, POLICY_HND *hnd, char *name, uint16 lang_id, uint16 lang_id_sys)
1429 {
1430         int len_name = strlen(name);
1431
1432         if(len_name == 0)
1433                 len_name = 1;
1434
1435         memcpy(&trn->pol, hnd, sizeof(trn->pol));
1436
1437         init_uni_hdr(&trn->hdr_name, len_name);
1438         init_unistr2(&trn->name, name, len_name);
1439         trn->lang_id = lang_id;
1440         trn->lang_id_sys = lang_id_sys;
1441 }
1442
1443 /*******************************************************************
1444 reads or writes a structure.
1445 ********************************************************************/
1446 BOOL lsa_io_q_priv_get_dispname(char *desc, LSA_Q_PRIV_GET_DISPNAME *q_q, prs_struct *ps, int depth)
1447 {
1448         if (q_q == NULL)
1449                 return False;
1450
1451         prs_debug(ps, depth, desc, "lsa_io_q_priv_get_dispname");
1452         depth++;
1453
1454         if(!prs_align(ps))
1455                 return False;
1456
1457         if (!smb_io_pol_hnd("", &q_q->pol, ps, depth))
1458                 return False;
1459
1460         if (!smb_io_unihdr("hdr_name", &q_q->hdr_name, ps, depth))
1461                 return False;
1462
1463         if (!smb_io_unistr2("name", &q_q->name, q_q->hdr_name.buffer, ps, depth))
1464                 return False;
1465
1466         if(!prs_uint16("lang_id    ", ps, depth, &q_q->lang_id))
1467                 return False;
1468         if(!prs_uint16("lang_id_sys", ps, depth, &q_q->lang_id_sys))
1469                 return False;
1470
1471         return True;
1472 }
1473
1474 /*******************************************************************
1475 reads or writes a structure.
1476 ********************************************************************/
1477 BOOL lsa_io_r_priv_get_dispname(char *desc, LSA_R_PRIV_GET_DISPNAME *r_q, prs_struct *ps, int depth)
1478 {
1479         if (r_q == NULL)
1480                 return False;
1481
1482         prs_debug(ps, depth, desc, "lsa_io_r_priv_get_dispname");
1483         depth++;
1484
1485         if (!prs_align(ps))
1486                 return False;
1487
1488         if (!prs_uint32("ptr_info", ps, depth, &r_q->ptr_info))
1489                 return False;
1490
1491         if (r_q->ptr_info){
1492                 if (!smb_io_unihdr("hdr_name", &r_q->hdr_desc, ps, depth))
1493                         return False;
1494
1495                 if (!smb_io_unistr2("desc", &r_q->desc, r_q->hdr_desc.buffer, ps, depth))
1496                         return False;
1497         }
1498 /*
1499         if(!prs_align(ps))
1500                 return False;
1501 */
1502         if(!prs_uint16("lang_id", ps, depth, &r_q->lang_id))
1503                 return False;
1504
1505         if(!prs_align(ps))
1506                 return False;
1507         if(!prs_ntstatus("status", ps, depth, &r_q->status))
1508                 return False;
1509
1510         return True;
1511 }
1512
1513 void init_lsa_q_enum_accounts(LSA_Q_ENUM_ACCOUNTS *trn, POLICY_HND *hnd, uint32 enum_context, uint32 pref_max_length)
1514 {
1515         memcpy(&trn->pol, hnd, sizeof(trn->pol));
1516
1517         trn->enum_context = enum_context;
1518         trn->pref_max_length = pref_max_length;
1519 }
1520
1521 /*******************************************************************
1522 reads or writes a structure.
1523 ********************************************************************/
1524 BOOL lsa_io_q_enum_accounts(char *desc, LSA_Q_ENUM_ACCOUNTS *q_q, prs_struct *ps, int depth)
1525 {
1526         if (q_q == NULL)
1527                 return False;
1528
1529         prs_debug(ps, depth, desc, "lsa_io_q_enum_accounts");
1530         depth++;
1531
1532         if (!smb_io_pol_hnd("", &q_q->pol, ps, depth))
1533                 return False;
1534
1535         if(!prs_uint32("enum_context   ", ps, depth, &q_q->enum_context))
1536                 return False;
1537         if(!prs_uint32("pref_max_length", ps, depth, &q_q->pref_max_length))
1538                 return False;
1539
1540         return True;
1541 }
1542
1543 /*******************************************************************
1544  Inits an LSA_R_ENUM_PRIVS structure.
1545 ********************************************************************/
1546
1547 void init_lsa_r_enum_accounts(LSA_R_ENUM_ACCOUNTS *r_u, uint32 enum_context)
1548 {
1549         DEBUG(5, ("init_lsa_r_enum_accounts\n"));
1550
1551         r_u->enum_context=enum_context;
1552         if (r_u->enum_context!=0) {
1553                 r_u->sids.num_entries=enum_context;
1554                 r_u->sids.ptr_sid_enum=1;
1555                 r_u->sids.num_entries2=enum_context;
1556         } else {
1557                 r_u->sids.num_entries=0;
1558                 r_u->sids.ptr_sid_enum=0;
1559                 r_u->sids.num_entries2=0;
1560         }
1561 }
1562
1563 /*******************************************************************
1564 reads or writes a structure.
1565 ********************************************************************/
1566 BOOL lsa_io_r_enum_accounts(char *desc, LSA_R_ENUM_ACCOUNTS *r_q, prs_struct *ps, int depth)
1567 {
1568         if (r_q == NULL)
1569                 return False;
1570
1571         prs_debug(ps, depth, desc, "lsa_io_r_enum_accounts");
1572         depth++;
1573
1574         if (!prs_align(ps))
1575                 return False;
1576
1577         if(!prs_uint32("enum_context", ps, depth, &r_q->enum_context))
1578                 return False;
1579
1580         if (!lsa_io_sid_enum("sids", &r_q->sids, ps, depth))
1581                 return False;
1582
1583         if (!prs_align(ps))
1584                 return False;
1585
1586         if(!prs_ntstatus("status", ps, depth, &r_q->status))
1587                 return False;
1588
1589         return True;
1590 }
1591
1592
1593 /*******************************************************************
1594  Reads or writes an LSA_Q_UNK_GET_CONNUSER structure.
1595 ********************************************************************/
1596
1597 BOOL lsa_io_q_unk_get_connuser(char *desc, LSA_Q_UNK_GET_CONNUSER *q_c, prs_struct *ps, int depth)
1598 {
1599         prs_debug(ps, depth, desc, "lsa_io_q_unk_get_connuser");
1600         depth++;
1601
1602         if(!prs_align(ps))
1603                 return False;
1604    
1605         if(!prs_uint32("ptr_srvname", ps, depth, &q_c->ptr_srvname))
1606                 return False;
1607
1608         if(!smb_io_unistr2("uni2_srvname", &q_c->uni2_srvname, q_c->ptr_srvname, ps, depth)) /* server name to be looked up */
1609                 return False;
1610
1611         if(!prs_uint32("unk1", ps, depth, &q_c->unk1))
1612                 return False;
1613         if(!prs_uint32("unk2", ps, depth, &q_c->unk2))
1614                 return False;
1615         if(!prs_uint32("unk3", ps, depth, &q_c->unk3))
1616                 return False;
1617
1618         /* Don't bother to read or write at present... */
1619         return True;
1620 }
1621
1622 /*******************************************************************
1623  Reads or writes an LSA_R_UNK_GET_CONNUSER structure.
1624 ********************************************************************/
1625
1626 BOOL lsa_io_r_unk_get_connuser(char *desc, LSA_R_UNK_GET_CONNUSER *r_c, prs_struct *ps, int depth)
1627 {
1628         prs_debug(ps, depth, desc, "lsa_io_r_unk_get_connuser");
1629         depth++;
1630
1631         if(!prs_align(ps))
1632                 return False;
1633    
1634         if(!prs_uint32("ptr_user_name", ps, depth, &r_c->ptr_user_name))
1635                 return False;
1636         if(!smb_io_unihdr("hdr_user_name", &r_c->hdr_user_name, ps, depth))
1637                 return False;
1638         if(!smb_io_unistr2("uni2_user_name", &r_c->uni2_user_name, r_c->ptr_user_name, ps, depth))
1639                 return False;
1640
1641         if (!prs_align(ps))
1642           return False;
1643         
1644         if(!prs_uint32("unk1", ps, depth, &r_c->unk1))
1645                 return False;
1646
1647         if(!prs_uint32("ptr_dom_name", ps, depth, &r_c->ptr_dom_name))
1648                 return False;
1649         if(!smb_io_unihdr("hdr_dom_name", &r_c->hdr_dom_name, ps, depth))
1650                 return False;
1651         if(!smb_io_unistr2("uni2_dom_name", &r_c->uni2_dom_name, r_c->ptr_dom_name, ps, depth))
1652                 return False;
1653
1654         if (!prs_align(ps))
1655           return False;
1656         
1657         if(!prs_ntstatus("status", ps, depth, &r_c->status))
1658                 return False;
1659
1660         return True;
1661 }
1662
1663 void init_lsa_q_open_account(LSA_Q_OPENACCOUNT *trn, POLICY_HND *hnd, DOM_SID *sid, uint32 access)
1664 {
1665         memcpy(&trn->pol, hnd, sizeof(trn->pol));
1666
1667         init_dom_sid2(&trn->sid, sid);
1668         trn->access = access;
1669 }
1670
1671 /*******************************************************************
1672  Reads or writes an LSA_Q_OPENACCOUNT structure.
1673 ********************************************************************/
1674
1675 BOOL lsa_io_q_open_account(char *desc, LSA_Q_OPENACCOUNT *r_c, prs_struct *ps, int depth)
1676 {
1677         prs_debug(ps, depth, desc, "lsa_io_q_open_account");
1678         depth++;
1679
1680         if(!prs_align(ps))
1681                 return False;
1682  
1683         if(!smb_io_pol_hnd("pol", &r_c->pol, ps, depth))
1684                 return False;
1685
1686         if(!smb_io_dom_sid2("sid", &r_c->sid, ps, depth)) /* domain SID */
1687                 return False;
1688
1689         if(!prs_uint32("access", ps, depth, &r_c->access))
1690                 return False;
1691   
1692         return True;
1693 }
1694
1695 /*******************************************************************
1696  Reads or writes an LSA_R_OPENACCOUNT structure.
1697 ********************************************************************/
1698
1699 BOOL lsa_io_r_open_account(char *desc, LSA_R_OPENACCOUNT  *r_c, prs_struct *ps, int depth)
1700 {
1701         prs_debug(ps, depth, desc, "lsa_io_r_open_account");
1702         depth++;
1703
1704         if(!prs_align(ps))
1705                 return False;
1706  
1707         if(!smb_io_pol_hnd("pol", &r_c->pol, ps, depth))
1708                 return False;
1709
1710         if(!prs_ntstatus("status", ps, depth, &r_c->status))
1711                 return False;
1712
1713         return True;
1714 }
1715
1716
1717 void init_lsa_q_enum_privsaccount(LSA_Q_ENUMPRIVSACCOUNT *trn, POLICY_HND *hnd)
1718 {
1719         memcpy(&trn->pol, hnd, sizeof(trn->pol));
1720
1721 }
1722
1723 /*******************************************************************
1724  Reads or writes an LSA_Q_ENUMPRIVSACCOUNT structure.
1725 ********************************************************************/
1726
1727 BOOL lsa_io_q_enum_privsaccount(char *desc, LSA_Q_ENUMPRIVSACCOUNT *r_c, prs_struct *ps, int depth)
1728 {
1729         prs_debug(ps, depth, desc, "lsa_io_q_enum_privsaccount");
1730         depth++;
1731
1732         if(!prs_align(ps))
1733                 return False;
1734  
1735         if(!smb_io_pol_hnd("pol", &r_c->pol, ps, depth))
1736                 return False;
1737
1738         return True;
1739 }
1740
1741 /*******************************************************************
1742  Reads or writes an LUID structure.
1743 ********************************************************************/
1744
1745 BOOL lsa_io_luid(char *desc, LUID *r_c, prs_struct *ps, int depth)
1746 {
1747         prs_debug(ps, depth, desc, "lsa_io_luid");
1748         depth++;
1749
1750         if(!prs_align(ps))
1751                 return False;
1752  
1753         if(!prs_uint32("low", ps, depth, &r_c->low))
1754                 return False;
1755
1756         if(!prs_uint32("high", ps, depth, &r_c->high))
1757                 return False;
1758
1759         return True;
1760 }
1761
1762 /*******************************************************************
1763  Reads or writes an LUID_ATTR structure.
1764 ********************************************************************/
1765
1766 BOOL lsa_io_luid_attr(char *desc, LUID_ATTR *r_c, prs_struct *ps, int depth)
1767 {
1768         prs_debug(ps, depth, desc, "lsa_io_luid_attr");
1769         depth++;
1770
1771         if(!prs_align(ps))
1772                 return False;
1773  
1774         if (!lsa_io_luid(desc, &r_c->luid, ps, depth))
1775                 return False;
1776
1777         if(!prs_uint32("attr", ps, depth, &r_c->attr))
1778                 return False;
1779
1780         return True;
1781 }
1782
1783 /*******************************************************************
1784  Reads or writes an PRIVILEGE_SET structure.
1785 ********************************************************************/
1786
1787 BOOL lsa_io_privilege_set(char *desc, PRIVILEGE_SET *r_c, prs_struct *ps, int depth)
1788 {
1789         uint32 i;
1790
1791         prs_debug(ps, depth, desc, "lsa_io_privilege_set");
1792         depth++;
1793
1794         if(!prs_align(ps))
1795                 return False;
1796  
1797         if(!prs_uint32("count", ps, depth, &r_c->count))
1798                 return False;
1799         if(!prs_uint32("control", ps, depth, &r_c->control))
1800                 return False;
1801
1802         for (i=0; i<r_c->count; i++) {
1803                 if (!lsa_io_luid_attr(desc, &r_c->set[i], ps, depth))
1804                         return False;
1805         }
1806         
1807         return True;
1808 }
1809
1810 void init_lsa_r_enum_privsaccount(LSA_R_ENUMPRIVSACCOUNT *r_u, LUID_ATTR *set, uint32 count, uint32 control)
1811 {
1812         r_u->ptr=1;
1813         r_u->count=count;
1814         r_u->set.set=set;
1815         r_u->set.count=count;
1816         r_u->set.control=control;
1817 }
1818
1819 /*******************************************************************
1820  Reads or writes an LSA_R_ENUMPRIVSACCOUNT structure.
1821 ********************************************************************/
1822
1823 BOOL lsa_io_r_enum_privsaccount(char *desc, LSA_R_ENUMPRIVSACCOUNT *r_c, prs_struct *ps, int depth)
1824 {
1825         prs_debug(ps, depth, desc, "lsa_io_r_enum_privsaccount");
1826         depth++;
1827
1828         if(!prs_align(ps))
1829                 return False;
1830  
1831         if(!prs_uint32("ptr", ps, depth, &r_c->ptr))
1832                 return False;
1833
1834         if (r_c->ptr!=0) {
1835                 if(!prs_uint32("count", ps, depth, &r_c->count))
1836                         return False;
1837
1838                 /* malloc memory if unmarshalling here */
1839
1840                 if (UNMARSHALLING(ps) && r_c->count!=0) {
1841                         if (!(r_c->set.set = (LUID_ATTR *)prs_alloc_mem(ps,sizeof(LUID_ATTR) * r_c->count)))
1842                                 return False;
1843
1844                 }
1845                 
1846                 if(!lsa_io_privilege_set(desc, &r_c->set, ps, depth))
1847                         return False;
1848         }
1849
1850         if(!prs_ntstatus("status", ps, depth, &r_c->status))
1851                 return False;
1852
1853         return True;
1854 }
1855
1856
1857
1858 /*******************************************************************
1859  Reads or writes an  LSA_Q_GETSYSTEMACCOUNTstructure.
1860 ********************************************************************/
1861
1862 BOOL lsa_io_q_getsystemaccount(char *desc, LSA_Q_GETSYSTEMACCOUNT  *r_c, prs_struct *ps, int depth)
1863 {
1864         prs_debug(ps, depth, desc, "lsa_io_q_getsystemaccount");
1865         depth++;
1866
1867         if(!prs_align(ps))
1868                 return False;
1869  
1870         if(!smb_io_pol_hnd("pol", &r_c->pol, ps, depth))
1871                 return False;
1872
1873         return True;
1874 }
1875
1876 /*******************************************************************
1877  Reads or writes an  LSA_R_GETSYSTEMACCOUNTstructure.
1878 ********************************************************************/
1879
1880 BOOL lsa_io_r_getsystemaccount(char *desc, LSA_R_GETSYSTEMACCOUNT  *r_c, prs_struct *ps, int depth)
1881 {
1882         prs_debug(ps, depth, desc, "lsa_io_r_getsystemaccount");
1883         depth++;
1884
1885         if(!prs_align(ps))
1886                 return False;
1887  
1888         if(!prs_uint32("access", ps, depth, &r_c->access))
1889                 return False;
1890
1891         if(!prs_ntstatus("status", ps, depth, &r_c->status))
1892                 return False;
1893
1894         return True;
1895 }
1896
1897 void init_lsa_q_lookupprivvalue(LSA_Q_LOOKUPPRIVVALUE *trn, POLICY_HND *hnd, char *name)
1898 {
1899         int len_name = strlen(name);
1900         memcpy(&trn->pol, hnd, sizeof(trn->pol));
1901
1902         if(len_name == 0)
1903                 len_name = 1;
1904
1905         init_uni_hdr(&trn->hdr_right, len_name);
1906         init_unistr2(&trn->uni2_right, name, len_name);
1907 }
1908
1909 /*******************************************************************
1910  Reads or writes an LSA_Q_LOOKUPPRIVVALUE  structure.
1911 ********************************************************************/
1912
1913 BOOL lsa_io_q_lookupprivvalue(char *desc, LSA_Q_LOOKUPPRIVVALUE  *r_c, prs_struct *ps, int depth)
1914 {
1915         prs_debug(ps, depth, desc, "lsa_io_q_lookupprivvalue");
1916         depth++;
1917
1918         if(!prs_align(ps))
1919                 return False;
1920  
1921         if(!smb_io_pol_hnd("pol", &r_c->pol, ps, depth))
1922                 return False;
1923         if(!smb_io_unihdr ("hdr_name", &r_c->hdr_right, ps, depth))
1924                 return False;
1925         if(!smb_io_unistr2("uni2_right", &r_c->uni2_right, r_c->hdr_right.buffer, ps, depth))
1926                 return False;
1927
1928         return True;
1929 }
1930
1931 /*******************************************************************
1932  Reads or writes an  LSA_R_LOOKUPPRIVVALUE structure.
1933 ********************************************************************/
1934
1935 BOOL lsa_io_r_lookupprivvalue(char *desc, LSA_R_LOOKUPPRIVVALUE  *r_c, prs_struct *ps, int depth)
1936 {
1937         prs_debug(ps, depth, desc, "lsa_io_r_lookupprivvalue");
1938         depth++;
1939
1940         if(!prs_align(ps))
1941                 return False;
1942                 
1943         if(!lsa_io_luid("luid", &r_c->luid, ps, depth))
1944                 return False;
1945  
1946         if(!prs_ntstatus("status", ps, depth, &r_c->status))
1947                 return False;
1948
1949         return True;
1950 }