?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* fix to display correct form information in REG_BINARY information
[Samba.git] / source / rpc_parse / parse_net.c
blob46fdce63ff4233505a8014bae13ef8be04032356
1 /*
2 * Unix SMB/CIFS implementation.
3 * RPC Pipe client / server routines
4 * Copyright (C) Andrew Tridgell 1992-1997,
5 * Copyright (C) Luke Kenneth Casson Leighton 1996-1997,
6 * Copyright (C) Paul Ashton 1997.
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 */
22
23 #include "includes.h"
24
25 #undef DBGC_CLASS
26 #define DBGC_CLASS DBGC_RPC_PARSE
27
28 /*******************************************************************
29 Reads or writes a structure.
30 ********************************************************************/
31
32 static BOOL net_io_neg_flags(char *desc, NEG_FLAGS *neg, prs_struct *ps, int depth)
33 {
34 if (neg == NULL)
35 return False;
36
37 prs_debug(ps, depth, desc, "net_io_neg_flags");
38 depth++;
39
40 if(!prs_align(ps))
41 return False;
42
43 if(!prs_uint32("neg_flags", ps, depth, &neg->neg_flags))
44 return False;
45
46 return True;
47 }
48
49 /*******************************************************************
50 Inits a NETLOGON_INFO_3 structure.
51 ********************************************************************/
52
53 static void init_netinfo_3(NETLOGON_INFO_3 *info, uint32 flags, uint32 logon_attempts)
54 {
55 info->flags = flags;
56 info->logon_attempts = logon_attempts;
57 info->reserved_1 = 0x0;
58 info->reserved_2 = 0x0;
59 info->reserved_3 = 0x0;
60 info->reserved_4 = 0x0;
61 info->reserved_5 = 0x0;
62 }
63
64 /*******************************************************************
65 Reads or writes a NETLOGON_INFO_3 structure.
66 ********************************************************************/
67
68 static BOOL net_io_netinfo_3(char *desc, NETLOGON_INFO_3 *info, prs_struct *ps, int depth)
69 {
70 if (info == NULL)
71 return False;
72
73 prs_debug(ps, depth, desc, "net_io_netinfo_3");
74 depth++;
75
76 if(!prs_align(ps))
77 return False;
78
79 if(!prs_uint32("flags ", ps, depth, &info->flags))
80 return False;
81 if(!prs_uint32("logon_attempts", ps, depth, &info->logon_attempts))
82 return False;
83 if(!prs_uint32("reserved_1 ", ps, depth, &info->reserved_1))
84 return False;
85 if(!prs_uint32("reserved_2 ", ps, depth, &info->reserved_2))
86 return False;
87 if(!prs_uint32("reserved_3 ", ps, depth, &info->reserved_3))
88 return False;
89 if(!prs_uint32("reserved_4 ", ps, depth, &info->reserved_4))
90 return False;
91 if(!prs_uint32("reserved_5 ", ps, depth, &info->reserved_5))
92 return False;
93
94 return True;
95 }
96
97
98 /*******************************************************************
99 Inits a NETLOGON_INFO_1 structure.
100 ********************************************************************/
101
102 static void init_netinfo_1(NETLOGON_INFO_1 *info, uint32 flags, uint32 pdc_status)
103 {
104 info->flags = flags;
105 info->pdc_status = pdc_status;
106 }
107
108 /*******************************************************************
109 Reads or writes a NETLOGON_INFO_1 structure.
110 ********************************************************************/
111
112 static BOOL net_io_netinfo_1(char *desc, NETLOGON_INFO_1 *info, prs_struct *ps, int depth)
113 {
114 if (info == NULL)
115 return False;
116
117 prs_debug(ps, depth, desc, "net_io_netinfo_1");
118 depth++;
119
120 if(!prs_align(ps))
121 return False;
122
123 if(!prs_uint32("flags ", ps, depth, &info->flags))
124 return False;
125 if(!prs_uint32("pdc_status", ps, depth, &info->pdc_status))
126 return False;
127
128 return True;
129 }
130
131 /*******************************************************************
132 Inits a NETLOGON_INFO_2 structure.
133 ********************************************************************/
134
135 static void init_netinfo_2(NETLOGON_INFO_2 *info, uint32 flags, uint32 pdc_status,
136 uint32 tc_status, char *trusted_dc_name)
137 {
138 int len_dc_name = strlen(trusted_dc_name);
139 info->flags = flags;
140 info->pdc_status = pdc_status;
141 info->ptr_trusted_dc_name = 1;
142 info->tc_status = tc_status;
143
144 if (trusted_dc_name != NULL)
145 init_unistr2(&info->uni_trusted_dc_name, trusted_dc_name, len_dc_name+1);
146 else
147 init_unistr2(&info->uni_trusted_dc_name, "", 1);
148 }
149
150 /*******************************************************************
151 Reads or writes a NETLOGON_INFO_2 structure.
152 ********************************************************************/
153
154 static BOOL net_io_netinfo_2(char *desc, NETLOGON_INFO_2 *info, prs_struct *ps, int depth)
155 {
156 if (info == NULL)
157 return False;
158
159 prs_debug(ps, depth, desc, "net_io_netinfo_2");
160 depth++;
161
162 if(!prs_align(ps))
163 return False;
164
165 if(!prs_uint32("flags ", ps, depth, &info->flags))
166 return False;
167 if(!prs_uint32("pdc_status ", ps, depth, &info->pdc_status))
168 return False;
169 if(!prs_uint32("ptr_trusted_dc_name", ps, depth, &info->ptr_trusted_dc_name))
170 return False;
171 if(!prs_uint32("tc_status ", ps, depth, &info->tc_status))
172 return False;
173
174 if (info->ptr_trusted_dc_name != 0) {
175 if(!smb_io_unistr2("unistr2", &info->uni_trusted_dc_name, info->ptr_trusted_dc_name, ps, depth))
176 return False;
177 }
178
179 if(!prs_align(ps))
180 return False;
181
182 return True;
183 }
184
185 /*******************************************************************
186 Reads or writes an NET_Q_LOGON_CTRL2 structure.
187 ********************************************************************/
188
189 BOOL net_io_q_logon_ctrl2(char *desc, NET_Q_LOGON_CTRL2 *q_l, prs_struct *ps, int depth)
190 {
191 if (q_l == NULL)
192 return False;
193
194 prs_debug(ps, depth, desc, "net_io_q_logon_ctrl2");
195 depth++;
196
197 if(!prs_align(ps))
198 return False;
199
200 if(!prs_uint32("ptr ", ps, depth, &q_l->ptr))
201 return False;
202
203 if(!smb_io_unistr2 ("", &q_l->uni_server_name, q_l->ptr, ps, depth))
204 return False;
205
206 if(!prs_align(ps))
207 return False;
208
209 if(!prs_uint32("function_code", ps, depth, &q_l->function_code))
210 return False;
211 if(!prs_uint32("query_level ", ps, depth, &q_l->query_level))
212 return False;
213 if(!prs_uint32("switch_value ", ps, depth, &q_l->switch_value))
214 return False;
215
216 return True;
217 }
218
219 /*******************************************************************
220 Inits an NET_Q_LOGON_CTRL2 structure.
221 ********************************************************************/
222
223 void init_net_q_logon_ctrl2(NET_Q_LOGON_CTRL2 *q_l, char *srv_name,
224 uint32 query_level)
225 {
226 DEBUG(5,("init_q_logon_ctrl2\n"));
227
228 q_l->function_code = 0x01;
229 q_l->query_level = query_level;
230 q_l->switch_value = 0x01;
231
232 init_unistr2(&q_l->uni_server_name, srv_name, strlen(srv_name) + 1);
233 }
234
235 /*******************************************************************
236 Inits an NET_R_LOGON_CTRL2 structure.
237 ********************************************************************/
238
239 void init_net_r_logon_ctrl2(NET_R_LOGON_CTRL2 *r_l, uint32 query_level,
240 uint32 flags, uint32 pdc_status,
241 uint32 logon_attempts, uint32 tc_status,
242 char *trusted_domain_name)
243 {
244 DEBUG(5,("init_r_logon_ctrl2\n"));
245
246 r_l->switch_value = query_level; /* should only be 0x1 */
247
248 switch (query_level) {
249 case 1:
250 r_l->ptr = 1; /* undocumented pointer */
251 init_netinfo_1(&r_l->logon.info1, flags, pdc_status);
252 r_l->status = NT_STATUS_OK;
253 break;
254 case 2:
255 r_l->ptr = 1; /* undocumented pointer */
256 init_netinfo_2(&r_l->logon.info2, flags, pdc_status,
257 tc_status, trusted_domain_name);
258 r_l->status = NT_STATUS_OK;
259 break;
260 case 3:
261 r_l->ptr = 1; /* undocumented pointer */
262 init_netinfo_3(&r_l->logon.info3, flags, logon_attempts);
263 r_l->status = NT_STATUS_OK;
264 break;
265 default:
266 DEBUG(2,("init_r_logon_ctrl2: unsupported switch value %d\n",
267 r_l->switch_value));
268 r_l->ptr = 0; /* undocumented pointer */
269
270 /* take a guess at an error code... */
271 r_l->status = NT_STATUS_INVALID_INFO_CLASS;
272 break;
273 }
274 }
275
276 /*******************************************************************
277 Reads or writes an NET_R_LOGON_CTRL2 structure.
278 ********************************************************************/
279
280 BOOL net_io_r_logon_ctrl2(char *desc, NET_R_LOGON_CTRL2 *r_l, prs_struct *ps, int depth)
281 {
282 if (r_l == NULL)
283 return False;
284
285 prs_debug(ps, depth, desc, "net_io_r_logon_ctrl2");
286 depth++;
287
288 if(!prs_uint32("switch_value ", ps, depth, &r_l->switch_value))
289 return False;
290 if(!prs_uint32("ptr ", ps, depth, &r_l->ptr))
291 return False;
292
293 if (r_l->ptr != 0) {
294 switch (r_l->switch_value) {
295 case 1:
296 if(!net_io_netinfo_1("", &r_l->logon.info1, ps, depth))
297 return False;
298 break;
299 case 2:
300 if(!net_io_netinfo_2("", &r_l->logon.info2, ps, depth))
301 return False;
302 break;
303 case 3:
304 if(!net_io_netinfo_3("", &r_l->logon.info3, ps, depth))
305 return False;
306 break;
307 default:
308 DEBUG(2,("net_io_r_logon_ctrl2: unsupported switch value %d\n",
309 r_l->switch_value));
310 break;
311 }
312 }
313
314 if(!prs_ntstatus("status ", ps, depth, &r_l->status))
315 return False;
316
317 return True;
318 }
319
320 /*******************************************************************
321 Reads or writes an NET_Q_LOGON_CTRL structure.
322 ********************************************************************/
323
324 BOOL net_io_q_logon_ctrl(char *desc, NET_Q_LOGON_CTRL *q_l, prs_struct *ps,
325 int depth)
326 {
327 prs_debug(ps, depth, desc, "net_io_q_logon_ctrl");
328 depth++;
329
330 if(!prs_align(ps))
331 return False;
332
333 if(!prs_uint32("ptr ", ps, depth, &q_l->ptr))
334 return False;
335
336 if(!smb_io_unistr2 ("", &q_l->uni_server_name, q_l->ptr, ps, depth))
337 return False;
338
339 if(!prs_align(ps))
340 return False;
341
342 if(!prs_uint32("function_code", ps, depth, &q_l->function_code))
343 return False;
344 if(!prs_uint32("query_level ", ps, depth, &q_l->query_level))
345 return False;
346
347 return True;
348 }
349
350 /*******************************************************************
351 Inits an NET_Q_LOGON_CTRL structure.
352 ********************************************************************/
353
354 void init_net_q_logon_ctrl(NET_Q_LOGON_CTRL *q_l, char *srv_name,
355 uint32 query_level)
356 {
357 DEBUG(5,("init_q_logon_ctrl\n"));
358
359 q_l->function_code = 0x01; /* ??? */
360 q_l->query_level = query_level;
361
362 init_unistr2(&q_l->uni_server_name, srv_name, strlen(srv_name) + 1);
363 }
364
365 /*******************************************************************
366 Inits an NET_R_LOGON_CTRL structure.
367 ********************************************************************/
368
369 void init_net_r_logon_ctrl(NET_R_LOGON_CTRL *r_l, uint32 query_level,
370 uint32 flags, uint32 pdc_status)
371 {
372 DEBUG(5,("init_r_logon_ctrl\n"));
373
374 r_l->switch_value = query_level; /* should only be 0x1 */
375
376 switch (query_level) {
377 case 1:
378 r_l->ptr = 1; /* undocumented pointer */
379 init_netinfo_1(&r_l->logon.info1, flags, pdc_status);
380 r_l->status = NT_STATUS_OK;
381 break;
382 default:
383 DEBUG(2,("init_r_logon_ctrl: unsupported switch value %d\n",
384 r_l->switch_value));
385 r_l->ptr = 0; /* undocumented pointer */
386
387 /* take a guess at an error code... */
388 r_l->status = NT_STATUS_INVALID_INFO_CLASS;
389 break;
390 }
391 }
392
393 /*******************************************************************
394 Reads or writes an NET_R_LOGON_CTRL structure.
395 ********************************************************************/
396
397 BOOL net_io_r_logon_ctrl(char *desc, NET_R_LOGON_CTRL *r_l, prs_struct *ps,
398 int depth)
399 {
400 prs_debug(ps, depth, desc, "net_io_r_logon_ctrl");
401 depth++;
402
403 if(!prs_uint32("switch_value ", ps, depth, &r_l->switch_value))
404 return False;
405 if(!prs_uint32("ptr ", ps, depth, &r_l->ptr))
406 return False;
407
408 if (r_l->ptr != 0) {
409 switch (r_l->switch_value) {
410 case 1:
411 if(!net_io_netinfo_1("", &r_l->logon.info1, ps, depth))
412 return False;
413 break;
414 default:
415 DEBUG(2,("net_io_r_logon_ctrl: unsupported switch value %d\n",
416 r_l->switch_value));
417 break;
418 }
419 }
420
421 if(!prs_ntstatus("status ", ps, depth, &r_l->status))
422 return False;
423
424 return True;
425 }
426
427 /*******************************************************************
428 Inits an NET_R_TRUST_DOM_LIST structure.
429 ********************************************************************/
430
431 void init_r_trust_dom(NET_R_TRUST_DOM_LIST *r_t,
432 uint32 num_doms, char *dom_name)
433 {
434 int i = 0;
435
436 DEBUG(5,("init_r_trust_dom\n"));
437
438 for (i = 0; i < MAX_TRUST_DOMS; i++) {
439 r_t->uni_trust_dom_name[i].uni_str_len = 0;
440 r_t->uni_trust_dom_name[i].uni_max_len = 0;
441 }
442 if (num_doms > MAX_TRUST_DOMS)
443 num_doms = MAX_TRUST_DOMS;
444
445 for (i = 0; i < num_doms; i++) {
446 fstring domain_name;
447 fstrcpy(domain_name, dom_name);
448 strupper(domain_name);
449 init_unistr2(&r_t->uni_trust_dom_name[i], domain_name, strlen(domain_name)+1);
450 /* the use of UNISTR2 here is non-standard. */
451 r_t->uni_trust_dom_name[i].undoc = 0x1;
452 }
453
454 r_t->status = NT_STATUS_OK;
455 }
456
457 /*******************************************************************
458 Reads or writes an NET_R_TRUST_DOM_LIST structure.
459 ********************************************************************/
460
461 BOOL net_io_r_trust_dom(char *desc, NET_R_TRUST_DOM_LIST *r_t, prs_struct *ps, int depth)
462 {
463 uint32 value;
464
465 if (r_t == NULL)
466 return False;
467
468 prs_debug(ps, depth, desc, "net_io_r_trust_dom");
469 depth++;
470
471 /* temporary code to give a valid response */
472 value=2;
473 if(!prs_uint32("status", ps, depth, &value))
474 return False;
475
476 value=1;
477 if(!prs_uint32("status", ps, depth, &value))
478 return False;
479 value=2;
480 if(!prs_uint32("status", ps, depth, &value))
481 return False;
482
483 value=0;
484 if(!prs_uint32("status", ps, depth, &value))
485 return False;
486
487 value=0;
488 if(!prs_uint32("status", ps, depth, &value))
489 return False;
490
491 /* old non working code */
492 #if 0
493 int i;
494
495 for (i = 0; i < MAX_TRUST_DOMS; i++) {
496 if (r_t->uni_trust_dom_name[i].uni_str_len == 0)
497 break;
498 if(!smb_io_unistr2("", &r_t->uni_trust_dom_name[i], True, ps, depth))
499 return False;
500 }
501
502 if(!prs_ntstatus("status", ps, depth, &r_t->status))
503 return False;
504 #endif
505 return True;
506 }
507
508
509 /*******************************************************************
510 Reads or writes an NET_Q_TRUST_DOM_LIST structure.
511 ********************************************************************/
512
513 BOOL net_io_q_trust_dom(char *desc, NET_Q_TRUST_DOM_LIST *q_l, prs_struct *ps, int depth)
514 {
515 if (q_l == NULL)
516 return False;
517
518 prs_debug(ps, depth, desc, "net_io_q_trust_dom");
519 depth++;
520
521 if(!prs_uint32("ptr ", ps, depth, &q_l->ptr))
522 return False;
523 if(!smb_io_unistr2 ("", &q_l->uni_server_name, q_l->ptr, ps, depth))
524 return False;
525
526 return True;
527 }
528
529 /*******************************************************************
530 Inits an NET_Q_REQ_CHAL structure.
531 ********************************************************************/
532
533 void init_q_req_chal(NET_Q_REQ_CHAL *q_c,
534 const char *logon_srv, const char *logon_clnt,
535 DOM_CHAL *clnt_chal)
536 {
537 DEBUG(5,("init_q_req_chal: %d\n", __LINE__));
538
539 q_c->undoc_buffer = 1; /* don't know what this buffer is */
540
541 init_unistr2(&q_c->uni_logon_srv, logon_srv , strlen(logon_srv )+1);
542 init_unistr2(&q_c->uni_logon_clnt, logon_clnt, strlen(logon_clnt)+1);
543
544 memcpy(q_c->clnt_chal.data, clnt_chal->data, sizeof(clnt_chal->data));
545
546 DEBUG(5,("init_q_req_chal: %d\n", __LINE__));
547 }
548
549 /*******************************************************************
550 Reads or writes an NET_Q_REQ_CHAL structure.
551 ********************************************************************/
552
553 BOOL net_io_q_req_chal(char *desc, NET_Q_REQ_CHAL *q_c, prs_struct *ps, int depth)
554 {
555 int old_align;
556
557 if (q_c == NULL)
558 return False;
559
560 prs_debug(ps, depth, desc, "net_io_q_req_chal");
561 depth++;
562
563 if(!prs_align(ps))
564 return False;
565
566 if(!prs_uint32("undoc_buffer", ps, depth, &q_c->undoc_buffer))
567 return False;
568
569 if(!smb_io_unistr2("", &q_c->uni_logon_srv, True, ps, depth)) /* logon server unicode string */
570 return False;
571 if(!smb_io_unistr2("", &q_c->uni_logon_clnt, True, ps, depth)) /* logon client unicode string */
572 return False;
573
574 old_align = ps->align;
575 ps->align = 0;
576 /* client challenge is _not_ aligned after the unicode strings */
577 if(!smb_io_chal("", &q_c->clnt_chal, ps, depth)) {
578 /* client challenge */
579 ps->align = old_align;
580 return False;
581 }
582 ps->align = old_align;
583
584 return True;
585 }
586
587 /*******************************************************************
588 Reads or writes a structure.
589 ********************************************************************/
590
591 BOOL net_io_r_req_chal(char *desc, NET_R_REQ_CHAL *r_c, prs_struct *ps, int depth)
592 {
593 if (r_c == NULL)
594 return False;
595
596 prs_debug(ps, depth, desc, "net_io_r_req_chal");
597 depth++;
598
599 if(!prs_align(ps))
600 return False;
601
602 if(!smb_io_chal("", &r_c->srv_chal, ps, depth)) /* server challenge */
603 return False;
604
605 if(!prs_ntstatus("status", ps, depth, &r_c->status))
606 return False;
607
608 return True;
609 }
610
611
612 /*******************************************************************
613 Reads or writes a structure.
614 ********************************************************************/
615
616 BOOL net_io_q_auth(char *desc, NET_Q_AUTH *q_a, prs_struct *ps, int depth)
617 {
618 int old_align;
619 if (q_a == NULL)
620 return False;
621
622 prs_debug(ps, depth, desc, "net_io_q_auth");
623 depth++;
624
625 if(!prs_align(ps))
626 return False;
627
628 if(!smb_io_log_info ("", &q_a->clnt_id, ps, depth)) /* client identification info */
629 return False;
630 /* client challenge is _not_ aligned */
631 old_align = ps->align;
632 ps->align = 0;
633 if(!smb_io_chal("", &q_a->clnt_chal, ps, depth)) {
634 /* client-calculated credentials */
635 ps->align = old_align;
636 return False;
637 }
638 ps->align = old_align;
639
640 return True;
641 }
642
643 /*******************************************************************
644 Reads or writes a structure.
645 ********************************************************************/
646
647 BOOL net_io_r_auth(char *desc, NET_R_AUTH *r_a, prs_struct *ps, int depth)
648 {
649 if (r_a == NULL)
650 return False;
651
652 prs_debug(ps, depth, desc, "net_io_r_auth");
653 depth++;
654
655 if(!prs_align(ps))
656 return False;
657
658 if(!smb_io_chal("", &r_a->srv_chal, ps, depth)) /* server challenge */
659 return False;
660
661 if(!prs_ntstatus("status", ps, depth, &r_a->status))
662 return False;
663
664 return True;
665 }
666
667 /*******************************************************************
668 Inits a NET_Q_AUTH_2 struct.
669 ********************************************************************/
670
671 void init_q_auth_2(NET_Q_AUTH_2 *q_a,
672 const char *logon_srv, const char *acct_name, uint16 sec_chan, const char *comp_name,
673 DOM_CHAL *clnt_chal, uint32 clnt_flgs)
674 {
675 DEBUG(5,("init_q_auth_2: %d\n", __LINE__));
676
677 init_log_info(&q_a->clnt_id, logon_srv, acct_name, sec_chan, comp_name);
678 memcpy(q_a->clnt_chal.data, clnt_chal->data, sizeof(clnt_chal->data));
679 q_a->clnt_flgs.neg_flags = clnt_flgs;
680
681 DEBUG(5,("init_q_auth_2: %d\n", __LINE__));
682 }
683
684 /*******************************************************************
685 Reads or writes a structure.
686 ********************************************************************/
687
688 BOOL net_io_q_auth_2(char *desc, NET_Q_AUTH_2 *q_a, prs_struct *ps, int depth)
689 {
690 int old_align;
691 if (q_a == NULL)
692 return False;
693
694 prs_debug(ps, depth, desc, "net_io_q_auth_2");
695 depth++;
696
697 if(!prs_align(ps))
698 return False;
699
700 if(!smb_io_log_info ("", &q_a->clnt_id, ps, depth)) /* client identification info */
701 return False;
702 /* client challenge is _not_ aligned */
703 old_align = ps->align;
704 ps->align = 0;
705 if(!smb_io_chal("", &q_a->clnt_chal, ps, depth)) {
706 /* client-calculated credentials */
707 ps->align = old_align;
708 return False;
709 }
710 ps->align = old_align;
711 if(!net_io_neg_flags("", &q_a->clnt_flgs, ps, depth))
712 return False;
713
714 return True;
715 }
716
717 /*******************************************************************
718 Reads or writes a structure.
719 ********************************************************************/
720
721 BOOL net_io_r_auth_2(char *desc, NET_R_AUTH_2 *r_a, prs_struct *ps, int depth)
722 {
723 if (r_a == NULL)
724 return False;
725
726 prs_debug(ps, depth, desc, "net_io_r_auth_2");
727 depth++;
728
729 if(!prs_align(ps))
730 return False;
731
732 if(!smb_io_chal("", &r_a->srv_chal, ps, depth)) /* server challenge */
733 return False;
734 if(!net_io_neg_flags("", &r_a->srv_flgs, ps, depth))
735 return False;
736
737 if(!prs_ntstatus("status", ps, depth, &r_a->status))
738 return False;
739
740 return True;
741 }
742
743
744 /*******************************************************************
745 Inits a NET_Q_SRV_PWSET.
746 ********************************************************************/
747
748 void init_q_srv_pwset(NET_Q_SRV_PWSET *q_s, char *logon_srv, char *sess_key, char *acct_name,
749 uint16 sec_chan, char *comp_name, DOM_CRED *cred, uchar hashed_mach_pwd[16])
750 {
751 unsigned char nt_cypher[16];
752
753 DEBUG(5,("init_q_srv_pwset\n"));
754
755 /* Process the new password. */
756 cred_hash3( nt_cypher, hashed_mach_pwd, sess_key, 1);
757
758 init_clnt_info(&q_s->clnt_id, logon_srv, acct_name, sec_chan, comp_name, cred);
759
760 memcpy(q_s->pwd, nt_cypher, sizeof(q_s->pwd));
761 }
762
763 /*******************************************************************
764 Reads or writes a structure.
765 ********************************************************************/
766
767 BOOL net_io_q_srv_pwset(char *desc, NET_Q_SRV_PWSET *q_s, prs_struct *ps, int depth)
768 {
769 if (q_s == NULL)
770 return False;
771
772 prs_debug(ps, depth, desc, "net_io_q_srv_pwset");
773 depth++;
774
775 if(!prs_align(ps))
776 return False;
777
778 if(!smb_io_clnt_info("", &q_s->clnt_id, ps, depth)) /* client identification/authentication info */
779 return False;
780 if(!prs_uint8s (False, "pwd", ps, depth, q_s->pwd, 16)) /* new password - undocumented */
781 return False;
782
783 return True;
784 }
785
786 /*******************************************************************
787 Reads or writes a structure.
788 ********************************************************************/
789
790 BOOL net_io_r_srv_pwset(char *desc, NET_R_SRV_PWSET *r_s, prs_struct *ps, int depth)
791 {
792 if (r_s == NULL)
793 return False;
794
795 prs_debug(ps, depth, desc, "net_io_r_srv_pwset");
796 depth++;
797
798 if(!prs_align(ps))
799 return False;
800
801 if(!smb_io_cred("", &r_s->srv_cred, ps, depth)) /* server challenge */
802 return False;
803
804 if(!prs_ntstatus("status", ps, depth, &r_s->status))
805 return False;
806
807 return True;
808 }
809
810 /*************************************************************************
811 Init DOM_SID2 array from a string containing multiple sids
812 *************************************************************************/
813
814 static int init_dom_sid2s(TALLOC_CTX *ctx, char *sids_str, DOM_SID2 **ppsids)
815 {
816 char *ptr;
817 pstring s2;
818 int count = 0;
819
820 DEBUG(4,("init_dom_sid2s: %s\n", sids_str ? sids_str:""));
821
822 *ppsids = NULL;
823
824 if(sids_str) {
825 int number;
826 DOM_SID2 *sids;
827
828 /* Count the number of SIDs. */
829 for (count = 0, ptr = sids_str;
830 next_token(&ptr, s2, NULL, sizeof(s2)); count++)
831 ;
832
833 /* Now allocate space for them. */
834 *ppsids = (DOM_SID2 *)talloc_zero(ctx, count * sizeof(DOM_SID2));
835 if (*ppsids == NULL)
836 return 0;
837
838 sids = *ppsids;
839
840 for (number = 0, ptr = sids_str;
841 next_token(&ptr, s2, NULL, sizeof(s2)); number++) {
842 DOM_SID tmpsid;
843 string_to_sid(&tmpsid, s2);
844 init_dom_sid2(&sids[number], &tmpsid);
845 }
846 }
847
848 return count;
849 }
850
851 /*******************************************************************
852 Inits a NET_ID_INFO_1 structure.
853 ********************************************************************/
854
855 void init_id_info1(NET_ID_INFO_1 *id, char *domain_name,
856 uint32 param_ctrl, uint32 log_id_low, uint32 log_id_high,
857 char *user_name, char *wksta_name,
858 char *sess_key,
859 unsigned char lm_cypher[16], unsigned char nt_cypher[16])
860 {
861 int len_domain_name = strlen(domain_name);
862 int len_user_name = strlen(user_name );
863 int len_wksta_name = strlen(wksta_name );
864
865 unsigned char lm_owf[16];
866 unsigned char nt_owf[16];
867
868 DEBUG(5,("init_id_info1: %d\n", __LINE__));
869
870 id->ptr_id_info1 = 1;
871
872 init_uni_hdr(&id->hdr_domain_name, len_domain_name);
873
874 id->param_ctrl = param_ctrl;
875 init_logon_id(&id->logon_id, log_id_low, log_id_high);
876
877 init_uni_hdr(&id->hdr_user_name, len_user_name);
878 init_uni_hdr(&id->hdr_wksta_name, len_wksta_name);
879
880 if (lm_cypher && nt_cypher) {
881 unsigned char key[16];
882 #ifdef DEBUG_PASSWORD
883 DEBUG(100,("lm cypher:"));
884 dump_data(100, (char *)lm_cypher, 16);
885
886 DEBUG(100,("nt cypher:"));
887 dump_data(100, (char *)nt_cypher, 16);
888 #endif
889
890 memset(key, 0, 16);
891 memcpy(key, sess_key, 8);
892
893 memcpy(lm_owf, lm_cypher, 16);
894 SamOEMhash(lm_owf, key, 16);
895 memcpy(nt_owf, nt_cypher, 16);
896 SamOEMhash(nt_owf, key, 16);
897
898 #ifdef DEBUG_PASSWORD
899 DEBUG(100,("encrypt of lm owf password:"));
900 dump_data(100, (char *)lm_owf, 16);
901
902 DEBUG(100,("encrypt of nt owf password:"));
903 dump_data(100, (char *)nt_owf, 16);
904 #endif
905 /* set up pointers to cypher blocks */
906 lm_cypher = lm_owf;
907 nt_cypher = nt_owf;
908 }
909
910 init_owf_info(&id->lm_owf, lm_cypher);
911 init_owf_info(&id->nt_owf, nt_cypher);
912
913 init_unistr2(&id->uni_domain_name, domain_name, len_domain_name);
914 init_unistr2(&id->uni_user_name, user_name, len_user_name);
915 init_unistr2(&id->uni_wksta_name, wksta_name, len_wksta_name);
916 }
917
918 /*******************************************************************
919 Reads or writes an NET_ID_INFO_1 structure.
920 ********************************************************************/
921
922 static BOOL net_io_id_info1(char *desc, NET_ID_INFO_1 *id, prs_struct *ps, int depth)
923 {
924 if (id == NULL)
925 return False;
926
927 prs_debug(ps, depth, desc, "net_io_id_info1");
928 depth++;
929
930 if(!prs_align(ps))
931 return False;
932
933 if(!prs_uint32("ptr_id_info1", ps, depth, &id->ptr_id_info1))
934 return False;
935
936 if (id->ptr_id_info1 != 0) {
937 if(!smb_io_unihdr("unihdr", &id->hdr_domain_name, ps, depth))
938 return False;
939
940 if(!prs_uint32("param_ctrl", ps, depth, &id->param_ctrl))
941 return False;
942 if(!smb_io_logon_id("", &id->logon_id, ps, depth))
943 return False;
944
945 if(!smb_io_unihdr("unihdr", &id->hdr_user_name, ps, depth))
946 return False;
947 if(!smb_io_unihdr("unihdr", &id->hdr_wksta_name, ps, depth))
948 return False;
949
950 if(!smb_io_owf_info("", &id->lm_owf, ps, depth))
951 return False;
952 if(!smb_io_owf_info("", &id->nt_owf, ps, depth))
953 return False;
954
955 if(!smb_io_unistr2("unistr2", &id->uni_domain_name,
956 id->hdr_domain_name.buffer, ps, depth))
957 return False;
958 if(!smb_io_unistr2("unistr2", &id->uni_user_name,
959 id->hdr_user_name.buffer, ps, depth))
960 return False;
961 if(!smb_io_unistr2("unistr2", &id->uni_wksta_name,
962 id->hdr_wksta_name.buffer, ps, depth))
963 return False;
964 }
965
966 return True;
967 }
968
969 /*******************************************************************
970 Inits a NET_ID_INFO_2 structure.
971
972 This is a network logon packet. The log_id parameters
973 are what an NT server would generate for LUID once the
974 user is logged on. I don't think we care about them.
975
976 Note that this has no access to the NT and LM hashed passwords,
977 so it forwards the challenge, and the NT and LM responses (24
978 bytes each) over the secure channel to the Domain controller
979 for it to say yea or nay. This is the preferred method of
980 checking for a logon as it doesn't export the password
981 hashes to anyone who has compromised the secure channel. JRA.
982 ********************************************************************/
983
984 void init_id_info2(NET_ID_INFO_2 * id, const char *domain_name,
985 uint32 param_ctrl,
986 uint32 log_id_low, uint32 log_id_high,
987 const char *user_name, const char *wksta_name,
988 const uchar lm_challenge[8],
989 const uchar * lm_chal_resp, int lm_chal_resp_len,
990 const uchar * nt_chal_resp, int nt_chal_resp_len)
991 {
992 int len_domain_name = strlen(domain_name);
993 int len_user_name = strlen(user_name );
994 int len_wksta_name = strlen(wksta_name );
995 unsigned char lm_owf[24];
996 unsigned char nt_owf[128];
997
998 DEBUG(5,("init_id_info2: %d\n", __LINE__));
999
1000 id->ptr_id_info2 = 1;
1001
1002 init_uni_hdr(&id->hdr_domain_name, len_domain_name);
1003
1004 id->param_ctrl = param_ctrl;
1005 init_logon_id(&id->logon_id, log_id_low, log_id_high);
1006
1007 init_uni_hdr(&id->hdr_user_name, len_user_name);
1008 init_uni_hdr(&id->hdr_wksta_name, len_wksta_name);
1009
1010 if (nt_chal_resp) {
1011 /* oops. can only send what-ever-it-is direct */
1012 memcpy(nt_owf, nt_chal_resp, MIN(sizeof(nt_owf), nt_chal_resp_len));
1013 nt_chal_resp = nt_owf;
1014 }
1015 if (lm_chal_resp) {
1016 /* oops. can only send what-ever-it-is direct */
1017 memcpy(lm_owf, lm_chal_resp, MIN(sizeof(lm_owf), lm_chal_resp_len));
1018 lm_chal_resp = lm_owf;
1019 }
1020
1021 memcpy(id->lm_chal, lm_challenge, sizeof(id->lm_chal));
1022 init_str_hdr(&id->hdr_nt_chal_resp, nt_chal_resp_len, nt_chal_resp_len, (nt_chal_resp != NULL) ? 1 : 0);
1023 init_str_hdr(&id->hdr_lm_chal_resp, lm_chal_resp_len, lm_chal_resp_len, (lm_chal_resp != NULL) ? 1 : 0);
1024
1025 init_unistr2(&id->uni_domain_name, domain_name, len_domain_name);
1026 init_unistr2(&id->uni_user_name, user_name, len_user_name);
1027 init_unistr2(&id->uni_wksta_name, wksta_name, len_wksta_name);
1028
1029 init_string2(&id->nt_chal_resp, (const char *)nt_chal_resp, nt_chal_resp_len, nt_chal_resp_len);
1030 init_string2(&id->lm_chal_resp, (const char *)lm_chal_resp, lm_chal_resp_len, lm_chal_resp_len);
1031
1032 }
1033
1034 /*******************************************************************
1035 Reads or writes an NET_ID_INFO_2 structure.
1036 ********************************************************************/
1037
1038 static BOOL net_io_id_info2(char *desc, NET_ID_INFO_2 *id, prs_struct *ps, int depth)
1039 {
1040 if (id == NULL)
1041 return False;
1042
1043 prs_debug(ps, depth, desc, "net_io_id_info2");
1044 depth++;
1045
1046 if(!prs_align(ps))
1047 return False;
1048
1049 if(!prs_uint32("ptr_id_info2", ps, depth, &id->ptr_id_info2))
1050 return False;
1051
1052 if (id->ptr_id_info2 != 0) {
1053 if(!smb_io_unihdr("unihdr", &id->hdr_domain_name, ps, depth))
1054 return False;
1055
1056 if(!prs_uint32("param_ctrl", ps, depth, &id->param_ctrl))
1057 return False;
1058 if(!smb_io_logon_id("", &id->logon_id, ps, depth))
1059 return False;
1060
1061 if(!smb_io_unihdr("unihdr", &id->hdr_user_name, ps, depth))
1062 return False;
1063 if(!smb_io_unihdr("unihdr", &id->hdr_wksta_name, ps, depth))
1064 return False;
1065
1066 if(!prs_uint8s (False, "lm_chal", ps, depth, id->lm_chal, 8)) /* lm 8 byte challenge */
1067 return False;
1068
1069 if(!smb_io_strhdr("hdr_nt_chal_resp", &id->hdr_nt_chal_resp, ps, depth))
1070 return False;
1071 if(!smb_io_strhdr("hdr_lm_chal_resp", &id->hdr_lm_chal_resp, ps, depth))
1072 return False;
1073
1074 if(!smb_io_unistr2("uni_domain_name", &id->uni_domain_name,
1075 id->hdr_domain_name.buffer, ps, depth))
1076 return False;
1077 if(!smb_io_unistr2("uni_user_name ", &id->uni_user_name,
1078 id->hdr_user_name.buffer, ps, depth))
1079 return False;
1080 if(!smb_io_unistr2("uni_wksta_name ", &id->uni_wksta_name,
1081 id->hdr_wksta_name.buffer, ps, depth))
1082 return False;
1083 if(!smb_io_string2("nt_chal_resp", &id->nt_chal_resp,
1084 id->hdr_nt_chal_resp.buffer, ps, depth))
1085 return False;
1086 if(!smb_io_string2("lm_chal_resp", &id->lm_chal_resp,
1087 id->hdr_lm_chal_resp.buffer, ps, depth))
1088 return False;
1089 }
1090
1091 return True;
1092 }
1093
1094
1095 /*******************************************************************
1096 Inits a DOM_SAM_INFO structure.
1097 ********************************************************************/
1098
1099 void init_sam_info(DOM_SAM_INFO *sam,
1100 char *logon_srv, char *comp_name, DOM_CRED *clnt_cred,
1101 DOM_CRED *rtn_cred, uint16 logon_level,
1102 NET_ID_INFO_CTR *ctr)
1103 {
1104 DEBUG(5,("init_sam_info: %d\n", __LINE__));
1105
1106 init_clnt_info2(&sam->client, logon_srv, comp_name, clnt_cred);
1107
1108 if (rtn_cred != NULL) {
1109 sam->ptr_rtn_cred = 1;
1110 memcpy(&sam->rtn_cred, rtn_cred, sizeof(sam->rtn_cred));
1111 } else {
1112 sam->ptr_rtn_cred = 0;
1113 }
1114
1115 sam->logon_level = logon_level;
1116 sam->ctr = ctr;
1117 }
1118
1119 /*******************************************************************
1120 Reads or writes a DOM_SAM_INFO structure.
1121 ********************************************************************/
1122
1123 static BOOL net_io_id_info_ctr(char *desc, NET_ID_INFO_CTR **pp_ctr, prs_struct *ps, int depth)
1124 {
1125 NET_ID_INFO_CTR *ctr = *pp_ctr;
1126
1127 prs_debug(ps, depth, desc, "smb_io_sam_info");
1128 depth++;
1129
1130 if (UNMARSHALLING(ps)) {
1131 ctr = *pp_ctr = (NET_ID_INFO_CTR *)prs_alloc_mem(ps, sizeof(NET_ID_INFO_CTR));
1132 if (ctr == NULL)
1133 return False;
1134 }
1135
1136 if (ctr == NULL)
1137 return False;
1138
1139 /* don't 4-byte align here! */
1140
1141 if(!prs_uint16("switch_value ", ps, depth, &ctr->switch_value))
1142 return False;
1143
1144 switch (ctr->switch_value) {
1145 case 1:
1146 if(!net_io_id_info1("", &ctr->auth.id1, ps, depth))
1147 return False;
1148 break;
1149 case 2:
1150 if(!net_io_id_info2("", &ctr->auth.id2, ps, depth))
1151 return False;
1152 break;
1153 default:
1154 /* PANIC! */
1155 DEBUG(4,("smb_io_sam_info: unknown switch_value!\n"));
1156 break;
1157 }
1158
1159 return True;
1160 }
1161
1162 /*******************************************************************
1163 Reads or writes a DOM_SAM_INFO structure.
1164 ********************************************************************/
1165
1166 static BOOL smb_io_sam_info(char *desc, DOM_SAM_INFO *sam, prs_struct *ps, int depth)
1167 {
1168 if (sam == NULL)
1169 return False;
1170
1171 prs_debug(ps, depth, desc, "smb_io_sam_info");
1172 depth++;
1173
1174 if(!prs_align(ps))
1175 return False;
1176
1177 if(!smb_io_clnt_info2("", &sam->client, ps, depth))
1178 return False;
1179
1180 if(!prs_uint32("ptr_rtn_cred ", ps, depth, &sam->ptr_rtn_cred))
1181 return False;
1182 if(!smb_io_cred("", &sam->rtn_cred, ps, depth))
1183 return False;
1184
1185 if(!prs_uint16("logon_level ", ps, depth, &sam->logon_level))
1186 return False;
1187
1188 if (sam->logon_level != 0) {
1189 if(!net_io_id_info_ctr("logon_info", &sam->ctr, ps, depth))
1190 return False;
1191 }
1192
1193 return True;
1194 }
1195
1196 /*************************************************************************
1197 Inits a NET_USER_INFO_3 structure.
1198
1199 This is a network logon reply packet, and contains much information about
1200 the user. This information is passed as a (very long) paramater list
1201 to avoid having to link in the PASSDB code to every program that deals
1202 with this file.
1203 *************************************************************************/
1204
1205 void init_net_user_info3(TALLOC_CTX *ctx, NET_USER_INFO_3 *usr,
1206 uint32 user_rid,
1207 uint32 group_rid,
1208
1209 const char* user_name,
1210 const char* full_name,
1211 const char* home_dir,
1212 const char* dir_drive,
1213 const char* logon_script,
1214 const char* profile_path,
1215
1216 time_t unix_logon_time,
1217 time_t unix_logoff_time,
1218 time_t unix_kickoff_time,
1219 time_t unix_pass_last_set_time,
1220 time_t unix_pass_can_change_time,
1221 time_t unix_pass_must_change_time,
1222
1223 uint16 logon_count, uint16 bad_pw_count,
1224 uint32 num_groups, const DOM_GID *gids,
1225 uint32 user_flgs, uchar *sess_key,
1226 const char *logon_srv, const char *logon_dom,
1227 const DOM_SID *dom_sid, char *other_sids)
1228 {
1229 /* only cope with one "other" sid, right now. */
1230 /* need to count the number of space-delimited sids */
1231 int i;
1232 int num_other_sids = 0;
1233
1234 NTTIME logon_time, logoff_time, kickoff_time,
1235 pass_last_set_time, pass_can_change_time,
1236 pass_must_change_time;
1237
1238 int len_user_name, len_full_name, len_home_dir,
1239 len_dir_drive, len_logon_script, len_profile_path;
1240
1241 int len_logon_srv = strlen(logon_srv);
1242 int len_logon_dom = strlen(logon_dom);
1243
1244 len_user_name = strlen(user_name );
1245 len_full_name = strlen(full_name );
1246 len_home_dir = strlen(home_dir );
1247 len_dir_drive = strlen(dir_drive );
1248 len_logon_script = strlen(logon_script);
1249 len_profile_path = strlen(profile_path);
1250
1251
1252 ZERO_STRUCTP(usr);
1253
1254 usr->ptr_user_info = 1; /* yes, we're bothering to put USER_INFO data here */
1255
1256
1257 /* Create NTTIME structs */
1258 unix_to_nt_time (&logon_time, unix_logon_time);
1259 unix_to_nt_time (&logoff_time, unix_logoff_time);
1260 unix_to_nt_time (&kickoff_time, unix_kickoff_time);
1261 unix_to_nt_time (&pass_last_set_time, unix_pass_last_set_time);
1262 unix_to_nt_time (&pass_can_change_time, unix_pass_can_change_time);
1263 unix_to_nt_time (&pass_must_change_time, unix_pass_must_change_time);
1264
1265 usr->logon_time = logon_time;
1266 usr->logoff_time = logoff_time;
1267 usr->kickoff_time = kickoff_time;
1268 usr->pass_last_set_time = pass_last_set_time;
1269 usr->pass_can_change_time = pass_can_change_time;
1270 usr->pass_must_change_time = pass_must_change_time;
1271
1272 init_uni_hdr(&usr->hdr_user_name, len_user_name);
1273 init_uni_hdr(&usr->hdr_full_name, len_full_name);
1274 init_uni_hdr(&usr->hdr_logon_script, len_logon_script);
1275 init_uni_hdr(&usr->hdr_profile_path, len_profile_path);
1276 init_uni_hdr(&usr->hdr_home_dir, len_home_dir);
1277 init_uni_hdr(&usr->hdr_dir_drive, len_dir_drive);
1278
1279 usr->logon_count = logon_count;
1280 usr->bad_pw_count = bad_pw_count;
1281
1282 usr->user_rid = user_rid;
1283 usr->group_rid = group_rid;
1284 usr->num_groups = num_groups;
1285
1286 usr->buffer_groups = 1; /* indicates fill in groups, below, even if there are none */
1287 usr->user_flgs = user_flgs;
1288
1289 if (sess_key != NULL)
1290 memcpy(usr->user_sess_key, sess_key, sizeof(usr->user_sess_key));
1291 else
1292 memset((char *)usr->user_sess_key, '\0', sizeof(usr->user_sess_key));
1293
1294 init_uni_hdr(&usr->hdr_logon_srv, len_logon_srv);
1295 init_uni_hdr(&usr->hdr_logon_dom, len_logon_dom);
1296
1297 usr->buffer_dom_id = dom_sid ? 1 : 0; /* yes, we're bothering to put a domain SID in */
1298
1299 memset((char *)usr->padding, '\0', sizeof(usr->padding));
1300
1301 num_other_sids = init_dom_sid2s(ctx, other_sids, &usr->other_sids);
1302
1303 usr->num_other_sids = num_other_sids;
1304 usr->buffer_other_sids = (num_other_sids != 0) ? 1 : 0;
1305
1306 init_unistr2(&usr->uni_user_name, user_name, len_user_name);
1307 init_unistr2(&usr->uni_full_name, full_name, len_full_name);
1308 init_unistr2(&usr->uni_logon_script, logon_script, len_logon_script);
1309 init_unistr2(&usr->uni_profile_path, profile_path, len_profile_path);
1310 init_unistr2(&usr->uni_home_dir, home_dir, len_home_dir);
1311 init_unistr2(&usr->uni_dir_drive, dir_drive, len_dir_drive);
1312
1313 usr->num_groups2 = num_groups;
1314
1315 usr->gids = (DOM_GID *)talloc_zero(ctx,sizeof(DOM_GID) * (num_groups));
1316 if (usr->gids == NULL && num_groups>0)
1317 return;
1318
1319 for (i = 0; i < num_groups; i++)
1320 usr->gids[i] = gids[i];
1321
1322 init_unistr2(&usr->uni_logon_srv, logon_srv, len_logon_srv);
1323 init_unistr2(&usr->uni_logon_dom, logon_dom, len_logon_dom);
1324
1325 init_dom_sid2(&usr->dom_sid, dom_sid);
1326 /* "other" sids are set up above */
1327 }
1328
1329 /*******************************************************************
1330 This code has been modified to cope with a NET_USER_INFO_2 - which is
1331 exactly the same as a NET_USER_INFO_3, minus the other sids parameters.
1332 We use validation level to determine if we're marshalling a info 2 or
1333 INFO_3 - be we always return an INFO_3. Based on code donated by Marc
1334 Jacobsen at HP. JRA.
1335 ********************************************************************/
1336
1337 BOOL net_io_user_info3(const char *desc, NET_USER_INFO_3 *usr, prs_struct *ps,
1338 int depth, uint16 validation_level)
1339 {
1340 int i;
1341
1342 if (usr == NULL)
1343 return False;
1344
1345 prs_debug(ps, depth, desc, "net_io_user_info3");
1346 depth++;
1347
1348 if (UNMARSHALLING(ps))
1349 ZERO_STRUCTP(usr);
1350
1351 if(!prs_align(ps))
1352 return False;
1353
1354 if(!prs_uint32("ptr_user_info ", ps, depth, &usr->ptr_user_info))
1355 return False;
1356
1357 if (usr->ptr_user_info == 0)
1358 return True;
1359
1360 if(!smb_io_time("logon time", &usr->logon_time, ps, depth)) /* logon time */
1361 return False;
1362 if(!smb_io_time("logoff time", &usr->logoff_time, ps, depth)) /* logoff time */
1363 return False;
1364 if(!smb_io_time("kickoff time", &usr->kickoff_time, ps, depth)) /* kickoff time */
1365 return False;
1366 if(!smb_io_time("last set time", &usr->pass_last_set_time, ps, depth)) /* password last set time */
1367 return False;
1368 if(!smb_io_time("can change time", &usr->pass_can_change_time , ps, depth)) /* password can change time */
1369 return False;
1370 if(!smb_io_time("must change time", &usr->pass_must_change_time, ps, depth)) /* password must change time */
1371 return False;
1372
1373 if(!smb_io_unihdr("hdr_user_name", &usr->hdr_user_name, ps, depth)) /* username unicode string header */
1374 return False;
1375 if(!smb_io_unihdr("hdr_full_name", &usr->hdr_full_name, ps, depth)) /* user's full name unicode string header */
1376 return False;
1377 if(!smb_io_unihdr("hdr_logon_script", &usr->hdr_logon_script, ps, depth)) /* logon script unicode string header */
1378 return False;
1379 if(!smb_io_unihdr("hdr_profile_path", &usr->hdr_profile_path, ps, depth)) /* profile path unicode string header */
1380 return False;
1381 if(!smb_io_unihdr("hdr_home_dir", &usr->hdr_home_dir, ps, depth)) /* home directory unicode string header */
1382 return False;
1383 if(!smb_io_unihdr("hdr_dir_drive", &usr->hdr_dir_drive, ps, depth)) /* home directory drive unicode string header */
1384 return False;
1385
1386 if(!prs_uint16("logon_count ", ps, depth, &usr->logon_count)) /* logon count */
1387 return False;
1388 if(!prs_uint16("bad_pw_count ", ps, depth, &usr->bad_pw_count)) /* bad password count */
1389 return False;
1390
1391 if(!prs_uint32("user_rid ", ps, depth, &usr->user_rid)) /* User RID */
1392 return False;
1393 if(!prs_uint32("group_rid ", ps, depth, &usr->group_rid)) /* Group RID */
1394 return False;
1395 if(!prs_uint32("num_groups ", ps, depth, &usr->num_groups)) /* num groups */
1396 return False;
1397 if(!prs_uint32("buffer_groups ", ps, depth, &usr->buffer_groups)) /* undocumented buffer pointer to groups. */
1398 return False;
1399 if(!prs_uint32("user_flgs ", ps, depth, &usr->user_flgs)) /* user flags */
1400 return False;
1401
1402 if(!prs_uint8s(False, "user_sess_key", ps, depth, usr->user_sess_key, 16)) /* unused user session key */
1403 return False;
1404
1405 if(!smb_io_unihdr("hdr_logon_srv", &usr->hdr_logon_srv, ps, depth)) /* logon server unicode string header */
1406 return False;
1407 if(!smb_io_unihdr("hdr_logon_dom", &usr->hdr_logon_dom, ps, depth)) /* logon domain unicode string header */
1408 return False;
1409
1410 if(!prs_uint32("buffer_dom_id ", ps, depth, &usr->buffer_dom_id)) /* undocumented logon domain id pointer */
1411 return False;
1412 if(!prs_uint8s (False, "padding ", ps, depth, usr->padding, 40)) /* unused padding bytes? */
1413 return False;
1414
1415 if (validation_level == 3) {
1416 if(!prs_uint32("num_other_sids", ps, depth, &usr->num_other_sids)) /* 0 - num_sids */
1417 return False;
1418 if(!prs_uint32("buffer_other_sids", ps, depth, &usr->buffer_other_sids)) /* NULL - undocumented pointer to SIDs. */
1419 return False;
1420 } else {
1421 if (UNMARSHALLING(ps)) {
1422 usr->num_other_sids = 0;
1423 usr->buffer_other_sids = 0;
1424 }
1425 }
1426
1427 if(!smb_io_unistr2("uni_user_name", &usr->uni_user_name, usr->hdr_user_name.buffer, ps, depth)) /* username unicode string */
1428 return False;
1429 if(!smb_io_unistr2("uni_full_name", &usr->uni_full_name, usr->hdr_full_name.buffer, ps, depth)) /* user's full name unicode string */
1430 return False;
1431 if(!smb_io_unistr2("uni_logon_script", &usr->uni_logon_script, usr->hdr_logon_script.buffer, ps, depth)) /* logon script unicode string */
1432 return False;
1433 if(!smb_io_unistr2("uni_profile_path", &usr->uni_profile_path, usr->hdr_profile_path.buffer, ps, depth)) /* profile path unicode string */
1434 return False;
1435 if(!smb_io_unistr2("uni_home_dir", &usr->uni_home_dir, usr->hdr_home_dir.buffer, ps, depth)) /* home directory unicode string */
1436 return False;
1437 if(!smb_io_unistr2("uni_dir_drive", &usr->uni_dir_drive, usr->hdr_dir_drive.buffer, ps, depth)) /* home directory drive unicode string */
1438 return False;
1439
1440 if(!prs_align(ps))
1441 return False;
1442 if(!prs_uint32("num_groups2 ", ps, depth, &usr->num_groups2)) /* num groups */
1443 return False;
1444
1445 if (UNMARSHALLING(ps) && usr->num_groups2 > 0) {
1446 usr->gids = (DOM_GID *)prs_alloc_mem(ps, sizeof(DOM_GID)*usr->num_groups2);
1447 if (usr->gids == NULL)
1448 return False;
1449 }
1450
1451 for (i = 0; i < usr->num_groups2; i++) {
1452 if(!smb_io_gid("", &usr->gids[i], ps, depth)) /* group info */
1453 return False;
1454 }
1455
1456 if(!smb_io_unistr2("uni_logon_srv", &usr->uni_logon_srv, usr->hdr_logon_srv.buffer, ps, depth)) /* logon server unicode string */
1457 return False;
1458 if(!smb_io_unistr2("uni_logon_dom", &usr->uni_logon_dom, usr->hdr_logon_srv.buffer, ps, depth)) /* logon domain unicode string */
1459 return False;
1460
1461 if(!smb_io_dom_sid2("", &usr->dom_sid, ps, depth)) /* domain SID */
1462 return False;
1463
1464 if (usr->num_other_sids) {
1465
1466 if (UNMARSHALLING(ps)) {
1467 usr->other_sids = (DOM_SID2 *)prs_alloc_mem(ps, sizeof(DOM_SID2)*usr->num_other_sids);
1468 if (usr->other_sids == NULL)
1469 return False;
1470 }
1471
1472 if(!prs_uint32("num_other_groups", ps, depth, &usr->num_other_groups))
1473 return False;
1474
1475 if (UNMARSHALLING(ps) && usr->num_other_groups > 0) {
1476 usr->other_gids = (DOM_GID *)prs_alloc_mem(ps, sizeof(DOM_GID)*usr->num_other_groups);
1477 if (usr->other_gids == NULL)
1478 return False;
1479 }
1480
1481 for (i = 0; i < usr->num_other_groups; i++) {
1482 if(!smb_io_gid("", &usr->other_gids[i], ps, depth)) /* other GIDs */
1483 return False;
1484 }
1485 for (i = 0; i < usr->num_other_sids; i++) {
1486 if(!smb_io_dom_sid2("", &usr->other_sids[i], ps, depth)) /* other domain SIDs */
1487 return False;
1488 }
1489 }
1490
1491 return True;
1492 }
1493
1494 /*******************************************************************
1495 Reads or writes a structure.
1496 ********************************************************************/
1497
1498 BOOL net_io_q_sam_logon(char *desc, NET_Q_SAM_LOGON *q_l, prs_struct *ps, int depth)
1499 {
1500 if (q_l == NULL)
1501 return False;
1502
1503 prs_debug(ps, depth, desc, "net_io_q_sam_logon");
1504 depth++;
1505
1506 if(!prs_align(ps))
1507 return False;
1508
1509 if(!smb_io_sam_info("", &q_l->sam_id, ps, depth))
1510 return False;
1511
1512 if(!prs_uint16("validation_level", ps, depth, &q_l->validation_level))
1513 return False;
1514
1515 return True;
1516 }
1517
1518 /*******************************************************************
1519 Reads or writes a structure.
1520 ********************************************************************/
1521
1522 BOOL net_io_r_sam_logon(char *desc, NET_R_SAM_LOGON *r_l, prs_struct *ps, int depth)
1523 {
1524 if (r_l == NULL)
1525 return False;
1526
1527 prs_debug(ps, depth, desc, "net_io_r_sam_logon");
1528 depth++;
1529
1530 if(!prs_uint32("buffer_creds", ps, depth, &r_l->buffer_creds)) /* undocumented buffer pointer */
1531 return False;
1532 if(!smb_io_cred("", &r_l->srv_creds, ps, depth)) /* server credentials. server time stamp appears to be ignored. */
1533 return False;
1534
1535 if(!prs_uint16("switch_value", ps, depth, &r_l->switch_value))
1536 return False;
1537 if(!prs_align(ps))
1538 return False;
1539
1540 #if 1 /* W2k always needs this - even for bad passwd. JRA */
1541 if(!net_io_user_info3("", r_l->user, ps, depth, r_l->switch_value))
1542 return False;
1543 #else
1544 if (r_l->switch_value != 0) {
1545 if(!net_io_user_info3("", r_l->user, ps, depth, r_l->switch_value))
1546 return False;
1547 }
1548 #endif
1549
1550 if(!prs_uint32("auth_resp ", ps, depth, &r_l->auth_resp)) /* 1 - Authoritative response; 0 - Non-Auth? */
1551 return False;
1552
1553 if(!prs_ntstatus("status ", ps, depth, &r_l->status))
1554 return False;
1555
1556 if(!prs_align(ps))
1557 return False;
1558
1559 return True;
1560 }
1561
1562 /*******************************************************************
1563 Reads or writes a structure.
1564 ********************************************************************/
1565
1566 BOOL net_io_q_sam_logoff(char *desc, NET_Q_SAM_LOGOFF *q_l, prs_struct *ps, int depth)
1567 {
1568 if (q_l == NULL)
1569 return False;
1570
1571 prs_debug(ps, depth, desc, "net_io_q_sam_logoff");
1572 depth++;
1573
1574 if(!prs_align(ps))
1575 return False;
1576
1577 if(!smb_io_sam_info("", &q_l->sam_id, ps, depth)) /* domain SID */
1578 return False;
1579
1580 return True;
1581 }
1582
1583 /*******************************************************************
1584 Reads or writes a structure.
1585 ********************************************************************/
1586
1587 BOOL net_io_r_sam_logoff(char *desc, NET_R_SAM_LOGOFF *r_l, prs_struct *ps, int depth)
1588 {
1589 if (r_l == NULL)
1590 return False;
1591
1592 prs_debug(ps, depth, desc, "net_io_r_sam_logoff");
1593 depth++;
1594
1595 if(!prs_align(ps))
1596 return False;
1597
1598 if(!prs_uint32("buffer_creds", ps, depth, &r_l->buffer_creds)) /* undocumented buffer pointer */
1599 return False;
1600 if(!smb_io_cred("", &r_l->srv_creds, ps, depth)) /* server credentials. server time stamp appears to be ignored. */
1601 return False;
1602
1603 if(!prs_ntstatus("status ", ps, depth, &r_l->status))
1604 return False;
1605
1606 return True;
1607 }
1608
1609 /*******************************************************************
1610 makes a NET_Q_SAM_SYNC structure.
1611 ********************************************************************/
1612 BOOL init_net_q_sam_sync(NET_Q_SAM_SYNC * q_s, const char *srv_name,
1613 const char *cli_name, DOM_CRED *cli_creds,
1614 DOM_CRED *ret_creds, uint32 database_id)
1615 {
1616 DEBUG(5, ("init_q_sam_sync\n"));
1617
1618 init_unistr2(&q_s->uni_srv_name, srv_name, strlen(srv_name) + 1);
1619 init_unistr2(&q_s->uni_cli_name, cli_name, strlen(cli_name) + 1);
1620
1621 if (cli_creds)
1622 memcpy(&q_s->cli_creds, cli_creds, sizeof(q_s->cli_creds));
1623
1624 if (cli_creds)
1625 memcpy(&q_s->ret_creds, ret_creds, sizeof(q_s->ret_creds));
1626 else
1627 memset(&q_s->ret_creds, 0, sizeof(q_s->ret_creds));
1628
1629 q_s->database_id = database_id;
1630 q_s->restart_state = 0;
1631 q_s->sync_context = 0;
1632 q_s->max_size = 0xffff;
1633
1634 return True;
1635 }
1636
1637 /*******************************************************************
1638 reads or writes a structure.
1639 ********************************************************************/
1640 BOOL net_io_q_sam_sync(char *desc, NET_Q_SAM_SYNC * q_s, prs_struct *ps,
1641 int depth)
1642 {
1643 prs_debug(ps, depth, desc, "net_io_q_sam_sync");
1644 depth++;
1645
1646 if (!smb_io_unistr2("", &q_s->uni_srv_name, True, ps, depth))
1647 return False;
1648 if (!smb_io_unistr2("", &q_s->uni_cli_name, True, ps, depth))
1649 return False;
1650
1651 if (!smb_io_cred("", &q_s->cli_creds, ps, depth))
1652 return False;
1653 if (!smb_io_cred("", &q_s->ret_creds, ps, depth))
1654 return False;
1655
1656 if (!prs_uint32("database_id ", ps, depth, &q_s->database_id))
1657 return False;
1658 if (!prs_uint32("restart_state", ps, depth, &q_s->restart_state))
1659 return False;
1660 if (!prs_uint32("sync_context ", ps, depth, &q_s->sync_context))
1661 return False;
1662
1663 if (!prs_uint32("max_size", ps, depth, &q_s->max_size))
1664 return False;
1665
1666 return True;
1667 }
1668
1669 /*******************************************************************
1670 reads or writes a structure.
1671 ********************************************************************/
1672 static BOOL net_io_sam_delta_hdr(char *desc, SAM_DELTA_HDR * delta,
1673 prs_struct *ps, int depth)
1674 {
1675 prs_debug(ps, depth, desc, "net_io_sam_delta_hdr");
1676 depth++;
1677
1678 if (!prs_uint16("type", ps, depth, &delta->type))
1679 return False;
1680 if (!prs_uint16("type2", ps, depth, &delta->type2))
1681 return False;
1682 if (!prs_uint32("target_rid", ps, depth, &delta->target_rid))
1683 return False;
1684
1685 if (!prs_uint32("type3", ps, depth, &delta->type3))
1686 return False;
1687
1688 /* Not sure why we need this but it seems to be necessary to get
1689 sam deltas working. */
1690
1691 if (delta->type != 0x16) {
1692 if (!prs_uint32("ptr_delta", ps, depth, &delta->ptr_delta))
1693 return False;
1694 }
1695
1696 return True;
1697 }
1698
1699 /*******************************************************************
1700 reads or writes a structure.
1701 ********************************************************************/
1702 static BOOL net_io_sam_delta_stamp(char *desc, SAM_DELTA_STAMP *info,
1703 prs_struct *ps, int depth)
1704 {
1705 prs_debug(ps, depth, desc, "net_io_sam_delta_stamp");
1706 depth++;
1707
1708 if (!prs_uint32("seqnum", ps, depth, &info->seqnum))
1709 return False;
1710 if (!prs_uint32("dom_mod_count_ptr", ps, depth,
1711 &info->dom_mod_count_ptr))
1712 return False;
1713
1714 if (info->dom_mod_count_ptr) {
1715 if (!prs_uint64("dom_mod_count", ps, depth,
1716 &info->dom_mod_count))
1717 return False;
1718 }
1719
1720 return True;
1721 }
1722
1723 /*******************************************************************
1724 reads or writes a structure.
1725 ********************************************************************/
1726 static BOOL net_io_sam_domain_info(char *desc, SAM_DOMAIN_INFO * info,
1727 prs_struct *ps, int depth)
1728 {
1729 prs_debug(ps, depth, desc, "net_io_sam_domain_info");
1730 depth++;
1731
1732 if (!smb_io_unihdr("hdr_dom_name", &info->hdr_dom_name, ps, depth))
1733 return False;
1734 if (!smb_io_unihdr("hdr_oem_info", &info->hdr_oem_info, ps, depth))
1735 return False;
1736
1737 if (!prs_uint64("force_logoff", ps, depth, &info->force_logoff))
1738 return False;
1739 if (!prs_uint16("min_pwd_len", ps, depth, &info->min_pwd_len))
1740 return False;
1741 if (!prs_uint16("pwd_history_len", ps, depth, &info->pwd_history_len))
1742 return False;
1743 if (!prs_uint64("max_pwd_age", ps, depth, &info->max_pwd_age))
1744 return False;
1745 if (!prs_uint64("min_pwd_age", ps, depth, &info->min_pwd_age))
1746 return False;
1747 if (!prs_uint64("dom_mod_count", ps, depth, &info->dom_mod_count))
1748 return False;
1749 if (!smb_io_time("creation_time", &info->creation_time, ps, depth))
1750 return False;
1751
1752 if (!smb_io_bufhdr2("hdr_sec_desc", &info->hdr_sec_desc, ps, depth))
1753 return False;
1754 if (!smb_io_unihdr("hdr_unknown", &info->hdr_unknown, ps, depth))
1755 return False;
1756
1757 if (ps->data_offset + 40 > ps->buffer_size)
1758 return False;
1759 ps->data_offset += 40;
1760
1761 if (!smb_io_unistr2("uni_dom_name", &info->uni_dom_name,
1762 info->hdr_dom_name.buffer, ps, depth))
1763 return False;
1764 if (!smb_io_unistr2("buf_oem_info", &info->buf_oem_info,
1765 info->hdr_oem_info.buffer, ps, depth))
1766 return False;
1767
1768 if (!smb_io_buffer4("buf_sec_desc", &info->buf_sec_desc,
1769 info->hdr_sec_desc.buffer, ps, depth))
1770 return False;
1771 if (!smb_io_unistr2("buf_unknown", &info->buf_unknown,
1772 info->hdr_unknown.buffer, ps, depth))
1773 return False;
1774
1775 return True;
1776 }
1777
1778 /*******************************************************************
1779 reads or writes a structure.
1780 ********************************************************************/
1781 static BOOL net_io_sam_group_info(char *desc, SAM_GROUP_INFO * info,
1782 prs_struct *ps, int depth)
1783 {
1784 prs_debug(ps, depth, desc, "net_io_sam_group_info");
1785 depth++;
1786
1787 if (!smb_io_unihdr("hdr_grp_name", &info->hdr_grp_name, ps, depth))
1788 return False;
1789 if (!smb_io_gid("gid", &info->gid, ps, depth))
1790 return False;
1791 if (!smb_io_unihdr("hdr_grp_desc", &info->hdr_grp_desc, ps, depth))
1792 return False;
1793 if (!smb_io_bufhdr2("hdr_sec_desc", &info->hdr_sec_desc, ps, depth))
1794 return False;
1795
1796 if (ps->data_offset + 48 > ps->buffer_size)
1797 return False;
1798 ps->data_offset += 48;
1799
1800 if (!smb_io_unistr2("uni_grp_name", &info->uni_grp_name,
1801 info->hdr_grp_name.buffer, ps, depth))
1802 return False;
1803 if (!smb_io_unistr2("uni_grp_desc", &info->uni_grp_desc,
1804 info->hdr_grp_desc.buffer, ps, depth))
1805 return False;
1806 if (!smb_io_buffer4("buf_sec_desc", &info->buf_sec_desc,
1807 info->hdr_sec_desc.buffer, ps, depth))
1808 return False;
1809
1810 return True;
1811 }
1812
1813 /*******************************************************************
1814 reads or writes a structure.
1815 ********************************************************************/
1816 static BOOL net_io_sam_passwd_info(char *desc, SAM_PWD * pwd,
1817 prs_struct *ps, int depth)
1818 {
1819 prs_debug(ps, depth, desc, "net_io_sam_passwd_info");
1820 depth++;
1821
1822 if (!prs_uint32("unk_0 ", ps, depth, &pwd->unk_0))
1823 return False;
1824
1825 if (!smb_io_unihdr("hdr_lm_pwd", &pwd->hdr_lm_pwd, ps, depth))
1826 return False;
1827 if (!prs_uint8s(False, "buf_lm_pwd", ps, depth, pwd->buf_lm_pwd, 16))
1828 return False;
1829
1830 if (!smb_io_unihdr("hdr_nt_pwd", &pwd->hdr_nt_pwd, ps, depth))
1831 return False;
1832 if (!prs_uint8s(False, "buf_nt_pwd", ps, depth, pwd->buf_nt_pwd, 16))
1833 return False;
1834
1835 if (!smb_io_unihdr("", &pwd->hdr_empty_lm, ps, depth))
1836 return False;
1837 if (!smb_io_unihdr("", &pwd->hdr_empty_nt, ps, depth))
1838 return False;
1839
1840 return True;
1841 }
1842
1843 /*******************************************************************
1844 makes a SAM_ACCOUNT_INFO structure.
1845 ********************************************************************/
1846 BOOL make_sam_account_info(SAM_ACCOUNT_INFO * info,
1847 const UNISTR2 *user_name,
1848 const UNISTR2 *full_name,
1849 uint32 user_rid, uint32 group_rid,
1850 const UNISTR2 *home_dir,
1851 const UNISTR2 *dir_drive,
1852 const UNISTR2 *log_scr,
1853 const UNISTR2 *desc,
1854 uint32 acb_info,
1855 const UNISTR2 *prof_path,
1856 const UNISTR2 *wkstas,
1857 const UNISTR2 *unk_str, const UNISTR2 *mung_dial)
1858 {
1859 int len_user_name = user_name != NULL ? user_name->uni_str_len : 0;
1860 int len_full_name = full_name != NULL ? full_name->uni_str_len : 0;
1861 int len_home_dir = home_dir != NULL ? home_dir->uni_str_len : 0;
1862 int len_dir_drive = dir_drive != NULL ? dir_drive->uni_str_len : 0;
1863 int len_logon_script = log_scr != NULL ? log_scr->uni_str_len : 0;
1864 int len_profile_path = prof_path != NULL ? prof_path->uni_str_len : 0;
1865 int len_description = desc != NULL ? desc->uni_str_len : 0;
1866 int len_workstations = wkstas != NULL ? wkstas->uni_str_len : 0;
1867 int len_unknown_str = unk_str != NULL ? unk_str->uni_str_len : 0;
1868 int len_munged_dial = mung_dial != NULL ? mung_dial->uni_str_len : 0;
1869
1870 DEBUG(5, ("make_sam_account_info\n"));
1871
1872 make_uni_hdr(&info->hdr_acct_name, len_user_name);
1873 make_uni_hdr(&info->hdr_full_name, len_full_name);
1874 make_uni_hdr(&info->hdr_home_dir, len_home_dir);
1875 make_uni_hdr(&info->hdr_dir_drive, len_dir_drive);
1876 make_uni_hdr(&info->hdr_logon_script, len_logon_script);
1877 make_uni_hdr(&info->hdr_profile, len_profile_path);
1878 make_uni_hdr(&info->hdr_acct_desc, len_description);
1879 make_uni_hdr(&info->hdr_workstations, len_workstations);
1880 make_uni_hdr(&info->hdr_comment, len_unknown_str);
1881 make_uni_hdr(&info->hdr_parameters, len_munged_dial);
1882
1883 /* not present */
1884 make_bufhdr2(&info->hdr_sec_desc, 0, 0, 0);
1885
1886 info->user_rid = user_rid;
1887 info->group_rid = group_rid;
1888
1889 init_nt_time(&info->logon_time);
1890 init_nt_time(&info->logoff_time);
1891 init_nt_time(&info->pwd_last_set_time);
1892 init_nt_time(&info->acct_expiry_time);
1893
1894 info->logon_divs = 0xA8;
1895 info->ptr_logon_hrs = 0; /* Don't care right now */
1896
1897 info->bad_pwd_count = 0;
1898 info->logon_count = 0;
1899 info->acb_info = acb_info;
1900 info->nt_pwd_present = 0;
1901 info->lm_pwd_present = 0;
1902 info->pwd_expired = 0;
1903 info->country = 0;
1904 info->codepage = 0;
1905
1906 info->unknown1 = 0x4EC;
1907 info->unknown2 = 0;
1908
1909 copy_unistr2(&info->uni_acct_name, user_name);
1910 copy_unistr2(&info->uni_full_name, full_name);
1911 copy_unistr2(&info->uni_home_dir, home_dir);
1912 copy_unistr2(&info->uni_dir_drive, dir_drive);
1913 copy_unistr2(&info->uni_logon_script, log_scr);
1914 copy_unistr2(&info->uni_profile, prof_path);
1915 copy_unistr2(&info->uni_acct_desc, desc);
1916 copy_unistr2(&info->uni_workstations, wkstas);
1917 copy_unistr2(&info->uni_comment, unk_str);
1918 copy_unistr2(&info->uni_parameters, mung_dial);
1919
1920 return True;
1921 }
1922
1923 /*******************************************************************
1924 reads or writes a structure.
1925 ********************************************************************/
1926 static BOOL net_io_sam_account_info(char *desc, uint8 sess_key[16],
1927 SAM_ACCOUNT_INFO * info, prs_struct *ps,
1928 int depth)
1929 {
1930 BUFHDR2 hdr_priv_data;
1931 uint32 i;
1932
1933 prs_debug(ps, depth, desc, "net_io_sam_account_info");
1934 depth++;
1935
1936 if (!smb_io_unihdr("hdr_acct_name", &info->hdr_acct_name, ps, depth))
1937 return False;
1938 if (!smb_io_unihdr("hdr_full_name", &info->hdr_full_name, ps, depth))
1939 return False;
1940
1941 if (!prs_uint32("user_rid ", ps, depth, &info->user_rid))
1942 return False;
1943 if (!prs_uint32("group_rid", ps, depth, &info->group_rid))
1944 return False;
1945
1946 if (!smb_io_unihdr("hdr_home_dir ", &info->hdr_home_dir, ps, depth))
1947 return False;
1948 if (!smb_io_unihdr("hdr_dir_drive", &info->hdr_dir_drive, ps, depth))
1949 return False;
1950 if (!smb_io_unihdr("hdr_logon_script", &info->hdr_logon_script, ps,
1951 depth))
1952 return False;
1953
1954 if (!smb_io_unihdr("hdr_acct_desc", &info->hdr_acct_desc, ps, depth))
1955 return False;
1956 if (!smb_io_unihdr("hdr_workstations", &info->hdr_workstations, ps,
1957 depth))
1958 return False;
1959
1960 if (!smb_io_time("logon_time", &info->logon_time, ps, depth))
1961 return False;
1962 if (!smb_io_time("logoff_time", &info->logoff_time, ps, depth))
1963 return False;
1964
1965 if (!prs_uint32("logon_divs ", ps, depth, &info->logon_divs))
1966 return False;
1967 if (!prs_uint32("ptr_logon_hrs", ps, depth, &info->ptr_logon_hrs))
1968 return False;
1969
1970 if (!prs_uint16("bad_pwd_count", ps, depth, &info->bad_pwd_count))
1971 return False;
1972 if (!prs_uint16("logon_count", ps, depth, &info->logon_count))
1973 return False;
1974 if (!smb_io_time("pwd_last_set_time", &info->pwd_last_set_time, ps,
1975 depth))
1976 return False;
1977 if (!smb_io_time("acct_expiry_time", &info->acct_expiry_time, ps,
1978 depth))
1979 return False;
1980
1981 if (!prs_uint32("acb_info", ps, depth, &info->acb_info))
1982 return False;
1983 if (!prs_uint8s(False, "nt_pwd", ps, depth, info->nt_pwd, 16))
1984 return False;
1985 if (!prs_uint8s(False, "lm_pwd", ps, depth, info->lm_pwd, 16))
1986 return False;
1987 if (!prs_uint8("lm_pwd_present", ps, depth, &info->lm_pwd_present))
1988 return False;
1989 if (!prs_uint8("nt_pwd_present", ps, depth, &info->nt_pwd_present))
1990 return False;
1991 if (!prs_uint8("pwd_expired", ps, depth, &info->pwd_expired))
1992 return False;
1993
1994 if (!smb_io_unihdr("hdr_comment", &info->hdr_comment, ps, depth))
1995 return False;
1996 if (!smb_io_unihdr("hdr_parameters", &info->hdr_parameters, ps,
1997 depth))
1998 return False;
1999 if (!prs_uint16("country", ps, depth, &info->country))
2000 return False;
2001 if (!prs_uint16("codepage", ps, depth, &info->codepage))
2002 return False;
2003
2004 if (!smb_io_bufhdr2("hdr_priv_data", &hdr_priv_data, ps, depth))
2005 return False;
2006 if (!smb_io_bufhdr2("hdr_sec_desc", &info->hdr_sec_desc, ps, depth))
2007 return False;
2008 if (!smb_io_unihdr("hdr_profile", &info->hdr_profile, ps, depth))
2009 return False;
2010
2011 for (i = 0; i < 3; i++)
2012 {
2013 if (!smb_io_unihdr("hdr_reserved", &info->hdr_reserved[i],
2014 ps, depth))
2015 return False;
2016 }
2017
2018 for (i = 0; i < 4; i++)
2019 {
2020 if (!prs_uint32("dw_reserved", ps, depth,
2021 &info->dw_reserved[i]))
2022 return False;
2023 }
2024
2025 if (!smb_io_unistr2("uni_acct_name", &info->uni_acct_name,
2026 info->hdr_acct_name.buffer, ps, depth))
2027 return False;
2028 prs_align(ps);
2029 if (!smb_io_unistr2("uni_full_name", &info->uni_full_name,
2030 info->hdr_full_name.buffer, ps, depth))
2031 return False;
2032 prs_align(ps);
2033 if (!smb_io_unistr2("uni_home_dir ", &info->uni_home_dir,
2034 info->hdr_home_dir.buffer, ps, depth))
2035 return False;
2036 prs_align(ps);
2037 if (!smb_io_unistr2("uni_dir_drive", &info->uni_dir_drive,
2038 info->hdr_dir_drive.buffer, ps, depth))
2039 return False;
2040 prs_align(ps);
2041 if (!smb_io_unistr2("uni_logon_script", &info->uni_logon_script,
2042 info->hdr_logon_script.buffer, ps, depth))
2043 return False;
2044 prs_align(ps);
2045 if (!smb_io_unistr2("uni_acct_desc", &info->uni_acct_desc,
2046 info->hdr_acct_desc.buffer, ps, depth))
2047 return False;
2048 prs_align(ps);
2049 if (!smb_io_unistr2("uni_workstations", &info->uni_workstations,
2050 info->hdr_workstations.buffer, ps, depth))
2051 return False;
2052 prs_align(ps);
2053
2054 if (!prs_uint32("unknown1", ps, depth, &info->unknown1))
2055 return False;
2056 if (!prs_uint32("unknown2", ps, depth, &info->unknown2))
2057 return False;
2058
2059 if (!smb_io_buffer4("buf_logon_hrs", &info->buf_logon_hrs,
2060 info->ptr_logon_hrs, ps, depth))
2061 return False;
2062 prs_align(ps);
2063 if (!smb_io_unistr2("uni_comment", &info->uni_comment,
2064 info->hdr_comment.buffer, ps, depth))
2065 return False;
2066 prs_align(ps);
2067 if (!smb_io_unistr2("uni_parameters", &info->uni_parameters,
2068 info->hdr_parameters.buffer, ps, depth))
2069 return False;
2070 prs_align(ps);
2071 if (hdr_priv_data.buffer != 0)
2072 {
2073 int old_offset = 0;
2074 uint32 len = 0x44;
2075 if (!prs_uint32("pwd_len", ps, depth, &len))
2076 return False;
2077 old_offset = ps->data_offset;
2078 if (len == 0x44)
2079 {
2080 if (ps->io)
2081 {
2082 /* reading */
2083 if (!prs_hash1(ps, ps->data_offset, sess_key))
2084 return False;
2085 }
2086 if (!net_io_sam_passwd_info("pass", &info->pass,
2087 ps, depth))
2088 return False;
2089
2090 if (!ps->io)
2091 {
2092 /* writing */
2093 if (!prs_hash1(ps, old_offset, sess_key))
2094 return False;
2095 }
2096 }
2097 if (old_offset + len > ps->buffer_size)
2098 return False;
2099 ps->data_offset = old_offset + len;
2100 }
2101 if (!smb_io_buffer4("buf_sec_desc", &info->buf_sec_desc,
2102 info->hdr_sec_desc.buffer, ps, depth))
2103 return False;
2104 prs_align(ps);
2105 if (!smb_io_unistr2("uni_profile", &info->uni_profile,
2106 info->hdr_profile.buffer, ps, depth))
2107 return False;
2108
2109 prs_align(ps);
2110
2111 return True;
2112 }
2113
2114 /*******************************************************************
2115 reads or writes a structure.
2116 ********************************************************************/
2117 static BOOL net_io_sam_group_mem_info(char *desc, SAM_GROUP_MEM_INFO * info,
2118 prs_struct *ps, int depth)
2119 {
2120 uint32 i;
2121 fstring tmp;
2122
2123 prs_debug(ps, depth, desc, "net_io_sam_group_mem_info");
2124 depth++;
2125
2126 prs_align(ps);
2127 if (!prs_uint32("ptr_rids ", ps, depth, &info->ptr_rids))
2128 return False;
2129 if (!prs_uint32("ptr_attribs", ps, depth, &info->ptr_attribs))
2130 return False;
2131 if (!prs_uint32("num_members", ps, depth, &info->num_members))
2132 return False;
2133
2134 if (ps->data_offset + 16 > ps->buffer_size)
2135 return False;
2136 ps->data_offset += 16;
2137
2138 if (info->ptr_rids != 0)
2139 {
2140 if (!prs_uint32("num_members2", ps, depth,
2141 &info->num_members2))
2142 return False;
2143
2144 if (info->num_members2 != info->num_members)
2145 {
2146 /* RPC fault */
2147 return False;
2148 }
2149
2150 info->rids = talloc(ps->mem_ctx, sizeof(uint32) *
2151 info->num_members2);
2152
2153 if (info->rids == NULL) {
2154 DEBUG(0, ("out of memory allocating %d rids\n",
2155 info->num_members2));
2156 return False;
2157 }
2158
2159 for (i = 0; i < info->num_members2; i++)
2160 {
2161 slprintf(tmp, sizeof(tmp) - 1, "rids[%02d]", i);
2162 if (!prs_uint32(tmp, ps, depth, &info->rids[i]))
2163 return False;
2164 }
2165 }
2166
2167 if (info->ptr_attribs != 0)
2168 {
2169 if (!prs_uint32("num_members3", ps, depth,
2170 &info->num_members3))
2171 return False;
2172 if (info->num_members3 != info->num_members)
2173 {
2174 /* RPC fault */
2175 return False;
2176 }
2177
2178 info->attribs = talloc(ps->mem_ctx, sizeof(uint32) *
2179 info->num_members3);
2180
2181 if (info->attribs == NULL) {
2182 DEBUG(0, ("out of memory allocating %d attribs\n",
2183 info->num_members3));
2184 return False;
2185 }
2186
2187 for (i = 0; i < info->num_members3; i++)
2188 {
2189 slprintf(tmp, sizeof(tmp) - 1, "attribs[%02d]", i);
2190 if (!prs_uint32(tmp, ps, depth, &info->attribs[i]))
2191 return False;
2192 }
2193 }
2194
2195 return True;
2196 }
2197
2198 /*******************************************************************
2199 reads or writes a structure.
2200 ********************************************************************/
2201 static BOOL net_io_sam_alias_info(char *desc, SAM_ALIAS_INFO * info,
2202 prs_struct *ps, int depth)
2203 {
2204 prs_debug(ps, depth, desc, "net_io_sam_alias_info");
2205 depth++;
2206
2207 if (!smb_io_unihdr("hdr_als_name", &info->hdr_als_name, ps, depth))
2208 return False;
2209 if (!prs_uint32("als_rid", ps, depth, &info->als_rid))
2210 return False;
2211 if (!smb_io_bufhdr2("hdr_sec_desc", &info->hdr_sec_desc, ps, depth))
2212 return False;
2213 if (!smb_io_unihdr("hdr_als_desc", &info->hdr_als_desc, ps, depth))
2214 return False;
2215
2216 if (ps->data_offset + 40 > ps->buffer_size)
2217 return False;
2218 ps->data_offset += 40;
2219
2220 if (!smb_io_unistr2("uni_als_name", &info->uni_als_name,
2221 info->hdr_als_name.buffer, ps, depth))
2222 return False;
2223 if (!smb_io_buffer4("buf_sec_desc", &info->buf_sec_desc,
2224 info->hdr_sec_desc.buffer, ps, depth))
2225 return False;
2226 if (!smb_io_unistr2("uni_als_desc", &info->uni_als_desc,
2227 info->hdr_als_name.buffer, ps, depth))
2228 return False;
2229
2230 return True;
2231 }
2232
2233 /*******************************************************************
2234 reads or writes a structure.
2235 ********************************************************************/
2236 static BOOL net_io_sam_alias_mem_info(char *desc, SAM_ALIAS_MEM_INFO * info,
2237 prs_struct *ps, int depth)
2238 {
2239 uint32 i;
2240 fstring tmp;
2241
2242 prs_debug(ps, depth, desc, "net_io_sam_alias_mem_info");
2243 depth++;
2244
2245 prs_align(ps);
2246 if (!prs_uint32("num_members", ps, depth, &info->num_members))
2247 return False;
2248 if (!prs_uint32("ptr_members", ps, depth, &info->ptr_members))
2249 return False;
2250
2251 if (info->ptr_members != 0)
2252 {
2253 if (ps->data_offset + 16 > ps->buffer_size)
2254 return False;
2255 ps->data_offset += 16;
2256
2257 if (!prs_uint32("num_sids", ps, depth, &info->num_sids))
2258 return False;
2259 if (info->num_sids != info->num_members)
2260 {
2261 /* RPC fault */
2262 return False;
2263 }
2264
2265 info->ptr_sids = talloc(ps->mem_ctx, sizeof(uint32) *
2266 info->num_sids);
2267
2268 if (info->ptr_sids == NULL) {
2269 DEBUG(0, ("out of memory allocating %d ptr_sids\n",
2270 info->num_sids));
2271 return False;
2272 }
2273
2274 for (i = 0; i < info->num_sids; i++)
2275 {
2276 slprintf(tmp, sizeof(tmp) - 1, "ptr_sids[%02d]", i);
2277 if (!prs_uint32(tmp, ps, depth, &info->ptr_sids[i]))
2278 return False;
2279 }
2280
2281 info->sids = talloc(ps->mem_ctx, sizeof(DOM_SID2) *
2282 info->num_sids);
2283
2284 if (info->sids == NULL) {
2285 DEBUG(0, ("error allocating %d sids\n",
2286 info->num_sids));
2287 return False;
2288 }
2289
2290 for (i = 0; i < info->num_sids; i++)
2291 {
2292 if (info->ptr_sids[i] != 0)
2293 {
2294 slprintf(tmp, sizeof(tmp) - 1, "sids[%02d]",
2295 i);
2296 if (!smb_io_dom_sid2(tmp, &info->sids[i],
2297 ps, depth))
2298 return False;
2299 }
2300 }
2301 }
2302
2303 return True;
2304 }
2305
2306 /*******************************************************************
2307 reads or writes a structure.
2308 ********************************************************************/
2309 static BOOL net_io_sam_dom_info(char *desc, SAM_DELTA_DOM *info,
2310 prs_struct *ps, int depth)
2311 {
2312 int i;
2313
2314 prs_debug(ps, depth, desc, "net_io_sam_dom_info");
2315 depth++;
2316
2317 if(!prs_align(ps))
2318 return False;
2319
2320 if (!prs_uint32("unknown1", ps, depth, &info->unknown1))
2321 return False;
2322 if (!prs_uint32("unknown2", ps, depth, &info->unknown2))
2323 return False;
2324 if (!prs_uint32("unknown3", ps, depth, &info->unknown3))
2325 return False;
2326 if (!prs_uint32("unknown4", ps, depth, &info->unknown4))
2327 return False;
2328 if (!prs_uint32("count1", ps, depth, &info->count1))
2329 return False;
2330 if (!prs_uint32("ptr1", ps, depth, &info->ptr1))
2331 return False;
2332
2333 if (!prs_uint16("count2", ps, depth, &info->count2))
2334 return False;
2335 if (!prs_uint16("count3", ps, depth, &info->count3))
2336 return False;
2337
2338 if (!prs_uint32("ptr2", ps, depth, &info->ptr2))
2339 return False;
2340 if (!prs_uint32("ptr3", ps, depth, &info->ptr3))
2341 return False;
2342
2343 if (!prs_uint32("unknown4b", ps, depth, &info->unknown4b))
2344 return False;
2345 if (!prs_uint32("unknown5", ps, depth, &info->unknown5))
2346 return False;
2347 if (!prs_uint32("unknown6", ps, depth, &info->unknown6))
2348 return False;
2349 if (!prs_uint32("unknown7", ps, depth, &info->unknown7))
2350 return False;
2351 if (!prs_uint32("unknown8", ps, depth, &info->unknown8))
2352 return False;
2353 if (!prs_uint32("unknown9", ps, depth, &info->unknown9))
2354 return False;
2355 if (!prs_uint32("unknown10", ps, depth, &info->unknown10))
2356 return False;
2357 if (!prs_uint32("unknown11", ps, depth, &info->unknown11))
2358 return False;
2359 if (!prs_uint32("unknown12", ps, depth, &info->unknown12))
2360 return False;
2361
2362 if (!prs_uint32("unknown13", ps, depth, &info->unknown13))
2363 return False;
2364 if (!prs_uint32("unknown14", ps, depth, &info->unknown14))
2365 return False;
2366 if (!prs_uint32("unknown15", ps, depth, &info->unknown15))
2367 return False;
2368 if (!prs_uint32("unknown16", ps, depth, &info->unknown16))
2369 return False;
2370 if (!prs_uint32("unknown17", ps, depth, &info->unknown17))
2371 return False;
2372
2373 for (i=0; i<info->count2; i++)
2374 if (!prs_uint32("unknown18", ps, depth, &info->unknown18))
2375 return False;
2376
2377 if (!prs_uint32("unknown19", ps, depth, &info->unknown19))
2378 return False;
2379
2380 for (i=0; i<info->count1; i++)
2381 if (!prs_uint32("unknown20", ps, depth, &info->unknown20))
2382 return False;
2383
2384 if (!prs_uint32("ptr4", ps, depth, &info->ptr4))
2385 return False;
2386
2387 if (!smb_io_unistr2("domain_name", &info->domain_name, True, ps, depth))
2388 return False;
2389
2390 if(!smb_io_dom_sid2("domain_sid", &info->domain_sid, ps, depth))
2391 return False;
2392
2393 return True;
2394 }
2395
2396 /*******************************************************************
2397 reads or writes a structure.
2398 ********************************************************************/
2399 static BOOL net_io_sam_unk0e_info(char *desc, SAM_DELTA_UNK0E *info,
2400 prs_struct *ps, int depth)
2401 {
2402 int i;
2403
2404 prs_debug(ps, depth, desc, "net_io_sam_unk0e_info");
2405 depth++;
2406
2407 if(!prs_align(ps))
2408 return False;
2409
2410 if(!prs_uint32("buf_size", ps, depth, &info->buf_size))
2411 return False;
2412
2413 if(!sec_io_desc("sec_desc", &info->sec_desc, ps, depth))
2414 return False;
2415
2416 if(!smb_io_dom_sid2("sid", &info->sid, ps, depth))
2417 return False;
2418
2419 if(!smb_io_unihdr("hdr_domain", &info->hdr_domain, ps, depth))
2420 return False;
2421
2422 if(!prs_uint32("unknown0", ps, depth, &info->unknown0))
2423 return False;
2424 if(!prs_uint32("unknown1", ps, depth, &info->unknown1))
2425 return False;
2426 if(!prs_uint32("unknown2", ps, depth, &info->unknown2))
2427 return False;
2428
2429 if(!prs_uint32("buf_size2", ps, depth, &info->buf_size2))
2430 return False;
2431 if(!prs_uint32("ptr", ps, depth, &info->ptr))
2432 return False;
2433
2434 for (i=0; i<12; i++)
2435 if(!prs_uint32("unknown3", ps, depth, &info->unknown3))
2436 return False;
2437
2438 if (!smb_io_unistr2("domain", &info->domain, True, ps, depth))
2439 return False;
2440
2441 return True;
2442 }
2443
2444 /*******************************************************************
2445 reads or writes a structure.
2446 ********************************************************************/
2447 static BOOL net_io_sam_unk12_info(char *desc, SAM_DELTA_UNK12 *info,
2448 prs_struct *ps, int depth)
2449 {
2450 int i;
2451
2452 prs_debug(ps, depth, desc, "net_io_sam_unk12_info");
2453 depth++;
2454
2455 if(!prs_align(ps))
2456 return False;
2457
2458 if(!prs_uint32("buf_size", ps, depth, &info->buf_size))
2459 return False;
2460
2461 if(!sec_io_desc("sec_desc", &info->sec_desc, ps, depth))
2462 return False;
2463
2464 if (!smb_io_unistr2("secret", &info->secret, True, ps, depth))
2465 return False;
2466
2467 if(!prs_align(ps))
2468 return False;
2469
2470 if(!prs_uint32("count1", ps, depth, &info->count1))
2471 return False;
2472 if(!prs_uint32("count2", ps, depth, &info->count2))
2473 return False;
2474 if(!prs_uint32("ptr", ps, depth, &info->ptr))
2475 return False;
2476
2477
2478 if(!smb_io_time("time1", &info->time1, ps, depth)) /* logon time */
2479 return False;
2480 if(!prs_uint32("count3", ps, depth, &info->count3))
2481 return False;
2482 if(!prs_uint32("count4", ps, depth, &info->count4))
2483 return False;
2484 if(!prs_uint32("ptr2", ps, depth, &info->ptr2))
2485 return False;
2486 if(!smb_io_time("time2", &info->time2, ps, depth)) /* logon time */
2487 return False;
2488 if(!prs_uint32("unknow1", ps, depth, &info->unknow1))
2489 return False;
2490
2491
2492 if(!prs_uint32("buf_size2", ps, depth, &info->buf_size2))
2493 return False;
2494 if(!prs_uint32("ptr3", ps, depth, &info->ptr3))
2495 return False;
2496 for(i=0; i<12; i++)
2497 if(!prs_uint32("unknow2", ps, depth, &info->unknow2))
2498 return False;
2499
2500 if(!prs_uint32("chal_len", ps, depth, &info->chal_len))
2501 return False;
2502 if(!prs_uint32("reserved1", ps, depth, &info->reserved1))
2503 return False;
2504 if(!prs_uint32("chal_len2", ps, depth, &info->chal_len2))
2505 return False;
2506
2507 if(!prs_uint8s (False, "chal", ps, depth, info->chal, info->chal_len2))
2508 return False;
2509
2510 if(!prs_uint32("key_len", ps, depth, &info->key_len))
2511 return False;
2512 if(!prs_uint32("reserved2", ps, depth, &info->reserved2))
2513 return False;
2514 if(!prs_uint32("key_len2", ps, depth, &info->key_len2))
2515 return False;
2516
2517 if(!prs_uint8s (False, "key", ps, depth, info->key, info->key_len2))
2518 return False;
2519
2520
2521 if(!prs_uint32("buf_size3", ps, depth, &info->buf_size3))
2522 return False;
2523
2524 if(!sec_io_desc("sec_desc2", &info->sec_desc2, ps, depth))
2525 return False;
2526
2527
2528 return True;
2529 }
2530
2531 /*******************************************************************
2532 reads or writes a structure.
2533 ********************************************************************/
2534 static BOOL net_io_sam_privs_info(char *desc, SAM_DELTA_PRIVS *info,
2535 prs_struct *ps, int depth)
2536 {
2537 int i;
2538
2539 prs_debug(ps, depth, desc, "net_io_sam_privs_info");
2540 depth++;
2541
2542 if(!prs_align(ps))
2543 return False;
2544
2545 if(!prs_uint32("buf_size", ps, depth, &info->buf_size))
2546 return False;
2547
2548 if(!sec_io_desc("sec_desc", &info->sec_desc, ps, depth))
2549 return False;
2550
2551 if(!smb_io_dom_sid2("sid", &info->sid, ps, depth))
2552 return False;
2553
2554 if(!prs_uint32("priv_count", ps, depth, &info->priv_count))
2555 return False;
2556 if(!prs_uint32("reserved1", ps, depth, &info->reserved1))
2557 return False;
2558
2559 if(!prs_uint32("ptr1", ps, depth, &info->ptr1))
2560 return False;
2561 if(!prs_uint32("ptr2", ps, depth, &info->ptr2))
2562 return False;
2563
2564 if(!prs_uint32("unknown1", ps, depth, &info->unknown1))
2565 return False;
2566 if(!prs_uint32("unknown2", ps, depth, &info->unknown2))
2567 return False;
2568 if(!prs_uint32("unknown3", ps, depth, &info->unknown3))
2569 return False;
2570 if(!prs_uint32("unknown4", ps, depth, &info->unknown4))
2571 return False;
2572 if(!prs_uint32("unknown5", ps, depth, &info->unknown5))
2573 return False;
2574 if(!prs_uint32("unknown6", ps, depth, &info->unknown6))
2575 return False;
2576 if(!prs_uint32("unknown7", ps, depth, &info->unknown7))
2577 return False;
2578 if(!prs_uint32("unknown8", ps, depth, &info->unknown8))
2579 return False;
2580 if(!prs_uint32("unknown9", ps, depth, &info->unknown9))
2581 return False;
2582
2583 if(!prs_uint32("buf_size2", ps, depth, &info->buf_size2))
2584 return False;
2585 if(!prs_uint32("ptr3", ps, depth, &info->ptr3))
2586 return False;
2587
2588 for (i=0; i<12; i++)
2589 if(!prs_uint32("unknown10", ps, depth, &info->unknown10))
2590 return False;
2591
2592 if(!prs_uint32("attribute_count", ps, depth, &info->attribute_count))
2593 return False;
2594
2595 info->attributes = talloc(ps->mem_ctx, sizeof(uint32) * info->attribute_count);
2596
2597 for (i=0; i<info->attribute_count; i++)
2598 if(!prs_uint32("attributes", ps, depth, &info->attributes[i]))
2599 return False;
2600
2601 if(!prs_uint32("privlist_count", ps, depth, &info->privlist_count))
2602 return False;
2603
2604 info->hdr_privslist = talloc(ps->mem_ctx, sizeof(UNIHDR) * info->privlist_count);
2605 info->uni_privslist = talloc(ps->mem_ctx, sizeof(UNISTR2) * info->privlist_count);
2606
2607 for (i=0; i<info->privlist_count; i++)
2608 if(!smb_io_unihdr("hdr_privslist", &info->hdr_privslist[i], ps, depth))
2609 return False;
2610
2611 for (i=0; i<info->privlist_count; i++)
2612 if (!smb_io_unistr2("uni_privslist", &info->uni_privslist[i], True, ps, depth))
2613 return False;
2614
2615 return True;
2616 }
2617
2618 /*******************************************************************
2619 reads or writes a structure.
2620 ********************************************************************/
2621 static BOOL net_io_sam_delta_ctr(char *desc, uint8 sess_key[16],
2622 SAM_DELTA_CTR * delta, uint16 type,
2623 prs_struct *ps, int depth)
2624 {
2625 prs_debug(ps, depth, desc, "net_io_sam_delta_ctr");
2626 depth++;
2627
2628 switch (type) {
2629 /* Seen in sam deltas */
2630 case SAM_DELTA_SAM_STAMP:
2631 if (!net_io_sam_delta_stamp("", &delta->stamp, ps, depth))
2632 return False;
2633 break;
2634
2635 case SAM_DELTA_DOMAIN_INFO:
2636 if (!net_io_sam_domain_info("", &delta->domain_info, ps, depth))
2637 return False;
2638 break;
2639
2640 case SAM_DELTA_GROUP_INFO:
2641 if (!net_io_sam_group_info("", &delta->group_info, ps, depth))
2642 return False;
2643 break;
2644
2645 case SAM_DELTA_ACCOUNT_INFO:
2646 if (!net_io_sam_account_info("", sess_key, &delta->account_info, ps, depth))
2647 return False;
2648 break;
2649
2650 case SAM_DELTA_GROUP_MEM:
2651 if (!net_io_sam_group_mem_info("", &delta->grp_mem_info, ps, depth))
2652 return False;
2653 break;
2654
2655 case SAM_DELTA_ALIAS_INFO:
2656 if (!net_io_sam_alias_info("", &delta->alias_info, ps, depth))
2657 return False;
2658 break;
2659
2660 case SAM_DELTA_DOM_INFO:
2661 if (!net_io_sam_dom_info("", &delta->dom_info, ps, depth))
2662 return False;
2663 break;
2664
2665 case SAM_DELTA_ALIAS_MEM:
2666 if (!net_io_sam_alias_mem_info("", &delta->als_mem_info, ps, depth))
2667 return False;
2668 break;
2669
2670 case SAM_DELTA_PRIVS_INFO:
2671 if (!net_io_sam_privs_info("", &delta->privs_info, ps, depth))
2672 return False;
2673 break;
2674
2675 case SAM_DELTA_UNK0E_INFO:
2676 if (!net_io_sam_unk0e_info("", &delta->unk0e_info, ps, depth))
2677 return False;
2678 break;
2679
2680 case SAM_DELTA_UNK12_INFO:
2681 if (!net_io_sam_unk12_info("", &delta->unk12_info, ps, depth))
2682 return False;
2683 break;
2684
2685 default:
2686 DEBUG(0, ("Replication error: Unknown delta type 0x%x\n", type));
2687 break;
2688 }
2689
2690 return True;
2691 }
2692
2693 /*******************************************************************
2694 reads or writes a structure.
2695 ********************************************************************/
2696 BOOL net_io_r_sam_sync(char *desc, uint8 sess_key[16],
2697 NET_R_SAM_SYNC * r_s, prs_struct *ps, int depth)
2698 {
2699 uint32 i;
2700
2701 prs_debug(ps, depth, desc, "net_io_r_sam_sync");
2702 depth++;
2703
2704 if (!smb_io_cred("srv_creds", &r_s->srv_creds, ps, depth))
2705 return False;
2706 if (!prs_uint32("sync_context", ps, depth, &r_s->sync_context))
2707 return False;
2708
2709 if (!prs_uint32("ptr_deltas", ps, depth, &r_s->ptr_deltas))
2710 return False;
2711 if (r_s->ptr_deltas != 0)
2712 {
2713 if (!prs_uint32("num_deltas ", ps, depth, &r_s->num_deltas))
2714 return False;
2715 if (!prs_uint32("ptr_deltas2", ps, depth, &r_s->ptr_deltas2))
2716 return False;
2717 if (r_s->ptr_deltas2 != 0)
2718 {
2719 if (!prs_uint32("num_deltas2", ps, depth,
2720 &r_s->num_deltas2))
2721 return False;
2722
2723 if (r_s->num_deltas2 != r_s->num_deltas)
2724 {
2725 /* RPC fault */
2726 return False;
2727 }
2728
2729 if (r_s->num_deltas2 > 0) {
2730 r_s->hdr_deltas = (SAM_DELTA_HDR *)
2731 talloc(ps->mem_ctx, r_s->num_deltas2 *
2732 sizeof(SAM_DELTA_HDR));
2733
2734 if (r_s->hdr_deltas == NULL) {
2735 DEBUG(0, ("error tallocating memory "
2736 "for %d delta headers\n",
2737 r_s->num_deltas2));
2738 return False;
2739 }
2740 }
2741
2742 for (i = 0; i < r_s->num_deltas2; i++)
2743 {
2744 if (!net_io_sam_delta_hdr("",
2745 &r_s->hdr_deltas[i],
2746 ps, depth))
2747 return False;
2748 }
2749
2750 if (r_s->num_deltas2 > 0) {
2751 r_s->deltas = (SAM_DELTA_CTR *)
2752 talloc(ps->mem_ctx, r_s->num_deltas2 *
2753 sizeof(SAM_DELTA_CTR));
2754
2755 if (r_s->deltas == NULL) {
2756 DEBUG(0, ("error tallocating memory "
2757 "for %d deltas\n",
2758 r_s->num_deltas2));
2759 return False;
2760 }
2761 }
2762
2763 for (i = 0; i < r_s->num_deltas2; i++)
2764 {
2765 if (!net_io_sam_delta_ctr(
2766 "", sess_key, &r_s->deltas[i],
2767 r_s->hdr_deltas[i].type3,
2768 ps, depth)) {
2769 DEBUG(0, ("hmm, failed on i=%d\n", i));
2770 return False;
2771 }
2772 }
2773 }
2774 }
2775
2776 prs_align(ps);
2777 if (!prs_ntstatus("status", ps, depth, &(r_s->status)))
2778 return False;
2779
2780 return True;
2781 }
2782
2783 /*******************************************************************
2784 makes a NET_Q_SAM_DELTAS structure.
2785 ********************************************************************/
2786 BOOL init_net_q_sam_deltas(NET_Q_SAM_DELTAS *q_s, const char *srv_name,
2787 const char *cli_name, DOM_CRED *cli_creds,
2788 uint32 database_id, UINT64_S dom_mod_count)
2789 {
2790 DEBUG(5, ("init_net_q_sam_deltas\n"));
2791
2792 init_unistr2(&q_s->uni_srv_name, srv_name, strlen(srv_name) + 1);
2793 init_unistr2(&q_s->uni_cli_name, cli_name, strlen(cli_name) + 1);
2794
2795 memcpy(&q_s->cli_creds, cli_creds, sizeof(q_s->cli_creds));
2796 memset(&q_s->ret_creds, 0, sizeof(q_s->ret_creds));
2797
2798 q_s->database_id = database_id;
2799 q_s->dom_mod_count.low = dom_mod_count.low;
2800 q_s->dom_mod_count.high = dom_mod_count.high;
2801 q_s->max_size = 0xffff;
2802
2803 return True;
2804 }
2805
2806 /*******************************************************************
2807 reads or writes a structure.
2808 ********************************************************************/
2809 BOOL net_io_q_sam_deltas(char *desc, NET_Q_SAM_DELTAS *q_s, prs_struct *ps,
2810 int depth)
2811 {
2812 prs_debug(ps, depth, desc, "net_io_q_sam_deltas");
2813 depth++;
2814
2815 if (!smb_io_unistr2("", &q_s->uni_srv_name, True, ps, depth))
2816 return False;
2817 if (!smb_io_unistr2("", &q_s->uni_cli_name, True, ps, depth))
2818 return False;
2819
2820 if (!smb_io_cred("", &q_s->cli_creds, ps, depth))
2821 return False;
2822 if (!smb_io_cred("", &q_s->ret_creds, ps, depth))
2823 return False;
2824
2825 if (!prs_uint32("database_id ", ps, depth, &q_s->database_id))
2826 return False;
2827 if (!prs_uint64("dom_mod_count", ps, depth, &q_s->dom_mod_count))
2828 return False;
2829 if (!prs_uint32("max_size", ps, depth, &q_s->max_size))
2830 return False;
2831
2832 return True;
2833 }
2834
2835 /*******************************************************************
2836 reads or writes a structure.
2837 ********************************************************************/
2838 BOOL net_io_r_sam_deltas(char *desc, uint8 sess_key[16],
2839 NET_R_SAM_DELTAS *r_s, prs_struct *ps, int depth)
2840 {
2841 int i;
2842
2843 prs_debug(ps, depth, desc, "net_io_r_sam_deltas");
2844 depth++;
2845
2846 if (!smb_io_cred("srv_creds", &r_s->srv_creds, ps, depth))
2847 return False;
2848 if (!prs_uint64("dom_mod_count", ps, depth, &r_s->dom_mod_count))
2849 return False;
2850
2851 if (!prs_uint32("ptr_deltas", ps, depth, &r_s->ptr_deltas))
2852 return False;
2853 if (!prs_uint32("num_deltas", ps, depth, &r_s->num_deltas))
2854 return False;
2855 if (!prs_uint32("ptr_deltas2", ps, depth, &r_s->num_deltas2))
2856 return False;
2857
2858 if (r_s->num_deltas2 != 0)
2859 {
2860 if (!prs_uint32("num_deltas2 ", ps, depth, &r_s->num_deltas2))
2861 return False;
2862
2863 if (r_s->ptr_deltas != 0)
2864 {
2865 if (r_s->num_deltas > 0) {
2866 r_s->hdr_deltas = (SAM_DELTA_HDR *)
2867 talloc(ps->mem_ctx, r_s->num_deltas *
2868 sizeof(SAM_DELTA_HDR));
2869 if (r_s->hdr_deltas == NULL) {
2870 DEBUG(0, ("error tallocating memory "
2871 "for %d delta headers\n",
2872 r_s->num_deltas));
2873 return False;
2874 }
2875 }
2876
2877 for (i = 0; i < r_s->num_deltas; i++)
2878 {
2879 net_io_sam_delta_hdr("", &r_s->hdr_deltas[i],
2880 ps, depth);
2881 }
2882
2883 if (r_s->num_deltas > 0) {
2884 r_s->deltas = (SAM_DELTA_CTR *)
2885 talloc(ps->mem_ctx, r_s->num_deltas *
2886 sizeof(SAM_DELTA_CTR));
2887
2888 if (r_s->deltas == NULL) {
2889 DEBUG(0, ("error tallocating memory "
2890 "for %d deltas\n",
2891 r_s->num_deltas));
2892 return False;
2893 }
2894 }
2895
2896 for (i = 0; i < r_s->num_deltas; i++)
2897 {
2898 if (!net_io_sam_delta_ctr(
2899 "", sess_key,
2900 &r_s->deltas[i],
2901 r_s->hdr_deltas[i].type2,
2902 ps, depth))
2903
2904 return False;
2905 }
2906 }
2907 }
2908
2909 prs_align(ps);
2910 if (!prs_ntstatus("status", ps, depth, &r_s->status))
2911 return False;
2912
2913 return True;
2914 }
Samba GIT mirror