?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
more OSF1 changes as well as changes to allow us to use the standard
[Samba/gbeck.git] / source / rpc_parse / parse_samr.c
blobab07e375f5add39060bf5e1c813d66ab2da467f5
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
25 #include "includes.h"
26
27 extern int DEBUGLEVEL;
28
29
30 /*******************************************************************
31 makes a SAMR_Q_CLOSE_HND structure.
32 ********************************************************************/
33 void make_samr_q_close_hnd(SAMR_Q_CLOSE_HND *q_c, POLICY_HND *hnd)
34 {
35 if (q_c == NULL || hnd == NULL) return;
36
37 DEBUG(5,("make_samr_q_close_hnd\n"));
38
39 memcpy(&(q_c->pol), hnd, sizeof(q_c->pol));
40 }
41
42 /*******************************************************************
43 reads or writes a structure.
44 ********************************************************************/
45 void samr_io_q_close_hnd(char *desc, SAMR_Q_CLOSE_HND *q_u, prs_struct *ps, int depth)
46 {
47 if (q_u == NULL) return;
48
49 prs_debug(ps, depth, desc, "samr_io_q_close_hnd");
50 depth++;
51
52 prs_align(ps);
53
54 smb_io_pol_hnd("pol", &(q_u->pol), ps, depth);
55 prs_align(ps);
56 }
57
58 /*******************************************************************
59 reads or writes a structure.
60 ********************************************************************/
61 void samr_io_r_close_hnd(char *desc, SAMR_R_CLOSE_HND *r_u, prs_struct *ps, int depth)
62 {
63 if (r_u == NULL) return;
64
65 prs_debug(ps, depth, desc, "samr_io_r_close_hnd");
66 depth++;
67
68 prs_align(ps);
69
70 smb_io_pol_hnd("pol", &(r_u->pol), ps, depth);
71 prs_align(ps);
72
73 prs_uint32("status", ps, depth, &(r_u->status));
74 }
75
76
77 /*******************************************************************
78 reads or writes a structure.
79 ********************************************************************/
80 void make_samr_q_open_domain(SAMR_Q_OPEN_DOMAIN *q_u,
81 POLICY_HND *connect_pol, uint32 rid,
82 DOM_SID *sid)
83 {
84 if (q_u == NULL) return;
85
86 DEBUG(5,("samr_make_q_open_domain\n"));
87
88 memcpy(&q_u->connect_pol, connect_pol, sizeof(q_u->connect_pol));
89 q_u->rid = rid;
90 make_dom_sid2(&(q_u->dom_sid), sid);
91 }
92
93 /*******************************************************************
94 reads or writes a structure.
95 ********************************************************************/
96 void samr_io_q_open_domain(char *desc, SAMR_Q_OPEN_DOMAIN *q_u, prs_struct *ps, int depth)
97 {
98 if (q_u == NULL) return;
99
100 prs_debug(ps, depth, desc, "samr_io_q_open_domain");
101 depth++;
102
103 prs_align(ps);
104
105 smb_io_pol_hnd("connect_pol", &(q_u->connect_pol), ps, depth);
106 prs_align(ps);
107
108 prs_uint32("rid", ps, depth, &(q_u->rid));
109
110 smb_io_dom_sid2("sid", &(q_u->dom_sid), ps, depth);
111 prs_align(ps);
112 }
113
114
115 /*******************************************************************
116 reads or writes a structure.
117 ********************************************************************/
118 void samr_io_r_open_domain(char *desc, SAMR_R_OPEN_DOMAIN *r_u, prs_struct *ps, int depth)
119 {
120 if (r_u == NULL) return;
121
122 prs_debug(ps, depth, desc, "samr_io_r_open_domain");
123 depth++;
124
125 prs_align(ps);
126
127 smb_io_pol_hnd("domain_pol", &(r_u->domain_pol), ps, depth);
128 prs_align(ps);
129
130 prs_uint32("status", ps, depth, &(r_u->status));
131 }
132
133 /*******************************************************************
134 reads or writes a structure.
135 ********************************************************************/
136 void make_samr_q_unknown_3(SAMR_Q_UNKNOWN_3 *q_u,
137 POLICY_HND *user_pol, uint16 switch_value)
138 {
139 if (q_u == NULL) return;
140
141 DEBUG(5,("samr_make_q_unknown_3\n"));
142
143 memcpy(&q_u->user_pol, user_pol, sizeof(q_u->user_pol));
144 q_u->switch_value = switch_value;
145 }
146
147
148 /*******************************************************************
149 reads or writes a structure.
150 ********************************************************************/
151 void samr_io_q_unknown_3(char *desc, SAMR_Q_UNKNOWN_3 *q_u, prs_struct *ps, int depth)
152 {
153 if (q_u == NULL) return;
154
155 prs_debug(ps, depth, desc, "samr_io_q_unknown_3");
156 depth++;
157
158 prs_align(ps);
159
160 smb_io_pol_hnd("user_pol", &(q_u->user_pol), ps, depth);
161 prs_align(ps);
162
163 prs_uint16("switch_value", ps, depth, &(q_u->switch_value));
164 prs_align(ps);
165 }
166
167 /*******************************************************************
168 reads or writes a structure.
169 ********************************************************************/
170 void make_samr_q_unknown_8(SAMR_Q_UNKNOWN_8 *q_u,
171 POLICY_HND *domain_pol, uint16 switch_value)
172 {
173 if (q_u == NULL) return;
174
175 DEBUG(5,("samr_make_q_unknown_8\n"));
176
177 memcpy(&q_u->domain_pol, domain_pol, sizeof(q_u->domain_pol));
178 q_u->switch_value = switch_value;
179 }
180
181 /*******************************************************************
182 reads or writes a structure.
183 ********************************************************************/
184 void samr_io_q_unknown_8(char *desc, SAMR_Q_UNKNOWN_8 *q_u, prs_struct *ps, int depth)
185 {
186 if (q_u == NULL) return;
187
188 prs_debug(ps, depth, desc, "samr_io_q_unknown_8");
189 depth++;
190
191 prs_align(ps);
192
193 smb_io_pol_hnd("domain_pol", &(q_u->domain_pol), ps, depth);
194 prs_align(ps);
195
196 prs_uint16("switch_value", ps, depth, &(q_u->switch_value));
197 prs_align(ps);
198 }
199 /*******************************************************************
200 makes a DOM_SID3 structure.
201
202 calculate length by adding up the size of the components.
203 ********************************************************************/
204 void make_dom_sid3(DOM_SID3 *sid3, uint16 unk_0, uint16 unk_1, DOM_SID *sid)
205 {
206 if (sid3 == NULL) return;
207
208 sid3->sid = *sid;
209 sid3->len = 2 + 8 + sid3->sid.num_auths * 4;
210 }
211
212 /*******************************************************************
213 reads or writes a SAM_SID3 structure.
214
215 this one's odd, because the length (in bytes) is specified at the beginning.
216 the length _includes_ the length of the length, too :-)
217
218 ********************************************************************/
219 static void sam_io_dom_sid3(char *desc, DOM_SID3 *sid3, prs_struct *ps, int depth)
220 {
221 if (sid3 == NULL) return;
222
223 prs_debug(ps, depth, desc, "sam_io_dom_sid3");
224 depth++;
225
226 prs_uint16("len", ps, depth, &(sid3->len));
227 prs_align(ps);
228 smb_io_dom_sid("", &(sid3->sid), ps, depth);
229 }
230
231 /*******************************************************************
232 makes a SAMR_R_UNKNOWN3 structure.
233
234 unknown_2 : 0x0001
235 unknown_3 : 0x8004
236
237 unknown_4,5 : 0x0000 0014
238
239 unknown_6 : 0x0002
240 unknown_7 : 0x5800 or 0x0070
241
242 ********************************************************************/
243 static void make_sam_sid_stuff(SAM_SID_STUFF *stf,
244 uint16 unknown_2, uint16 unknown_3,
245 uint32 unknown_4, uint16 unknown_6, uint16 unknown_7,
246 int num_sid3s, DOM_SID3 sid3[MAX_SAM_SIDS])
247 {
248 stf->unknown_2 = unknown_2;
249 stf->unknown_3 = unknown_3;
250
251 bzero(stf->padding1, sizeof(stf->padding1));
252
253 stf->unknown_4 = unknown_4;
254 stf->unknown_5 = unknown_4;
255
256 stf->unknown_6 = unknown_6;
257 stf->unknown_7 = unknown_7;
258
259 stf->num_sids = num_sid3s;
260
261 stf->padding2 = 0x0000;
262
263 memcpy(stf->sid, sid3, sizeof(DOM_SID3) * num_sid3s);
264 }
265
266 /*******************************************************************
267 reads or writes a SAM_SID_STUFF structure.
268 ********************************************************************/
269 static void sam_io_sid_stuff(char *desc, SAM_SID_STUFF *stf, prs_struct *ps, int depth)
270 {
271 int i;
272
273 if (stf == NULL) return;
274
275 DEBUG(5,("make_sam_sid_stuff\n"));
276
277 prs_uint16("unknown_2", ps, depth, &(stf->unknown_2));
278 prs_uint16("unknown_3", ps, depth, &(stf->unknown_3));
279
280 prs_uint8s(False, "padding1", ps, depth, stf->padding1, sizeof(stf->padding1));
281
282 prs_uint32("unknown_4", ps, depth, &(stf->unknown_4));
283 prs_uint32("unknown_5", ps, depth, &(stf->unknown_5));
284 prs_uint16("unknown_6", ps, depth, &(stf->unknown_6));
285 prs_uint16("unknown_7", ps, depth, &(stf->unknown_7));
286
287 prs_uint32("num_sids ", ps, depth, &(stf->num_sids ));
288 prs_uint16("padding2 ", ps, depth, &(stf->padding2 ));
289
290 SMB_ASSERT_ARRAY(stf->sid, stf->num_sids);
291
292 for (i = 0; i < stf->num_sids; i++)
293 {
294 sam_io_dom_sid3("", &(stf->sid[i]), ps, depth);
295 }
296 }
297
298 /*******************************************************************
299 reads or writes a SAMR_R_UNKNOWN3 structure.
300 ********************************************************************/
301 void make_samr_r_unknown_3(SAMR_R_UNKNOWN_3 *r_u,
302 uint16 unknown_2, uint16 unknown_3,
303 uint32 unknown_4, uint16 unknown_6, uint16 unknown_7,
304 int num_sid3s, DOM_SID3 sid3[MAX_SAM_SIDS],
305 uint32 status)
306 {
307 if (r_u == NULL) return;
308
309 DEBUG(5,("samr_make_r_unknown_3\n"));
310
311 r_u->ptr_0 = 0;
312 r_u->ptr_1 = 0;
313
314 if (status == 0x0)
315 {
316 r_u->ptr_0 = 1;
317 r_u->ptr_1 = 1;
318 make_sam_sid_stuff(&(r_u->sid_stuff), unknown_2, unknown_3,
319 unknown_4, unknown_6, unknown_7,
320 num_sid3s, sid3);
321 }
322
323 r_u->status = status;
324 }
325
326
327 /*******************************************************************
328 reads or writes a SAMR_R_UNKNOWN_3 structure.
329
330 this one's odd, because the daft buggers use a different mechanism
331 for writing out the array of sids. they put the number of sids in
332 only one place: they've calculated the length of each sid and jumped
333 by that amount. then, retrospectively, the length of the whole buffer
334 is put at the beginning of the data stream.
335
336 wierd.
337
338 ********************************************************************/
339 void samr_io_r_unknown_3(char *desc, SAMR_R_UNKNOWN_3 *r_u, prs_struct *ps, int depth)
340 {
341 int ptr_len0=0;
342 int ptr_len1=0;
343 int ptr_sid_stuff = 0;
344
345 if (r_u == NULL) return;
346
347 prs_debug(ps, depth, desc, "samr_io_r_unknown_3");
348 depth++;
349
350 prs_align(ps);
351
352 prs_uint32("ptr_0 ", ps, depth, &(r_u->ptr_0 ));
353
354 if (ps->io)
355 {
356 /* reading. do the length later */
357 prs_uint32("sid_stuff_len0", ps, depth, &(r_u->sid_stuff_len0));
358 }
359 else
360 {
361 /* storing */
362 ptr_len0 = ps->offset; ps->offset += 4;
363 }
364
365 if (r_u->ptr_0 != 0)
366 {
367 prs_uint32("ptr_1 ", ps, depth, &(r_u->ptr_1 ));
368 if (ps->io)
369 {
370 /* reading. do the length later */
371 prs_uint32("sid_stuff_len1", ps, depth, &(r_u->sid_stuff_len1));
372 }
373 else
374 {
375 /* storing */
376 ptr_len1 = ps->offset; ps->offset += 4;
377 }
378
379 if (r_u->ptr_1 != 0)
380 {
381 ptr_sid_stuff = ps->offset;
382 sam_io_sid_stuff("", &(r_u->sid_stuff), ps, depth);
383 }
384 }
385
386 if (!(ps->io)) /* storing not reading. do the length, now. */
387 {
388 if (ptr_sid_stuff != 0)
389 {
390 uint32 sid_stuff_len = ps->offset - ptr_sid_stuff;
391 int old_len = ps->offset;
392
393 ps->offset = ptr_len0;
394 prs_uint32("sid_stuff_len0", ps, depth, &sid_stuff_len);
395
396 ps->offset = ptr_len1;
397 prs_uint32("sid_stuff_len1", ps, depth, &sid_stuff_len);
398
399 ps->offset = old_len;
400 }
401 }
402
403 prs_uint32("status", ps, depth, &(r_u->status));
404 }
405
406 /*******************************************************************
407 reads or writes a SAM_STR1 structure.
408 ********************************************************************/
409 static void sam_io_sam_str1(char *desc, SAM_STR1 *sam, uint32 acct_buf, uint32 name_buf, uint32 desc_buf, prs_struct *ps, int depth)
410 {
411 if (sam == NULL) return;
412
413 prs_debug(ps, depth, desc, "sam_io_sam_str1");
414 depth++;
415
416 prs_align(ps);
417
418 smb_io_unistr2("unistr2", &(sam->uni_acct_name), acct_buf, ps, depth); /* account name unicode string */
419 smb_io_unistr2("unistr2", &(sam->uni_full_name), name_buf, ps, depth); /* full name unicode string */
420 smb_io_unistr2("unistr2", &(sam->uni_acct_desc), desc_buf, ps, depth); /* account description unicode string */
421 }
422
423 /*******************************************************************
424 makes a SAM_ENTRY1 structure.
425 ********************************************************************/
426 static void make_sam_entry1(SAM_ENTRY1 *sam, uint32 user_idx,
427 uint32 len_sam_name, uint32 len_sam_full, uint32 len_sam_desc,
428 uint32 rid_user, uint16 acb_info)
429 {
430 if (sam == NULL) return;
431
432 DEBUG(5,("make_sam_entry1\n"));
433
434 sam->user_idx = user_idx;
435 sam->rid_user = rid_user;
436 sam->acb_info = acb_info;
437 sam->pad = 0;
438
439 make_uni_hdr(&(sam->hdr_acct_name), len_sam_name, len_sam_name, len_sam_name != 0);
440 make_uni_hdr(&(sam->hdr_user_name), len_sam_full, len_sam_full, len_sam_full != 0);
441 make_uni_hdr(&(sam->hdr_user_desc), len_sam_desc, len_sam_desc, len_sam_desc != 0);
442 }
443
444 /*******************************************************************
445 reads or writes a SAM_ENTRY1 structure.
446 ********************************************************************/
447 static void sam_io_sam_entry1(char *desc, SAM_ENTRY1 *sam, prs_struct *ps, int depth)
448 {
449 if (sam == NULL) return;
450
451 prs_debug(ps, depth, desc, "sam_io_sam_entry1");
452 depth++;
453
454 prs_align(ps);
455
456 prs_uint32("user_idx ", ps, depth, &(sam->user_idx ));
457
458 prs_uint32("rid_user ", ps, depth, &(sam->rid_user ));
459 prs_uint16("acb_info ", ps, depth, &(sam->acb_info ));
460 prs_uint16("pad ", ps, depth, &(sam->pad ));
461
462 smb_io_unihdr("unihdr", &(sam->hdr_acct_name), ps, depth); /* account name unicode string header */
463 smb_io_unihdr("unihdr", &(sam->hdr_user_name), ps, depth); /* account name unicode string header */
464 smb_io_unihdr("unihdr", &(sam->hdr_user_desc), ps, depth); /* account name unicode string header */
465 }
466
467 /*******************************************************************
468 reads or writes a SAM_STR2 structure.
469 ********************************************************************/
470 static void sam_io_sam_str2(char *desc, SAM_STR2 *sam, uint32 acct_buf, uint32 desc_buf, prs_struct *ps, int depth)
471 {
472 if (sam == NULL) return;
473
474 prs_debug(ps, depth, desc, "sam_io_sam_str2");
475 depth++;
476
477 prs_align(ps);
478
479 smb_io_unistr2("unistr2", &(sam->uni_srv_name), acct_buf, ps, depth); /* account name unicode string */
480 smb_io_unistr2("unistr2", &(sam->uni_srv_desc), desc_buf, ps, depth); /* account description unicode string */
481 }
482
483 /*******************************************************************
484 makes a SAM_ENTRY2 structure.
485 ********************************************************************/
486 static void make_sam_entry2(SAM_ENTRY2 *sam, uint32 user_idx,
487 uint32 len_sam_name, uint32 len_sam_desc,
488 uint32 rid_user, uint16 acb_info)
489 {
490 if (sam == NULL) return;
491
492 DEBUG(5,("make_sam_entry2\n"));
493
494 sam->user_idx = user_idx;
495 sam->rid_user = rid_user;
496 sam->acb_info = acb_info;
497 sam->pad = 0;
498
499 make_uni_hdr(&(sam->hdr_srv_name), len_sam_name, len_sam_name, len_sam_name != 0);
500 make_uni_hdr(&(sam->hdr_srv_desc), len_sam_desc, len_sam_desc, len_sam_desc != 0);
501 }
502
503 /*******************************************************************
504 reads or writes a SAM_ENTRY2 structure.
505 ********************************************************************/
506 static void sam_io_sam_entry2(char *desc, SAM_ENTRY2 *sam, prs_struct *ps, int depth)
507 {
508 if (sam == NULL) return;
509
510 prs_debug(ps, depth, desc, "sam_io_sam_entry2");
511 depth++;
512
513 prs_align(ps);
514
515 prs_uint32("user_idx ", ps, depth, &(sam->user_idx ));
516
517 prs_uint32("rid_user ", ps, depth, &(sam->rid_user ));
518 prs_uint16("acb_info ", ps, depth, &(sam->acb_info ));
519 prs_uint16("pad ", ps, depth, &(sam->pad ));
520
521 smb_io_unihdr("unihdr", &(sam->hdr_srv_name), ps, depth); /* account name unicode string header */
522 smb_io_unihdr("unihdr", &(sam->hdr_srv_desc), ps, depth); /* account name unicode string header */
523 }
524
525 /*******************************************************************
526 reads or writes a SAM_STR3 structure.
527 ********************************************************************/
528 static void sam_io_sam_str3(char *desc, SAM_STR3 *sam, uint32 acct_buf, uint32 desc_buf, prs_struct *ps, int depth)
529 {
530 if (sam == NULL) return;
531
532 prs_debug(ps, depth, desc, "sam_io_sam_str3");
533 depth++;
534
535 prs_align(ps);
536
537 smb_io_unistr2("unistr2", &(sam->uni_grp_name), acct_buf, ps, depth); /* account name unicode string */
538 smb_io_unistr2("unistr2", &(sam->uni_grp_desc), desc_buf, ps, depth); /* account description unicode string */
539 }
540
541 /*******************************************************************
542 makes a SAM_ENTRY3 structure.
543 ********************************************************************/
544 static void make_sam_entry3(SAM_ENTRY3 *sam, uint32 grp_idx,
545 uint32 len_grp_name, uint32 len_grp_desc, uint32 rid_grp)
546 {
547 if (sam == NULL) return;
548
549 DEBUG(5,("make_sam_entry3\n"));
550
551 sam->grp_idx = grp_idx;
552 sam->rid_grp = rid_grp;
553 sam->attr = 0x07; /* group rid attributes - gets ignored by nt 4.0 */
554
555 make_uni_hdr(&(sam->hdr_grp_name), len_grp_name, len_grp_name, len_grp_name != 0);
556 make_uni_hdr(&(sam->hdr_grp_desc), len_grp_desc, len_grp_desc, len_grp_desc != 0);
557 }
558
559 /*******************************************************************
560 reads or writes a SAM_ENTRY3 structure.
561 ********************************************************************/
562 static void sam_io_sam_entry3(char *desc, SAM_ENTRY3 *sam, prs_struct *ps, int depth)
563 {
564 if (sam == NULL) return;
565
566 prs_debug(ps, depth, desc, "sam_io_sam_entry3");
567 depth++;
568
569 prs_align(ps);
570
571 prs_uint32("grp_idx", ps, depth, &(sam->grp_idx));
572
573 prs_uint32("rid_grp", ps, depth, &(sam->rid_grp));
574 prs_uint32("attr ", ps, depth, &(sam->attr ));
575
576 smb_io_unihdr("unihdr", &(sam->hdr_grp_name), ps, depth); /* account name unicode string header */
577 smb_io_unihdr("unihdr", &(sam->hdr_grp_desc), ps, depth); /* account name unicode string header */
578 }
579
580 /*******************************************************************
581 makes a SAM_ENTRY structure.
582 ********************************************************************/
583 static void make_sam_entry(SAM_ENTRY *sam, uint32 len_sam_name, uint32 rid)
584 {
585 if (sam == NULL) return;
586
587 DEBUG(5,("make_sam_entry\n"));
588
589 sam->rid = rid;
590 make_uni_hdr(&(sam->hdr_name), len_sam_name, len_sam_name, len_sam_name != 0);
591 }
592
593 /*******************************************************************
594 reads or writes a SAM_ENTRY structure.
595 ********************************************************************/
596 static void sam_io_sam_entry(char *desc, SAM_ENTRY *sam, prs_struct *ps, int depth)
597 {
598 if (sam == NULL) return;
599
600 prs_debug(ps, depth, desc, "sam_io_sam_entry");
601 depth++;
602
603 prs_align(ps);
604 prs_uint32("rid", ps, depth, &(sam->rid ));
605 smb_io_unihdr("unihdr", &(sam->hdr_name), ps, depth); /* account name unicode string header */
606 }
607
608
609 /*******************************************************************
610 makes a SAMR_Q_ENUM_DOM_USERS structure.
611 ********************************************************************/
612 void make_samr_q_enum_dom_users(SAMR_Q_ENUM_DOM_USERS *q_e, POLICY_HND *pol,
613 uint16 req_num_entries, uint16 unk_0,
614 uint16 acb_mask, uint16 unk_1, uint32 size)
615 {
616 if (q_e == NULL || pol == NULL) return;
617
618 DEBUG(5,("make_q_enum_dom_users\n"));
619
620 memcpy(&(q_e->pol), pol, sizeof(*pol));
621
622 q_e->req_num_entries = req_num_entries; /* zero indicates lots */
623 q_e->unknown_0 = unk_0; /* this gets returned in the response */
624 q_e->acb_mask = acb_mask;
625 q_e->unknown_1 = unk_1;
626 q_e->max_size = size;
627 }
628
629 /*******************************************************************
630 reads or writes a structure.
631 ********************************************************************/
632 void samr_io_q_enum_dom_users(char *desc, SAMR_Q_ENUM_DOM_USERS *q_e, prs_struct *ps, int depth)
633 {
634 if (q_e == NULL) return;
635
636 prs_debug(ps, depth, desc, "samr_io_q_enum_dom_users");
637 depth++;
638
639 prs_align(ps);
640
641 smb_io_pol_hnd("pol", &(q_e->pol), ps, depth);
642 prs_align(ps);
643
644 prs_uint16("req_num_entries", ps, depth, &(q_e->req_num_entries));
645 prs_uint16("unknown_0 ", ps, depth, &(q_e->unknown_0 ));
646
647 prs_uint16("acb_mask ", ps, depth, &(q_e->acb_mask ));
648 prs_uint16("unknown_1 ", ps, depth, &(q_e->unknown_1 ));
649
650 prs_uint32("max_size ", ps, depth, &(q_e->max_size ));
651
652 prs_align(ps);
653 }
654
655
656 /*******************************************************************
657 makes a SAMR_R_ENUM_DOM_USERS structure.
658 ********************************************************************/
659 void make_samr_r_enum_dom_users(SAMR_R_ENUM_DOM_USERS *r_u,
660 uint16 total_num_entries, uint16 unk_0,
661 uint32 num_sam_entries, SAM_USER_INFO_21 pass[MAX_SAM_ENTRIES], uint32 status)
662 {
663 int i;
664
665 if (r_u == NULL) return;
666
667 DEBUG(5,("make_samr_r_enum_dom_users\n"));
668
669 if (num_sam_entries >= MAX_SAM_ENTRIES)
670 {
671 num_sam_entries = MAX_SAM_ENTRIES;
672 DEBUG(5,("limiting number of entries to %d\n",
673 num_sam_entries));
674 }
675
676 r_u->total_num_entries = total_num_entries;
677 r_u->unknown_0 = unk_0;
678
679 if (total_num_entries > 0)
680 {
681 r_u->ptr_entries1 = 1;
682 r_u->ptr_entries2 = 1;
683 r_u->num_entries2 = num_sam_entries;
684 r_u->num_entries3 = num_sam_entries;
685
686 SMB_ASSERT_ARRAY(r_u->sam, num_sam_entries);
687 SMB_ASSERT_ARRAY(r_u->uni_acct_name, num_sam_entries);
688
689 for (i = 0; i < num_sam_entries; i++)
690 {
691 make_sam_entry(&(r_u->sam[i]),
692 pass[i].uni_user_name.uni_str_len,
693 pass[i].user_rid);
694
695 copy_unistr2(&(r_u->uni_acct_name[i]), &(pass[i].uni_user_name));
696 }
697
698 r_u->num_entries4 = num_sam_entries;
699 }
700 else
701 {
702 r_u->ptr_entries1 = 0;
703 r_u->num_entries2 = num_sam_entries;
704 r_u->ptr_entries2 = 1;
705 }
706
707 r_u->status = status;
708 }
709
710 /*******************************************************************
711 reads or writes a structure.
712 ********************************************************************/
713 void samr_io_r_enum_dom_users(char *desc, SAMR_R_ENUM_DOM_USERS *r_u, prs_struct *ps, int depth)
714 {
715 int i;
716
717 if (r_u == NULL) return;
718
719 prs_debug(ps, depth, desc, "samr_io_r_enum_dom_users");
720 depth++;
721
722 prs_align(ps);
723
724 prs_uint16("total_num_entries", ps, depth, &(r_u->total_num_entries));
725 prs_uint16("unknown_0 ", ps, depth, &(r_u->unknown_0 ));
726 prs_uint32("ptr_entries1", ps, depth, &(r_u->ptr_entries1));
727
728 if (r_u->total_num_entries != 0 && r_u->ptr_entries1 != 0)
729 {
730 prs_uint32("num_entries2", ps, depth, &(r_u->num_entries2));
731 prs_uint32("ptr_entries2", ps, depth, &(r_u->ptr_entries2));
732 prs_uint32("num_entries3", ps, depth, &(r_u->num_entries3));
733
734 SMB_ASSERT_ARRAY(r_u->sam, r_u->num_entries2);
735
736 for (i = 0; i < r_u->num_entries2; i++)
737 {
738 prs_grow(ps);
739 sam_io_sam_entry("", &(r_u->sam[i]), ps, depth);
740 }
741
742 SMB_ASSERT_ARRAY(r_u->uni_acct_name, r_u->num_entries2);
743
744 for (i = 0; i < r_u->num_entries2; i++)
745 {
746 prs_grow(ps);
747 smb_io_unistr2("", &(r_u->uni_acct_name[i]), r_u->sam[i].hdr_name.buffer, ps, depth);
748 }
749
750 prs_align(ps);
751
752 prs_uint32("num_entries4", ps, depth, &(r_u->num_entries4));
753 }
754
755 prs_uint32("status", ps, depth, &(r_u->status));
756 }
757
758 /*******************************************************************
759 makes a SAMR_Q_ENUM_DOM_ALIASES structure.
760 ********************************************************************/
761 void make_samr_q_enum_dom_aliases(SAMR_Q_ENUM_DOM_ALIASES *q_e, POLICY_HND *pol, uint32 size)
762 {
763 if (q_e == NULL || pol == NULL) return;
764
765 DEBUG(5,("make_q_enum_dom_aliases\n"));
766
767 memcpy(&(q_e->pol), pol, sizeof(*pol));
768
769 q_e->unknown_0 = 0;
770 q_e->max_size = size;
771 }
772
773
774 /*******************************************************************
775 reads or writes a structure.
776 ********************************************************************/
777 void samr_io_q_enum_dom_aliases(char *desc, SAMR_Q_ENUM_DOM_ALIASES *q_e, prs_struct *ps, int depth)
778 {
779 if (q_e == NULL) return;
780
781 prs_debug(ps, depth, desc, "samr_io_q_enum_dom_aliases");
782 depth++;
783
784 prs_align(ps);
785
786 smb_io_pol_hnd("pol", &(q_e->pol), ps, depth);
787 prs_align(ps);
788
789 prs_uint32("unknown_0", ps, depth, &(q_e->unknown_0));
790 prs_uint32("max_size ", ps, depth, &(q_e->max_size ));
791
792 prs_align(ps);
793 }
794
795
796 /*******************************************************************
797 makes a SAMR_R_ENUM_DOM_ALIASES structure.
798 ********************************************************************/
799 void make_samr_r_enum_dom_aliases(SAMR_R_ENUM_DOM_ALIASES *r_u,
800 uint32 num_sam_entries, SAM_USER_INFO_21 grps[MAX_SAM_ENTRIES],
801 uint32 status)
802 {
803 int i;
804
805 if (r_u == NULL) return;
806
807 DEBUG(5,("make_samr_r_enum_dom_aliases\n"));
808
809 if (num_sam_entries >= MAX_SAM_ENTRIES)
810 {
811 num_sam_entries = MAX_SAM_ENTRIES;
812 DEBUG(5,("limiting number of entries to %d\n",
813 num_sam_entries));
814 }
815
816 r_u->num_entries = num_sam_entries;
817
818 if (num_sam_entries > 0)
819 {
820 r_u->ptr_entries = 1;
821 r_u->num_entries2 = num_sam_entries;
822 r_u->ptr_entries2 = 1;
823 r_u->num_entries3 = num_sam_entries;
824
825 SMB_ASSERT_ARRAY(r_u->sam, num_sam_entries);
826
827 for (i = 0; i < num_sam_entries; i++)
828 {
829 make_sam_entry(&(r_u->sam[i]),
830 grps[i].uni_user_name.uni_str_len,
831 grps[i].user_rid);
832
833 copy_unistr2(&(r_u->uni_grp_name[i]), &(grps[i].uni_user_name));
834 }
835
836 r_u->num_entries4 = num_sam_entries;
837 }
838 else
839 {
840 r_u->ptr_entries = 0;
841 }
842
843 r_u->status = status;
844 }
845
846 /*******************************************************************
847 reads or writes a structure.
848 ********************************************************************/
849 void samr_io_r_enum_dom_aliases(char *desc, SAMR_R_ENUM_DOM_ALIASES *r_u, prs_struct *ps, int depth)
850 {
851 int i;
852
853 if (r_u == NULL) return;
854
855 prs_debug(ps, depth, desc, "samr_io_r_enum_dom_aliases");
856 depth++;
857
858 prs_align(ps);
859
860 prs_uint32("num_entries", ps, depth, &(r_u->num_entries));
861 prs_uint32("ptr_entries", ps, depth, &(r_u->ptr_entries));
862
863 if (r_u->num_entries != 0 && r_u->ptr_entries != 0)
864 {
865 prs_uint32("num_entries2", ps, depth, &(r_u->num_entries2));
866 prs_uint32("ptr_entries2", ps, depth, &(r_u->ptr_entries2));
867 prs_uint32("num_entries3", ps, depth, &(r_u->num_entries3));
868
869 SMB_ASSERT_ARRAY(r_u->sam, r_u->num_entries);
870
871 for (i = 0; i < r_u->num_entries; i++)
872 {
873 sam_io_sam_entry("", &(r_u->sam[i]), ps, depth);
874 }
875
876 for (i = 0; i < r_u->num_entries; i++)
877 {
878 smb_io_unistr2("", &(r_u->uni_grp_name[i]), r_u->sam[i].hdr_name.buffer, ps, depth);
879 }
880
881 prs_align(ps);
882
883 prs_uint32("num_entries4", ps, depth, &(r_u->num_entries4));
884 }
885
886 prs_uint32("status", ps, depth, &(r_u->status));
887 }
888
889
890 /*******************************************************************
891 makes a SAMR_Q_QUERY_DISPINFO structure.
892 ********************************************************************/
893 void make_samr_q_query_dispinfo(SAMR_Q_QUERY_DISPINFO *q_e, POLICY_HND *pol,
894 uint16 switch_level, uint32 start_idx, uint32 size)
895 {
896 if (q_e == NULL || pol == NULL) return;
897
898 DEBUG(5,("make_q_query_dispinfo\n"));
899
900 memcpy(&(q_e->pol), pol, sizeof(*pol));
901
902 q_e->switch_level = switch_level;
903
904 q_e->unknown_0 = 0;
905 q_e->start_idx = start_idx;
906 q_e->unknown_1 = 0x000007d0;
907 q_e->max_size = size;
908 }
909
910 /*******************************************************************
911 reads or writes a structure.
912 ********************************************************************/
913 void samr_io_q_query_dispinfo(char *desc, SAMR_Q_QUERY_DISPINFO *q_e, prs_struct *ps, int depth)
914 {
915 if (q_e == NULL) return;
916
917 prs_debug(ps, depth, desc, "samr_io_q_query_dispinfo");
918 depth++;
919
920 prs_align(ps);
921
922 smb_io_pol_hnd("pol", &(q_e->pol), ps, depth);
923 prs_align(ps);
924
925 prs_uint16("switch_level", ps, depth, &(q_e->switch_level));
926 prs_uint16("unknown_0 ", ps, depth, &(q_e->unknown_0 ));
927 prs_uint32("start_idx ", ps, depth, &(q_e->start_idx ));
928 prs_uint32("unknown_1 ", ps, depth, &(q_e->unknown_1 ));
929 prs_uint32("max_size ", ps, depth, &(q_e->max_size ));
930
931 prs_align(ps);
932 }
933
934
935 /*******************************************************************
936 makes a SAM_INFO_2 structure.
937 ********************************************************************/
938 void make_sam_info_2(SAM_INFO_2 *sam, uint32 acb_mask,
939 uint32 start_idx, uint32 num_sam_entries,
940 SAM_USER_INFO_21 pass[MAX_SAM_ENTRIES])
941 {
942 int i;
943 int entries_added;
944
945 if (sam == NULL) return;
946
947 DEBUG(5,("make_sam_info_2\n"));
948
949 if (num_sam_entries >= MAX_SAM_ENTRIES)
950 {
951 num_sam_entries = MAX_SAM_ENTRIES;
952 DEBUG(5,("limiting number of entries to %d\n",
953 num_sam_entries));
954 }
955
956 for (i = start_idx, entries_added = 0; i < num_sam_entries; i++)
957 {
958 if (IS_BITS_SET_ALL(pass[i].acb_info, acb_mask))
959 {
960 make_sam_entry2(&(sam->sam[entries_added]),
961 start_idx + entries_added + 1,
962 pass[i].uni_user_name.uni_str_len,
963 pass[i].uni_acct_desc.uni_str_len,
964 pass[i].user_rid,
965 pass[i].acb_info);
966
967 copy_unistr2(&(sam->str[entries_added].uni_srv_name), &(pass[i].uni_user_name));
968 copy_unistr2(&(sam->str[entries_added].uni_srv_desc), &(pass[i].uni_acct_desc));
969
970 entries_added++;
971 }
972
973 sam->num_entries = entries_added;
974 sam->ptr_entries = 1;
975 sam->num_entries2 = entries_added;
976 }
977 }
978
979 /*******************************************************************
980 reads or writes a structure.
981 ********************************************************************/
982 static void sam_io_sam_info_2(char *desc, SAM_INFO_2 *sam, prs_struct *ps, int depth)
983 {
984 int i;
985
986 if (sam == NULL) return;
987
988 prs_debug(ps, depth, desc, "sam_io_sam_info_2");
989 depth++;
990
991 prs_align(ps);
992
993 prs_uint32("num_entries ", ps, depth, &(sam->num_entries ));
994 prs_uint32("ptr_entries ", ps, depth, &(sam->ptr_entries ));
995
996 prs_uint32("num_entries2 ", ps, depth, &(sam->num_entries2 ));
997
998 SMB_ASSERT_ARRAY(sam->sam, sam->num_entries);
999
1000 for (i = 0; i < sam->num_entries; i++)
1001 {
1002 sam_io_sam_entry2("", &(sam->sam[i]), ps, depth);
1003 }
1004
1005 for (i = 0; i < sam->num_entries; i++)
1006 {
1007 sam_io_sam_str2 ("", &(sam->str[i]),
1008 sam->sam[i].hdr_srv_name.buffer,
1009 sam->sam[i].hdr_srv_desc.buffer,
1010 ps, depth);
1011 }
1012 }
1013
1014
1015 /*******************************************************************
1016 makes a SAM_INFO_1 structure.
1017 ********************************************************************/
1018 void make_sam_info_1(SAM_INFO_1 *sam, uint32 acb_mask,
1019 uint32 start_idx, uint32 num_sam_entries,
1020 SAM_USER_INFO_21 pass[MAX_SAM_ENTRIES])
1021 {
1022 int i;
1023 int entries_added;
1024
1025 if (sam == NULL) return;
1026
1027 DEBUG(5,("make_sam_info_1\n"));
1028
1029 if (num_sam_entries >= MAX_SAM_ENTRIES)
1030 {
1031 num_sam_entries = MAX_SAM_ENTRIES;
1032 DEBUG(5,("limiting number of entries to %d\n",
1033 num_sam_entries));
1034 }
1035
1036 for (i = start_idx, entries_added = 0; i < num_sam_entries; i++)
1037 {
1038 if (IS_BITS_SET_ALL(pass[i].acb_info, acb_mask))
1039 {
1040 make_sam_entry1(&(sam->sam[entries_added]),
1041 start_idx + entries_added + 1,
1042 pass[i].uni_user_name.uni_str_len,
1043 pass[i].uni_full_name.uni_str_len,
1044 pass[i].uni_acct_desc.uni_str_len,
1045 pass[i].user_rid,
1046 pass[i].acb_info);
1047
1048 copy_unistr2(&(sam->str[entries_added].uni_acct_name), &(pass[i].uni_user_name));
1049 copy_unistr2(&(sam->str[entries_added].uni_full_name), &(pass[i].uni_full_name));
1050 copy_unistr2(&(sam->str[entries_added].uni_acct_desc), &(pass[i].uni_acct_desc));
1051
1052 entries_added++;
1053 }
1054 }
1055
1056 sam->num_entries = entries_added;
1057 sam->ptr_entries = 1;
1058 sam->num_entries2 = entries_added;
1059 }
1060
1061
1062 /*******************************************************************
1063 reads or writes a structure.
1064 ********************************************************************/
1065 static void sam_io_sam_info_1(char *desc, SAM_INFO_1 *sam, prs_struct *ps, int depth)
1066 {
1067 int i;
1068
1069 if (sam == NULL) return;
1070
1071 prs_debug(ps, depth, desc, "sam_io_sam_info_1");
1072 depth++;
1073
1074 prs_align(ps);
1075
1076 prs_uint32("num_entries ", ps, depth, &(sam->num_entries ));
1077 prs_uint32("ptr_entries ", ps, depth, &(sam->ptr_entries ));
1078
1079 prs_uint32("num_entries2 ", ps, depth, &(sam->num_entries2 ));
1080
1081 SMB_ASSERT_ARRAY(sam->sam, sam->num_entries);
1082
1083 for (i = 0; i < sam->num_entries; i++)
1084 {
1085 sam_io_sam_entry1("", &(sam->sam[i]), ps, depth);
1086 }
1087
1088 for (i = 0; i < sam->num_entries; i++)
1089 {
1090 sam_io_sam_str1 ("", &(sam->str[i]),
1091 sam->sam[i].hdr_acct_name.buffer,
1092 sam->sam[i].hdr_user_name.buffer,
1093 sam->sam[i].hdr_user_desc.buffer,
1094 ps, depth);
1095 }
1096 }
1097
1098
1099 /*******************************************************************
1100 makes a SAMR_R_QUERY_DISPINFO structure.
1101 ********************************************************************/
1102 void make_samr_r_query_dispinfo(SAMR_R_QUERY_DISPINFO *r_u,
1103 uint16 switch_level, SAM_INFO_CTR *ctr, uint32 status)
1104 {
1105 if (r_u == NULL) return;
1106
1107 DEBUG(5,("make_samr_r_query_dispinfo\n"));
1108
1109 if (status == 0x0)
1110 {
1111 r_u->unknown_0 = 0x0000001;
1112 r_u->unknown_1 = 0x0000001;
1113 }
1114 else
1115 {
1116 r_u->unknown_0 = 0x0;
1117 r_u->unknown_1 = 0x0;
1118 }
1119
1120 r_u->switch_level = switch_level;
1121 r_u->ctr = ctr;
1122 r_u->status = status;
1123 }
1124
1125
1126 /*******************************************************************
1127 reads or writes a structure.
1128 ********************************************************************/
1129 void samr_io_r_query_dispinfo(char *desc, SAMR_R_QUERY_DISPINFO *r_u, prs_struct *ps, int depth)
1130 {
1131 if (r_u == NULL) return;
1132
1133 prs_debug(ps, depth, desc, "samr_io_r_query_dispinfo");
1134 depth++;
1135
1136 prs_align(ps);
1137
1138 prs_uint32("unknown_0 ", ps, depth, &(r_u->unknown_0 ));
1139 prs_uint32("unknown_1 ", ps, depth, &(r_u->unknown_1 ));
1140 prs_uint16("switch_level ", ps, depth, &(r_u->switch_level ));
1141
1142 prs_align(ps);
1143
1144 switch (r_u->switch_level)
1145 {
1146 case 0x1:
1147 {
1148 sam_io_sam_info_1("users", r_u->ctr->sam.info1, ps, depth);
1149 break;
1150 }
1151 case 0x2:
1152 {
1153 sam_io_sam_info_2("servers", r_u->ctr->sam.info2, ps, depth);
1154 break;
1155 }
1156 default:
1157 {
1158 DEBUG(5,("samr_io_r_query_dispinfo: unknown switch value\n"));
1159 break;
1160 }
1161 }
1162
1163 prs_uint32("status", ps, depth, &(r_u->status));
1164 }
1165
1166
1167 /*******************************************************************
1168 makes a SAMR_Q_ENUM_DOM_GROUPS structure.
1169 ********************************************************************/
1170 void make_samr_q_enum_dom_groups(SAMR_Q_ENUM_DOM_GROUPS *q_e, POLICY_HND *pol,
1171 uint16 switch_level, uint32 start_idx, uint32 size)
1172 {
1173 if (q_e == NULL || pol == NULL) return;
1174
1175 DEBUG(5,("make_q_enum_dom_groups\n"));
1176
1177 memcpy(&(q_e->pol), pol, sizeof(*pol));
1178
1179 q_e->switch_level = switch_level;
1180
1181 q_e->unknown_0 = 0;
1182 q_e->start_idx = start_idx;
1183 q_e->unknown_1 = 0x000007d0;
1184 q_e->max_size = size;
1185 }
1186
1187
1188 /*******************************************************************
1189 reads or writes a structure.
1190 ********************************************************************/
1191 void samr_io_q_enum_dom_groups(char *desc, SAMR_Q_ENUM_DOM_GROUPS *q_e, prs_struct *ps, int depth)
1192 {
1193 if (q_e == NULL) return;
1194
1195 prs_debug(ps, depth, desc, "samr_io_q_enum_dom_groups");
1196 depth++;
1197
1198 prs_align(ps);
1199
1200 smb_io_pol_hnd("pol", &(q_e->pol), ps, depth);
1201 prs_align(ps);
1202
1203 prs_uint16("switch_level", ps, depth, &(q_e->switch_level));
1204 prs_uint16("unknown_0 ", ps, depth, &(q_e->unknown_0 ));
1205 prs_uint32("start_idx ", ps, depth, &(q_e->start_idx ));
1206 prs_uint32("unknown_1 ", ps, depth, &(q_e->unknown_1 ));
1207 prs_uint32("max_size ", ps, depth, &(q_e->max_size ));
1208
1209 prs_align(ps);
1210 }
1211
1212
1213 /*******************************************************************
1214 makes a SAMR_R_ENUM_DOM_GROUPS structure.
1215 ********************************************************************/
1216 void make_samr_r_enum_dom_groups(SAMR_R_ENUM_DOM_GROUPS *r_u,
1217 uint32 start_idx, uint32 num_sam_entries,
1218 SAM_USER_INFO_21 pass[MAX_SAM_ENTRIES],
1219 uint32 status)
1220 {
1221 int i;
1222 int entries_added;
1223
1224 if (r_u == NULL) return;
1225
1226 DEBUG(5,("make_samr_r_enum_dom_groups\n"));
1227
1228 if (num_sam_entries >= MAX_SAM_ENTRIES)
1229 {
1230 num_sam_entries = MAX_SAM_ENTRIES;
1231 DEBUG(5,("limiting number of entries to %d\n",
1232 num_sam_entries));
1233 }
1234
1235 if (status == 0x0)
1236 {
1237 for (i = start_idx, entries_added = 0; i < num_sam_entries; i++)
1238 {
1239 make_sam_entry3(&(r_u->sam[entries_added]),
1240 start_idx + entries_added + 1,
1241 pass[i].uni_user_name.uni_str_len,
1242 pass[i].uni_acct_desc.uni_str_len,
1243 pass[i].user_rid);
1244
1245 copy_unistr2(&(r_u->str[entries_added].uni_grp_name), &(pass[i].uni_user_name));
1246 copy_unistr2(&(r_u->str[entries_added].uni_grp_desc), &(pass[i].uni_acct_desc));
1247
1248 entries_added++;
1249 }
1250
1251 if (entries_added > 0)
1252 {
1253 r_u->unknown_0 = 0x0000492;
1254 r_u->unknown_1 = 0x000049a;
1255 }
1256 else
1257 {
1258 r_u->unknown_0 = 0x0;
1259 r_u->unknown_1 = 0x0;
1260 }
1261 r_u->switch_level = 3;
1262 r_u->num_entries = entries_added;
1263 r_u->ptr_entries = 1;
1264 r_u->num_entries2 = entries_added;
1265 }
1266 else
1267 {
1268 r_u->switch_level = 0;
1269 }
1270
1271 r_u->status = status;
1272 }
1273
1274 /*******************************************************************
1275 reads or writes a structure.
1276 ********************************************************************/
1277 void samr_io_r_enum_dom_groups(char *desc, SAMR_R_ENUM_DOM_GROUPS *r_u, prs_struct *ps, int depth)
1278 {
1279 int i;
1280
1281 if (r_u == NULL) return;
1282
1283 prs_debug(ps, depth, desc, "samr_io_r_enum_dom_groups");
1284 depth++;
1285
1286 prs_align(ps);
1287
1288 prs_uint32("unknown_0 ", ps, depth, &(r_u->unknown_0 ));
1289 prs_uint32("unknown_1 ", ps, depth, &(r_u->unknown_1 ));
1290 prs_uint32("switch_level ", ps, depth, &(r_u->switch_level ));
1291
1292 if (r_u->switch_level != 0)
1293 {
1294 prs_uint32("num_entries ", ps, depth, &(r_u->num_entries ));
1295 prs_uint32("ptr_entries ", ps, depth, &(r_u->ptr_entries ));
1296
1297 prs_uint32("num_entries2 ", ps, depth, &(r_u->num_entries2 ));
1298
1299 SMB_ASSERT_ARRAY(r_u->sam, r_u->num_entries);
1300
1301 for (i = 0; i < r_u->num_entries; i++)
1302 {
1303 sam_io_sam_entry3("", &(r_u->sam[i]), ps, depth);
1304 }
1305
1306 for (i = 0; i < r_u->num_entries; i++)
1307 {
1308 sam_io_sam_str3 ("", &(r_u->str[i]),
1309 r_u->sam[i].hdr_grp_name.buffer,
1310 r_u->sam[i].hdr_grp_desc.buffer,
1311 ps, depth);
1312 }
1313 }
1314
1315 prs_uint32("status", ps, depth, &(r_u->status));
1316 }
1317
1318
1319 /*******************************************************************
1320 makes a SAMR_Q_QUERY_ALIASINFO structure.
1321 ********************************************************************/
1322 void make_samr_q_query_aliasinfo(SAMR_Q_QUERY_ALIASINFO *q_e,
1323 POLICY_HND *pol,
1324 uint16 switch_level)
1325 {
1326 if (q_e == NULL || pol == NULL) return;
1327
1328 DEBUG(5,("make_q_query_aliasinfo\n"));
1329
1330 memcpy(&(q_e->pol), pol, sizeof(*pol));
1331
1332 q_e->switch_level = switch_level;
1333 }
1334
1335
1336 /*******************************************************************
1337 reads or writes a structure.
1338 ********************************************************************/
1339 void samr_io_q_query_aliasinfo(char *desc, SAMR_Q_QUERY_ALIASINFO *q_e, prs_struct *ps, int depth)
1340 {
1341 if (q_e == NULL) return;
1342
1343 prs_debug(ps, depth, desc, "samr_io_q_query_aliasinfo");
1344 depth++;
1345
1346 prs_align(ps);
1347
1348 smb_io_pol_hnd("pol", &(q_e->pol), ps, depth);
1349 prs_align(ps);
1350
1351 prs_uint16("switch_level", ps, depth, &(q_e->switch_level));
1352 }
1353
1354
1355 /*******************************************************************
1356 makes a SAMR_R_QUERY_ALIASINFO structure.
1357 ********************************************************************/
1358 void make_samr_r_query_aliasinfo(SAMR_R_QUERY_ALIASINFO *r_u,
1359 uint16 switch_value, char *acct_desc,
1360 uint32 status)
1361 {
1362 if (r_u == NULL) return;
1363
1364 DEBUG(5,("make_samr_r_query_aliasinfo\n"));
1365
1366 r_u->ptr = 0;
1367
1368 if (status == 0)
1369 {
1370 r_u->switch_value = switch_value;
1371
1372 switch (switch_value)
1373 {
1374 case 3:
1375 {
1376 int acct_len = acct_desc ? strlen(acct_desc) : 0;
1377
1378 r_u->ptr = 1;
1379
1380 make_uni_hdr(&(r_u->alias.info3.hdr_acct_desc), acct_len , acct_len, acct_desc ? 1 : 0);
1381 make_unistr2(&(r_u->alias.info3.uni_acct_desc), acct_desc, acct_len);
1382
1383 break;
1384 }
1385
1386 default:
1387 {
1388 DEBUG(4,("make_samr_r_query_aliasinfo: unsupported switch level\n"));
1389 break;
1390 }
1391 }
1392 }
1393
1394 r_u->status = status;
1395 }
1396
1397
1398 /*******************************************************************
1399 reads or writes a structure.
1400 ********************************************************************/
1401 void samr_io_r_query_aliasinfo(char *desc, SAMR_R_QUERY_ALIASINFO *r_u, prs_struct *ps, int depth)
1402 {
1403 if (r_u == NULL) return;
1404
1405 prs_debug(ps, depth, desc, "samr_io_r_query_aliasinfo");
1406 depth++;
1407
1408 prs_align(ps);
1409
1410 prs_uint32("ptr ", ps, depth, &(r_u->ptr ));
1411
1412 if (r_u->ptr != 0)
1413 {
1414 prs_uint16("switch_value", ps, depth, &(r_u->switch_value));
1415 prs_align(ps);
1416
1417 if (r_u->switch_value != 0)
1418 {
1419 switch (r_u->switch_value)
1420 {
1421 case 3:
1422 {
1423 smb_io_unihdr ("", &(r_u->alias.info3.hdr_acct_desc), ps, depth);
1424 smb_io_unistr2("", &(r_u->alias.info3.uni_acct_desc), r_u->alias.info3.hdr_acct_desc.buffer, ps, depth);
1425 break;
1426 }
1427 default:
1428 {
1429 DEBUG(4,("samr_io_r_query_aliasinfo: unsupported switch level\n"));
1430 break;
1431 }
1432 }
1433 }
1434 }
1435
1436 prs_align(ps);
1437
1438 prs_uint32("status", ps, depth, &(r_u->status));
1439 }
1440
1441 /*******************************************************************
1442 reads or writes a SAMR_Q_LOOKUP_IDS structure.
1443 ********************************************************************/
1444 void samr_io_q_lookup_ids(char *desc, SAMR_Q_LOOKUP_IDS *q_u, prs_struct *ps, int depth)
1445 {
1446 fstring tmp;
1447 int i;
1448
1449 if (q_u == NULL) return;
1450
1451 prs_debug(ps, depth, desc, "samr_io_q_lookup_ids");
1452 depth++;
1453
1454 prs_align(ps);
1455
1456 smb_io_pol_hnd("pol", &(q_u->pol), ps, depth);
1457 prs_align(ps);
1458
1459 prs_uint32("num_sids1", ps, depth, &(q_u->num_sids1));
1460 prs_uint32("ptr ", ps, depth, &(q_u->ptr ));
1461 prs_uint32("num_sids2", ps, depth, &(q_u->num_sids2));
1462
1463 SMB_ASSERT_ARRAY(q_u->ptr_sid, q_u->num_sids2);
1464
1465 for (i = 0; i < q_u->num_sids2; i++)
1466 {
1467 slprintf(tmp, sizeof(tmp) - 1, "ptr[%02d]", i);
1468 prs_uint32(tmp, ps, depth, &(q_u->ptr_sid[i]));
1469 }
1470
1471 for (i = 0; i < q_u->num_sids2; i++)
1472 {
1473 if (q_u->ptr_sid[i] != 0)
1474 {
1475 slprintf(tmp, sizeof(tmp)-1, "sid[%02d]", i);
1476 smb_io_dom_sid2(tmp, &(q_u->sid[i]), ps, depth);
1477 }
1478 }
1479
1480 prs_align(ps);
1481 }
1482
1483
1484 /*******************************************************************
1485 makes a SAMR_R_LOOKUP_IDS structure.
1486 ********************************************************************/
1487 void make_samr_r_lookup_ids(SAMR_R_LOOKUP_IDS *r_u,
1488 uint32 num_rids, uint32 *rid, uint32 status)
1489 {
1490 int i;
1491 if (r_u == NULL) return;
1492
1493 DEBUG(5,("make_samr_r_lookup_ids\n"));
1494
1495 if (status == 0x0)
1496 {
1497 r_u->num_entries = num_rids;
1498 r_u->ptr = 1;
1499 r_u->num_entries2 = num_rids;
1500
1501 SMB_ASSERT_ARRAY(r_u->rid, num_rids);
1502
1503 for (i = 0; i < num_rids; i++)
1504 {
1505 r_u->rid[i] = rid[i];
1506 }
1507 }
1508 else
1509 {
1510 r_u->num_entries = 0;
1511 r_u->ptr = 0;
1512 r_u->num_entries2 = 0;
1513 }
1514
1515 r_u->status = status;
1516 }
1517
1518 /*******************************************************************
1519 reads or writes a structure.
1520 ********************************************************************/
1521 void samr_io_r_lookup_ids(char *desc, SAMR_R_LOOKUP_IDS *r_u, prs_struct *ps, int depth)
1522 {
1523 fstring tmp;
1524 int i;
1525 if (r_u == NULL) return;
1526
1527 prs_debug(ps, depth, desc, "samr_io_r_lookup_ids");
1528 depth++;
1529
1530 prs_align(ps);
1531
1532 prs_uint32("num_entries", ps, depth, &(r_u->num_entries));
1533 prs_uint32("ptr ", ps, depth, &(r_u->ptr ));
1534 prs_uint32("num_entries2", ps, depth, &(r_u->num_entries2));
1535
1536 if (r_u->num_entries != 0)
1537 {
1538 SMB_ASSERT_ARRAY(r_u->rid, r_u->num_entries2);
1539
1540 for (i = 0; i < r_u->num_entries2; i++)
1541 {
1542 slprintf(tmp, sizeof(tmp)-1, "rid[%02d]", i);
1543 prs_uint32(tmp, ps, depth, &(r_u->rid[i]));
1544 }
1545 }
1546
1547 prs_uint32("status", ps, depth, &(r_u->status));
1548 }
1549
1550 /*******************************************************************
1551 reads or writes a structure.
1552 ********************************************************************/
1553 void samr_io_q_lookup_names(char *desc, SAMR_Q_LOOKUP_NAMES *q_u, prs_struct *ps, int depth)
1554 {
1555 int i;
1556
1557 if (q_u == NULL) return;
1558
1559 prs_debug(ps, depth, desc, "samr_io_q_lookup_names");
1560 depth++;
1561
1562 prs_align(ps);
1563
1564 smb_io_pol_hnd("pol", &(q_u->pol), ps, depth);
1565 prs_align(ps);
1566
1567 prs_uint32("num_rids1", ps, depth, &(q_u->num_rids1));
1568 prs_uint32("rid ", ps, depth, &(q_u->rid ));
1569 prs_uint32("ptr ", ps, depth, &(q_u->ptr ));
1570 prs_uint32("num_rids2", ps, depth, &(q_u->num_rids2));
1571
1572 SMB_ASSERT_ARRAY(q_u->hdr_user_name, q_u->num_rids2);
1573
1574 for (i = 0; i < q_u->num_rids2; i++)
1575 {
1576 smb_io_unihdr ("", &(q_u->hdr_user_name[i]), ps, depth);
1577 }
1578 for (i = 0; i < q_u->num_rids2; i++)
1579 {
1580 smb_io_unistr2("", &(q_u->uni_user_name[i]), q_u->hdr_user_name[i].buffer, ps, depth);
1581 }
1582
1583 prs_align(ps);
1584 }
1585
1586
1587 /*******************************************************************
1588 makes a SAMR_R_LOOKUP_NAMES structure.
1589 ********************************************************************/
1590 void make_samr_r_lookup_names(SAMR_R_LOOKUP_NAMES *r_u,
1591 uint32 num_rids, uint32 *rid, uint32 status)
1592 {
1593 int i;
1594 if (r_u == NULL) return;
1595
1596 DEBUG(5,("make_samr_r_lookup_names\n"));
1597
1598 if (status == 0x0)
1599 {
1600 r_u->num_entries = num_rids;
1601 r_u->undoc_buffer = 1;
1602 r_u->num_entries2 = num_rids;
1603
1604 SMB_ASSERT_ARRAY(r_u->dom_rid, num_rids);
1605
1606 for (i = 0; i < num_rids; i++)
1607 {
1608 make_dom_rid3(&(r_u->dom_rid[i]), rid[i]);
1609 }
1610
1611 r_u->num_entries3 = num_rids;
1612 }
1613 else
1614 {
1615 r_u->num_entries = 0;
1616 r_u->undoc_buffer = 0;
1617 r_u->num_entries2 = 0;
1618 r_u->num_entries3 = 0;
1619 }
1620
1621 r_u->status = status;
1622 }
1623
1624 /*******************************************************************
1625 reads or writes a structure.
1626 ********************************************************************/
1627 void samr_io_r_lookup_names(char *desc, SAMR_R_LOOKUP_NAMES *r_u, prs_struct *ps, int depth)
1628 {
1629 int i;
1630 if (r_u == NULL) return;
1631
1632 prs_debug(ps, depth, desc, "samr_io_r_lookup_names");
1633 depth++;
1634
1635 prs_align(ps);
1636
1637 prs_uint32("num_entries ", ps, depth, &(r_u->num_entries ));
1638 prs_uint32("undoc_buffer", ps, depth, &(r_u->undoc_buffer));
1639 prs_uint32("num_entries2", ps, depth, &(r_u->num_entries2));
1640
1641 if (r_u->num_entries != 0)
1642 {
1643 SMB_ASSERT_ARRAY(r_u->dom_rid, r_u->num_entries2);
1644
1645 for (i = 0; i < r_u->num_entries2; i++)
1646 {
1647 smb_io_dom_rid3("", &(r_u->dom_rid[i]), ps, depth);
1648 }
1649
1650 }
1651
1652 prs_uint32("num_entries3", ps, depth, &(r_u->num_entries3));
1653
1654 prs_uint32("status", ps, depth, &(r_u->status));
1655 }
1656
1657 /*******************************************************************
1658 reads or writes a structure.
1659 ********************************************************************/
1660 void samr_io_q_unknown_12(char *desc, SAMR_Q_UNKNOWN_12 *q_u, prs_struct *ps, int depth)
1661 {
1662 int i;
1663 fstring tmp;
1664
1665 if (q_u == NULL) return;
1666
1667 prs_debug(ps, depth, desc, "samr_io_q_unknown_12");
1668 depth++;
1669
1670 prs_align(ps);
1671
1672 smb_io_pol_hnd("pol", &(q_u->pol), ps, depth);
1673 prs_align(ps);
1674
1675 prs_uint32("num_gids1", ps, depth, &(q_u->num_gids1));
1676 prs_uint32("rid ", ps, depth, &(q_u->rid ));
1677 prs_uint32("ptr ", ps, depth, &(q_u->ptr ));
1678 prs_uint32("num_gids2", ps, depth, &(q_u->num_gids2));
1679
1680 SMB_ASSERT_ARRAY(q_u->gid, q_u->num_gids2);
1681
1682 for (i = 0; i < q_u->num_gids2; i++)
1683 {
1684 slprintf(tmp, sizeof(tmp) - 1, "gid[%02d] ", i);
1685 prs_uint32(tmp, ps, depth, &(q_u->gid[i]));
1686 }
1687
1688 prs_align(ps);
1689 }
1690
1691
1692 /*******************************************************************
1693 makes a SAMR_R_UNKNOWN_12 structure.
1694 ********************************************************************/
1695 void make_samr_r_unknown_12(SAMR_R_UNKNOWN_12 *r_u,
1696 uint32 num_aliases, fstring *als_name, uint32 *num_als_usrs,
1697 uint32 status)
1698 {
1699 int i;
1700 if (r_u == NULL || als_name == NULL || num_als_usrs == NULL) return;
1701
1702 DEBUG(5,("make_samr_r_unknown_12\n"));
1703
1704 if (status == 0x0)
1705 {
1706 r_u->num_aliases1 = num_aliases;
1707 r_u->ptr_aliases = 1;
1708 r_u->num_aliases2 = num_aliases;
1709
1710 r_u->num_als_usrs1 = num_aliases;
1711 r_u->ptr_als_usrs = 1;
1712 r_u->num_als_usrs2 = num_aliases;
1713
1714 SMB_ASSERT_ARRAY(r_u->hdr_als_name, num_aliases);
1715
1716 for (i = 0; i < num_aliases; i++)
1717 {
1718 int als_len = als_name[i] != NULL ? strlen(als_name[i]) : 0;
1719 make_uni_hdr(&(r_u->hdr_als_name[i]), als_len , als_len, als_name[i] ? 1 : 0);
1720 make_unistr2(&(r_u->uni_als_name[i]), als_name[i], als_len);
1721 r_u->num_als_usrs[i] = num_als_usrs[i];
1722 }
1723 }
1724 else
1725 {
1726 r_u->num_aliases1 = num_aliases;
1727 r_u->ptr_aliases = 0;
1728 r_u->num_aliases2 = num_aliases;
1729
1730 r_u->num_als_usrs1 = num_aliases;
1731 r_u->ptr_als_usrs = 0;
1732 r_u->num_als_usrs2 = num_aliases;
1733 }
1734
1735 r_u->status = status;
1736 }
1737
1738 /*******************************************************************
1739 reads or writes a structure.
1740 ********************************************************************/
1741 void samr_io_r_unknown_12(char *desc, SAMR_R_UNKNOWN_12 *r_u, prs_struct *ps, int depth)
1742 {
1743 int i;
1744 fstring tmp;
1745 if (r_u == NULL) return;
1746
1747 prs_debug(ps, depth, desc, "samr_io_r_unknown_12");
1748 depth++;
1749
1750 prs_align(ps);
1751
1752 prs_uint32("num_aliases1", ps, depth, &(r_u->num_aliases1));
1753 prs_uint32("ptr_aliases ", ps, depth, &(r_u->ptr_aliases ));
1754 prs_uint32("num_aliases2", ps, depth, &(r_u->num_aliases2));
1755
1756 if (r_u->ptr_aliases != 0 && r_u->num_aliases1 != 0)
1757 {
1758 SMB_ASSERT_ARRAY(r_u->hdr_als_name, r_u->num_aliases2);
1759
1760 for (i = 0; i < r_u->num_aliases2; i++)
1761 {
1762 slprintf(tmp, sizeof(tmp) - 1, "als_hdr[%02d] ", i);
1763 smb_io_unihdr ("", &(r_u->hdr_als_name[i]), ps, depth);
1764 }
1765 for (i = 0; i < r_u->num_aliases2; i++)
1766 {
1767 slprintf(tmp, sizeof(tmp) - 1, "als_str[%02d] ", i);
1768 smb_io_unistr2("", &(r_u->uni_als_name[i]), r_u->hdr_als_name[i].buffer, ps, depth);
1769 }
1770 }
1771
1772 prs_align(ps);
1773
1774 prs_uint32("num_als_usrs1", ps, depth, &(r_u->num_als_usrs1));
1775 prs_uint32("ptr_als_usrs ", ps, depth, &(r_u->ptr_als_usrs ));
1776 prs_uint32("num_als_usrs2", ps, depth, &(r_u->num_als_usrs2));
1777
1778 if (r_u->ptr_als_usrs != 0 && r_u->num_als_usrs1 != 0)
1779 {
1780 SMB_ASSERT_ARRAY(r_u->num_als_usrs, r_u->num_als_usrs2);
1781
1782 for (i = 0; i < r_u->num_als_usrs2; i++)
1783 {
1784 slprintf(tmp, sizeof(tmp) - 1, "als_usrs[%02d] ", i);
1785 prs_uint32(tmp, ps, depth, &(r_u->num_als_usrs[i]));
1786 }
1787 }
1788
1789 prs_uint32("status", ps, depth, &(r_u->status));
1790 }
1791
1792
1793 /*******************************************************************
1794 reads or writes a structure.
1795 ********************************************************************/
1796 void make_samr_q_open_user(SAMR_Q_OPEN_USER *q_u,
1797 POLICY_HND *pol,
1798 uint32 unk_0, uint32 rid)
1799 {
1800 if (q_u == NULL) return;
1801
1802 DEBUG(5,("samr_make_q_open_user\n"));
1803
1804 memcpy(&q_u->domain_pol, pol, sizeof(q_u->domain_pol));
1805
1806 q_u->unknown_0 = unk_0;
1807 q_u->user_rid = rid;
1808 }
1809
1810 /*******************************************************************
1811 reads or writes a structure.
1812 ********************************************************************/
1813 void samr_io_q_open_user(char *desc, SAMR_Q_OPEN_USER *q_u, prs_struct *ps, int depth)
1814 {
1815 if (q_u == NULL) return;
1816
1817 prs_debug(ps, depth, desc, "samr_io_q_open_user");
1818 depth++;
1819
1820 prs_align(ps);
1821
1822 smb_io_pol_hnd("domain_pol", &(q_u->domain_pol), ps, depth);
1823 prs_align(ps);
1824
1825 prs_uint32("unknown_0", ps, depth, &(q_u->unknown_0));
1826 prs_uint32("user_rid ", ps, depth, &(q_u->user_rid ));
1827
1828 prs_align(ps);
1829 }
1830
1831 /*******************************************************************
1832 reads or writes a structure.
1833 ********************************************************************/
1834 void samr_io_r_open_user(char *desc, SAMR_R_OPEN_USER *r_u, prs_struct *ps, int depth)
1835 {
1836 if (r_u == NULL) return;
1837
1838 prs_debug(ps, depth, desc, "samr_io_r_open_user");
1839 depth++;
1840
1841 prs_align(ps);
1842
1843 smb_io_pol_hnd("user_pol", &(r_u->user_pol), ps, depth);
1844 prs_align(ps);
1845
1846 prs_uint32("status", ps, depth, &(r_u->status));
1847 }
1848
1849 /*******************************************************************
1850 makes a SAMR_Q_QUERY_USERGROUPS structure.
1851 ********************************************************************/
1852 void make_samr_q_query_usergroups(SAMR_Q_QUERY_USERGROUPS *q_u,
1853 POLICY_HND *hnd)
1854 {
1855 if (q_u == NULL || hnd == NULL) return;
1856
1857 DEBUG(5,("make_samr_q_query_usergroups\n"));
1858
1859 memcpy(&(q_u->pol), hnd, sizeof(q_u->pol));
1860 }
1861
1862
1863 /*******************************************************************
1864 reads or writes a structure.
1865 ********************************************************************/
1866 void samr_io_q_query_usergroups(char *desc, SAMR_Q_QUERY_USERGROUPS *q_u, prs_struct *ps, int depth)
1867 {
1868 if (q_u == NULL) return;
1869
1870 prs_debug(ps, depth, desc, "samr_io_q_query_usergroups");
1871 depth++;
1872
1873 prs_align(ps);
1874
1875 smb_io_pol_hnd("pol", &(q_u->pol), ps, depth);
1876 prs_align(ps);
1877 }
1878
1879 /*******************************************************************
1880 makes a SAMR_R_QUERY_USERGROUPS structure.
1881 ********************************************************************/
1882 void make_samr_r_query_usergroups(SAMR_R_QUERY_USERGROUPS *r_u,
1883 uint32 num_gids, DOM_GID *gid, uint32 status)
1884 {
1885 if (r_u == NULL) return;
1886
1887 DEBUG(5,("make_samr_r_query_usergroups\n"));
1888
1889 if (status == 0x0)
1890 {
1891 r_u->ptr_0 = 1;
1892 r_u->num_entries = num_gids;
1893 r_u->ptr_1 = 1;
1894 r_u->num_entries2 = num_gids;
1895
1896 r_u->gid = gid;
1897 }
1898 else
1899 {
1900 r_u->ptr_0 = 0;
1901 r_u->num_entries = 0;
1902 r_u->ptr_1 = 0;
1903 }
1904
1905 r_u->status = status;
1906 }
1907
1908 /*******************************************************************
1909 reads or writes a structure.
1910 ********************************************************************/
1911 void samr_io_r_query_usergroups(char *desc, SAMR_R_QUERY_USERGROUPS *r_u, prs_struct *ps, int depth)
1912 {
1913 int i;
1914 if (r_u == NULL) return;
1915
1916 prs_debug(ps, depth, desc, "samr_io_r_query_usergroups");
1917 depth++;
1918
1919 prs_align(ps);
1920
1921 prs_uint32("ptr_0 ", ps, depth, &(r_u->ptr_0 ));
1922
1923 if (r_u->ptr_0 != 0)
1924 {
1925 prs_uint32("num_entries ", ps, depth, &(r_u->num_entries));
1926 prs_uint32("ptr_1 ", ps, depth, &(r_u->ptr_1 ));
1927
1928 if (r_u->num_entries != 0)
1929 {
1930 prs_uint32("num_entries2", ps, depth, &(r_u->num_entries2));
1931
1932 for (i = 0; i < r_u->num_entries2; i++)
1933 {
1934 smb_io_gid("", &(r_u->gid[i]), ps, depth);
1935 }
1936 }
1937 }
1938 prs_uint32("status", ps, depth, &(r_u->status));
1939 }
1940
1941 /*******************************************************************
1942 makes a SAMR_Q_QUERY_USERINFO structure.
1943 ********************************************************************/
1944 void make_samr_q_query_userinfo(SAMR_Q_QUERY_USERINFO *q_u,
1945 POLICY_HND *hnd, uint16 switch_value)
1946 {
1947 if (q_u == NULL || hnd == NULL) return;
1948
1949 DEBUG(5,("make_samr_q_query_userinfo\n"));
1950
1951 memcpy(&(q_u->pol), hnd, sizeof(q_u->pol));
1952 q_u->switch_value = switch_value;
1953 }
1954
1955
1956 /*******************************************************************
1957 reads or writes a structure.
1958 ********************************************************************/
1959 void samr_io_q_query_userinfo(char *desc, SAMR_Q_QUERY_USERINFO *q_u, prs_struct *ps, int depth)
1960 {
1961 if (q_u == NULL) return;
1962
1963 prs_debug(ps, depth, desc, "samr_io_q_query_userinfo");
1964 depth++;
1965
1966 prs_align(ps);
1967
1968 smb_io_pol_hnd("pol", &(q_u->pol), ps, depth);
1969 prs_align(ps);
1970
1971 prs_uint16("switch_value", ps, depth, &(q_u->switch_value)); /* 0x0015 or 0x0011 */
1972
1973 prs_align(ps);
1974 }
1975
1976 /*******************************************************************
1977 reads or writes a LOGON_HRS structure.
1978 ********************************************************************/
1979 static void sam_io_logon_hrs(char *desc, LOGON_HRS *hrs, prs_struct *ps, int depth)
1980 {
1981 if (hrs == NULL) return;
1982
1983 prs_debug(ps, depth, desc, "sam_io_logon_hrs");
1984 depth++;
1985
1986 prs_align(ps);
1987
1988 prs_uint32 ( "len ", ps, depth, &(hrs->len ));
1989
1990 if (hrs->len > 64)
1991 {
1992 DEBUG(5,("sam_io_logon_hrs: truncating length\n"));
1993 hrs->len = 64;
1994 }
1995
1996 prs_uint8s (False, "hours", ps, depth, hrs->hours, hrs->len);
1997 }
1998
1999 /*************************************************************************
2000 make_sam_user_info21
2001
2002 unknown_3 = 0x00ff ffff
2003 unknown_5 = 0x0002 0000
2004 unknown_6 = 0x0000 04ec
2005
2006 *************************************************************************/
2007 void make_sam_user_info21(SAM_USER_INFO_21 *usr,
2008
2009 NTTIME *logon_time,
2010 NTTIME *logoff_time,
2011 NTTIME *kickoff_time,
2012 NTTIME *pass_last_set_time,
2013 NTTIME *pass_can_change_time,
2014 NTTIME *pass_must_change_time,
2015
2016 char *user_name,
2017 char *full_name,
2018 char *home_dir,
2019 char *dir_drive,
2020 char *logon_script,
2021 char *profile_path,
2022 char *description,
2023 char *workstations,
2024 char *unknown_str,
2025 char *munged_dial,
2026
2027 uint32 user_rid,
2028 uint32 group_rid,
2029 uint16 acb_info,
2030
2031 uint32 unknown_3,
2032 uint16 logon_divs,
2033 LOGON_HRS *hrs,
2034 uint32 unknown_5,
2035 uint32 unknown_6)
2036 {
2037 int len_user_name = user_name != NULL ? strlen(user_name ) : 0;
2038 int len_full_name = full_name != NULL ? strlen(full_name ) : 0;
2039 int len_home_dir = home_dir != NULL ? strlen(home_dir ) : 0;
2040 int len_dir_drive = dir_drive != NULL ? strlen(dir_drive ) : 0;
2041 int len_logon_script = logon_script != NULL ? strlen(logon_script) : 0;
2042 int len_profile_path = profile_path != NULL ? strlen(profile_path) : 0;
2043 int len_description = description != NULL ? strlen(description ) : 0;
2044 int len_workstations = workstations != NULL ? strlen(workstations) : 0;
2045 int len_unknown_str = unknown_str != NULL ? strlen(unknown_str ) : 0;
2046 int len_munged_dial = munged_dial != NULL ? strlen(munged_dial ) : 0;
2047
2048 usr->logon_time = *logon_time;
2049 usr->logoff_time = *logoff_time;
2050 usr->kickoff_time = *kickoff_time;
2051 usr->pass_last_set_time = *pass_last_set_time;
2052 usr->pass_can_change_time = *pass_can_change_time;
2053 usr->pass_must_change_time = *pass_must_change_time;
2054
2055 make_uni_hdr(&(usr->hdr_user_name ), len_user_name , len_user_name , len_user_name != 0);
2056 make_uni_hdr(&(usr->hdr_full_name ), len_full_name , len_full_name , len_full_name != 0);
2057 make_uni_hdr(&(usr->hdr_home_dir ), len_home_dir , len_home_dir , len_home_dir != 0);
2058 make_uni_hdr(&(usr->hdr_dir_drive ), len_dir_drive , len_dir_drive , len_dir_drive != 0);
2059 make_uni_hdr(&(usr->hdr_logon_script), len_logon_script, len_logon_script, len_logon_script != 0);
2060 make_uni_hdr(&(usr->hdr_profile_path), len_profile_path, len_profile_path, len_profile_path != 0);
2061 make_uni_hdr(&(usr->hdr_acct_desc ), len_description , len_description , len_description != 0);
2062 make_uni_hdr(&(usr->hdr_workstations), len_workstations, len_workstations, len_workstations != 0);
2063 make_uni_hdr(&(usr->hdr_unknown_str ), len_unknown_str , len_unknown_str , len_workstations != 0);
2064 make_uni_hdr(&(usr->hdr_munged_dial ), len_munged_dial , len_munged_dial , len_workstations != 0);
2065
2066 bzero(usr->nt_pwd, sizeof(usr->nt_pwd));
2067 bzero(usr->lm_pwd, sizeof(usr->lm_pwd));
2068
2069 usr->user_rid = user_rid;
2070 usr->group_rid = group_rid;
2071 usr->acb_info = acb_info;
2072 usr->unknown_3 = unknown_3; /* 0x00ff ffff */
2073
2074 usr->logon_divs = logon_divs; /* should be 168 (hours/week) */
2075 usr->ptr_logon_hrs = hrs ? 1 : 0;
2076 usr->unknown_5 = unknown_5; /* 0x0002 0000 */
2077
2078 bzero(usr->padding1, sizeof(usr->padding1));
2079
2080 make_unistr2(&(usr->uni_user_name ), user_name , len_user_name );
2081 make_unistr2(&(usr->uni_full_name ), full_name , len_full_name );
2082 make_unistr2(&(usr->uni_home_dir ), home_dir , len_home_dir );
2083 make_unistr2(&(usr->uni_dir_drive ), dir_drive , len_dir_drive );
2084 make_unistr2(&(usr->uni_logon_script), logon_script, len_logon_script);
2085 make_unistr2(&(usr->uni_profile_path), profile_path, len_profile_path);
2086 make_unistr2(&(usr->uni_acct_desc ), description , len_description );
2087 make_unistr2(&(usr->uni_workstations), workstations, len_workstations);
2088 make_unistr2(&(usr->uni_unknown_str ), unknown_str , len_unknown_str );
2089 make_unistr2(&(usr->uni_munged_dial ), munged_dial , len_munged_dial );
2090
2091 usr->unknown_6 = unknown_6; /* 0x0000 04ec */
2092 usr->padding4 = 0;
2093
2094 if (hrs)
2095 {
2096 memcpy(&(usr->logon_hrs), hrs, sizeof(usr->logon_hrs));
2097 }
2098 else
2099 {
2100 memset(&(usr->logon_hrs), 0xff, sizeof(usr->logon_hrs));
2101 }
2102 }
2103
2104
2105 /*******************************************************************
2106 reads or writes a structure.
2107 ********************************************************************/
2108 static void sam_io_user_info21(char *desc, SAM_USER_INFO_21 *usr, prs_struct *ps, int depth)
2109 {
2110 if (usr == NULL) return;
2111
2112 prs_debug(ps, depth, desc, "lsa_io_user_info");
2113 depth++;
2114
2115 prs_align(ps);
2116
2117 smb_io_time("logon_time ", &(usr->logon_time) , ps, depth);
2118 smb_io_time("logoff_time ", &(usr->logoff_time) , ps, depth);
2119 smb_io_time("kickoff_time ", &(usr->kickoff_time) , ps, depth);
2120 smb_io_time("pass_last_set_time ", &(usr->pass_last_set_time) , ps, depth);
2121 smb_io_time("pass_can_change_time ", &(usr->pass_can_change_time) , ps, depth);
2122 smb_io_time("pass_must_change_time", &(usr->pass_must_change_time), ps, depth);
2123
2124 smb_io_unihdr("hdr_user_name ", &(usr->hdr_user_name) , ps, depth); /* username unicode string header */
2125 smb_io_unihdr("hdr_full_name ", &(usr->hdr_full_name) , ps, depth); /* user's full name unicode string header */
2126 smb_io_unihdr("hdr_home_dir ", &(usr->hdr_home_dir) , ps, depth); /* home directory unicode string header */
2127 smb_io_unihdr("hdr_dir_drive ", &(usr->hdr_dir_drive) , ps, depth); /* home directory drive */
2128 smb_io_unihdr("hdr_logon_script", &(usr->hdr_logon_script), ps, depth); /* logon script unicode string header */
2129 smb_io_unihdr("hdr_profile_path", &(usr->hdr_profile_path), ps, depth); /* profile path unicode string header */
2130 smb_io_unihdr("hdr_acct_desc ", &(usr->hdr_acct_desc ) , ps, depth); /* account description */
2131 smb_io_unihdr("hdr_workstations", &(usr->hdr_workstations), ps, depth); /* workstations user can log on from */
2132 smb_io_unihdr("hdr_unknown_str ", &(usr->hdr_unknown_str ), ps, depth); /* unknown string */
2133 smb_io_unihdr("hdr_munged_dial ", &(usr->hdr_munged_dial ), ps, depth); /* workstations user can log on from */
2134
2135 prs_uint8s (False, "lm_pwd ", ps, depth, usr->lm_pwd , sizeof(usr->lm_pwd ));
2136 prs_uint8s (False, "nt_pwd ", ps, depth, usr->nt_pwd , sizeof(usr->nt_pwd ));
2137
2138 prs_uint32("user_rid ", ps, depth, &(usr->user_rid )); /* User ID */
2139 prs_uint32("group_rid ", ps, depth, &(usr->group_rid )); /* Group ID */
2140 prs_uint16("acb_info ", ps, depth, &(usr->acb_info )); /* Group ID */
2141 prs_align(ps);
2142
2143 prs_uint32("unknown_3 ", ps, depth, &(usr->unknown_3 ));
2144 prs_uint16("logon_divs ", ps, depth, &(usr->logon_divs )); /* logon divisions per week */
2145 prs_align(ps);
2146 prs_uint32("ptr_logon_hrs ", ps, depth, &(usr->ptr_logon_hrs));
2147 prs_uint32("unknown_5 ", ps, depth, &(usr->unknown_5 ));
2148
2149 prs_uint8s (False, "padding1 ", ps, depth, usr->padding1, sizeof(usr->padding1));
2150
2151 /* here begins pointed-to data */
2152
2153 smb_io_unistr2("uni_user_name ", &(usr->uni_user_name) , usr->hdr_user_name .buffer, ps, depth); /* username unicode string */
2154 smb_io_unistr2("uni_full_name ", &(usr->uni_full_name) , usr->hdr_full_name .buffer, ps, depth); /* user's full name unicode string */
2155 smb_io_unistr2("uni_home_dir ", &(usr->uni_home_dir) , usr->hdr_home_dir .buffer, ps, depth); /* home directory unicode string */
2156 smb_io_unistr2("uni_dir_drive ", &(usr->uni_dir_drive) , usr->hdr_dir_drive .buffer, ps, depth); /* home directory drive unicode string */
2157 smb_io_unistr2("uni_logon_script", &(usr->uni_logon_script), usr->hdr_logon_script.buffer, ps, depth); /* logon script unicode string */
2158 smb_io_unistr2("uni_profile_path", &(usr->uni_profile_path), usr->hdr_profile_path.buffer, ps, depth); /* profile path unicode string */
2159 smb_io_unistr2("uni_acct_desc ", &(usr->uni_acct_desc ), usr->hdr_acct_desc .buffer, ps, depth); /* user description unicode string */
2160 smb_io_unistr2("uni_workstations", &(usr->uni_workstations), usr->hdr_workstations.buffer, ps, depth); /* worksations user can log on from */
2161 smb_io_unistr2("uni_unknown_str ", &(usr->uni_unknown_str ), usr->hdr_unknown_str .buffer, ps, depth); /* unknown string */
2162 smb_io_unistr2("uni_munged_dial ", &(usr->uni_munged_dial ), usr->hdr_munged_dial .buffer, ps, depth); /* worksations user can log on from */
2163
2164 prs_uint32("unknown_6 ", ps, depth, &(usr->unknown_6 ));
2165 prs_uint32("padding4 ", ps, depth, &(usr->padding4 ));
2166
2167 if (usr->ptr_logon_hrs)
2168 {
2169 sam_io_logon_hrs("logon_hrs", &(usr->logon_hrs) , ps, depth);
2170 prs_align(ps);
2171 }
2172 }
2173
2174
2175 /*******************************************************************
2176 makes a SAMR_R_QUERY_USERINFO structure.
2177 ********************************************************************/
2178 void make_samr_r_query_userinfo(SAMR_R_QUERY_USERINFO *r_u,
2179 uint16 switch_value, void *info, uint32 status)
2180
2181 {
2182 if (r_u == NULL || info == NULL) return;
2183
2184 DEBUG(5,("make_samr_r_query_userinfo\n"));
2185
2186 r_u->ptr = 0;
2187 r_u->switch_value = 0;
2188
2189 if (status == 0)
2190 {
2191 r_u->switch_value = switch_value;
2192
2193 switch (switch_value)
2194 {
2195 case 0x10:
2196 {
2197 r_u->ptr = 1;
2198 r_u->info.id10 = (SAM_USER_INFO_10*)info;
2199
2200 break;
2201 }
2202
2203 case 0x11:
2204 {
2205 r_u->ptr = 1;
2206 r_u->info.id11 = (SAM_USER_INFO_11*)info;
2207
2208 break;
2209 }
2210
2211 case 21:
2212 {
2213 r_u->ptr = 1;
2214 r_u->info.id21 = (SAM_USER_INFO_21*)info;
2215
2216 break;
2217 }
2218
2219 default:
2220 {
2221 DEBUG(4,("make_samr_r_query_aliasinfo: unsupported switch level\n"));
2222 break;
2223 }
2224 }
2225 }
2226
2227 r_u->status = status; /* return status */
2228 }
2229
2230 /*******************************************************************
2231 reads or writes a structure.
2232 ********************************************************************/
2233 void samr_io_r_query_userinfo(char *desc, SAMR_R_QUERY_USERINFO *r_u, prs_struct *ps, int depth)
2234 {
2235 if (r_u == NULL) return;
2236
2237 prs_debug(ps, depth, desc, "samr_io_r_query_userinfo");
2238 depth++;
2239
2240 prs_align(ps);
2241
2242 prs_uint32("ptr ", ps, depth, &(r_u->ptr ));
2243 prs_uint16("switch_value", ps, depth, &(r_u->switch_value));
2244 prs_align(ps);
2245
2246 if (r_u->ptr != 0 && r_u->switch_value != 0)
2247 {
2248 switch (r_u->switch_value)
2249 {
2250 /*
2251 case 0x10:
2252 {
2253 if (r_u->info.id10 != NULL)
2254 {
2255 sam_io_user_info10("", r_u->info.id10, ps, depth);
2256 }
2257 else
2258 {
2259 DEBUG(2,("samr_io_r_query_userinfo: info pointer not initialised\n"));
2260 return NULL;
2261 }
2262 break;
2263 }
2264 case 0x11:
2265 {
2266 if (r_u->info.id11 != NULL)
2267 {
2268 sam_io_user_info11("", r_u->info.id11, ps, depth);
2269 }
2270 else
2271 {
2272 DEBUG(2,("samr_io_r_query_userinfo: info pointer not initialised\n"));
2273 return NULL;
2274 }
2275 break;
2276 }
2277 */
2278 case 21:
2279 {
2280 if (r_u->info.id21 != NULL)
2281 {
2282 sam_io_user_info21("", r_u->info.id21, ps, depth);
2283 }
2284 else
2285 {
2286 DEBUG(2,("samr_io_r_query_userinfo: info pointer not initialised\n"));
2287 return;
2288 }
2289 break;
2290 }
2291 default:
2292 {
2293 DEBUG(2,("samr_io_r_query_userinfo: unknown switch level\n"));
2294 break;
2295 }
2296
2297 }
2298 }
2299
2300 prs_uint32("status", ps, depth, &(r_u->status));
2301 }
2302
2303 /*******************************************************************
2304 reads or writes a structure.
2305 ********************************************************************/
2306 void samr_io_q_unknown_32(char *desc, SAMR_Q_UNKNOWN_32 *q_u, prs_struct *ps, int depth)
2307 {
2308 if (q_u == NULL) return;
2309
2310 prs_debug(ps, depth, desc, "samr_io_q_unknown_32");
2311 depth++;
2312
2313 prs_align(ps);
2314
2315 smb_io_pol_hnd("pol", &(q_u->pol), ps, depth);
2316 prs_align(ps);
2317
2318 smb_io_unihdr ("", &(q_u->hdr_mach_acct), ps, depth);
2319 smb_io_unistr2("", &(q_u->uni_mach_acct), q_u->hdr_mach_acct.buffer, ps, depth);
2320
2321 prs_align(ps);
2322
2323 prs_uint32("acct_ctrl", ps, depth, &(q_u->acct_ctrl));
2324 prs_uint16("unknown_1", ps, depth, &(q_u->unknown_1));
2325 prs_uint16("unknown_2", ps, depth, &(q_u->unknown_2));
2326 }
2327
2328 /*******************************************************************
2329 reads or writes a structure.
2330 ********************************************************************/
2331 void samr_io_r_unknown_32(char *desc, SAMR_R_UNKNOWN_32 *r_u, prs_struct *ps, int depth)
2332 {
2333 if (r_u == NULL) return;
2334
2335 prs_debug(ps, depth, desc, "samr_io_r_unknown_32");
2336 depth++;
2337
2338 prs_align(ps);
2339
2340 smb_io_pol_hnd("pol", &(r_u->pol), ps, depth);
2341 prs_align(ps);
2342
2343 prs_uint32("status", ps, depth, &(r_u->status));
2344 }
2345
2346
2347 /*******************************************************************
2348 makes a SAMR_Q_CONNECT structure.
2349 ********************************************************************/
2350 void make_samr_q_connect(SAMR_Q_CONNECT *q_u,
2351 char *srv_name, uint32 unknown_0)
2352 {
2353 int len_srv_name = strlen(srv_name);
2354
2355 if (q_u == NULL) return;
2356
2357 DEBUG(5,("make_q_connect\n"));
2358
2359 /* make PDC server name \\server */
2360 make_unistr2(&(q_u->uni_srv_name), srv_name, len_srv_name);
2361
2362 /* example values: 0x0000 0002 */
2363 q_u->unknown_0 = unknown_0;
2364 }
2365
2366
2367 /*******************************************************************
2368 reads or writes a structure.
2369 ********************************************************************/
2370 void samr_io_q_connect(char *desc, SAMR_Q_CONNECT *q_u, prs_struct *ps, int depth)
2371 {
2372 if (q_u == NULL) return;
2373
2374 prs_debug(ps, depth, desc, "samr_io_q_connect");
2375 depth++;
2376
2377 prs_align(ps);
2378
2379 prs_uint32("ptr_srv_name", ps, depth, &(q_u->ptr_srv_name));
2380 smb_io_unistr2("", &(q_u->uni_srv_name), q_u->ptr_srv_name, ps, depth);
2381
2382 prs_align(ps);
2383
2384 prs_uint32("unknown_0 ", ps, depth, &(q_u->unknown_0 ));
2385 }
2386
2387 /*******************************************************************
2388 reads or writes a structure.
2389 ********************************************************************/
2390 void samr_io_r_connect(char *desc, SAMR_R_CONNECT *r_u, prs_struct *ps, int depth)
2391 {
2392 if (r_u == NULL) return;
2393
2394 prs_debug(ps, depth, desc, "samr_io_r_connect");
2395 depth++;
2396
2397 prs_align(ps);
2398
2399 smb_io_pol_hnd("connect_pol", &(r_u->connect_pol), ps, depth);
2400 prs_align(ps);
2401
2402 prs_uint32("status", ps, depth, &(r_u->status));
2403 }
2404
2405 /*******************************************************************
2406 makes a SAMR_Q_OPEN_ALIAS structure.
2407 ********************************************************************/
2408 void make_samr_q_open_alias(SAMR_Q_OPEN_ALIAS *q_u,
2409 uint32 unknown_0, uint32 rid)
2410 {
2411 if (q_u == NULL) return;
2412
2413 DEBUG(5,("make_q_open_alias\n"));
2414
2415 /* example values: 0x0000 0008 */
2416 q_u->unknown_0 = unknown_0;
2417
2418 q_u->rid_alias = rid;
2419 }
2420
2421 /*******************************************************************
2422 reads or writes a structure.
2423 ********************************************************************/
2424 void samr_io_q_open_alias(char *desc, SAMR_Q_OPEN_ALIAS *q_u, prs_struct *ps, int depth)
2425 {
2426 if (q_u == NULL) return;
2427
2428 prs_debug(ps, depth, desc, "samr_io_q_open_alias");
2429 depth++;
2430
2431 prs_align(ps);
2432
2433 prs_uint32("unknown_0", ps, depth, &(q_u->unknown_0));
2434 prs_uint32("rid_alias", ps, depth, &(q_u->rid_alias));
2435 }
2436
2437 /*******************************************************************
2438 reads or writes a structure.
2439 ********************************************************************/
2440 void samr_io_r_open_alias(char *desc, SAMR_R_OPEN_ALIAS *r_u, prs_struct *ps, int depth)
2441 {
2442 if (r_u == NULL) return;
2443
2444 prs_debug(ps, depth, desc, "samr_io_r_open_alias");
2445 depth++;
2446
2447 prs_align(ps);
2448
2449 smb_io_pol_hnd("pol", &(r_u->pol), ps, depth);
2450 prs_align(ps);
2451
2452 prs_uint32("status", ps, depth, &(r_u->status));
2453 }
2454
2455
2456 #if 0
2457 /* SAMR_Q_CHGPASSWD_USER */
2458 typedef struct q_samr_chgpasswd_user_info
2459 {
2460 uint32 ptr_0;
2461
2462 UNIHDR hdr_server; /* server name unicode header */
2463 UNISTR2 uni_server; /* server name unicode string */
2464
2465 UNIHDR hdr_user_name; /* username unicode string header */
2466 UNISTR2 uni_user_name; /* username unicode string */
2467
2468 SAMR_ENC_PASSWD nt_newpass;
2469 SAMR_ENC_HASH nt_oldhash;
2470
2471 uint32 unknown_1; /* seems to always contain 0001 */
2472
2473 SAMR_ENC_PASSWD lm_newpass;
2474 SAMR_ENC_HASH lm_oldhash;
2475
2476 } SAMR_Q_CHGPASSWD_USER;
2477
2478 /* SAMR_R_CHGPASSWD_USER */
2479 typedef struct r_samr_chgpasswd_user_info
2480 {
2481 uint32 result; /* 0 == OK, C000006A (NT_STATUS_WRONG_PASSWORD) */
2482
2483 } SAMR_R_CHGPASSWD_USER;
2484
2485 #endif /* 0 */
2486
2487
2488 /*******************************************************************
2489 makes a SAMR_Q_UNKNOWN_38 structure.
2490 ********************************************************************/
2491 void make_samr_q_unknown_38(SAMR_Q_UNKNOWN_38 *q_u, char *srv_name)
2492 {
2493 int len_srv_name = strlen(srv_name);
2494
2495 if (q_u == NULL) return;
2496
2497 DEBUG(5,("make_q_unknown_38\n"));
2498
2499 q_u->ptr = 1;
2500 make_uni_hdr(&(q_u->hdr_srv_name), len_srv_name, len_srv_name, len_srv_name != 0);
2501 make_unistr2(&(q_u->uni_srv_name), srv_name, len_srv_name);
2502
2503 }
2504
2505 /*******************************************************************
2506 reads or writes a structure.
2507 ********************************************************************/
2508 void samr_io_q_unknown_38(char *desc, SAMR_Q_UNKNOWN_38 *q_u, prs_struct *ps, int depth)
2509 {
2510 if (q_u == NULL) return;
2511
2512 prs_debug(ps, depth, desc, "samr_io_q_unknown_38");
2513 depth++;
2514
2515 prs_align(ps);
2516
2517 prs_uint32("ptr", ps, depth, &(q_u->ptr));
2518 if (q_u->ptr != 0)
2519 {
2520 smb_io_unihdr ("", &(q_u->hdr_srv_name), ps, depth);
2521 smb_io_unistr2("", &(q_u->uni_srv_name), q_u->hdr_srv_name.buffer, ps, depth);
2522 }
2523 }
2524
2525 /*******************************************************************
2526 makes a SAMR_R_UNKNOWN_38 structure.
2527 ********************************************************************/
2528 void make_samr_r_unknown_38(SAMR_R_UNKNOWN_38 *r_u,
2529 uint16 level, uint32 status)
2530 {
2531 if (r_u == NULL) return;
2532
2533 DEBUG(5,("make_r_unknown_38\n"));
2534
2535 r_u->level.value = level;
2536 r_u->ptr_0 = 0;
2537 r_u->status = status;
2538 }
2539
2540 /*******************************************************************
2541 reads or writes a structure.
2542 ********************************************************************/
2543 void samr_io_r_unknown_38(char *desc, SAMR_R_UNKNOWN_38 *r_u, prs_struct *ps, int depth)
2544 {
2545 if (r_u == NULL) return;
2546
2547 prs_debug(ps, depth, desc, "samr_io_r_unknown_38");
2548 depth++;
2549
2550 prs_align(ps);
2551
2552 smb_io_lookup_level("level ", &(r_u->level), ps, depth);
2553 prs_uint32("ptr_0 ", ps, depth, &(r_u->ptr_0 ));
2554 prs_uint32("status", ps, depth, &(r_u->status));
2555 }
2556
2557 /*******************************************************************
2558 reads or writes a SAMR_ENC_PASSWD structure.
2559 ********************************************************************/
2560 void samr_io_enc_passwd(char *desc, SAMR_ENC_PASSWD *pwd, prs_struct *ps, int depth)
2561 {
2562 if (pwd == NULL) return;
2563
2564 prs_debug(ps, depth, desc, "samr_io_enc_passwd");
2565 depth++;
2566
2567 prs_align(ps);
2568
2569 prs_uint32("ptr", ps, depth, &(pwd->ptr));
2570 prs_uint8s(False, "pwd", ps, depth, pwd->pass, sizeof(pwd->pass));
2571 }
2572
2573 /*******************************************************************
2574 reads or writes a SAMR_ENC_HASH structure.
2575 ********************************************************************/
2576 void samr_io_enc_hash(char *desc, SAMR_ENC_HASH *hsh, prs_struct *ps, int depth)
2577 {
2578 if (hsh == NULL) return;
2579
2580 prs_debug(ps, depth, desc, "samr_io_enc_hash");
2581 depth++;
2582
2583 prs_align(ps);
2584
2585 prs_uint32("ptr ", ps, depth, &(hsh->ptr));
2586 prs_uint8s(False, "hash", ps, depth, hsh->hash, sizeof(hsh->hash));
2587 }
2588
2589 #if 0
2590 /* SAMR_Q_CHGPASSWD_USER */
2591 typedef struct q_samr_chgpasswd_user_info
2592 {
2593 uint32 ptr_0;
2594
2595 UNIHDR hdr_server; /* server name unicode header */
2596 UNISTR2 uni_server; /* server name unicode string */
2597
2598 UNIHDR hdr_user_name; /* username unicode string header */
2599 UNISTR2 uni_user_name; /* username unicode string */
2600
2601 SAMR_ENC_PASSWD nt_newpass;
2602 SAMR_ENC_HASH nt_oldhash;
2603
2604 uint32 unknown_1; /* seems to always contain 0001 */
2605
2606 SAMR_ENC_PASSWD lm_newpass;
2607 SAMR_ENC_HASH lm_oldhash;
2608
2609 } SAMR_Q_CHGPASSWD_USER;
2610
2611 /* SAMR_R_CHGPASSWD_USER */
2612 typedef struct r_samr_chgpasswd_user_info
2613 {
2614 uint32 result; /* 0 == OK, C000006A (NT_STATUS_WRONG_PASSWORD) */
2615
2616 } SAMR_R_CHGPASSWD_USER;
2617
2618 #endif /* 0 */
2619
2620
2621 /*******************************************************************
2622 makes a SAMR_Q_UNKNOWN_12 structure.
2623 ********************************************************************/
2624 void make_samr_q_unknown_12(SAMR_Q_UNKNOWN_12 *q_u,
2625 POLICY_HND *pol, uint32 rid,
2626 uint32 num_gids, uint32 *gid)
2627 {
2628 int i;
2629 if (q_u == NULL) return;
2630
2631 DEBUG(5,("make_samr_r_unknwon_12\n"));
2632
2633 memcpy(&(q_u->pol), pol, sizeof(*pol));
2634
2635 q_u->num_gids1 = num_gids;
2636 q_u->rid = rid;
2637 q_u->ptr = 0;
2638 q_u->num_gids2 = num_gids;
2639
2640 for (i = 0; i < num_gids; i++)
2641 {
2642 q_u->gid[i] = gid[i];
2643 }
2644 }
2645
2646
2647
2648
2649 /*******************************************************************
2650 makes a SAMR_Q_UNKNOWN_21 structure.
2651 ********************************************************************/
2652 void make_samr_q_unknown_21(SAMR_Q_UNKNOWN_21 *q_c,
2653 POLICY_HND *hnd, uint16 unk_1, uint16 unk_2)
2654 {
2655 if (q_c == NULL || hnd == NULL) return;
2656
2657 DEBUG(5,("make_samr_q_unknown_21\n"));
2658
2659 memcpy(&(q_c->group_pol), hnd, sizeof(q_c->group_pol));
2660 q_c->unknown_1 = unk_1;
2661 q_c->unknown_2 = unk_2;
2662 }
2663
2664
2665 /*******************************************************************
2666 makes a SAMR_Q_UNKNOWN_13 structure.
2667 ********************************************************************/
2668 void make_samr_q_unknown_13(SAMR_Q_UNKNOWN_13 *q_c,
2669 POLICY_HND *hnd, uint16 unk_1, uint16 unk_2)
2670 {
2671 if (q_c == NULL || hnd == NULL) return;
2672
2673 DEBUG(5,("make_samr_q_unknown_13\n"));
2674
2675 memcpy(&(q_c->alias_pol), hnd, sizeof(q_c->alias_pol));
2676 q_c->unknown_1 = unk_1;
2677 q_c->unknown_2 = unk_2;
2678 }
2679
2680
WIP