?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Started converion of the lsa code to canonical RPC format (as srv_reg, and
[Samba.git] / source / rpc_parse / parse_lsa.c
blob56ff2fe6b20b1c5cf530eb3827cb8d9009c86036
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 extern int DEBUGLEVEL;
27
28 static BOOL lsa_io_trans_names(char *desc, LSA_TRANS_NAME_ENUM *trn, prs_struct *ps, int depth);
29
30 /*******************************************************************
31 Inits a LSA_TRANS_NAME structure.
32 ********************************************************************/
33
34 void init_lsa_trans_name(LSA_TRANS_NAME *trn, UNISTR2 *uni_name,
35 uint16 sid_name_use, char *name, uint32 idx)
36 {
37 int len_name = strlen(name);
38
39 if(len_name == 0)
40 len_name = 1;
41
42 trn->sid_name_use = sid_name_use;
43 init_uni_hdr(&trn->hdr_name, len_name);
44 init_unistr2(uni_name, name, len_name);
45 trn->domain_idx = idx;
46 }
47
48 /*******************************************************************
49 Reads or writes a LSA_TRANS_NAME structure.
50 ********************************************************************/
51
52 static BOOL lsa_io_trans_name(char *desc, LSA_TRANS_NAME *trn, prs_struct *ps,
53 int depth)
54 {
55 prs_debug(ps, depth, desc, "lsa_io_trans_name");
56 depth++;
57
58 if(!prs_align(ps))
59 return False;
60
61 if(!prs_uint16("sid_name_use", ps, depth, &trn->sid_name_use))
62 return False;
63 if(!prs_align(ps))
64 return False;
65
66 if(!smb_io_unihdr ("hdr_name", &trn->hdr_name, ps, depth))
67 return False;
68 if(!prs_uint32("domain_idx ", ps, depth, &trn->domain_idx))
69 return False;
70
71 return True;
72 }
73
74 /*******************************************************************
75 Reads or writes a DOM_R_REF structure.
76 ********************************************************************/
77
78 static BOOL lsa_io_dom_r_ref(char *desc, DOM_R_REF *r_r, prs_struct *ps,
79 int depth)
80 {
81 int i;
82
83 prs_debug(ps, depth, desc, "lsa_io_dom_r_ref");
84 depth++;
85
86 if(!prs_align(ps))
87 return False;
88
89 if(!prs_uint32("num_ref_doms_1", ps, depth, &r_r->num_ref_doms_1)) /* num referenced domains? */
90 return False;
91 if(!prs_uint32("ptr_ref_dom ", ps, depth, &r_r->ptr_ref_dom)) /* undocumented buffer pointer. */
92 return False;
93 if(!prs_uint32("max_entries ", ps, depth, &r_r->max_entries)) /* 32 - max number of entries */
94 return False;
95
96 SMB_ASSERT_ARRAY(r_r->hdr_ref_dom, r_r->num_ref_doms_1);
97
98 if (r_r->ptr_ref_dom != 0) {
99
100 if(!prs_uint32("num_ref_doms_2", ps, depth, &r_r->num_ref_doms_2)) /* 4 - num referenced domains? */
101 return False;
102
103 SMB_ASSERT_ARRAY(r_r->ref_dom, r_r->num_ref_doms_2);
104
105 for (i = 0; i < r_r->num_ref_doms_1; i++) {
106 fstring t;
107
108 slprintf(t, sizeof(t) - 1, "dom_ref[%d] ", i);
109 if(!smb_io_unihdr(t, &r_r->hdr_ref_dom[i].hdr_dom_name, ps, depth))
110 return False;
111
112 slprintf(t, sizeof(t) - 1, "sid_ptr[%d] ", i);
113 if(!prs_uint32(t, ps, depth, &r_r->hdr_ref_dom[i].ptr_dom_sid))
114 return False;
115 }
116
117 for (i = 0; i < r_r->num_ref_doms_2; i++) {
118 fstring t;
119
120 if (r_r->hdr_ref_dom[i].hdr_dom_name.buffer != 0) {
121 slprintf(t, sizeof(t) - 1, "dom_ref[%d] ", i);
122 if(!smb_io_unistr2(t, &r_r->ref_dom[i].uni_dom_name, True, ps, depth)) /* domain name unicode string */
123 return False;
124 if(!prs_align(ps))
125 return False;
126 }
127
128 if (r_r->hdr_ref_dom[i].ptr_dom_sid != 0) {
129 slprintf(t, sizeof(t) - 1, "sid_ptr[%d] ", i);
130 if(!smb_io_dom_sid2(t, &r_r->ref_dom[i].ref_dom, ps, depth)) /* referenced domain SIDs */
131 return False;
132 }
133 }
134 }
135
136 return True;
137 }
138
139 /*******************************************************************
140 Inits an LSA_SEC_QOS structure.
141 ********************************************************************/
142
143 void init_lsa_sec_qos(LSA_SEC_QOS *qos, uint16 imp_lev, uint8 ctxt, uint8 eff,
144 uint32 unknown)
145 {
146 DEBUG(5, ("init_lsa_sec_qos\n"));
147
148 qos->len = 0x0c; /* length of quality of service block, in bytes */
149 qos->sec_imp_level = imp_lev;
150 qos->sec_ctxt_mode = ctxt;
151 qos->effective_only = eff;
152 qos->unknown = unknown;
153 }
154
155 /*******************************************************************
156 Reads or writes an LSA_SEC_QOS structure.
157 ********************************************************************/
158
159 static BOOL lsa_io_sec_qos(char *desc, LSA_SEC_QOS *qos, prs_struct *ps,
160 int depth)
161 {
162 uint32 start;
163
164 prs_debug(ps, depth, desc, "lsa_io_obj_qos");
165 depth++;
166
167 if(!prs_align(ps))
168 return False;
169
170 start = prs_offset(ps);
171
172 /* these pointers had _better_ be zero, because we don't know
173 what they point to!
174 */
175 if(!prs_uint32("len ", ps, depth, &qos->len)) /* 0x18 - length (in bytes) inc. the length field. */
176 return False;
177 if(!prs_uint16("sec_imp_level ", ps, depth, &qos->sec_imp_level ))
178 return False;
179 if(!prs_uint8 ("sec_ctxt_mode ", ps, depth, &qos->sec_ctxt_mode ))
180 return False;
181 if(!prs_uint8 ("effective_only", ps, depth, &qos->effective_only))
182 return False;
183 if(!prs_uint32("unknown ", ps, depth, &qos->unknown))
184 return False;
185
186 if (qos->len != prs_offset(ps) - start) {
187 DEBUG(3,("lsa_io_sec_qos: length %x does not match size %x\n",
188 qos->len, prs_offset(ps) - start));
189 return False;
190 }
191
192 return True;
193 }
194
195 /*******************************************************************
196 Inits an LSA_OBJ_ATTR structure.
197 ********************************************************************/
198
199 void init_lsa_obj_attr(LSA_OBJ_ATTR *attr, uint32 attributes, LSA_SEC_QOS *qos)
200 {
201 DEBUG(5, ("init_lsa_obj_attr\n"));
202
203 attr->len = 0x18; /* length of object attribute block, in bytes */
204 attr->ptr_root_dir = 0;
205 attr->ptr_obj_name = 0;
206 attr->attributes = attributes;
207 attr->ptr_sec_desc = 0;
208
209 if (qos != NULL) {
210 attr->ptr_sec_qos = 1;
211 attr->sec_qos = qos;
212 } else {
213 attr->ptr_sec_qos = 0;
214 attr->sec_qos = NULL;
215 }
216 }
217
218 /*******************************************************************
219 Reads or writes an LSA_OBJ_ATTR structure.
220 ********************************************************************/
221
222 static BOOL lsa_io_obj_attr(char *desc, LSA_OBJ_ATTR *attr, prs_struct *ps,
223 int depth)
224 {
225 uint32 start;
226
227 prs_debug(ps, depth, desc, "lsa_io_obj_attr");
228 depth++;
229
230 if(!prs_align(ps))
231 return False;
232
233 start = prs_offset(ps);
234
235 /* these pointers had _better_ be zero, because we don't know
236 what they point to!
237 */
238 if(!prs_uint32("len ", ps, depth, &attr->len)) /* 0x18 - length (in bytes) inc. the length field. */
239 return False;
240 if(!prs_uint32("ptr_root_dir", ps, depth, &attr->ptr_root_dir)) /* 0 - root directory (pointer) */
241 return False;
242 if(!prs_uint32("ptr_obj_name", ps, depth, &attr->ptr_obj_name)) /* 0 - object name (pointer) */
243 return False;
244 if(!prs_uint32("attributes ", ps, depth, &attr->attributes)) /* 0 - attributes (undocumented) */
245 return False;
246 if(!prs_uint32("ptr_sec_desc", ps, depth, &attr->ptr_sec_desc)) /* 0 - security descriptior (pointer) */
247 return False;
248 if(!prs_uint32("ptr_sec_qos ", ps, depth, &attr->ptr_sec_qos )) /* security quality of service (pointer) */
249 return False;
250
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
257 if (attr->ptr_sec_qos != 0 && attr->sec_qos != NULL) {
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 if (qos == NULL)
280 r_q->des_access = desired_access;
281
282 r_q->system_name = system_name;
283 init_lsa_obj_attr(&r_q->attr, attributes, qos);
284 }
285
286 /*******************************************************************
287 Reads or writes an LSA_Q_OPEN_POL structure.
288 ********************************************************************/
289
290 BOOL lsa_io_q_open_pol(char *desc, LSA_Q_OPEN_POL *r_q, prs_struct *ps,
291 int depth)
292 {
293 prs_debug(ps, depth, desc, "lsa_io_q_open_pol");
294 depth++;
295
296 if(!prs_uint32("ptr ", ps, depth, &r_q->ptr))
297 return False;
298 if(!prs_uint16("system_name", ps, depth, &r_q->system_name))
299 return False;
300 if(!prs_align( ps ))
301 return False;
302
303 if(!lsa_io_obj_attr("", &r_q->attr, ps, depth))
304 return False;
305
306 if (r_q->attr.ptr_sec_qos == 0) {
307 if(!prs_uint32("des_access", ps, depth, &r_q->des_access))
308 return False;
309 }
310
311 return True;
312 }
313
314 /*******************************************************************
315 Reads or writes an LSA_R_OPEN_POL structure.
316 ********************************************************************/
317
318 BOOL lsa_io_r_open_pol(char *desc, LSA_R_OPEN_POL *r_p, prs_struct *ps,
319 int depth)
320 {
321 prs_debug(ps, depth, desc, "lsa_io_r_open_pol");
322 depth++;
323
324 if(!smb_io_pol_hnd("", &r_p->pol, ps, depth))
325 return False;
326
327 if(!prs_uint32("status", ps, depth, &r_p->status))
328 return False;
329
330 return True;
331 }
332
333 /*******************************************************************
334 Inits an LSA_Q_OPEN_POL2 structure.
335 ********************************************************************/
336
337 void init_q_open_pol2(LSA_Q_OPEN_POL2 *r_q, char *server_name,
338 uint32 attributes, uint32 desired_access,
339 LSA_SEC_QOS *qos)
340 {
341 DEBUG(5, ("init_q_open_pol2: attr:%d da:%d\n", attributes,
342 desired_access));
343
344 r_q->ptr = 1; /* undocumented pointer */
345
346 if (qos == NULL)
347 r_q->des_access = desired_access;
348
349 init_unistr2(&r_q->uni_server_name, server_name,
350 strlen(server_name) + 1);
351
352 init_lsa_obj_attr(&r_q->attr, attributes, qos);
353 }
354
355 /*******************************************************************
356 Reads or writes an LSA_Q_OPEN_POL2 structure.
357 ********************************************************************/
358
359 BOOL lsa_io_q_open_pol2(char *desc, LSA_Q_OPEN_POL2 *r_q, prs_struct *ps,
360 int depth)
361 {
362 prs_debug(ps, depth, desc, "lsa_io_q_open_pol2");
363 depth++;
364
365 if(!prs_uint32("ptr ", ps, depth, &r_q->ptr))
366 return False;
367
368 if(!smb_io_unistr2 ("", &r_q->uni_server_name, r_q->ptr, ps, depth))
369 return False;
370 if(!lsa_io_obj_attr("", &r_q->attr, ps, depth))
371 return False;
372
373 if (r_q->attr.ptr_sec_qos == 0) {
374 if(!prs_uint32("des_access", ps, depth, &r_q->des_access))
375 return False;
376 }
377
378 return True;
379 }
380
381 /*******************************************************************
382 Reads or writes an LSA_R_OPEN_POL2 structure.
383 ********************************************************************/
384
385 BOOL lsa_io_r_open_pol2(char *desc, LSA_R_OPEN_POL2 *r_p, prs_struct *ps,
386 int depth)
387 {
388 prs_debug(ps, depth, desc, "lsa_io_r_open_pol2");
389 depth++;
390
391 if(!smb_io_pol_hnd("", &r_p->pol, ps, depth))
392 return False;
393
394 if(!prs_uint32("status", ps, depth, &r_p->status))
395 return False;
396
397 return True;
398 }
399
400 /*******************************************************************
401 makes an LSA_Q_QUERY_SEC_OBJ structure.
402 ********************************************************************/
403
404 void init_q_query_sec_obj(LSA_Q_QUERY_SEC_OBJ *q_q, const POLICY_HND *hnd,
405 uint32 sec_info)
406 {
407 DEBUG(5, ("init_q_query_sec_obj\n"));
408
409 q_q->pol = *hnd;
410 q_q->sec_info = sec_info;
411
412 return;
413 }
414
415 /*******************************************************************
416 Reads or writes an LSA_Q_QUERY_SEC_OBJ structure.
417 ********************************************************************/
418
419 BOOL lsa_io_q_query_sec_obj(char *desc, LSA_Q_QUERY_SEC_OBJ *q_q,
420 prs_struct *ps, int depth)
421 {
422 prs_debug(ps, depth, desc, "lsa_io_q_query_sec_obj");
423 depth++;
424
425 if (!smb_io_pol_hnd("", &q_q->pol, ps, depth))
426 return False;
427
428 if (!prs_uint32("sec_info", ps, depth, &q_q->sec_info))
429 return False;
430
431 return True;
432 }
433
434 /*******************************************************************
435 Reads or writes a LSA_R_QUERY_SEC_OBJ structure.
436 ********************************************************************/
437
438 BOOL lsa_io_r_query_sec_obj(char *desc, LSA_R_QUERY_SEC_OBJ *r_u,
439 prs_struct *ps, int depth)
440 {
441 prs_debug(ps, depth, desc, "lsa_io_r_query_sec_obj");
442 depth++;
443
444 if (!prs_align(ps))
445 return False;
446
447 if (!prs_uint32("ptr", ps, depth, &r_u->ptr))
448 return False;
449
450 if (r_u->ptr != 0) {
451 if (!sec_io_desc_buf("sec", &r_u->buf, ps, depth))
452 return False;
453 }
454
455 if (!prs_uint32("status", ps, depth, &r_u->status))
456 return False;
457
458 return True;
459 }
460
461 /*******************************************************************
462 Inits an LSA_Q_QUERY_INFO structure.
463 ********************************************************************/
464
465 void init_q_query(LSA_Q_QUERY_INFO *q_q, POLICY_HND *hnd, uint16 info_class)
466 {
467 DEBUG(5, ("init_q_query\n"));
468
469 memcpy(&q_q->pol, hnd, sizeof(q_q->pol));
470
471 q_q->info_class = info_class;
472 }
473
474 /*******************************************************************
475 Reads or writes an LSA_Q_QUERY_INFO structure.
476 ********************************************************************/
477
478 BOOL lsa_io_q_query(char *desc, LSA_Q_QUERY_INFO *q_q, prs_struct *ps,
479 int depth)
480 {
481 prs_debug(ps, depth, desc, "lsa_io_q_query");
482 depth++;
483
484 if(!smb_io_pol_hnd("", &q_q->pol, ps, depth))
485 return False;
486
487 if(!prs_uint16("info_class", ps, depth, &q_q->info_class))
488 return False;
489
490 return True;
491 }
492
493 /*******************************************************************
494 makes an LSA_Q_ENUM_TRUST_DOM structure.
495 ********************************************************************/
496 BOOL init_q_enum_trust_dom(LSA_Q_ENUM_TRUST_DOM * q_e, POLICY_HND *pol,
497 uint32 enum_context, uint32 preferred_len)
498 {
499 DEBUG(5, ("init_q_enum_trust_dom\n"));
500
501 q_e->pol = *pol;
502 q_e->enum_context = enum_context;
503 q_e->preferred_len = preferred_len;
504
505 return True;
506 }
507
508 /*******************************************************************
509 Reads or writes an LSA_Q_ENUM_TRUST_DOM structure.
510 ********************************************************************/
511
512 BOOL lsa_io_q_enum_trust_dom(char *desc, LSA_Q_ENUM_TRUST_DOM *q_e,
513 prs_struct *ps, int depth)
514 {
515 prs_debug(ps, depth, desc, "lsa_io_q_enum_trust_dom");
516 depth++;
517
518 if(!smb_io_pol_hnd("", &q_e->pol, ps, depth))
519 return False;
520
521 if(!prs_uint32("enum_context ", ps, depth, &q_e->enum_context))
522 return False;
523 if(!prs_uint32("preferred_len", ps, depth, &q_e->preferred_len))
524 return False;
525
526 return True;
527 }
528
529 /*******************************************************************
530 Inits an LSA_R_ENUM_TRUST_DOM structure.
531 ********************************************************************/
532
533 void init_r_enum_trust_dom(LSA_R_ENUM_TRUST_DOM *r_e, uint32 enum_context,
534 char *domain_name, DOM_SID *domain_sid,
535 uint32 status)
536 {
537 DEBUG(5, ("init_r_enum_trust_dom\n"));
538
539 r_e->enum_context = enum_context;
540
541 if (status == 0) {
542 int len_domain_name = strlen(domain_name) + 1;
543
544 r_e->num_domains = 1;
545 r_e->ptr_enum_domains = 1;
546 r_e->num_domains2 = 1;
547
548 if (!(r_e->hdr_domain_name = (UNIHDR2 *)
549 malloc(sizeof(UNIHDR2)))) return;
550
551 if (!(r_e->uni_domain_name = (UNISTR2 *)
552 malloc(sizeof(UNISTR2)))) return;
553
554 if (!(r_e->domain_sid = (DOM_SID2 *)
555 malloc(sizeof(DOM_SID2)))) return;
556
557 init_uni_hdr2(&r_e->hdr_domain_name[0], len_domain_name);
558 init_unistr2 (&r_e->uni_domain_name[0], domain_name,
559 len_domain_name);
560 init_dom_sid2(&r_e->domain_sid[0], domain_sid);
561 } else {
562 r_e->num_domains = 0;
563 r_e->ptr_enum_domains = 0;
564 }
565
566 r_e->status = status;
567 }
568
569 /*******************************************************************
570 Reads or writes an LSA_R_ENUM_TRUST_DOM structure.
571 ********************************************************************/
572
573 BOOL lsa_io_r_enum_trust_dom(char *desc, LSA_R_ENUM_TRUST_DOM *r_e,
574 prs_struct *ps, int depth)
575 {
576 prs_debug(ps, depth, desc, "lsa_io_r_enum_trust_dom");
577 depth++;
578
579 if(!prs_uint32("enum_context ", ps, depth, &r_e->enum_context))
580 return False;
581 if(!prs_uint32("num_domains ", ps, depth, &r_e->num_domains))
582 return False;
583 if(!prs_uint32("ptr_enum_domains", ps, depth, &r_e->ptr_enum_domains))
584 return False;
585
586 if (r_e->ptr_enum_domains) {
587 int i, num_domains;
588
589 if(!prs_uint32("num_domains2", ps, depth, &r_e->num_domains2))
590 return False;
591
592 num_domains = r_e->num_domains2;
593
594 if (UNMARSHALLING(ps)) {
595 if (!(r_e->hdr_domain_name = (UNIHDR2 *)prs_alloc_mem(ps,sizeof(UNIHDR2) * num_domains)))
596 return False;
597
598 if (!(r_e->uni_domain_name = (UNISTR2 *)prs_alloc_mem(ps,sizeof(UNISTR2) * num_domains)))
599 return False;
600
601 if (!(r_e->domain_sid = (DOM_SID2 *)prs_alloc_mem(ps,sizeof(DOM_SID2) * num_domains)))
602 return False;
603 }
604
605 for (i = 0; i < num_domains; i++) {
606 if(!smb_io_unihdr2 ("", &r_e->hdr_domain_name[i], ps,
607 depth))
608 return False;
609 }
610
611 for (i = 0; i < num_domains; i++) {
612 if(!smb_io_unistr2 ("", &r_e->uni_domain_name[i],
613 r_e->hdr_domain_name[i].buffer,
614 ps, depth))
615 return False;
616 if(!smb_io_dom_sid2("", &r_e->domain_sid[i], ps,
617 depth))
618 return False;
619 }
620 }
621
622 if(!prs_uint32("status", ps, depth, &r_e->status))
623 return False;
624
625 return True;
626 }
627
628 void lsa_free_r_enum_trust_dom(LSA_R_ENUM_TRUST_DOM * r_e)
629 {
630 safe_free(r_e->uni_domain_name);
631 safe_free(r_e->hdr_domain_name);
632 safe_free(r_e->domain_sid);
633
634 r_e->uni_domain_name = NULL;
635 r_e->hdr_domain_name = NULL;
636 r_e->domain_sid = NULL;
637
638 r_e->num_domains = 0;
639 r_e->ptr_enum_domains = 0;
640 }
641
642 /*******************************************************************
643 reads or writes a dom query structure.
644 ********************************************************************/
645
646 static BOOL lsa_io_dom_query(char *desc, DOM_QUERY *d_q, prs_struct *ps, int depth)
647 {
648 if (d_q == NULL)
649 return False;
650
651 prs_debug(ps, depth, desc, "lsa_io_dom_query");
652 depth++;
653
654 if(!prs_align(ps))
655 return False;
656
657 if(!prs_uint16("uni_dom_max_len", ps, depth, &d_q->uni_dom_max_len)) /* domain name string length * 2 */
658 return False;
659 if(!prs_uint16("uni_dom_str_len", ps, depth, &d_q->uni_dom_str_len)) /* domain name string length * 2 */
660 return False;
661
662 if(!prs_uint32("buffer_dom_name", ps, depth, &d_q->buffer_dom_name)) /* undocumented domain name string buffer pointer */
663 return False;
664 if(!prs_uint32("buffer_dom_sid ", ps, depth, &d_q->buffer_dom_sid)) /* undocumented domain SID string buffer pointer */
665 return False;
666
667 if(!smb_io_unistr2("unistr2", &d_q->uni_domain_name, d_q->buffer_dom_name, ps, depth)) /* domain name (unicode string) */
668 return False;
669
670 if(!prs_align(ps))
671 return False;
672
673 if (d_q->buffer_dom_sid != 0) {
674 if(!smb_io_dom_sid2("", &d_q->dom_sid, ps, depth)) /* domain SID */
675 return False;
676 } else {
677 memset((char *)&d_q->dom_sid, '\0', sizeof(d_q->dom_sid));
678 }
679
680 return True;
681 }
682
683 /*******************************************************************
684 reads or writes a structure.
685 ********************************************************************/
686
687 static BOOL lsa_io_dom_query_2(char *desc, DOM_QUERY_2 *d_q, prs_struct *ps, int depth)
688 {
689 uint32 ptr = 1;
690
691 if (d_q == NULL)
692 return False;
693
694 prs_debug(ps, depth, desc, "lsa_io_dom_query_2");
695 depth++;
696
697 if (!prs_align(ps))
698 return False;
699
700 if (!prs_uint32("auditing_enabled", ps, depth, &d_q->auditing_enabled))
701 return False;
702 if (!prs_uint32("ptr ", ps, depth, &ptr))
703 return False;
704 if (!prs_uint32("count1", ps, depth, &d_q->count1))
705 return False;
706 if (!prs_uint32("count2", ps, depth, &d_q->count2))
707 return False;
708
709 if (UNMARSHALLING(ps)) {
710 d_q->auditsettings = (uint32 *)talloc(ps->mem_ctx, d_q->count2 * sizeof(uint32));
711 }
712
713 if (d_q->auditsettings == NULL) {
714 DEBUG(1, ("lsa_io_dom_query_2: NULL auditsettings!\n"));
715 return False;
716 }
717
718 if (!prs_uint32s(False, "auditsettings", ps, depth, d_q->auditsettings, d_q->count2))
719 return False;
720
721 return True;
722 }
723
724 /*******************************************************************
725 Reads or writes a dom query structure.
726 ********************************************************************/
727
728 static BOOL lsa_io_dom_query_3(char *desc, DOM_QUERY_3 *d_q, prs_struct *ps, int depth)
729 {
730 return lsa_io_dom_query("", d_q, ps, depth);
731 }
732
733 /*******************************************************************
734 Reads or writes a dom query structure.
735 ********************************************************************/
736
737 BOOL lsa_io_dom_query_5(char *desc, DOM_QUERY_5 *d_q, prs_struct *ps, int depth)
738 {
739 return lsa_io_dom_query("", d_q, ps, depth);
740 }
741
742 /*******************************************************************
743 Reads or writes a dom query structure.
744 ********************************************************************/
745
746 static BOOL lsa_io_dom_query_6(char *desc, DOM_QUERY_6 *d_q, prs_struct *ps, int depth)
747 {
748 if (d_q == NULL)
749 return False;
750
751 prs_debug(ps, depth, desc, "lsa_io_dom_query_6");
752 depth++;
753
754 if (!prs_uint16("server_role", ps, depth, &d_q->server_role))
755 return False;
756
757 return True;
758 }
759
760 /*******************************************************************
761 Reads or writes an LSA_Q_QUERY_INFO structure.
762 ********************************************************************/
763
764 BOOL lsa_io_r_query(char *desc, LSA_R_QUERY_INFO *r_q, prs_struct *ps,
765 int depth)
766 {
767 prs_debug(ps, depth, desc, "lsa_io_r_query");
768 depth++;
769
770 if(!prs_uint32("undoc_buffer", ps, depth, &r_q->undoc_buffer))
771 return False;
772
773 if (r_q->undoc_buffer != 0) {
774 if(!prs_uint16("info_class", ps, depth, &r_q->info_class))
775 return False;
776
777 if(!prs_align(ps))
778 return False;
779
780 switch (r_q->info_class) {
781 case 2:
782 if(!lsa_io_dom_query_2("", &r_q->dom.id2, ps, depth))
783 return False;
784 break;
785 case 3:
786 if(!lsa_io_dom_query_3("", &r_q->dom.id3, ps, depth))
787 return False;
788 break;
789 case 5:
790 if(!lsa_io_dom_query_5("", &r_q->dom.id5, ps, depth))
791 return False;
792 break;
793 case 6:
794 if(!lsa_io_dom_query_6("", &r_q->dom.id6, ps, depth))
795 return False;
796 break;
797 default:
798 /* PANIC! */
799 break;
800 }
801 }
802
803 if(!prs_align(ps))
804 return False;
805
806 if(!prs_uint32("status", ps, depth, &r_q->status))
807 return False;
808
809 return True;
810 }
811
812 /*******************************************************************
813 Inits a LSA_SID_ENUM structure.
814 ********************************************************************/
815
816 void init_lsa_sid_enum(TALLOC_CTX *mem_ctx, LSA_SID_ENUM *sen,
817 int num_entries, DOM_SID *sids)
818 {
819 int i;
820
821 DEBUG(5, ("init_lsa_sid_enum\n"));
822
823 sen->num_entries = num_entries;
824 sen->ptr_sid_enum = (num_entries != 0);
825 sen->num_entries2 = num_entries;
826
827 /* Allocate memory for sids and sid pointers */
828
829 if (num_entries == 0) return;
830
831 if ((sen->ptr_sid = (uint32 *)talloc(mem_ctx, num_entries *
832 sizeof(uint32))) == NULL) {
833 DEBUG(3, ("init_lsa_sid_enum(): out of memory for ptr_sid\n"));
834 return;
835 }
836
837 if ((sen->sid = (DOM_SID2 *)talloc(mem_ctx, num_entries *
838 sizeof(DOM_SID2))) == NULL) {
839 DEBUG(3, ("init_lsa_sid_enum(): out of memory for sids\n"));
840 return;
841 }
842
843 /* Copy across SIDs and SID pointers */
844
845 for (i = 0; i < num_entries; i++) {
846 sen->ptr_sid[i] = 1;
847 init_dom_sid2(&sen->sid[i], &sids[i]);
848 }
849 }
850
851 /*******************************************************************
852 Reads or writes a LSA_SID_ENUM structure.
853 ********************************************************************/
854
855 static BOOL lsa_io_sid_enum(char *desc, LSA_SID_ENUM *sen, prs_struct *ps,
856 int depth)
857 {
858 int i;
859
860 prs_debug(ps, depth, desc, "lsa_io_sid_enum");
861 depth++;
862
863 if(!prs_align(ps))
864 return False;
865
866 if(!prs_uint32("num_entries ", ps, depth, &sen->num_entries))
867 return False;
868 if(!prs_uint32("ptr_sid_enum", ps, depth, &sen->ptr_sid_enum))
869 return False;
870 if(!prs_uint32("num_entries2", ps, depth, &sen->num_entries2))
871 return False;
872
873 /* Mallocate memory if we're unpacking from the wire */
874
875 if (UNMARSHALLING(ps)) {
876 if ((sen->ptr_sid = (uint32 *)prs_alloc_mem( ps,
877 sen->num_entries * sizeof(uint32))) == NULL) {
878 DEBUG(3, ("init_lsa_sid_enum(): out of memory for "
879 "ptr_sid\n"));
880 return False;
881 }
882
883 if ((sen->sid = (DOM_SID2 *)prs_alloc_mem( ps,
884 sen->num_entries * sizeof(DOM_SID2))) == NULL) {
885 DEBUG(3, ("init_lsa_sid_enum(): out of memory for "
886 "sids\n"));
887 return False;
888 }
889 }
890
891 for (i = 0; i < sen->num_entries; i++) {
892 fstring temp;
893
894 slprintf(temp, sizeof(temp) - 1, "ptr_sid[%d]", i);
895 if(!prs_uint32(temp, ps, depth, &sen->ptr_sid[i])) {
896 return False;
897 }
898 }
899
900 for (i = 0; i < sen->num_entries; i++) {
901 fstring temp;
902
903 slprintf(temp, sizeof(temp) - 1, "sid[%d]", i);
904 if(!smb_io_dom_sid2(temp, &sen->sid[i], ps, depth)) {
905 return False;
906 }
907 }
908
909 return True;
910 }
911
912 /*******************************************************************
913 Inits an LSA_R_ENUM_TRUST_DOM structure.
914 ********************************************************************/
915
916 void init_q_lookup_sids(TALLOC_CTX *mem_ctx, LSA_Q_LOOKUP_SIDS *q_l,
917 POLICY_HND *hnd, int num_sids, DOM_SID *sids,
918 uint16 level)
919 {
920 DEBUG(5, ("init_r_enum_trust_dom\n"));
921
922 ZERO_STRUCTP(q_l);
923
924 memcpy(&q_l->pol, hnd, sizeof(q_l->pol));
925 init_lsa_sid_enum(mem_ctx, &q_l->sids, num_sids, sids);
926
927 q_l->level.value = level;
928 }
929
930 /*******************************************************************
931 Reads or writes a LSA_Q_LOOKUP_SIDS structure.
932 ********************************************************************/
933
934 BOOL lsa_io_q_lookup_sids(char *desc, LSA_Q_LOOKUP_SIDS *q_s, prs_struct *ps,
935 int depth)
936 {
937 prs_debug(ps, depth, desc, "lsa_io_q_lookup_sids");
938 depth++;
939
940 if(!prs_align(ps))
941 return False;
942
943 if(!smb_io_pol_hnd("pol_hnd", &q_s->pol, ps, depth)) /* policy handle */
944 return False;
945 if(!lsa_io_sid_enum("sids ", &q_s->sids, ps, depth)) /* sids to be looked up */
946 return False;
947 if(!lsa_io_trans_names("names ", &q_s->names, ps, depth)) /* translated names */
948 return False;
949 if(!smb_io_lookup_level("switch ", &q_s->level, ps, depth)) /* lookup level */
950 return False;
951
952 if(!prs_uint32("mapped_count", ps, depth, &q_s->mapped_count))
953 return False;
954
955 return True;
956 }
957
958 /*******************************************************************
959 Reads or writes a structure.
960 ********************************************************************/
961
962 static BOOL lsa_io_trans_names(char *desc, LSA_TRANS_NAME_ENUM *trn,
963 prs_struct *ps, int depth)
964 {
965 int i;
966
967 prs_debug(ps, depth, desc, "lsa_io_trans_names");
968 depth++;
969
970 if(!prs_align(ps))
971 return False;
972
973 if(!prs_uint32("num_entries ", ps, depth, &trn->num_entries))
974 return False;
975 if(!prs_uint32("ptr_trans_names", ps, depth, &trn->ptr_trans_names))
976 return False;
977
978 if (trn->ptr_trans_names != 0) {
979 if(!prs_uint32("num_entries2 ", ps, depth,
980 &trn->num_entries2))
981 return False;
982
983 if (UNMARSHALLING(ps)) {
984 if ((trn->name = (LSA_TRANS_NAME *)
985 prs_alloc_mem(ps, trn->num_entries *
986 sizeof(LSA_TRANS_NAME))) == NULL) {
987 return False;
988 }
989
990 if ((trn->uni_name = (UNISTR2 *)
991 prs_alloc_mem(ps, trn->num_entries *
992 sizeof(UNISTR2))) == NULL) {
993 return False;
994 }
995 }
996
997 for (i = 0; i < trn->num_entries2; i++) {
998 fstring t;
999 slprintf(t, sizeof(t) - 1, "name[%d] ", i);
1000
1001 if(!lsa_io_trans_name(t, &trn->name[i], ps, depth)) /* translated name */
1002 return False;
1003 }
1004
1005 for (i = 0; i < trn->num_entries2; i++) {
1006 fstring t;
1007 slprintf(t, sizeof(t) - 1, "name[%d] ", i);
1008
1009 if(!smb_io_unistr2(t, &trn->uni_name[i], trn->name[i].hdr_name.buffer, ps, depth))
1010 return False;
1011 if(!prs_align(ps))
1012 return False;
1013 }
1014 }
1015
1016 return True;
1017 }
1018
1019 /*******************************************************************
1020 Reads or writes a structure.
1021 ********************************************************************/
1022
1023 BOOL lsa_io_r_lookup_sids(char *desc, LSA_R_LOOKUP_SIDS *r_s,
1024 prs_struct *ps, int depth)
1025 {
1026 prs_debug(ps, depth, desc, "lsa_io_r_lookup_sids");
1027 depth++;
1028
1029 if(!prs_align(ps))
1030 return False;
1031
1032 if(!prs_uint32("ptr_dom_ref", ps, depth, &r_s->ptr_dom_ref))
1033 return False;
1034
1035 if (r_s->ptr_dom_ref != 0)
1036 if(!lsa_io_dom_r_ref ("dom_ref", r_s->dom_ref, ps, depth)) /* domain reference info */
1037 return False;
1038
1039 if(!lsa_io_trans_names("names ", r_s->names, ps, depth)) /* translated names */
1040 return False;
1041
1042 if(!prs_align(ps))
1043 return False;
1044
1045 if(!prs_uint32("mapped_count", ps, depth, &r_s->mapped_count))
1046 return False;
1047
1048 if(!prs_uint32("status ", ps, depth, &r_s->status))
1049 return False;
1050
1051 return True;
1052 }
1053
1054 /*******************************************************************
1055 makes a structure.
1056 ********************************************************************/
1057
1058 void init_q_lookup_names(TALLOC_CTX *mem_ctx, LSA_Q_LOOKUP_NAMES *q_l,
1059 POLICY_HND *hnd, int num_names, char **names)
1060 {
1061 int i;
1062
1063 DEBUG(5, ("init_q_lookup_names\n"));
1064
1065 ZERO_STRUCTP(q_l);
1066
1067 q_l->pol = *hnd;
1068 q_l->num_entries = num_names;
1069 q_l->num_entries2 = num_names;
1070 q_l->lookup_level = 1;
1071
1072 if ((q_l->uni_name = (UNISTR2 *)talloc(
1073 mem_ctx, num_names * sizeof(UNISTR2))) == NULL) {
1074 DEBUG(3, ("init_q_lookup_names(): out of memory\n"));
1075 return;
1076 }
1077
1078 if ((q_l->hdr_name = (UNIHDR *)talloc(
1079 mem_ctx, num_names * sizeof(UNIHDR))) == NULL) {
1080 DEBUG(3, ("init_q_lookup_names(): out of memory\n"));
1081 return;
1082 }
1083
1084 for (i = 0; i < num_names; i++) {
1085 char* name = names[i];
1086 int len = strlen(name);
1087
1088 init_uni_hdr(&q_l->hdr_name[i], len);
1089 init_unistr2(&q_l->uni_name[i], name, len);
1090 }
1091 }
1092
1093 /*******************************************************************
1094 reads or writes a structure.
1095 ********************************************************************/
1096
1097 BOOL lsa_io_q_lookup_names(char *desc, LSA_Q_LOOKUP_NAMES *q_r,
1098 prs_struct *ps, int depth)
1099 {
1100 int i;
1101
1102 prs_debug(ps, depth, desc, "lsa_io_q_lookup_names");
1103 depth++;
1104
1105 if(!prs_align(ps))
1106 return False;
1107
1108 if(!smb_io_pol_hnd("", &q_r->pol, ps, depth)) /* policy handle */
1109 return False;
1110
1111 if(!prs_align(ps))
1112 return False;
1113 if(!prs_uint32("num_entries ", ps, depth, &q_r->num_entries))
1114 return False;
1115 if(!prs_uint32("num_entries2 ", ps, depth, &q_r->num_entries2))
1116 return False;
1117
1118 if (UNMARSHALLING(ps)) {
1119 if (q_r->num_entries) {
1120 if ((q_r->hdr_name = (UNIHDR *)prs_alloc_mem(ps,
1121 q_r->num_entries * sizeof(UNIHDR))) == NULL)
1122 return False;
1123 if ((q_r->uni_name = (UNISTR2 *)prs_alloc_mem(ps,
1124 q_r->num_entries * sizeof(UNISTR2))) == NULL)
1125 return False;
1126 }
1127 }
1128
1129 for (i = 0; i < q_r->num_entries; i++) {
1130 if(!prs_align(ps))
1131 return False;
1132 if(!smb_io_unihdr("hdr_name", &q_r->hdr_name[i], ps, depth)) /* pointer names */
1133 return False;
1134 }
1135
1136 for (i = 0; i < q_r->num_entries; i++) {
1137 if(!prs_align(ps))
1138 return False;
1139 if(!smb_io_unistr2("dom_name", &q_r->uni_name[i], q_r->hdr_name[i].buffer, ps, depth)) /* names to be looked up */
1140 return False;
1141 }
1142
1143 if(!prs_align(ps))
1144 return False;
1145 if(!prs_uint32("num_trans_entries ", ps, depth, &q_r->num_trans_entries))
1146 return False;
1147 if(!prs_uint32("ptr_trans_sids ", ps, depth, &q_r->ptr_trans_sids))
1148 return False;
1149 if(!prs_uint32("lookup_level ", ps, depth, &q_r->lookup_level))
1150 return False;
1151 if(!prs_uint32("mapped_count ", ps, depth, &q_r->mapped_count))
1152 return False;
1153
1154 return True;
1155 }
1156
1157 /*******************************************************************
1158 reads or writes a structure.
1159 ********************************************************************/
1160
1161 BOOL lsa_io_r_lookup_names(char *desc, LSA_R_LOOKUP_NAMES *r_r,
1162 prs_struct *ps, int depth)
1163 {
1164 int i;
1165
1166 prs_debug(ps, depth, desc, "lsa_io_r_lookup_names");
1167 depth++;
1168
1169 if(!prs_align(ps))
1170 return False;
1171
1172 if(!prs_uint32("ptr_dom_ref", ps, depth, &r_r->ptr_dom_ref))
1173 return False;
1174
1175 if (r_r->ptr_dom_ref != 0)
1176 if(!lsa_io_dom_r_ref("", r_r->dom_ref, ps, depth))
1177 return False;
1178
1179 if(!prs_uint32("num_entries", ps, depth, &r_r->num_entries))
1180 return False;
1181 if(!prs_uint32("ptr_entries", ps, depth, &r_r->ptr_entries))
1182 return False;
1183
1184 if (r_r->ptr_entries != 0) {
1185 if(!prs_uint32("num_entries2", ps, depth, &r_r->num_entries2))
1186 return False;
1187
1188 if (r_r->num_entries2 != r_r->num_entries) {
1189 /* RPC fault */
1190 return False;
1191 }
1192
1193 if (UNMARSHALLING(ps)) {
1194 if ((r_r->dom_rid = (DOM_RID2 *)prs_alloc_mem(ps, r_r->num_entries2 * sizeof(DOM_RID2)))
1195 == NULL) {
1196 DEBUG(3, ("lsa_io_r_lookup_names(): out of memory\n"));
1197 return False;
1198 }
1199 }
1200
1201 for (i = 0; i < r_r->num_entries2; i++)
1202 if(!smb_io_dom_rid2("", &r_r->dom_rid[i], ps, depth)) /* domain RIDs being looked up */
1203 return False;
1204 }
1205
1206 if(!prs_uint32("mapped_count", ps, depth, &r_r->mapped_count))
1207 return False;
1208
1209 if(!prs_uint32("status ", ps, depth, &r_r->status))
1210 return False;
1211
1212 return True;
1213 }
1214
1215
1216 /*******************************************************************
1217 Inits an LSA_Q_CLOSE structure.
1218 ********************************************************************/
1219
1220 void init_lsa_q_close(LSA_Q_CLOSE *q_c, POLICY_HND *hnd)
1221 {
1222 DEBUG(5, ("init_lsa_q_close\n"));
1223
1224 memcpy(&q_c->pol, hnd, sizeof(q_c->pol));
1225 }
1226
1227 /*******************************************************************
1228 Reads or writes an LSA_Q_CLOSE structure.
1229 ********************************************************************/
1230
1231 BOOL lsa_io_q_close(char *desc, LSA_Q_CLOSE *q_c, prs_struct *ps, int depth)
1232 {
1233 prs_debug(ps, depth, desc, "lsa_io_q_close");
1234 depth++;
1235
1236 if(!smb_io_pol_hnd("", &q_c->pol, ps, depth))
1237 return False;
1238
1239 return True;
1240 }
1241
1242 /*******************************************************************
1243 Reads or writes an LSA_R_CLOSE structure.
1244 ********************************************************************/
1245
1246 BOOL lsa_io_r_close(char *desc, LSA_R_CLOSE *r_c, prs_struct *ps, int depth)
1247 {
1248 prs_debug(ps, depth, desc, "lsa_io_r_close");
1249 depth++;
1250
1251 if(!smb_io_pol_hnd("", &r_c->pol, ps, depth))
1252 return False;
1253
1254 if(!prs_uint32("status", ps, depth, &r_c->status))
1255 return False;
1256
1257 return True;
1258 }
1259
1260 /*******************************************************************
1261 Reads or writes an LSA_Q_OPEN_SECRET structure.
1262 ********************************************************************/
1263
1264 BOOL lsa_io_q_open_secret(char *desc, LSA_Q_OPEN_SECRET *q_c, prs_struct *ps, int depth)
1265 {
1266 prs_debug(ps, depth, desc, "lsa_io_q_open_secret");
1267 depth++;
1268
1269 /* Don't bother to read or write at present... */
1270 return True;
1271 }
1272
1273 /*******************************************************************
1274 Reads or writes an LSA_R_OPEN_SECRET structure.
1275 ********************************************************************/
1276
1277 BOOL lsa_io_r_open_secret(char *desc, LSA_R_OPEN_SECRET *r_c, prs_struct *ps, int depth)
1278 {
1279 prs_debug(ps, depth, desc, "lsa_io_r_open_secret");
1280 depth++;
1281
1282 if(!prs_align(ps))
1283 return False;
1284
1285 if(!prs_uint32("dummy1", ps, depth, &r_c->dummy1))
1286 return False;
1287 if(!prs_uint32("dummy2", ps, depth, &r_c->dummy2))
1288 return False;
1289 if(!prs_uint32("dummy3", ps, depth, &r_c->dummy3))
1290 return False;
1291 if(!prs_uint32("dummy4", ps, depth, &r_c->dummy4))
1292 return False;
1293 if(!prs_uint32("status", ps, depth, &r_c->status))
1294 return False;
1295
1296 return True;
1297 }
Samba GIT mirror