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