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