?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r10227: more ntsvcs code for the MMC service control plugin. Making some progress
[Samba.git] / source / rpc_parse / parse_net.c
blobe84ba23e80abc01e9bf392f0332a00bcbb5e7ae0
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 const 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 const 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 const 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_dom.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, SAM_ACCOUNT_INFO *info,
2143 prs_struct *ps, int depth)
2144 {
2145 BUFHDR2 hdr_priv_data;
2146 uint32 i;
2147
2148 prs_debug(ps, depth, desc, "net_io_sam_account_info");
2149 depth++;
2150
2151 if (!smb_io_unihdr("hdr_acct_name", &info->hdr_acct_name, ps, depth))
2152 return False;
2153 if (!smb_io_unihdr("hdr_full_name", &info->hdr_full_name, ps, depth))
2154 return False;
2155
2156 if (!prs_uint32("user_rid ", ps, depth, &info->user_rid))
2157 return False;
2158 if (!prs_uint32("group_rid", ps, depth, &info->group_rid))
2159 return False;
2160
2161 if (!smb_io_unihdr("hdr_home_dir ", &info->hdr_home_dir, ps, depth))
2162 return False;
2163 if (!smb_io_unihdr("hdr_dir_drive", &info->hdr_dir_drive, ps, depth))
2164 return False;
2165 if (!smb_io_unihdr("hdr_logon_script", &info->hdr_logon_script, ps,
2166 depth))
2167 return False;
2168
2169 if (!smb_io_unihdr("hdr_acct_desc", &info->hdr_acct_desc, ps, depth))
2170 return False;
2171 if (!smb_io_unihdr("hdr_workstations", &info->hdr_workstations, ps,
2172 depth))
2173 return False;
2174
2175 if (!smb_io_time("logon_time", &info->logon_time, ps, depth))
2176 return False;
2177 if (!smb_io_time("logoff_time", &info->logoff_time, ps, depth))
2178 return False;
2179
2180 if (!prs_uint32("logon_divs ", ps, depth, &info->logon_divs))
2181 return False;
2182 if (!prs_uint32("ptr_logon_hrs", ps, depth, &info->ptr_logon_hrs))
2183 return False;
2184
2185 if (!prs_uint16("bad_pwd_count", ps, depth, &info->bad_pwd_count))
2186 return False;
2187 if (!prs_uint16("logon_count", ps, depth, &info->logon_count))
2188 return False;
2189 if (!smb_io_time("pwd_last_set_time", &info->pwd_last_set_time, ps,
2190 depth))
2191 return False;
2192 if (!smb_io_time("acct_expiry_time", &info->acct_expiry_time, ps,
2193 depth))
2194 return False;
2195
2196 if (!prs_uint32("acb_info", ps, depth, &info->acb_info))
2197 return False;
2198 if (!prs_uint8s(False, "nt_pwd", ps, depth, info->nt_pwd, 16))
2199 return False;
2200 if (!prs_uint8s(False, "lm_pwd", ps, depth, info->lm_pwd, 16))
2201 return False;
2202 if (!prs_uint8("lm_pwd_present", ps, depth, &info->lm_pwd_present))
2203 return False;
2204 if (!prs_uint8("nt_pwd_present", ps, depth, &info->nt_pwd_present))
2205 return False;
2206 if (!prs_uint8("pwd_expired", ps, depth, &info->pwd_expired))
2207 return False;
2208
2209 if (!smb_io_unihdr("hdr_comment", &info->hdr_comment, ps, depth))
2210 return False;
2211 if (!smb_io_unihdr("hdr_parameters", &info->hdr_parameters, ps,
2212 depth))
2213 return False;
2214 if (!prs_uint16("country", ps, depth, &info->country))
2215 return False;
2216 if (!prs_uint16("codepage", ps, depth, &info->codepage))
2217 return False;
2218
2219 if (!smb_io_bufhdr2("hdr_priv_data", &hdr_priv_data, ps, depth))
2220 return False;
2221 if (!smb_io_bufhdr2("hdr_sec_desc", &info->hdr_sec_desc, ps, depth))
2222 return False;
2223 if (!smb_io_unihdr("hdr_profile", &info->hdr_profile, ps, depth))
2224 return False;
2225
2226 for (i = 0; i < 3; i++)
2227 {
2228 if (!smb_io_unihdr("hdr_reserved", &info->hdr_reserved[i],
2229 ps, depth))
2230 return False;
2231 }
2232
2233 for (i = 0; i < 4; i++)
2234 {
2235 if (!prs_uint32("dw_reserved", ps, depth,
2236 &info->dw_reserved[i]))
2237 return False;
2238 }
2239
2240 if (!smb_io_unistr2("uni_acct_name", &info->uni_acct_name,
2241 info->hdr_acct_name.buffer, ps, depth))
2242 return False;
2243 prs_align(ps);
2244 if (!smb_io_unistr2("uni_full_name", &info->uni_full_name,
2245 info->hdr_full_name.buffer, ps, depth))
2246 return False;
2247 prs_align(ps);
2248 if (!smb_io_unistr2("uni_home_dir ", &info->uni_home_dir,
2249 info->hdr_home_dir.buffer, ps, depth))
2250 return False;
2251 prs_align(ps);
2252 if (!smb_io_unistr2("uni_dir_drive", &info->uni_dir_drive,
2253 info->hdr_dir_drive.buffer, ps, depth))
2254 return False;
2255 prs_align(ps);
2256 if (!smb_io_unistr2("uni_logon_script", &info->uni_logon_script,
2257 info->hdr_logon_script.buffer, ps, depth))
2258 return False;
2259 prs_align(ps);
2260 if (!smb_io_unistr2("uni_acct_desc", &info->uni_acct_desc,
2261 info->hdr_acct_desc.buffer, ps, depth))
2262 return False;
2263 prs_align(ps);
2264 if (!smb_io_unistr2("uni_workstations", &info->uni_workstations,
2265 info->hdr_workstations.buffer, ps, depth))
2266 return False;
2267 prs_align(ps);
2268
2269 if (!prs_uint32("unknown1", ps, depth, &info->unknown1))
2270 return False;
2271 if (!prs_uint32("unknown2", ps, depth, &info->unknown2))
2272 return False;
2273
2274 if (!smb_io_rpc_blob("buf_logon_hrs", &info->buf_logon_hrs, ps, depth))
2275 return False;
2276 prs_align(ps);
2277 if (!smb_io_unistr2("uni_comment", &info->uni_comment,
2278 info->hdr_comment.buffer, ps, depth))
2279 return False;
2280 prs_align(ps);
2281 if (!smb_io_unistr2("uni_parameters", &info->uni_parameters,
2282 info->hdr_parameters.buffer, ps, depth))
2283 return False;
2284 prs_align(ps);
2285 if (hdr_priv_data.buffer != 0)
2286 {
2287 int old_offset = 0;
2288 uint32 len = 0x44;
2289 if (!prs_uint32("pwd_len", ps, depth, &len))
2290 return False;
2291 old_offset = ps->data_offset;
2292 if (len > 0)
2293 {
2294 if (ps->io)
2295 {
2296 /* reading */
2297 if (!prs_hash1(ps, ps->data_offset, len))
2298 return False;
2299 }
2300 if (!net_io_sam_passwd_info("pass", &info->pass,
2301 ps, depth))
2302 return False;
2303
2304 if (!ps->io)
2305 {
2306 /* writing */
2307 if (!prs_hash1(ps, old_offset, len))
2308 return False;
2309 }
2310 }
2311 if (old_offset + len > ps->buffer_size)
2312 return False;
2313 ps->data_offset = old_offset + len;
2314 }
2315 if (!smb_io_rpc_blob("buf_sec_desc", &info->buf_sec_desc, ps, depth))
2316 return False;
2317 prs_align(ps);
2318 if (!smb_io_unistr2("uni_profile", &info->uni_profile,
2319 info->hdr_profile.buffer, ps, depth))
2320 return False;
2321
2322 prs_align(ps);
2323
2324 return True;
2325 }
2326
2327 /*******************************************************************
2328 reads or writes a structure.
2329 ********************************************************************/
2330 static BOOL net_io_sam_group_mem_info(const char *desc, SAM_GROUP_MEM_INFO * info,
2331 prs_struct *ps, int depth)
2332 {
2333 uint32 i;
2334 fstring tmp;
2335
2336 prs_debug(ps, depth, desc, "net_io_sam_group_mem_info");
2337 depth++;
2338
2339 prs_align(ps);
2340 if (!prs_uint32("ptr_rids ", ps, depth, &info->ptr_rids))
2341 return False;
2342 if (!prs_uint32("ptr_attribs", ps, depth, &info->ptr_attribs))
2343 return False;
2344 if (!prs_uint32("num_members", ps, depth, &info->num_members))
2345 return False;
2346
2347 if (ps->data_offset + 16 > ps->buffer_size)
2348 return False;
2349 ps->data_offset += 16;
2350
2351 if (info->ptr_rids != 0)
2352 {
2353 if (!prs_uint32("num_members2", ps, depth,
2354 &info->num_members2))
2355 return False;
2356
2357 if (info->num_members2 != info->num_members)
2358 {
2359 /* RPC fault */
2360 return False;
2361 }
2362
2363 info->rids = TALLOC_ARRAY(ps->mem_ctx, uint32, info->num_members2);
2364
2365 if (info->rids == NULL) {
2366 DEBUG(0, ("out of memory allocating %d rids\n",
2367 info->num_members2));
2368 return False;
2369 }
2370
2371 for (i = 0; i < info->num_members2; i++)
2372 {
2373 slprintf(tmp, sizeof(tmp) - 1, "rids[%02d]", i);
2374 if (!prs_uint32(tmp, ps, depth, &info->rids[i]))
2375 return False;
2376 }
2377 }
2378
2379 if (info->ptr_attribs != 0)
2380 {
2381 if (!prs_uint32("num_members3", ps, depth,
2382 &info->num_members3))
2383 return False;
2384 if (info->num_members3 != info->num_members)
2385 {
2386 /* RPC fault */
2387 return False;
2388 }
2389
2390 info->attribs = TALLOC_ARRAY(ps->mem_ctx, uint32, info->num_members3);
2391
2392 if (info->attribs == NULL) {
2393 DEBUG(0, ("out of memory allocating %d attribs\n",
2394 info->num_members3));
2395 return False;
2396 }
2397
2398 for (i = 0; i < info->num_members3; i++)
2399 {
2400 slprintf(tmp, sizeof(tmp) - 1, "attribs[%02d]", i);
2401 if (!prs_uint32(tmp, ps, depth, &info->attribs[i]))
2402 return False;
2403 }
2404 }
2405
2406 return True;
2407 }
2408
2409 /*******************************************************************
2410 reads or writes a structure.
2411 ********************************************************************/
2412 static BOOL net_io_sam_alias_info(const char *desc, SAM_ALIAS_INFO * info,
2413 prs_struct *ps, int depth)
2414 {
2415 prs_debug(ps, depth, desc, "net_io_sam_alias_info");
2416 depth++;
2417
2418 if (!smb_io_unihdr("hdr_als_name", &info->hdr_als_name, ps, depth))
2419 return False;
2420 if (!prs_uint32("als_rid", ps, depth, &info->als_rid))
2421 return False;
2422 if (!smb_io_bufhdr2("hdr_sec_desc", &info->hdr_sec_desc, ps, depth))
2423 return False;
2424 if (!smb_io_unihdr("hdr_als_desc", &info->hdr_als_desc, ps, depth))
2425 return False;
2426
2427 if (ps->data_offset + 40 > ps->buffer_size)
2428 return False;
2429 ps->data_offset += 40;
2430
2431 if (!smb_io_unistr2("uni_als_name", &info->uni_als_name,
2432 info->hdr_als_name.buffer, ps, depth))
2433 return False;
2434 if (!smb_io_rpc_blob("buf_sec_desc", &info->buf_sec_desc, ps, depth))
2435 return False;
2436
2437 if (!smb_io_unistr2("uni_als_desc", &info->uni_als_desc,
2438 info->hdr_als_desc.buffer, ps, depth))
2439 return False;
2440
2441 return True;
2442 }
2443
2444 /*******************************************************************
2445 reads or writes a structure.
2446 ********************************************************************/
2447 static BOOL net_io_sam_alias_mem_info(const char *desc, SAM_ALIAS_MEM_INFO * info,
2448 prs_struct *ps, int depth)
2449 {
2450 uint32 i;
2451 fstring tmp;
2452
2453 prs_debug(ps, depth, desc, "net_io_sam_alias_mem_info");
2454 depth++;
2455
2456 prs_align(ps);
2457 if (!prs_uint32("num_members", ps, depth, &info->num_members))
2458 return False;
2459 if (!prs_uint32("ptr_members", ps, depth, &info->ptr_members))
2460 return False;
2461
2462 if (ps->data_offset + 16 > ps->buffer_size)
2463 return False;
2464 ps->data_offset += 16;
2465
2466 if (info->ptr_members != 0)
2467 {
2468 if (!prs_uint32("num_sids", ps, depth, &info->num_sids))
2469 return False;
2470 if (info->num_sids != info->num_members)
2471 {
2472 /* RPC fault */
2473 return False;
2474 }
2475
2476 info->ptr_sids = TALLOC_ARRAY(ps->mem_ctx, uint32, info->num_sids);
2477
2478 if (info->ptr_sids == NULL) {
2479 DEBUG(0, ("out of memory allocating %d ptr_sids\n",
2480 info->num_sids));
2481 return False;
2482 }
2483
2484 for (i = 0; i < info->num_sids; i++)
2485 {
2486 slprintf(tmp, sizeof(tmp) - 1, "ptr_sids[%02d]", i);
2487 if (!prs_uint32(tmp, ps, depth, &info->ptr_sids[i]))
2488 return False;
2489 }
2490
2491 info->sids = TALLOC_ARRAY(ps->mem_ctx, DOM_SID2, info->num_sids);
2492
2493 if (info->sids == NULL) {
2494 DEBUG(0, ("error allocating %d sids\n",
2495 info->num_sids));
2496 return False;
2497 }
2498
2499 for (i = 0; i < info->num_sids; i++)
2500 {
2501 if (info->ptr_sids[i] != 0)
2502 {
2503 slprintf(tmp, sizeof(tmp) - 1, "sids[%02d]",
2504 i);
2505 if (!smb_io_dom_sid2(tmp, &info->sids[i],
2506 ps, depth))
2507 return False;
2508 }
2509 }
2510 }
2511
2512 return True;
2513 }
2514
2515 /*******************************************************************
2516 reads or writes a structure.
2517 ********************************************************************/
2518 static BOOL net_io_sam_policy_info(const char *desc, SAM_DELTA_POLICY *info,
2519 prs_struct *ps, int depth)
2520 {
2521 unsigned int i;
2522 prs_debug(ps, depth, desc, "net_io_sam_policy_info");
2523 depth++;
2524
2525 if(!prs_align(ps))
2526 return False;
2527
2528 if (!prs_uint32("max_log_size", ps, depth, &info->max_log_size))
2529 return False;
2530 if (!prs_uint64("audit_retention_period", ps, depth,
2531 &info->audit_retention_period))
2532 return False;
2533 if (!prs_uint32("auditing_mode", ps, depth, &info->auditing_mode))
2534 return False;
2535 if (!prs_uint32("num_events", ps, depth, &info->num_events))
2536 return False;
2537 if (!prs_uint32("ptr_events", ps, depth, &info->ptr_events))
2538 return False;
2539
2540 if (!smb_io_unihdr("hdr_dom_name", &info->hdr_dom_name, ps, depth))
2541 return False;
2542
2543 if (!prs_uint32("sid_ptr", ps, depth, &info->sid_ptr))
2544 return False;
2545
2546 if (!prs_uint32("paged_pool_limit", ps, depth, &info->paged_pool_limit))
2547 return False;
2548 if (!prs_uint32("non_paged_pool_limit", ps, depth,
2549 &info->non_paged_pool_limit))
2550 return False;
2551 if (!prs_uint32("min_workset_size", ps, depth, &info->min_workset_size))
2552 return False;
2553 if (!prs_uint32("max_workset_size", ps, depth, &info->max_workset_size))
2554 return False;
2555 if (!prs_uint32("page_file_limit", ps, depth, &info->page_file_limit))
2556 return False;
2557 if (!prs_uint64("time_limit", ps, depth, &info->time_limit))
2558 return False;
2559 if (!smb_io_time("modify_time", &info->modify_time, ps, depth))
2560 return False;
2561 if (!smb_io_time("create_time", &info->create_time, ps, depth))
2562 return False;
2563 if (!smb_io_bufhdr2("hdr_sec_desc", &info->hdr_sec_desc, ps, depth))
2564 return False;
2565
2566 for (i=0; i<4; i++) {
2567 UNIHDR dummy;
2568 if (!smb_io_unihdr("dummy", &dummy, ps, depth))
2569 return False;
2570 }
2571
2572 for (i=0; i<4; i++) {
2573 uint32 reserved;
2574 if (!prs_uint32("reserved", ps, depth, &reserved))
2575 return False;
2576 }
2577
2578 if (!prs_uint32("num_event_audit_options", ps, depth,
2579 &info->num_event_audit_options))
2580 return False;
2581
2582 for (i=0; i<info->num_event_audit_options; i++)
2583 if (!prs_uint32("event_audit_option", ps, depth,
2584 &info->event_audit_option))
2585 return False;
2586
2587 if (!smb_io_unistr2("domain_name", &info->domain_name, True, ps, depth))
2588 return False;
2589
2590 if(!smb_io_dom_sid2("domain_sid", &info->domain_sid, ps, depth))
2591 return False;
2592
2593 if (!smb_io_rpc_blob("buf_sec_desc", &info->buf_sec_desc, ps, depth))
2594
2595 return False;
2596
2597 return True;
2598 }
2599
2600 #if 0
2601
2602 /* This function is pretty broken - see bug #334 */
2603
2604 /*******************************************************************
2605 reads or writes a structure.
2606 ********************************************************************/
2607 static BOOL net_io_sam_trustdoms_info(const char *desc, SAM_DELTA_TRUSTDOMS *info,
2608 prs_struct *ps, int depth)
2609 {
2610 int i;
2611
2612 prs_debug(ps, depth, desc, "net_io_sam_trustdoms_info");
2613 depth++;
2614
2615 if(!prs_align(ps))
2616 return False;
2617
2618 if(!prs_uint32("buf_size", ps, depth, &info->buf_size))
2619 return False;
2620
2621 if(!sec_io_desc("sec_desc", &info->sec_desc, ps, depth))
2622 return False;
2623
2624 if(!smb_io_dom_sid2("sid", &info->sid, ps, depth))
2625 return False;
2626
2627 if(!smb_io_unihdr("hdr_domain", &info->hdr_domain, ps, depth))
2628 return False;
2629
2630 if(!prs_uint32("unknown0", ps, depth, &info->unknown0))
2631 return False;
2632 if(!prs_uint32("unknown1", ps, depth, &info->unknown1))
2633 return False;
2634 if(!prs_uint32("unknown2", ps, depth, &info->unknown2))
2635 return False;
2636
2637 if(!prs_uint32("buf_size2", ps, depth, &info->buf_size2))
2638 return False;
2639 if(!prs_uint32("ptr", ps, depth, &info->ptr))
2640 return False;
2641
2642 for (i=0; i<12; i++)
2643 if(!prs_uint32("unknown3", ps, depth, &info->unknown3))
2644 return False;
2645
2646 if (!smb_io_unistr2("domain", &info->domain, True, ps, depth))
2647 return False;
2648
2649 return True;
2650 }
2651
2652 #endif
2653
2654 #if 0
2655
2656 /* This function doesn't work - see bug #334 */
2657
2658 /*******************************************************************
2659 reads or writes a structure.
2660 ********************************************************************/
2661 static BOOL net_io_sam_secret_info(const char *desc, SAM_DELTA_SECRET *info,
2662 prs_struct *ps, int depth)
2663 {
2664 int i;
2665
2666 prs_debug(ps, depth, desc, "net_io_sam_secret_info");
2667 depth++;
2668
2669 if(!prs_align(ps))
2670 return False;
2671
2672 if(!prs_uint32("buf_size", ps, depth, &info->buf_size))
2673 return False;
2674
2675 if(!sec_io_desc("sec_desc", &info->sec_desc, ps, depth))
2676 return False;
2677
2678 if (!smb_io_unistr2("secret", &info->secret, True, ps, depth))
2679 return False;
2680
2681 if(!prs_align(ps))
2682 return False;
2683
2684 if(!prs_uint32("count1", ps, depth, &info->count1))
2685 return False;
2686 if(!prs_uint32("count2", ps, depth, &info->count2))
2687 return False;
2688 if(!prs_uint32("ptr", ps, depth, &info->ptr))
2689 return False;
2690
2691
2692 if(!smb_io_time("time1", &info->time1, ps, depth)) /* logon time */
2693 return False;
2694 if(!prs_uint32("count3", ps, depth, &info->count3))
2695 return False;
2696 if(!prs_uint32("count4", ps, depth, &info->count4))
2697 return False;
2698 if(!prs_uint32("ptr2", ps, depth, &info->ptr2))
2699 return False;
2700 if(!smb_io_time("time2", &info->time2, ps, depth)) /* logon time */
2701 return False;
2702 if(!prs_uint32("unknow1", ps, depth, &info->unknow1))
2703 return False;
2704
2705
2706 if(!prs_uint32("buf_size2", ps, depth, &info->buf_size2))
2707 return False;
2708 if(!prs_uint32("ptr3", ps, depth, &info->ptr3))
2709 return False;
2710 for(i=0; i<12; i++)
2711 if(!prs_uint32("unknow2", ps, depth, &info->unknow2))
2712 return False;
2713
2714 if(!prs_uint32("chal_len", ps, depth, &info->chal_len))
2715 return False;
2716 if(!prs_uint32("reserved1", ps, depth, &info->reserved1))
2717 return False;
2718 if(!prs_uint32("chal_len2", ps, depth, &info->chal_len2))
2719 return False;
2720
2721 if(!prs_uint8s (False, "chal", ps, depth, info->chal, info->chal_len2))
2722 return False;
2723
2724 if(!prs_uint32("key_len", ps, depth, &info->key_len))
2725 return False;
2726 if(!prs_uint32("reserved2", ps, depth, &info->reserved2))
2727 return False;
2728 if(!prs_uint32("key_len2", ps, depth, &info->key_len2))
2729 return False;
2730
2731 if(!prs_uint8s (False, "key", ps, depth, info->key, info->key_len2))
2732 return False;
2733
2734
2735 if(!prs_uint32("buf_size3", ps, depth, &info->buf_size3))
2736 return False;
2737
2738 if(!sec_io_desc("sec_desc2", &info->sec_desc2, ps, depth))
2739 return False;
2740
2741
2742 return True;
2743 }
2744
2745 #endif
2746
2747 /*******************************************************************
2748 reads or writes a structure.
2749 ********************************************************************/
2750 static BOOL net_io_sam_privs_info(const char *desc, SAM_DELTA_PRIVS *info,
2751 prs_struct *ps, int depth)
2752 {
2753 unsigned int i;
2754
2755 prs_debug(ps, depth, desc, "net_io_sam_privs_info");
2756 depth++;
2757
2758 if(!prs_align(ps))
2759 return False;
2760
2761 if(!smb_io_dom_sid2("sid", &info->sid, ps, depth))
2762 return False;
2763
2764 if(!prs_uint32("priv_count", ps, depth, &info->priv_count))
2765 return False;
2766 if(!prs_uint32("priv_control", ps, depth, &info->priv_control))
2767 return False;
2768
2769 if(!prs_uint32("priv_attr_ptr", ps, depth, &info->priv_attr_ptr))
2770 return False;
2771 if(!prs_uint32("priv_name_ptr", ps, depth, &info->priv_name_ptr))
2772 return False;
2773
2774 if (!prs_uint32("paged_pool_limit", ps, depth, &info->paged_pool_limit))
2775 return False;
2776 if (!prs_uint32("non_paged_pool_limit", ps, depth,
2777 &info->non_paged_pool_limit))
2778 return False;
2779 if (!prs_uint32("min_workset_size", ps, depth, &info->min_workset_size))
2780 return False;
2781 if (!prs_uint32("max_workset_size", ps, depth, &info->max_workset_size))
2782 return False;
2783 if (!prs_uint32("page_file_limit", ps, depth, &info->page_file_limit))
2784 return False;
2785 if (!prs_uint64("time_limit", ps, depth, &info->time_limit))
2786 return False;
2787 if (!prs_uint32("system_flags", ps, depth, &info->system_flags))
2788 return False;
2789 if (!smb_io_bufhdr2("hdr_sec_desc", &info->hdr_sec_desc, ps, depth))
2790 return False;
2791
2792 for (i=0; i<4; i++) {
2793 UNIHDR dummy;
2794 if (!smb_io_unihdr("dummy", &dummy, ps, depth))
2795 return False;
2796 }
2797
2798 for (i=0; i<4; i++) {
2799 uint32 reserved;
2800 if (!prs_uint32("reserved", ps, depth, &reserved))
2801 return False;
2802 }
2803
2804 if(!prs_uint32("attribute_count", ps, depth, &info->attribute_count))
2805 return False;
2806
2807 info->attributes = TALLOC_ARRAY(ps->mem_ctx, uint32, info->attribute_count);
2808
2809 for (i=0; i<info->attribute_count; i++)
2810 if(!prs_uint32("attributes", ps, depth, &info->attributes[i]))
2811 return False;
2812
2813 if(!prs_uint32("privlist_count", ps, depth, &info->privlist_count))
2814 return False;
2815
2816 info->hdr_privslist = TALLOC_ARRAY(ps->mem_ctx, UNIHDR, info->privlist_count);
2817 info->uni_privslist = TALLOC_ARRAY(ps->mem_ctx, UNISTR2, info->privlist_count);
2818
2819 for (i=0; i<info->privlist_count; i++)
2820 if(!smb_io_unihdr("hdr_privslist", &info->hdr_privslist[i], ps, depth))
2821 return False;
2822
2823 for (i=0; i<info->privlist_count; i++)
2824 if (!smb_io_unistr2("uni_privslist", &info->uni_privslist[i], True, ps, depth))
2825 return False;
2826
2827 if (!smb_io_rpc_blob("buf_sec_desc", &info->buf_sec_desc, ps, depth))
2828 return False;
2829
2830 return True;
2831 }
2832
2833 /*******************************************************************
2834 reads or writes a structure.
2835 ********************************************************************/
2836 static BOOL net_io_sam_delta_ctr(const char *desc,
2837 SAM_DELTA_CTR * delta, uint16 type,
2838 prs_struct *ps, int depth)
2839 {
2840 prs_debug(ps, depth, desc, "net_io_sam_delta_ctr");
2841 depth++;
2842
2843 switch (type) {
2844 /* Seen in sam deltas */
2845 case SAM_DELTA_MODIFIED_COUNT:
2846 if (!net_io_sam_delta_mod_count("", &delta->mod_count, ps, depth))
2847 return False;
2848 break;
2849
2850 case SAM_DELTA_DOMAIN_INFO:
2851 if (!net_io_sam_domain_info("", &delta->domain_info, ps, depth))
2852 return False;
2853 break;
2854
2855 case SAM_DELTA_GROUP_INFO:
2856 if (!net_io_sam_group_info("", &delta->group_info, ps, depth))
2857 return False;
2858 break;
2859
2860 case SAM_DELTA_ACCOUNT_INFO:
2861 if (!net_io_sam_account_info("", &delta->account_info, ps, depth))
2862 return False;
2863 break;
2864
2865 case SAM_DELTA_GROUP_MEM:
2866 if (!net_io_sam_group_mem_info("", &delta->grp_mem_info, ps, depth))
2867 return False;
2868 break;
2869
2870 case SAM_DELTA_ALIAS_INFO:
2871 if (!net_io_sam_alias_info("", &delta->alias_info, ps, depth))
2872 return False;
2873 break;
2874
2875 case SAM_DELTA_POLICY_INFO:
2876 if (!net_io_sam_policy_info("", &delta->policy_info, ps, depth))
2877 return False;
2878 break;
2879
2880 case SAM_DELTA_ALIAS_MEM:
2881 if (!net_io_sam_alias_mem_info("", &delta->als_mem_info, ps, depth))
2882 return False;
2883 break;
2884
2885 case SAM_DELTA_PRIVS_INFO:
2886 if (!net_io_sam_privs_info("", &delta->privs_info, ps, depth))
2887 return False;
2888 break;
2889
2890 /* These guys are implemented but broken */
2891
2892 case SAM_DELTA_TRUST_DOMS:
2893 case SAM_DELTA_SECRET_INFO:
2894 break;
2895
2896 /* These guys are not implemented yet */
2897
2898 case SAM_DELTA_RENAME_GROUP:
2899 case SAM_DELTA_RENAME_USER:
2900 case SAM_DELTA_RENAME_ALIAS:
2901 case SAM_DELTA_DELETE_GROUP:
2902 case SAM_DELTA_DELETE_USER:
2903 default:
2904 DEBUG(0, ("Replication error: Unknown delta type 0x%x\n", type));
2905 break;
2906 }
2907
2908 return True;
2909 }
2910
2911 /*******************************************************************
2912 reads or writes a structure.
2913 ********************************************************************/
2914 BOOL net_io_r_sam_sync(const char *desc,
2915 NET_R_SAM_SYNC * r_s, prs_struct *ps, int depth)
2916 {
2917 uint32 i;
2918
2919 prs_debug(ps, depth, desc, "net_io_r_sam_sync");
2920 depth++;
2921
2922 if (!smb_io_cred("srv_creds", &r_s->srv_creds, ps, depth))
2923 return False;
2924 if (!prs_uint32("sync_context", ps, depth, &r_s->sync_context))
2925 return False;
2926
2927 if (!prs_uint32("ptr_deltas", ps, depth, &r_s->ptr_deltas))
2928 return False;
2929 if (r_s->ptr_deltas != 0)
2930 {
2931 if (!prs_uint32("num_deltas ", ps, depth, &r_s->num_deltas))
2932 return False;
2933 if (!prs_uint32("ptr_deltas2", ps, depth, &r_s->ptr_deltas2))
2934 return False;
2935 if (r_s->ptr_deltas2 != 0)
2936 {
2937 if (!prs_uint32("num_deltas2", ps, depth,
2938 &r_s->num_deltas2))
2939 return False;
2940
2941 if (r_s->num_deltas2 != r_s->num_deltas)
2942 {
2943 /* RPC fault */
2944 return False;
2945 }
2946
2947 if (r_s->num_deltas2 > 0) {
2948 r_s->hdr_deltas = TALLOC_ARRAY(ps->mem_ctx, SAM_DELTA_HDR, r_s->num_deltas2);
2949 if (r_s->hdr_deltas == NULL) {
2950 DEBUG(0, ("error tallocating memory "
2951 "for %d delta headers\n",
2952 r_s->num_deltas2));
2953 return False;
2954 }
2955 }
2956
2957 for (i = 0; i < r_s->num_deltas2; i++)
2958 {
2959 if (!net_io_sam_delta_hdr("",
2960 &r_s->hdr_deltas[i],
2961 ps, depth))
2962 return False;
2963 }
2964
2965 if (r_s->num_deltas2 > 0) {
2966 r_s->deltas = TALLOC_ARRAY(ps->mem_ctx, SAM_DELTA_CTR, r_s->num_deltas2);
2967 if (r_s->deltas == NULL) {
2968 DEBUG(0, ("error tallocating memory "
2969 "for %d deltas\n",
2970 r_s->num_deltas2));
2971 return False;
2972 }
2973 }
2974
2975 for (i = 0; i < r_s->num_deltas2; i++)
2976 {
2977 if (!net_io_sam_delta_ctr(
2978 "", &r_s->deltas[i],
2979 r_s->hdr_deltas[i].type3,
2980 ps, depth)) {
2981 DEBUG(0, ("hmm, failed on i=%d\n", i));
2982 return False;
2983 }
2984 }
2985 }
2986 }
2987
2988 prs_align(ps);
2989 if (!prs_ntstatus("status", ps, depth, &(r_s->status)))
2990 return False;
2991
2992 return True;
2993 }
2994
2995 /*******************************************************************
2996 makes a NET_Q_SAM_DELTAS structure.
2997 ********************************************************************/
2998 BOOL init_net_q_sam_deltas(NET_Q_SAM_DELTAS *q_s, const char *srv_name,
2999 const char *cli_name, DOM_CRED *cli_creds,
3000 uint32 database_id, UINT64_S dom_mod_count)
3001 {
3002 DEBUG(5, ("init_net_q_sam_deltas\n"));
3003
3004 init_unistr2(&q_s->uni_srv_name, srv_name, UNI_STR_TERMINATE);
3005 init_unistr2(&q_s->uni_cli_name, cli_name, UNI_STR_TERMINATE);
3006
3007 memcpy(&q_s->cli_creds, cli_creds, sizeof(q_s->cli_creds));
3008 memset(&q_s->ret_creds, 0, sizeof(q_s->ret_creds));
3009
3010 q_s->database_id = database_id;
3011 q_s->dom_mod_count.low = dom_mod_count.low;
3012 q_s->dom_mod_count.high = dom_mod_count.high;
3013 q_s->max_size = 0xffff;
3014
3015 return True;
3016 }
3017
3018 /*******************************************************************
3019 reads or writes a structure.
3020 ********************************************************************/
3021 BOOL net_io_q_sam_deltas(const char *desc, NET_Q_SAM_DELTAS *q_s, prs_struct *ps,
3022 int depth)
3023 {
3024 prs_debug(ps, depth, desc, "net_io_q_sam_deltas");
3025 depth++;
3026
3027 if (!smb_io_unistr2("", &q_s->uni_srv_name, True, ps, depth))
3028 return False;
3029 if (!smb_io_unistr2("", &q_s->uni_cli_name, True, ps, depth))
3030 return False;
3031
3032 if (!smb_io_cred("", &q_s->cli_creds, ps, depth))
3033 return False;
3034 if (!smb_io_cred("", &q_s->ret_creds, ps, depth))
3035 return False;
3036
3037 if (!prs_uint32("database_id ", ps, depth, &q_s->database_id))
3038 return False;
3039 if (!prs_uint64("dom_mod_count", ps, depth, &q_s->dom_mod_count))
3040 return False;
3041 if (!prs_uint32("max_size", ps, depth, &q_s->max_size))
3042 return False;
3043
3044 return True;
3045 }
3046
3047 /*******************************************************************
3048 reads or writes a structure.
3049 ********************************************************************/
3050 BOOL net_io_r_sam_deltas(const char *desc,
3051 NET_R_SAM_DELTAS *r_s, prs_struct *ps, int depth)
3052 {
3053 unsigned int i;
3054
3055 prs_debug(ps, depth, desc, "net_io_r_sam_deltas");
3056 depth++;
3057
3058 if (!smb_io_cred("srv_creds", &r_s->srv_creds, ps, depth))
3059 return False;
3060 if (!prs_uint64("dom_mod_count", ps, depth, &r_s->dom_mod_count))
3061 return False;
3062
3063 if (!prs_uint32("ptr_deltas", ps, depth, &r_s->ptr_deltas))
3064 return False;
3065 if (!prs_uint32("num_deltas", ps, depth, &r_s->num_deltas))
3066 return False;
3067 if (!prs_uint32("ptr_deltas2", ps, depth, &r_s->num_deltas2))
3068 return False;
3069
3070 if (r_s->num_deltas2 != 0)
3071 {
3072 if (!prs_uint32("num_deltas2 ", ps, depth, &r_s->num_deltas2))
3073 return False;
3074
3075 if (r_s->ptr_deltas != 0)
3076 {
3077 if (r_s->num_deltas > 0) {
3078 r_s->hdr_deltas = TALLOC_ARRAY(ps->mem_ctx, SAM_DELTA_HDR, r_s->num_deltas);
3079 if (r_s->hdr_deltas == NULL) {
3080 DEBUG(0, ("error tallocating memory "
3081 "for %d delta headers\n",
3082 r_s->num_deltas));
3083 return False;
3084 }
3085 }
3086
3087 for (i = 0; i < r_s->num_deltas; i++)
3088 {
3089 net_io_sam_delta_hdr("", &r_s->hdr_deltas[i],
3090 ps, depth);
3091 }
3092
3093 if (r_s->num_deltas > 0) {
3094 r_s->deltas = TALLOC_ARRAY(ps->mem_ctx, SAM_DELTA_CTR, r_s->num_deltas);
3095 if (r_s->deltas == NULL) {
3096 DEBUG(0, ("error tallocating memory "
3097 "for %d deltas\n",
3098 r_s->num_deltas));
3099 return False;
3100 }
3101 }
3102
3103 for (i = 0; i < r_s->num_deltas; i++)
3104 {
3105 if (!net_io_sam_delta_ctr(
3106 "",
3107 &r_s->deltas[i],
3108 r_s->hdr_deltas[i].type2,
3109 ps, depth))
3110
3111 return False;
3112 }
3113 }
3114 }
3115
3116 prs_align(ps);
3117 if (!prs_ntstatus("status", ps, depth, &r_s->status))
3118 return False;
3119
3120 return True;
3121 }
Samba GIT mirror