source: branches/samba-3.0/source/rpc_parse/parse_net.c

Last change on this file was 165, checked in by Paul Smedley, 16 years ago

Add 'missing' 3.0.34 diffs
File size: 112.7 KB
Line 
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 Francois 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
33static 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
54static 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
69static 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
103static 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
113static 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
136static 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
154static 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
185static 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
207static 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
233BOOL 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
281void 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
296void 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
335BOOL 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
379BOOL 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
409void 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
424void 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
452BOOL 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_GETANYDCNAME structure.
484********************************************************************/
485void init_net_q_getanydcname(NET_Q_GETANYDCNAME *r_t, const char *logon_server,
486 const char *domainname)
487{
488 DEBUG(5,("init_q_getanydcname\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_GETANYDCNAME structure.
498********************************************************************/
499
500BOOL net_io_q_getanydcname(const char *desc, NET_Q_GETANYDCNAME *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_getanydcname");
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_GETANYDCNAME structure.
532********************************************************************/
533void init_net_r_getanydcname(NET_R_GETANYDCNAME *r_t, const char *dcname)
534{
535 DEBUG(5,("init_r_getanydcname\n"));
536
537 init_unistr2(&r_t->uni_dcname, dcname, UNI_STR_TERMINATE);
538}
539
540/*******************************************************************
541 Reads or writes an NET_R_GETANYDCNAME structure.
542********************************************************************/
543
544BOOL net_io_r_getanydcname(const char *desc, NET_R_GETANYDCNAME *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_getanydcname");
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_align(ps))
561 return False;
562
563 if (!prs_werror("status", ps, depth, &r_t->status))
564 return False;
565
566 return True;
567}
568
569/*******************************************************************
570 Inits an NET_R_TRUST_DOM_LIST structure.
571********************************************************************/
572
573void init_r_trust_dom(NET_R_TRUST_DOM_LIST *r_t,
574 uint32 num_doms, const char *dom_name)
575{
576 unsigned int i = 0;
577
578 DEBUG(5,("init_r_trust_dom\n"));
579
580 for (i = 0; i < MAX_TRUST_DOMS; i++) {
581 r_t->uni_trust_dom_name[i].uni_str_len = 0;
582 r_t->uni_trust_dom_name[i].uni_max_len = 0;
583 }
584 if (num_doms > MAX_TRUST_DOMS)
585 num_doms = MAX_TRUST_DOMS;
586
587 for (i = 0; i < num_doms; i++) {
588 fstring domain_name;
589 fstrcpy(domain_name, dom_name);
590 strupper_m(domain_name);
591 init_unistr2(&r_t->uni_trust_dom_name[i], domain_name, UNI_STR_TERMINATE);
592 /* the use of UNISTR2 here is non-standard. */
593 r_t->uni_trust_dom_name[i].offset = 0x1;
594 }
595
596 r_t->status = NT_STATUS_OK;
597}
598
599/*******************************************************************
600 Reads or writes an NET_R_TRUST_DOM_LIST structure.
601********************************************************************/
602
603BOOL net_io_r_trust_dom(const char *desc, NET_R_TRUST_DOM_LIST *r_t, prs_struct *ps, int depth)
604{
605 uint32 value;
606
607 if (r_t == NULL)
608 return False;
609
610 prs_debug(ps, depth, desc, "net_io_r_trust_dom");
611 depth++;
612
613 /* temporary code to give a valid response */
614 value=2;
615 if(!prs_uint32("status", ps, depth, &value))
616 return False;
617
618 value=1;
619 if(!prs_uint32("status", ps, depth, &value))
620 return False;
621 value=2;
622 if(!prs_uint32("status", ps, depth, &value))
623 return False;
624
625 value=0;
626 if(!prs_uint32("status", ps, depth, &value))
627 return False;
628
629 value=0;
630 if(!prs_uint32("status", ps, depth, &value))
631 return False;
632
633/* old non working code */
634#if 0
635 int i;
636
637 for (i = 0; i < MAX_TRUST_DOMS; i++) {
638 if (r_t->uni_trust_dom_name[i].uni_str_len == 0)
639 break;
640 if(!smb_io_unistr2("", &r_t->uni_trust_dom_name[i], True, ps, depth))
641 return False;
642 }
643
644 if(!prs_ntstatus("status", ps, depth, &r_t->status))
645 return False;
646#endif
647 return True;
648}
649
650
651/*******************************************************************
652 Reads or writes an NET_Q_TRUST_DOM_LIST structure.
653********************************************************************/
654
655BOOL net_io_q_trust_dom(const char *desc, NET_Q_TRUST_DOM_LIST *q_l, prs_struct *ps, int depth)
656{
657 if (q_l == NULL)
658 return False;
659
660 prs_debug(ps, depth, desc, "net_io_q_trust_dom");
661 depth++;
662
663 if(!prs_uint32("ptr ", ps, depth, &q_l->ptr))
664 return False;
665 if(!smb_io_unistr2 ("", &q_l->uni_server_name, q_l->ptr, ps, depth))
666 return False;
667
668 return True;
669}
670
671/*******************************************************************
672 Inits an NET_Q_REQ_CHAL structure.
673********************************************************************/
674
675void init_q_req_chal(NET_Q_REQ_CHAL *q_c,
676 const char *logon_srv, const char *logon_clnt,
677 const DOM_CHAL *clnt_chal)
678{
679 DEBUG(5,("init_q_req_chal: %d\n", __LINE__));
680
681 q_c->undoc_buffer = 1; /* don't know what this buffer is */
682
683 init_unistr2(&q_c->uni_logon_srv, logon_srv , UNI_STR_TERMINATE);
684 init_unistr2(&q_c->uni_logon_clnt, logon_clnt, UNI_STR_TERMINATE);
685
686 memcpy(q_c->clnt_chal.data, clnt_chal->data, sizeof(clnt_chal->data));
687
688 DEBUG(5,("init_q_req_chal: %d\n", __LINE__));
689}
690
691/*******************************************************************
692 Reads or writes an NET_Q_REQ_CHAL structure.
693********************************************************************/
694
695BOOL net_io_q_req_chal(const char *desc, NET_Q_REQ_CHAL *q_c, prs_struct *ps, int depth)
696{
697 if (q_c == NULL)
698 return False;
699
700 prs_debug(ps, depth, desc, "net_io_q_req_chal");
701 depth++;
702
703 if(!prs_align(ps))
704 return False;
705
706 if(!prs_uint32("undoc_buffer", ps, depth, &q_c->undoc_buffer))
707 return False;
708
709 if(!smb_io_unistr2("", &q_c->uni_logon_srv, True, ps, depth)) /* logon server unicode string */
710 return False;
711 if(!smb_io_unistr2("", &q_c->uni_logon_clnt, True, ps, depth)) /* logon client unicode string */
712 return False;
713
714 if(!smb_io_chal("", &q_c->clnt_chal, ps, depth))
715 return False;
716
717 return True;
718}
719
720/*******************************************************************
721 Reads or writes a structure.
722********************************************************************/
723
724BOOL net_io_r_req_chal(const char *desc, NET_R_REQ_CHAL *r_c, prs_struct *ps, int depth)
725{
726 if (r_c == NULL)
727 return False;
728
729 prs_debug(ps, depth, desc, "net_io_r_req_chal");
730 depth++;
731
732 if(!prs_align(ps))
733 return False;
734
735 if(!smb_io_chal("", &r_c->srv_chal, ps, depth)) /* server challenge */
736 return False;
737
738 if(!prs_ntstatus("status", ps, depth, &r_c->status))
739 return False;
740
741 return True;
742}
743
744
745/*******************************************************************
746 Reads or writes a structure.
747********************************************************************/
748
749BOOL net_io_q_auth(const char *desc, NET_Q_AUTH *q_a, prs_struct *ps, int depth)
750{
751 if (q_a == NULL)
752 return False;
753
754 prs_debug(ps, depth, desc, "net_io_q_auth");
755 depth++;
756
757 if(!prs_align(ps))
758 return False;
759
760 if(!smb_io_log_info ("", &q_a->clnt_id, ps, depth)) /* client identification info */
761 return False;
762 if(!smb_io_chal("", &q_a->clnt_chal, ps, depth))
763 return False;
764
765 return True;
766}
767
768/*******************************************************************
769 Reads or writes a structure.
770********************************************************************/
771
772BOOL net_io_r_auth(const char *desc, NET_R_AUTH *r_a, prs_struct *ps, int depth)
773{
774 if (r_a == NULL)
775 return False;
776
777 prs_debug(ps, depth, desc, "net_io_r_auth");
778 depth++;
779
780 if(!prs_align(ps))
781 return False;
782
783 if(!smb_io_chal("", &r_a->srv_chal, ps, depth)) /* server challenge */
784 return False;
785
786 if(!prs_ntstatus("status", ps, depth, &r_a->status))
787 return False;
788
789 return True;
790}
791
792/*******************************************************************
793 Inits a NET_Q_AUTH_2 struct.
794********************************************************************/
795
796void init_q_auth_2(NET_Q_AUTH_2 *q_a,
797 const char *logon_srv, const char *acct_name, uint16 sec_chan, const char *comp_name,
798 const DOM_CHAL *clnt_chal, uint32 clnt_flgs)
799{
800 DEBUG(5,("init_q_auth_2: %d\n", __LINE__));
801
802 init_log_info(&q_a->clnt_id, logon_srv, acct_name, sec_chan, comp_name);
803 memcpy(q_a->clnt_chal.data, clnt_chal->data, sizeof(clnt_chal->data));
804 q_a->clnt_flgs.neg_flags = clnt_flgs;
805
806 DEBUG(5,("init_q_auth_2: %d\n", __LINE__));
807}
808
809/*******************************************************************
810 Reads or writes a structure.
811********************************************************************/
812
813BOOL net_io_q_auth_2(const char *desc, NET_Q_AUTH_2 *q_a, prs_struct *ps, int depth)
814{
815 if (q_a == NULL)
816 return False;
817
818 prs_debug(ps, depth, desc, "net_io_q_auth_2");
819 depth++;
820
821 if(!prs_align(ps))
822 return False;
823
824 if(!smb_io_log_info ("", &q_a->clnt_id, ps, depth)) /* client identification info */
825 return False;
826 if(!smb_io_chal("", &q_a->clnt_chal, ps, depth))
827 return False;
828 if(!net_io_neg_flags("", &q_a->clnt_flgs, ps, depth))
829 return False;
830
831 return True;
832}
833
834/*******************************************************************
835 Reads or writes a structure.
836********************************************************************/
837
838BOOL net_io_r_auth_2(const char *desc, NET_R_AUTH_2 *r_a, prs_struct *ps, int depth)
839{
840 if (r_a == NULL)
841 return False;
842
843 prs_debug(ps, depth, desc, "net_io_r_auth_2");
844 depth++;
845
846 if(!prs_align(ps))
847 return False;
848
849 if(!smb_io_chal("", &r_a->srv_chal, ps, depth)) /* server challenge */
850 return False;
851 if(!net_io_neg_flags("", &r_a->srv_flgs, ps, depth))
852 return False;
853
854 if(!prs_ntstatus("status", ps, depth, &r_a->status))
855 return False;
856
857 return True;
858}
859
860/*******************************************************************
861 Inits a NET_Q_AUTH_3 struct.
862********************************************************************/
863
864void init_q_auth_3(NET_Q_AUTH_3 *q_a,
865 const char *logon_srv, const char *acct_name, uint16 sec_chan, const char *comp_name,
866 const DOM_CHAL *clnt_chal, uint32 clnt_flgs)
867{
868 DEBUG(5,("init_q_auth_3: %d\n", __LINE__));
869
870 init_log_info(&q_a->clnt_id, logon_srv, acct_name, sec_chan, comp_name);
871 memcpy(q_a->clnt_chal.data, clnt_chal->data, sizeof(clnt_chal->data));
872 q_a->clnt_flgs.neg_flags = clnt_flgs;
873
874 DEBUG(5,("init_q_auth_3: %d\n", __LINE__));
875}
876
877/*******************************************************************
878 Reads or writes a structure.
879********************************************************************/
880
881BOOL net_io_q_auth_3(const char *desc, NET_Q_AUTH_3 *q_a, prs_struct *ps, int depth)
882{
883 if (q_a == NULL)
884 return False;
885
886 prs_debug(ps, depth, desc, "net_io_q_auth_3");
887 depth++;
888
889 if(!prs_align(ps))
890 return False;
891
892 if(!smb_io_log_info ("", &q_a->clnt_id, ps, depth)) /* client identification info */
893 return False;
894 if(!smb_io_chal("", &q_a->clnt_chal, ps, depth))
895 return False;
896 if(!net_io_neg_flags("", &q_a->clnt_flgs, ps, depth))
897 return False;
898
899 return True;
900}
901
902/*******************************************************************
903 Reads or writes a structure.
904********************************************************************/
905
906BOOL net_io_r_auth_3(const char *desc, NET_R_AUTH_3 *r_a, prs_struct *ps, int depth)
907{
908 if (r_a == NULL)
909 return False;
910
911 prs_debug(ps, depth, desc, "net_io_r_auth_3");
912 depth++;
913
914 if(!prs_align(ps))
915 return False;
916
917 if(!smb_io_chal("srv_chal", &r_a->srv_chal, ps, depth)) /* server challenge */
918 return False;
919 if(!net_io_neg_flags("srv_flgs", &r_a->srv_flgs, ps, depth))
920 return False;
921 if (!prs_uint32("unknown", ps, depth, &r_a->unknown))
922 return False;
923
924 if(!prs_ntstatus("status", ps, depth, &r_a->status))
925 return False;
926
927 return True;
928}
929
930
931/*******************************************************************
932 Inits a NET_Q_SRV_PWSET.
933********************************************************************/
934
935void init_q_srv_pwset(NET_Q_SRV_PWSET *q_s,
936 const char *logon_srv, const char *sess_key, const char *acct_name,
937 uint16 sec_chan, const char *comp_name,
938 DOM_CRED *cred, const uchar hashed_mach_pwd[16])
939{
940 unsigned char nt_cypher[16];
941
942 DEBUG(5,("init_q_srv_pwset\n"));
943
944 /* Process the new password. */
945 cred_hash3( nt_cypher, hashed_mach_pwd, (const unsigned char *)sess_key, 1);
946
947 init_clnt_info(&q_s->clnt_id, logon_srv, acct_name, sec_chan, comp_name, cred);
948
949 memcpy(q_s->pwd, nt_cypher, sizeof(q_s->pwd));
950}
951
952/*******************************************************************
953 Reads or writes a structure.
954********************************************************************/
955
956BOOL net_io_q_srv_pwset(const char *desc, NET_Q_SRV_PWSET *q_s, prs_struct *ps, int depth)
957{
958 if (q_s == NULL)
959 return False;
960
961 prs_debug(ps, depth, desc, "net_io_q_srv_pwset");
962 depth++;
963
964 if(!prs_align(ps))
965 return False;
966
967 if(!smb_io_clnt_info("", &q_s->clnt_id, ps, depth)) /* client identification/authentication info */
968 return False;
969 if(!prs_uint8s (False, "pwd", ps, depth, q_s->pwd, 16)) /* new password - undocumented */
970 return False;
971
972 return True;
973}
974
975/*******************************************************************
976 Reads or writes a structure.
977********************************************************************/
978
979BOOL net_io_r_srv_pwset(const char *desc, NET_R_SRV_PWSET *r_s, prs_struct *ps, int depth)
980{
981 if (r_s == NULL)
982 return False;
983
984 prs_debug(ps, depth, desc, "net_io_r_srv_pwset");
985 depth++;
986
987 if(!prs_align(ps))
988 return False;
989
990 if(!smb_io_cred("", &r_s->srv_cred, ps, depth)) /* server challenge */
991 return False;
992
993 if(!prs_ntstatus("status", ps, depth, &r_s->status))
994 return False;
995
996 return True;
997}
998
999/*******************************************************************
1000 Inits a NET_Q_SRV_PWSET2.
1001********************************************************************/
1002
1003void init_q_srv_pwset2(NET_Q_SRV_PWSET2 *q_s,
1004 const char *logon_srv,
1005 const char *sess_key,
1006 const char *acct_name,
1007 uint16 sec_chan,
1008 const char *comp_name,
1009 DOM_CRED *cred,
1010 const char *clear_text_mach_pwd)
1011{
1012 uint8_t password_buf[516];
1013 NET_CRYPT_PWD new_password;
1014
1015 DEBUG(5,("init_q_srv_pwset2\n"));
1016
1017 /* Process the new password. */
1018
1019 encode_pw_buffer(password_buf, clear_text_mach_pwd, STR_UNICODE);
1020
1021 SamOEMhash(password_buf, (const unsigned char *)sess_key, 516);
1022 memcpy(new_password.data, password_buf, 512);
1023 new_password.length = IVAL(password_buf, 512);
1024
1025 init_clnt_info(&q_s->clnt_id, logon_srv, acct_name, sec_chan, comp_name, cred);
1026
1027 memcpy(&q_s->pwd, &new_password, sizeof(q_s->pwd));
1028}
1029
1030/*******************************************************************
1031 Reads or writes a structure.
1032********************************************************************/
1033
1034BOOL net_io_q_srv_pwset2(const char *desc, NET_Q_SRV_PWSET2 *q_s, prs_struct *ps, int depth)
1035{
1036 if (q_s == NULL)
1037 return False;
1038
1039 prs_debug(ps, depth, desc, "net_io_q_srv_pwset2");
1040 depth++;
1041
1042 if(!prs_align(ps))
1043 return False;
1044
1045 if(!smb_io_clnt_info("", &q_s->clnt_id, ps, depth)) /* client identification/authentication info */
1046 return False;
1047 if(!prs_uint8s(False, "pwd.data", ps, depth, q_s->pwd.data, 512)) /* new password - undocumented */
1048 return False;
1049 if(!prs_uint32("pwd.length", ps, depth, &q_s->pwd.length)) /* new password - undocumented */
1050 return False;
1051
1052 return True;
1053}
1054
1055/*******************************************************************
1056 Reads or writes a structure.
1057********************************************************************/
1058
1059BOOL net_io_r_srv_pwset2(const char *desc, NET_R_SRV_PWSET2 *r_s, prs_struct *ps, int depth)
1060{
1061 if (r_s == NULL)
1062 return False;
1063
1064 prs_debug(ps, depth, desc, "net_io_r_srv_pwset2");
1065 depth++;
1066
1067 if(!prs_align(ps))
1068 return False;
1069
1070 if(!smb_io_cred("", &r_s->srv_cred, ps, depth)) /* server challenge */
1071 return False;
1072
1073 if(!prs_ntstatus("status", ps, depth, &r_s->status))
1074 return False;
1075
1076 return True;
1077}
1078
1079/*************************************************************************
1080 Init DOM_SID2 array from a string containing multiple sids
1081 *************************************************************************/
1082
1083static int init_dom_sid2s(TALLOC_CTX *ctx, const char *sids_str, DOM_SID2 **ppsids)
1084{
1085 const char *ptr;
1086 pstring s2;
1087 int count = 0;
1088
1089 DEBUG(4,("init_dom_sid2s: %s\n", sids_str ? sids_str:""));
1090
1091 *ppsids = NULL;
1092
1093 if(sids_str) {
1094 int number;
1095 DOM_SID2 *sids;
1096
1097 /* Count the number of valid SIDs. */
1098 for (count = 0, ptr = sids_str; next_token(&ptr, s2, NULL, sizeof(s2)); ) {
1099 DOM_SID tmpsid;
1100 if (string_to_sid(&tmpsid, s2))
1101 count++;
1102 }
1103
1104 /* Now allocate space for them. */
1105 if (count) {
1106 *ppsids = TALLOC_ZERO_ARRAY(ctx, DOM_SID2, count);
1107 if (*ppsids == NULL)
1108 return 0;
1109 } else {
1110 *ppsids = NULL;
1111 }
1112
1113 sids = *ppsids;
1114
1115 for (number = 0, ptr = sids_str; next_token(&ptr, s2, NULL, sizeof(s2)); ) {
1116 DOM_SID tmpsid;
1117 if (string_to_sid(&tmpsid, s2)) {
1118 /* count only valid sids */
1119 init_dom_sid2(&sids[number], &tmpsid);
1120 number++;
1121 }
1122 }
1123 }
1124
1125 return count;
1126}
1127
1128/*******************************************************************
1129 Inits a NET_ID_INFO_1 structure.
1130********************************************************************/
1131
1132void init_id_info1(NET_ID_INFO_1 *id, const char *domain_name,
1133 uint32 param_ctrl, uint32 log_id_low, uint32 log_id_high,
1134 const char *user_name, const char *wksta_name,
1135 const char *sess_key,
1136 unsigned char lm_cypher[16], unsigned char nt_cypher[16])
1137{
1138 unsigned char lm_owf[16];
1139 unsigned char nt_owf[16];
1140
1141 DEBUG(5,("init_id_info1: %d\n", __LINE__));
1142
1143 id->ptr_id_info1 = 1;
1144
1145 id->param_ctrl = param_ctrl;
1146 init_logon_id(&id->logon_id, log_id_low, log_id_high);
1147
1148
1149 if (lm_cypher && nt_cypher) {
1150 unsigned char key[16];
1151#ifdef DEBUG_PASSWORD
1152 DEBUG(100,("lm cypher:"));
1153 dump_data(100, (char *)lm_cypher, 16);
1154
1155 DEBUG(100,("nt cypher:"));
1156 dump_data(100, (char *)nt_cypher, 16);
1157#endif
1158
1159 memset(key, 0, 16);
1160 memcpy(key, sess_key, 8);
1161
1162 memcpy(lm_owf, lm_cypher, 16);
1163 SamOEMhash(lm_owf, key, 16);
1164 memcpy(nt_owf, nt_cypher, 16);
1165 SamOEMhash(nt_owf, key, 16);
1166
1167#ifdef DEBUG_PASSWORD
1168 DEBUG(100,("encrypt of lm owf password:"));
1169 dump_data(100, (char *)lm_owf, 16);
1170
1171 DEBUG(100,("encrypt of nt owf password:"));
1172 dump_data(100, (char *)nt_owf, 16);
1173#endif
1174 /* set up pointers to cypher blocks */
1175 lm_cypher = lm_owf;
1176 nt_cypher = nt_owf;
1177 }
1178
1179 init_owf_info(&id->lm_owf, lm_cypher);
1180 init_owf_info(&id->nt_owf, nt_cypher);
1181
1182 init_unistr2(&id->uni_domain_name, domain_name, UNI_FLAGS_NONE);
1183 init_uni_hdr(&id->hdr_domain_name, &id->uni_domain_name);
1184 init_unistr2(&id->uni_user_name, user_name, UNI_FLAGS_NONE);
1185 init_uni_hdr(&id->hdr_user_name, &id->uni_user_name);
1186 init_unistr2(&id->uni_wksta_name, wksta_name, UNI_FLAGS_NONE);
1187 init_uni_hdr(&id->hdr_wksta_name, &id->uni_wksta_name);
1188}
1189
1190/*******************************************************************
1191 Reads or writes an NET_ID_INFO_1 structure.
1192********************************************************************/
1193
1194static BOOL net_io_id_info1(const char *desc, NET_ID_INFO_1 *id, prs_struct *ps, int depth)
1195{
1196 if (id == NULL)
1197 return False;
1198
1199 prs_debug(ps, depth, desc, "net_io_id_info1");
1200 depth++;
1201
1202 if(!prs_align(ps))
1203 return False;
1204
1205 if(!prs_uint32("ptr_id_info1", ps, depth, &id->ptr_id_info1))
1206 return False;
1207
1208 if (id->ptr_id_info1 != 0) {
1209 if(!smb_io_unihdr("unihdr", &id->hdr_domain_name, ps, depth))
1210 return False;
1211
1212 if(!prs_uint32("param_ctrl", ps, depth, &id->param_ctrl))
1213 return False;
1214 if(!smb_io_logon_id("", &id->logon_id, ps, depth))
1215 return False;
1216
1217 if(!smb_io_unihdr("unihdr", &id->hdr_user_name, ps, depth))
1218 return False;
1219 if(!smb_io_unihdr("unihdr", &id->hdr_wksta_name, ps, depth))
1220 return False;
1221
1222 if(!smb_io_owf_info("", &id->lm_owf, ps, depth))
1223 return False;
1224 if(!smb_io_owf_info("", &id->nt_owf, ps, depth))
1225 return False;
1226
1227 if(!smb_io_unistr2("unistr2", &id->uni_domain_name,
1228 id->hdr_domain_name.buffer, ps, depth))
1229 return False;
1230 if(!smb_io_unistr2("unistr2", &id->uni_user_name,
1231 id->hdr_user_name.buffer, ps, depth))
1232 return False;
1233 if(!smb_io_unistr2("unistr2", &id->uni_wksta_name,
1234 id->hdr_wksta_name.buffer, ps, depth))
1235 return False;
1236 }
1237
1238 return True;
1239}
1240
1241/*******************************************************************
1242Inits a NET_ID_INFO_2 structure.
1243
1244This is a network logon packet. The log_id parameters
1245are what an NT server would generate for LUID once the
1246user is logged on. I don't think we care about them.
1247
1248Note that this has no access to the NT and LM hashed passwords,
1249so it forwards the challenge, and the NT and LM responses (24
1250bytes each) over the secure channel to the Domain controller
1251for it to say yea or nay. This is the preferred method of
1252checking for a logon as it doesn't export the password
1253hashes to anyone who has compromised the secure channel. JRA.
1254********************************************************************/
1255
1256void init_id_info2(NET_ID_INFO_2 * id, const char *domain_name,
1257 uint32 param_ctrl,
1258 uint32 log_id_low, uint32 log_id_high,
1259 const char *user_name, const char *wksta_name,
1260 const uchar lm_challenge[8],
1261 const uchar * lm_chal_resp, size_t lm_chal_resp_len,
1262 const uchar * nt_chal_resp, size_t nt_chal_resp_len)
1263{
1264
1265 DEBUG(5,("init_id_info2: %d\n", __LINE__));
1266
1267 id->ptr_id_info2 = 1;
1268
1269 id->param_ctrl = param_ctrl;
1270 init_logon_id(&id->logon_id, log_id_low, log_id_high);
1271
1272 memcpy(id->lm_chal, lm_challenge, sizeof(id->lm_chal));
1273 init_str_hdr(&id->hdr_nt_chal_resp, nt_chal_resp_len, nt_chal_resp_len, (nt_chal_resp != NULL) ? 1 : 0);
1274 init_str_hdr(&id->hdr_lm_chal_resp, lm_chal_resp_len, lm_chal_resp_len, (lm_chal_resp != NULL) ? 1 : 0);
1275
1276 init_unistr2(&id->uni_domain_name, domain_name, UNI_FLAGS_NONE);
1277 init_uni_hdr(&id->hdr_domain_name, &id->uni_domain_name);
1278 init_unistr2(&id->uni_user_name, user_name, UNI_FLAGS_NONE);
1279 init_uni_hdr(&id->hdr_user_name, &id->uni_user_name);
1280 init_unistr2(&id->uni_wksta_name, wksta_name, UNI_FLAGS_NONE);
1281 init_uni_hdr(&id->hdr_wksta_name, &id->uni_wksta_name);
1282
1283 init_string2(&id->nt_chal_resp, (const char *)nt_chal_resp, nt_chal_resp_len, nt_chal_resp_len);
1284 init_string2(&id->lm_chal_resp, (const char *)lm_chal_resp, lm_chal_resp_len, lm_chal_resp_len);
1285
1286}
1287
1288/*******************************************************************
1289 Reads or writes an NET_ID_INFO_2 structure.
1290********************************************************************/
1291
1292static BOOL net_io_id_info2(const char *desc, NET_ID_INFO_2 *id, prs_struct *ps, int depth)
1293{
1294 if (id == NULL)
1295 return False;
1296
1297 prs_debug(ps, depth, desc, "net_io_id_info2");
1298 depth++;
1299
1300 if(!prs_align(ps))
1301 return False;
1302
1303 if(!prs_uint32("ptr_id_info2", ps, depth, &id->ptr_id_info2))
1304 return False;
1305
1306 if (id->ptr_id_info2 != 0) {
1307 if(!smb_io_unihdr("unihdr", &id->hdr_domain_name, ps, depth))
1308 return False;
1309
1310 if(!prs_uint32("param_ctrl", ps, depth, &id->param_ctrl))
1311 return False;
1312 if(!smb_io_logon_id("", &id->logon_id, ps, depth))
1313 return False;
1314
1315 if(!smb_io_unihdr("unihdr", &id->hdr_user_name, ps, depth))
1316 return False;
1317 if(!smb_io_unihdr("unihdr", &id->hdr_wksta_name, ps, depth))
1318 return False;
1319
1320 if(!prs_uint8s (False, "lm_chal", ps, depth, id->lm_chal, 8)) /* lm 8 byte challenge */
1321 return False;
1322
1323 if(!smb_io_strhdr("hdr_nt_chal_resp", &id->hdr_nt_chal_resp, ps, depth))
1324 return False;
1325 if(!smb_io_strhdr("hdr_lm_chal_resp", &id->hdr_lm_chal_resp, ps, depth))
1326 return False;
1327
1328 if(!smb_io_unistr2("uni_domain_name", &id->uni_domain_name,
1329 id->hdr_domain_name.buffer, ps, depth))
1330 return False;
1331 if(!smb_io_unistr2("uni_user_name ", &id->uni_user_name,
1332 id->hdr_user_name.buffer, ps, depth))
1333 return False;
1334 if(!smb_io_unistr2("uni_wksta_name ", &id->uni_wksta_name,
1335 id->hdr_wksta_name.buffer, ps, depth))
1336 return False;
1337 if(!smb_io_string2("nt_chal_resp", &id->nt_chal_resp,
1338 id->hdr_nt_chal_resp.buffer, ps, depth))
1339 return False;
1340 if(!smb_io_string2("lm_chal_resp", &id->lm_chal_resp,
1341 id->hdr_lm_chal_resp.buffer, ps, depth))
1342 return False;
1343 }
1344
1345 return True;
1346}
1347
1348
1349/*******************************************************************
1350 Inits a DOM_SAM_INFO structure.
1351********************************************************************/
1352
1353void init_sam_info(DOM_SAM_INFO *sam,
1354 const char *logon_srv, const char *comp_name,
1355 DOM_CRED *clnt_cred,
1356 DOM_CRED *rtn_cred, uint16 logon_level,
1357 NET_ID_INFO_CTR *ctr)
1358{
1359 DEBUG(5,("init_sam_info: %d\n", __LINE__));
1360
1361 init_clnt_info2(&sam->client, logon_srv, comp_name, clnt_cred);
1362
1363 if (rtn_cred != NULL) {
1364 sam->ptr_rtn_cred = 1;
1365 memcpy(&sam->rtn_cred, rtn_cred, sizeof(sam->rtn_cred));
1366 } else {
1367 sam->ptr_rtn_cred = 0;
1368 }
1369
1370 sam->logon_level = logon_level;
1371 sam->ctr = ctr;
1372}
1373
1374/*******************************************************************
1375 Reads or writes a DOM_SAM_INFO structure.
1376********************************************************************/
1377
1378static BOOL net_io_id_info_ctr(const char *desc, NET_ID_INFO_CTR **pp_ctr, prs_struct *ps, int depth)
1379{
1380 NET_ID_INFO_CTR *ctr = *pp_ctr;
1381
1382 prs_debug(ps, depth, desc, "smb_io_sam_info_ctr");
1383 depth++;
1384
1385 if (UNMARSHALLING(ps)) {
1386 ctr = *pp_ctr = PRS_ALLOC_MEM(ps, NET_ID_INFO_CTR, 1);
1387 if (ctr == NULL)
1388 return False;
1389 }
1390
1391 if (ctr == NULL)
1392 return False;
1393
1394 /* don't 4-byte align here! */
1395
1396 if(!prs_uint16("switch_value ", ps, depth, &ctr->switch_value))
1397 return False;
1398
1399 switch (ctr->switch_value) {
1400 case 1:
1401 if(!net_io_id_info1("", &ctr->auth.id1, ps, depth))
1402 return False;
1403 break;
1404 case 2:
1405 if(!net_io_id_info2("", &ctr->auth.id2, ps, depth))
1406 return False;
1407 break;
1408 default:
1409 /* PANIC! */
1410 DEBUG(4,("smb_io_sam_info_ctr: unknown switch_value!\n"));
1411 break;
1412 }
1413
1414 return True;
1415}
1416
1417/*******************************************************************
1418 Reads or writes a DOM_SAM_INFO structure.
1419 ********************************************************************/
1420
1421static BOOL smb_io_sam_info(const char *desc, DOM_SAM_INFO *sam, prs_struct *ps, int depth)
1422{
1423 if (sam == NULL)
1424 return False;
1425
1426 prs_debug(ps, depth, desc, "smb_io_sam_info");
1427 depth++;
1428
1429 if(!prs_align(ps))
1430 return False;
1431
1432 if(!smb_io_clnt_info2("", &sam->client, ps, depth))
1433 return False;
1434
1435 if(!prs_uint32("ptr_rtn_cred ", ps, depth, &sam->ptr_rtn_cred))
1436 return False;
1437 if (sam->ptr_rtn_cred) {
1438 if(!smb_io_cred("", &sam->rtn_cred, ps, depth))
1439 return False;
1440 }
1441
1442 if(!prs_uint16("logon_level ", ps, depth, &sam->logon_level))
1443 return False;
1444
1445 if (sam->logon_level != 0) {
1446 if(!net_io_id_info_ctr("logon_info", &sam->ctr, ps, depth))
1447 return False;
1448 }
1449
1450 return True;
1451}
1452
1453/*******************************************************************
1454 Reads or writes a DOM_SAM_INFO_EX structure.
1455 ********************************************************************/
1456
1457static BOOL smb_io_sam_info_ex(const char *desc, DOM_SAM_INFO_EX *sam, prs_struct *ps, int depth)
1458{
1459 if (sam == NULL)
1460 return False;
1461
1462 prs_debug(ps, depth, desc, "smb_io_sam_info_ex");
1463 depth++;
1464
1465 if(!prs_align(ps))
1466 return False;
1467
1468 if(!smb_io_clnt_srv("", &sam->client, ps, depth))
1469 return False;
1470
1471 if(!prs_uint16("logon_level ", ps, depth, &sam->logon_level))
1472 return False;
1473
1474 if (sam->logon_level != 0) {
1475 if(!net_io_id_info_ctr("logon_info", &sam->ctr, ps, depth))
1476 return False;
1477 }
1478
1479 return True;
1480}
1481
1482/*************************************************************************
1483 Inits a NET_USER_INFO_3 structure.
1484
1485 This is a network logon reply packet, and contains much information about
1486 the user. This information is passed as a (very long) paramater list
1487 to avoid having to link in the PASSDB code to every program that deals
1488 with this file.
1489 *************************************************************************/
1490
1491void init_net_user_info3(TALLOC_CTX *ctx, NET_USER_INFO_3 *usr,
1492 uint32 user_rid,
1493 uint32 group_rid,
1494
1495 const char* user_name,
1496 const char* full_name,
1497 const char* home_dir,
1498 const char* dir_drive,
1499 const char* logon_script,
1500 const char* profile_path,
1501
1502 time_t unix_logon_time,
1503 time_t unix_logoff_time,
1504 time_t unix_kickoff_time,
1505 time_t unix_pass_last_set_time,
1506 time_t unix_pass_can_change_time,
1507 time_t unix_pass_must_change_time,
1508
1509 uint16 logon_count, uint16 bad_pw_count,
1510 uint32 num_groups, const DOM_GID *gids,
1511 uint32 user_flgs, uint32 acct_flags,
1512 uchar user_session_key[16],
1513 uchar lm_session_key[8],
1514 const char *logon_srv, const char *logon_dom,
1515 const DOM_SID *dom_sid)
1516{
1517 /* only cope with one "other" sid, right now. */
1518 /* need to count the number of space-delimited sids */
1519 unsigned int i;
1520 int num_other_sids = 0;
1521
1522 NTTIME logon_time, logoff_time, kickoff_time,
1523 pass_last_set_time, pass_can_change_time,
1524 pass_must_change_time;
1525
1526 ZERO_STRUCTP(usr);
1527
1528 usr->ptr_user_info = 1; /* yes, we're bothering to put USER_INFO data here */
1529
1530 /* Create NTTIME structs */
1531 unix_to_nt_time (&logon_time, unix_logon_time);
1532 unix_to_nt_time (&logoff_time, unix_logoff_time);
1533 unix_to_nt_time (&kickoff_time, unix_kickoff_time);
1534 unix_to_nt_time (&pass_last_set_time, unix_pass_last_set_time);
1535 unix_to_nt_time (&pass_can_change_time, unix_pass_can_change_time);
1536 unix_to_nt_time (&pass_must_change_time, unix_pass_must_change_time);
1537
1538 usr->logon_time = logon_time;
1539 usr->logoff_time = logoff_time;
1540 usr->kickoff_time = kickoff_time;
1541 usr->pass_last_set_time = pass_last_set_time;
1542 usr->pass_can_change_time = pass_can_change_time;
1543 usr->pass_must_change_time = pass_must_change_time;
1544
1545 usr->logon_count = logon_count;
1546 usr->bad_pw_count = bad_pw_count;
1547
1548 usr->user_rid = user_rid;
1549 usr->group_rid = group_rid;
1550 usr->num_groups = num_groups;
1551
1552 usr->buffer_groups = 1; /* indicates fill in groups, below, even if there are none */
1553 usr->user_flgs = user_flgs;
1554 usr->acct_flags = acct_flags;
1555
1556 if (user_session_key != NULL)
1557 memcpy(usr->user_sess_key, user_session_key, sizeof(usr->user_sess_key));
1558 else
1559 memset((char *)usr->user_sess_key, '\0', sizeof(usr->user_sess_key));
1560
1561 usr->buffer_dom_id = dom_sid ? 1 : 0; /* yes, we're bothering to put a domain SID in */
1562
1563 memset((char *)usr->lm_sess_key, '\0', sizeof(usr->lm_sess_key));
1564
1565 for (i=0; i<7; i++) {
1566 memset(&usr->unknown[i], '\0', sizeof(usr->unknown));
1567 }
1568
1569 if (lm_session_key != NULL) {
1570 memcpy(usr->lm_sess_key, lm_session_key, sizeof(usr->lm_sess_key));
1571 }
1572
1573 num_other_sids = init_dom_sid2s(ctx, NULL, &usr->other_sids);
1574
1575 usr->num_other_sids = num_other_sids;
1576 usr->buffer_other_sids = (num_other_sids != 0) ? 1 : 0;
1577
1578 init_unistr2(&usr->uni_user_name, user_name, UNI_FLAGS_NONE);
1579 init_uni_hdr(&usr->hdr_user_name, &usr->uni_user_name);
1580 init_unistr2(&usr->uni_full_name, full_name, UNI_FLAGS_NONE);
1581 init_uni_hdr(&usr->hdr_full_name, &usr->uni_full_name);
1582 init_unistr2(&usr->uni_logon_script, logon_script, UNI_FLAGS_NONE);
1583 init_uni_hdr(&usr->hdr_logon_script, &usr->uni_logon_script);
1584 init_unistr2(&usr->uni_profile_path, profile_path, UNI_FLAGS_NONE);
1585 init_uni_hdr(&usr->hdr_profile_path, &usr->uni_profile_path);
1586 init_unistr2(&usr->uni_home_dir, home_dir, UNI_FLAGS_NONE);
1587 init_uni_hdr(&usr->hdr_home_dir, &usr->uni_home_dir);
1588 init_unistr2(&usr->uni_dir_drive, dir_drive, UNI_FLAGS_NONE);
1589 init_uni_hdr(&usr->hdr_dir_drive, &usr->uni_dir_drive);
1590
1591 usr->num_groups2 = num_groups;
1592
1593 if (num_groups) {
1594 usr->gids = TALLOC_ZERO_ARRAY(ctx,DOM_GID,num_groups);
1595 if (usr->gids == NULL)
1596 return;
1597 } else {
1598 usr->gids = NULL;
1599 }
1600
1601 for (i = 0; i < num_groups; i++)
1602 usr->gids[i] = gids[i];
1603
1604 init_unistr2(&usr->uni_logon_srv, logon_srv, UNI_FLAGS_NONE);
1605 init_uni_hdr(&usr->hdr_logon_srv, &usr->uni_logon_srv);
1606 init_unistr2(&usr->uni_logon_dom, logon_dom, UNI_FLAGS_NONE);
1607 init_uni_hdr(&usr->hdr_logon_dom, &usr->uni_logon_dom);
1608
1609 init_dom_sid2(&usr->dom_sid, dom_sid);
1610 /* "other" sids are set up above */
1611}
1612
1613static void dump_acct_flags(uint32 acct_flags) {
1614
1615 int lvl = 10;
1616 DEBUG(lvl,("dump_acct_flags\n"));
1617 if (acct_flags & ACB_NORMAL) {
1618 DEBUGADD(lvl,("\taccount has ACB_NORMAL\n"));
1619 }
1620 if (acct_flags & ACB_PWNOEXP) {
1621 DEBUGADD(lvl,("\taccount has ACB_PWNOEXP\n"));
1622 }
1623 if (acct_flags & ACB_ENC_TXT_PWD_ALLOWED) {
1624 DEBUGADD(lvl,("\taccount has ACB_ENC_TXT_PWD_ALLOWED\n"));
1625 }
1626 if (acct_flags & ACB_NOT_DELEGATED) {
1627 DEBUGADD(lvl,("\taccount has ACB_NOT_DELEGATED\n"));
1628 }
1629 if (acct_flags & ACB_USE_DES_KEY_ONLY) {
1630 DEBUGADD(lvl,("\taccount has ACB_USE_DES_KEY_ONLY set, sig verify wont work\n"));
1631 }
1632 if (acct_flags & ACB_NO_AUTH_DATA_REQD) {
1633 DEBUGADD(lvl,("\taccount has ACB_NO_AUTH_DATA_REQD set\n"));
1634 }
1635 if (acct_flags & ACB_PWEXPIRED) {
1636 DEBUGADD(lvl,("\taccount has ACB_PWEXPIRED set\n"));
1637 }
1638}
1639
1640static void dump_user_flgs(uint32 user_flags) {
1641
1642 int lvl = 10;
1643 DEBUG(lvl,("dump_user_flgs\n"));
1644 if (user_flags & LOGON_EXTRA_SIDS) {
1645 DEBUGADD(lvl,("\taccount has LOGON_EXTRA_SIDS\n"));
1646 }
1647 if (user_flags & LOGON_RESOURCE_GROUPS) {
1648 DEBUGADD(lvl,("\taccount has LOGON_RESOURCE_GROUPS\n"));
1649 }
1650 if (user_flags & LOGON_NTLMV2_ENABLED) {
1651 DEBUGADD(lvl,("\taccount has LOGON_NTLMV2_ENABLED\n"));
1652 }
1653 if (user_flags & LOGON_CACHED_ACCOUNT) {
1654 DEBUGADD(lvl,("\taccount has LOGON_CACHED_ACCOUNT\n"));
1655 }
1656 if (user_flags & LOGON_PROFILE_PATH_RETURNED) {
1657 DEBUGADD(lvl,("\taccount has LOGON_PROFILE_PATH_RETURNED\n"));
1658 }
1659 if (user_flags & LOGON_SERVER_TRUST_ACCOUNT) {
1660 DEBUGADD(lvl,("\taccount has LOGON_SERVER_TRUST_ACCOUNT\n"));
1661 }
1662
1663
1664}
1665
1666/*******************************************************************
1667 This code has been modified to cope with a NET_USER_INFO_2 - which is
1668 exactly the same as a NET_USER_INFO_3, minus the other sids parameters.
1669 We use validation level to determine if we're marshalling a info 2 or
1670 INFO_3 - be we always return an INFO_3. Based on code donated by Marc
1671 Jacobsen at HP. JRA.
1672********************************************************************/
1673
1674BOOL net_io_user_info3(const char *desc, NET_USER_INFO_3 *usr, prs_struct *ps,
1675 int depth, uint16 validation_level, BOOL kerb_validation_level)
1676{
1677 unsigned int i;
1678
1679 if (usr == NULL)
1680 return False;
1681
1682 prs_debug(ps, depth, desc, "net_io_user_info3");
1683 depth++;
1684
1685 if (UNMARSHALLING(ps))
1686 ZERO_STRUCTP(usr);
1687
1688 if(!prs_align(ps))
1689 return False;
1690
1691 if(!prs_uint32("ptr_user_info ", ps, depth, &usr->ptr_user_info))
1692 return False;
1693
1694 if (usr->ptr_user_info == 0)
1695 return True;
1696
1697 if(!smb_io_time("logon time", &usr->logon_time, ps, depth)) /* logon time */
1698 return False;
1699 if(!smb_io_time("logoff time", &usr->logoff_time, ps, depth)) /* logoff time */
1700 return False;
1701 if(!smb_io_time("kickoff time", &usr->kickoff_time, ps, depth)) /* kickoff time */
1702 return False;
1703 if(!smb_io_time("last set time", &usr->pass_last_set_time, ps, depth)) /* password last set time */
1704 return False;
1705 if(!smb_io_time("can change time", &usr->pass_can_change_time , ps, depth)) /* password can change time */
1706 return False;
1707 if(!smb_io_time("must change time", &usr->pass_must_change_time, ps, depth)) /* password must change time */
1708 return False;
1709
1710 if(!smb_io_unihdr("hdr_user_name", &usr->hdr_user_name, ps, depth)) /* username unicode string header */
1711 return False;
1712 if(!smb_io_unihdr("hdr_full_name", &usr->hdr_full_name, ps, depth)) /* user's full name unicode string header */
1713 return False;
1714 if(!smb_io_unihdr("hdr_logon_script", &usr->hdr_logon_script, ps, depth)) /* logon script unicode string header */
1715 return False;
1716 if(!smb_io_unihdr("hdr_profile_path", &usr->hdr_profile_path, ps, depth)) /* profile path unicode string header */
1717 return False;
1718 if(!smb_io_unihdr("hdr_home_dir", &usr->hdr_home_dir, ps, depth)) /* home directory unicode string header */
1719 return False;
1720 if(!smb_io_unihdr("hdr_dir_drive", &usr->hdr_dir_drive, ps, depth)) /* home directory drive unicode string header */
1721 return False;
1722
1723 if(!prs_uint16("logon_count ", ps, depth, &usr->logon_count)) /* logon count */
1724 return False;
1725 if(!prs_uint16("bad_pw_count ", ps, depth, &usr->bad_pw_count)) /* bad password count */
1726 return False;
1727
1728 if(!prs_uint32("user_rid ", ps, depth, &usr->user_rid)) /* User RID */
1729 return False;
1730 if(!prs_uint32("group_rid ", ps, depth, &usr->group_rid)) /* Group RID */
1731 return False;
1732 if(!prs_uint32("num_groups ", ps, depth, &usr->num_groups)) /* num groups */
1733 return False;
1734 if(!prs_uint32("buffer_groups ", ps, depth, &usr->buffer_groups)) /* undocumented buffer pointer to groups. */
1735 return False;
1736 if(!prs_uint32("user_flgs ", ps, depth, &usr->user_flgs)) /* user flags */
1737 return False;
1738 dump_user_flgs(usr->user_flgs);
1739 if(!prs_uint8s(False, "user_sess_key", ps, depth, usr->user_sess_key, 16)) /* user session key */
1740 return False;
1741
1742 if(!smb_io_unihdr("hdr_logon_srv", &usr->hdr_logon_srv, ps, depth)) /* logon server unicode string header */
1743 return False;
1744 if(!smb_io_unihdr("hdr_logon_dom", &usr->hdr_logon_dom, ps, depth)) /* logon domain unicode string header */
1745 return False;
1746
1747 if(!prs_uint32("buffer_dom_id ", ps, depth, &usr->buffer_dom_id)) /* undocumented logon domain id pointer */
1748 return False;
1749
1750 if(!prs_uint8s(False, "lm_sess_key", ps, depth, usr->lm_sess_key, 8)) /* lm session key */
1751 return False;
1752
1753 if(!prs_uint32("acct_flags ", ps, depth, &usr->acct_flags)) /* Account flags */
1754 return False;
1755 dump_acct_flags(usr->acct_flags);
1756 for (i = 0; i < 7; i++)
1757 {
1758 if (!prs_uint32("unkown", ps, depth, &usr->unknown[i])) /* unknown */
1759 return False;
1760 }
1761
1762 if (validation_level == 3) {
1763 if(!prs_uint32("num_other_sids", ps, depth, &usr->num_other_sids)) /* 0 - num_sids */
1764 return False;
1765 if(!prs_uint32("buffer_other_sids", ps, depth, &usr->buffer_other_sids)) /* NULL - undocumented pointer to SIDs. */
1766 return False;
1767 } else {
1768 if (UNMARSHALLING(ps)) {
1769 usr->num_other_sids = 0;
1770 usr->buffer_other_sids = 0;
1771 }
1772 }
1773
1774 /* get kerb validation info (not really part of user_info_3) - Guenther */
1775
1776 if (kerb_validation_level) {
1777
1778 if(!prs_uint32("ptr_res_group_dom_sid", ps, depth, &usr->ptr_res_group_dom_sid))
1779 return False;
1780 if(!prs_uint32("res_group_count", ps, depth, &usr->res_group_count))
1781 return False;
1782 if(!prs_uint32("ptr_res_groups", ps, depth, &usr->ptr_res_groups))
1783 return False;
1784 }
1785
1786 if(!smb_io_unistr2("uni_user_name", &usr->uni_user_name, usr->hdr_user_name.buffer, ps, depth)) /* username unicode string */
1787 return False;
1788 if(!smb_io_unistr2("uni_full_name", &usr->uni_full_name, usr->hdr_full_name.buffer, ps, depth)) /* user's full name unicode string */
1789 return False;
1790 if(!smb_io_unistr2("uni_logon_script", &usr->uni_logon_script, usr->hdr_logon_script.buffer, ps, depth)) /* logon script unicode string */
1791 return False;
1792 if(!smb_io_unistr2("uni_profile_path", &usr->uni_profile_path, usr->hdr_profile_path.buffer, ps, depth)) /* profile path unicode string */
1793 return False;
1794 if(!smb_io_unistr2("uni_home_dir", &usr->uni_home_dir, usr->hdr_home_dir.buffer, ps, depth)) /* home directory unicode string */
1795 return False;
1796 if(!smb_io_unistr2("uni_dir_drive", &usr->uni_dir_drive, usr->hdr_dir_drive.buffer, ps, depth)) /* home directory drive unicode string */
1797 return False;
1798
1799 if(!prs_align(ps))
1800 return False;
1801
1802 if(!prs_uint32("num_groups2 ", ps, depth, &usr->num_groups2)) /* num groups2 */
1803 return False;
1804
1805 if (usr->num_groups != usr->num_groups2) {
1806 DEBUG(3,("net_io_user_info3: num_groups mismatch! (%d != %d)\n",
1807 usr->num_groups, usr->num_groups2));
1808 return False;
1809 }
1810
1811 if (UNMARSHALLING(ps)) {
1812 if (usr->num_groups) {
1813 usr->gids = PRS_ALLOC_MEM(ps, DOM_GID, usr->num_groups);
1814 if (usr->gids == NULL)
1815 return False;
1816 } else {
1817 usr->gids = NULL;
1818 }
1819 }
1820
1821 for (i = 0; i < usr->num_groups; i++) {
1822 if(!smb_io_gid("", &usr->gids[i], ps, depth)) /* group info */
1823 return False;
1824 }
1825
1826 if(!smb_io_unistr2("uni_logon_srv", &usr->uni_logon_srv, usr->hdr_logon_srv.buffer, ps, depth)) /* logon server unicode string */
1827 return False;
1828 if(!smb_io_unistr2("uni_logon_dom", &usr->uni_logon_dom, usr->hdr_logon_dom.buffer, ps, depth)) /* logon domain unicode string */
1829 return False;
1830
1831 if(!smb_io_dom_sid2("", &usr->dom_sid, ps, depth)) /* domain SID */
1832 return False;
1833
1834 if (validation_level == 3 && usr->buffer_other_sids) {
1835
1836 uint32 num_other_sids = usr->num_other_sids;
1837
1838 if (!(usr->user_flgs & LOGON_EXTRA_SIDS)) {
1839 DEBUG(10,("net_io_user_info3: user_flgs attribute does not have LOGON_EXTRA_SIDS\n"));
1840 /* return False; */
1841 }
1842
1843 if (!prs_uint32("num_other_sids", ps, depth,
1844 &num_other_sids))
1845 return False;
1846
1847 if (num_other_sids != usr->num_other_sids)
1848 return False;
1849
1850 if (UNMARSHALLING(ps)) {
1851 if (usr->num_other_sids) {
1852 usr->other_sids = PRS_ALLOC_MEM(ps, DOM_SID2, usr->num_other_sids);
1853 usr->other_sids_attrib =
1854 PRS_ALLOC_MEM(ps, uint32, usr->num_other_sids);
1855 } else {
1856 usr->other_sids = NULL;
1857 usr->other_sids_attrib = NULL;
1858 }
1859
1860 if ((num_other_sids != 0) &&
1861 ((usr->other_sids == NULL) ||
1862 (usr->other_sids_attrib == NULL)))
1863 return False;
1864 }
1865
1866 /* First the pointers to the SIDS and attributes */
1867
1868 depth++;
1869
1870 for (i=0; i<usr->num_other_sids; i++) {
1871 uint32 ptr = 1;
1872
1873 if (!prs_uint32("sid_ptr", ps, depth, &ptr))
1874 return False;
1875
1876 if (UNMARSHALLING(ps) && (ptr == 0))
1877 return False;
1878
1879 if (!prs_uint32("attribute", ps, depth,
1880 &usr->other_sids_attrib[i]))
1881 return False;
1882 }
1883
1884 for (i = 0; i < usr->num_other_sids; i++) {
1885 if(!smb_io_dom_sid2("", &usr->other_sids[i], ps, depth)) /* other domain SIDs */
1886 return False;
1887 }
1888
1889 depth--;
1890 }
1891
1892 return True;
1893}
1894
1895/*******************************************************************
1896 Reads or writes a structure.
1897********************************************************************/
1898
1899BOOL net_io_q_sam_logon(const char *desc, NET_Q_SAM_LOGON *q_l, prs_struct *ps, int depth)
1900{
1901 if (q_l == NULL)
1902 return False;
1903
1904 prs_debug(ps, depth, desc, "net_io_q_sam_logon");
1905 depth++;
1906
1907 if(!prs_align(ps))
1908 return False;
1909
1910 if(!smb_io_sam_info("", &q_l->sam_id, ps, depth))
1911 return False;
1912
1913 if(!prs_align_uint16(ps))
1914 return False;
1915
1916 if(!prs_uint16("validation_level", ps, depth, &q_l->validation_level))
1917 return False;
1918
1919 return True;
1920}
1921
1922/*******************************************************************
1923 Reads or writes a structure.
1924********************************************************************/
1925
1926BOOL net_io_r_sam_logon(const char *desc, NET_R_SAM_LOGON *r_l, prs_struct *ps, int depth)
1927{
1928 if (r_l == NULL)
1929 return False;
1930
1931 prs_debug(ps, depth, desc, "net_io_r_sam_logon");
1932 depth++;
1933
1934 if(!prs_uint32("buffer_creds", ps, depth, &r_l->buffer_creds)) /* undocumented buffer pointer */
1935 return False;
1936 if (&r_l->buffer_creds) {
1937 if(!smb_io_cred("", &r_l->srv_creds, ps, depth)) /* server credentials. server time stamp appears to be ignored. */
1938 return False;
1939 }
1940
1941 if(!prs_uint16("switch_value", ps, depth, &r_l->switch_value))
1942 return False;
1943 if(!prs_align(ps))
1944 return False;
1945
1946#if 1 /* W2k always needs this - even for bad passwd. JRA */
1947 if(!net_io_user_info3("", r_l->user, ps, depth, r_l->switch_value, False))
1948 return False;
1949#else
1950 if (r_l->switch_value != 0) {
1951 if(!net_io_user_info3("", r_l->user, ps, depth, r_l->switch_value, False))
1952 return False;
1953 }
1954#endif
1955
1956 if(!prs_uint32("auth_resp ", ps, depth, &r_l->auth_resp)) /* 1 - Authoritative response; 0 - Non-Auth? */
1957 return False;
1958
1959 if(!prs_ntstatus("status ", ps, depth, &r_l->status))
1960 return False;
1961
1962 if(!prs_align(ps))
1963 return False;
1964
1965 return True;
1966}
1967
1968/*******************************************************************
1969 Reads or writes a structure.
1970********************************************************************/
1971
1972BOOL net_io_q_sam_logon_ex(const char *desc, NET_Q_SAM_LOGON_EX *q_l, prs_struct *ps, int depth)
1973{
1974 if (q_l == NULL)
1975 return False;
1976
1977 prs_debug(ps, depth, desc, "net_io_q_sam_logon_ex");
1978 depth++;
1979
1980 if(!prs_align(ps))
1981 return False;
1982
1983 if(!smb_io_sam_info_ex("", &q_l->sam_id, ps, depth))
1984 return False;
1985
1986 if(!prs_align_uint16(ps))
1987 return False;
1988
1989 if(!prs_uint16("validation_level", ps, depth, &q_l->validation_level))
1990 return False;
1991
1992 if(!prs_uint32("flags ", ps, depth, &q_l->flags))
1993 return False;
1994
1995 return True;
1996}
1997
1998/*******************************************************************
1999 Reads or writes a structure.
2000********************************************************************/
2001
2002BOOL net_io_r_sam_logon_ex(const char *desc, NET_R_SAM_LOGON_EX *r_l, prs_struct *ps, int depth)
2003{
2004 if (r_l == NULL)
2005 return False;
2006
2007 prs_debug(ps, depth, desc, "net_io_r_sam_logon_ex");
2008 depth++;
2009
2010 if(!prs_uint16("switch_value", ps, depth, &r_l->switch_value))
2011 return False;
2012 if(!prs_align(ps))
2013 return False;
2014
2015#if 1 /* W2k always needs this - even for bad passwd. JRA */
2016 if(!net_io_user_info3("", r_l->user, ps, depth, r_l->switch_value, False))
2017 return False;
2018#else
2019 if (r_l->switch_value != 0) {
2020 if(!net_io_user_info3("", r_l->user, ps, depth, r_l->switch_value, False))
2021 return False;
2022 }
2023#endif
2024
2025 if(!prs_uint32("auth_resp ", ps, depth, &r_l->auth_resp)) /* 1 - Authoritative response; 0 - Non-Auth? */
2026 return False;
2027
2028 if(!prs_uint32("flags ", ps, depth, &r_l->flags))
2029 return False;
2030
2031 if(!prs_ntstatus("status ", ps, depth, &r_l->status))
2032 return False;
2033
2034 if(!prs_align(ps))
2035 return False;
2036
2037 return True;
2038}
2039
2040
2041/*******************************************************************
2042 Reads or writes a structure.
2043********************************************************************/
2044
2045BOOL net_io_q_sam_logoff(const char *desc, NET_Q_SAM_LOGOFF *q_l, prs_struct *ps, int depth)
2046{
2047 if (q_l == NULL)
2048 return False;
2049
2050 prs_debug(ps, depth, desc, "net_io_q_sam_logoff");
2051 depth++;
2052
2053 if(!prs_align(ps))
2054 return False;
2055
2056 if(!smb_io_sam_info("", &q_l->sam_id, ps, depth)) /* domain SID */
2057 return False;
2058
2059 return True;
2060}
2061
2062/*******************************************************************
2063 Reads or writes a structure.
2064********************************************************************/
2065
2066BOOL net_io_r_sam_logoff(const char *desc, NET_R_SAM_LOGOFF *r_l, prs_struct *ps, int depth)
2067{
2068 if (r_l == NULL)
2069 return False;
2070
2071 prs_debug(ps, depth, desc, "net_io_r_sam_logoff");
2072 depth++;
2073
2074 if(!prs_align(ps))
2075 return False;
2076
2077 if(!prs_uint32("buffer_creds", ps, depth, &r_l->buffer_creds)) /* undocumented buffer pointer */
2078 return False;
2079 if(!smb_io_cred("", &r_l->srv_creds, ps, depth)) /* server credentials. server time stamp appears to be ignored. */
2080 return False;
2081
2082 if(!prs_ntstatus("status ", ps, depth, &r_l->status))
2083 return False;
2084
2085 return True;
2086}
2087
2088/*******************************************************************
2089makes a NET_Q_SAM_SYNC structure.
2090********************************************************************/
2091BOOL init_net_q_sam_sync(NET_Q_SAM_SYNC * q_s, const char *srv_name,
2092 const char *cli_name, DOM_CRED *cli_creds,
2093 DOM_CRED *ret_creds, uint32 database_id,
2094 uint32 next_rid)
2095{
2096 DEBUG(5, ("init_q_sam_sync\n"));
2097
2098 init_unistr2(&q_s->uni_srv_name, srv_name, UNI_STR_TERMINATE);
2099 init_unistr2(&q_s->uni_cli_name, cli_name, UNI_STR_TERMINATE);
2100
2101 if (cli_creds)
2102 memcpy(&q_s->cli_creds, cli_creds, sizeof(q_s->cli_creds));
2103
2104 if (cli_creds)
2105 memcpy(&q_s->ret_creds, ret_creds, sizeof(q_s->ret_creds));
2106 else
2107 memset(&q_s->ret_creds, 0, sizeof(q_s->ret_creds));
2108
2109 q_s->database_id = database_id;
2110 q_s->restart_state = 0;
2111 q_s->sync_context = next_rid;
2112 q_s->max_size = 0xffff;
2113
2114 return True;
2115}
2116
2117/*******************************************************************
2118reads or writes a structure.
2119********************************************************************/
2120BOOL net_io_q_sam_sync(const char *desc, NET_Q_SAM_SYNC * q_s, prs_struct *ps,
2121 int depth)
2122{
2123 prs_debug(ps, depth, desc, "net_io_q_sam_sync");
2124 depth++;
2125
2126 if (!smb_io_unistr2("", &q_s->uni_srv_name, True, ps, depth))
2127 return False;
2128 if (!smb_io_unistr2("", &q_s->uni_cli_name, True, ps, depth))
2129 return False;
2130
2131 if (!smb_io_cred("", &q_s->cli_creds, ps, depth))
2132 return False;
2133 if (!smb_io_cred("", &q_s->ret_creds, ps, depth))
2134 return False;
2135
2136 if (!prs_uint32("database_id ", ps, depth, &q_s->database_id))
2137 return False;
2138 if (!prs_uint32("restart_state", ps, depth, &q_s->restart_state))
2139 return False;
2140 if (!prs_uint32("sync_context ", ps, depth, &q_s->sync_context))
2141 return False;
2142
2143 if (!prs_uint32("max_size", ps, depth, &q_s->max_size))
2144 return False;
2145
2146 return True;
2147}
2148
2149/*******************************************************************
2150reads or writes a structure.
2151********************************************************************/
2152static BOOL net_io_sam_delta_hdr(const char *desc, SAM_DELTA_HDR * delta,
2153 prs_struct *ps, int depth)
2154{
2155 prs_debug(ps, depth, desc, "net_io_sam_delta_hdr");
2156 depth++;
2157
2158 if (!prs_uint16("type", ps, depth, &delta->type))
2159 return False;
2160 if (!prs_uint16("type2", ps, depth, &delta->type2))
2161 return False;
2162 if (!prs_uint32("target_rid", ps, depth, &delta->target_rid))
2163 return False;
2164
2165 if (!prs_uint32("type3", ps, depth, &delta->type3))
2166 return False;
2167
2168 /* Not sure why we need this but it seems to be necessary to get
2169 sam deltas working. */
2170
2171 if (delta->type != 0x16) {
2172 if (!prs_uint32("ptr_delta", ps, depth, &delta->ptr_delta))
2173 return False;
2174 }
2175
2176 return True;
2177}
2178
2179/*******************************************************************
2180reads or writes a structure.
2181********************************************************************/
2182static BOOL net_io_sam_delta_mod_count(const char *desc, SAM_DELTA_MOD_COUNT *info,
2183 prs_struct *ps, int depth)
2184{
2185 prs_debug(ps, depth, desc, "net_io_sam_delta_stamp");
2186 depth++;
2187
2188 if (!prs_uint32("seqnum", ps, depth, &info->seqnum))
2189 return False;
2190 if (!prs_uint32("dom_mod_count_ptr", ps, depth,
2191 &info->dom_mod_count_ptr))
2192 return False;
2193
2194 if (info->dom_mod_count_ptr) {
2195 if (!prs_uint64("dom_mod_count", ps, depth,
2196 &info->dom_mod_count))
2197 return False;
2198 }
2199
2200 return True;
2201}
2202
2203/*******************************************************************
2204reads or writes a structure.
2205********************************************************************/
2206static BOOL net_io_sam_domain_info(const char *desc, SAM_DOMAIN_INFO * info,
2207 prs_struct *ps, int depth)
2208{
2209 prs_debug(ps, depth, desc, "net_io_sam_domain_info");
2210 depth++;
2211
2212 if (!smb_io_unihdr("hdr_dom_name", &info->hdr_dom_name, ps, depth))
2213 return False;
2214 if (!smb_io_unihdr("hdr_oem_info", &info->hdr_oem_info, ps, depth))
2215 return False;
2216
2217 if (!prs_uint64("force_logoff", ps, depth, &info->force_logoff))
2218 return False;
2219 if (!prs_uint16("min_pwd_len", ps, depth, &info->min_pwd_len))
2220 return False;
2221 if (!prs_uint16("pwd_history_len", ps, depth, &info->pwd_history_len))
2222 return False;
2223 if (!prs_uint64("max_pwd_age", ps, depth, &info->max_pwd_age))
2224 return False;
2225 if (!prs_uint64("min_pwd_age", ps, depth, &info->min_pwd_age))
2226 return False;
2227 if (!prs_uint64("dom_mod_count", ps, depth, &info->dom_mod_count))
2228 return False;
2229 if (!smb_io_time("creation_time", &info->creation_time, ps, depth))
2230 return False;
2231 if (!prs_uint32("security_information", ps, depth, &info->security_information))
2232 return False;
2233 if (!smb_io_bufhdr4("hdr_sec_desc", &info->hdr_sec_desc, ps, depth))
2234 return False;
2235 if (!smb_io_lockout_string_hdr("hdr_account_lockout_string", &info->hdr_account_lockout, ps, depth))
2236 return False;
2237 if (!smb_io_unihdr("hdr_unknown2", &info->hdr_unknown2, ps, depth))
2238 return False;
2239 if (!smb_io_unihdr("hdr_unknown3", &info->hdr_unknown3, ps, depth))
2240 return False;
2241 if (!smb_io_unihdr("hdr_unknown4", &info->hdr_unknown4, ps, depth))
2242 return False;
2243 if (!prs_uint32("logon_chgpass", ps, depth, &info->logon_chgpass))
2244 return False;
2245 if (!prs_uint32("unknown6", ps, depth, &info->unknown6))
2246 return False;
2247 if (!prs_uint32("unknown7", ps, depth, &info->unknown7))
2248 return False;
2249 if (!prs_uint32("unknown8", ps, depth, &info->unknown8))
2250 return False;
2251
2252 if (!smb_io_unistr2("uni_dom_name", &info->uni_dom_name,
2253 info->hdr_dom_name.buffer, ps, depth))
2254 return False;
2255 if (!smb_io_unistr2("buf_oem_info", &info->buf_oem_info,
2256 info->hdr_oem_info.buffer, ps, depth))
2257 return False;
2258
2259 if (!smb_io_rpc_blob("buf_sec_desc", &info->buf_sec_desc, ps, depth))
2260 return False;
2261
2262 if (!smb_io_account_lockout_str("account_lockout", &info->account_lockout,
2263 info->hdr_account_lockout.buffer, ps, depth))
2264 return False;
2265
2266 if (!smb_io_unistr2("buf_unknown2", &info->buf_unknown2,
2267 info->hdr_unknown2.buffer, ps, depth))
2268 return False;
2269 if (!smb_io_unistr2("buf_unknown3", &info->buf_unknown3,
2270 info->hdr_unknown3.buffer, ps, depth))
2271 return False;
2272 if (!smb_io_unistr2("buf_unknown4", &info->buf_unknown4,
2273 info->hdr_unknown4.buffer, ps, depth))
2274 return False;
2275
2276 return True;
2277}
2278
2279/*******************************************************************
2280reads or writes a structure.
2281********************************************************************/
2282static BOOL net_io_sam_group_info(const char *desc, SAM_GROUP_INFO * info,
2283 prs_struct *ps, int depth)
2284{
2285 prs_debug(ps, depth, desc, "net_io_sam_group_info");
2286 depth++;
2287
2288 if (!smb_io_unihdr("hdr_grp_name", &info->hdr_grp_name, ps, depth))
2289 return False;
2290 if (!smb_io_gid("gid", &info->gid, ps, depth))
2291 return False;
2292 if (!smb_io_unihdr("hdr_grp_desc", &info->hdr_grp_desc, ps, depth))
2293 return False;
2294 if (!smb_io_bufhdr2("hdr_sec_desc", &info->hdr_sec_desc, ps, depth))
2295 return False;
2296
2297 if (ps->data_offset + 48 > ps->buffer_size)
2298 return False;
2299 ps->data_offset += 48;
2300
2301 if (!smb_io_unistr2("uni_grp_name", &info->uni_grp_name,
2302 info->hdr_grp_name.buffer, ps, depth))
2303 return False;
2304 if (!smb_io_unistr2("uni_grp_desc", &info->uni_grp_desc,
2305 info->hdr_grp_desc.buffer, ps, depth))
2306 return False;
2307 if (!smb_io_rpc_blob("buf_sec_desc", &info->buf_sec_desc, ps, depth))
2308 return False;
2309
2310 return True;
2311}
2312
2313/*******************************************************************
2314reads or writes a structure.
2315********************************************************************/
2316static BOOL net_io_sam_passwd_info(const char *desc, SAM_PWD * pwd,
2317 prs_struct *ps, int depth)
2318{
2319 prs_debug(ps, depth, desc, "net_io_sam_passwd_info");
2320 depth++;
2321
2322 if (!prs_uint32("unk_0 ", ps, depth, &pwd->unk_0))
2323 return False;
2324
2325 if (!smb_io_unihdr("hdr_lm_pwd", &pwd->hdr_lm_pwd, ps, depth))
2326 return False;
2327 if (!prs_uint8s(False, "buf_lm_pwd", ps, depth, pwd->buf_lm_pwd, 16))
2328 return False;
2329
2330 if (!smb_io_unihdr("hdr_nt_pwd", &pwd->hdr_nt_pwd, ps, depth))
2331 return False;
2332 if (!prs_uint8s(False, "buf_nt_pwd", ps, depth, pwd->buf_nt_pwd, 16))
2333 return False;
2334
2335 if (!smb_io_unihdr("", &pwd->hdr_empty_lm, ps, depth))
2336 return False;
2337 if (!smb_io_unihdr("", &pwd->hdr_empty_nt, ps, depth))
2338 return False;
2339
2340 return True;
2341}
2342
2343/*******************************************************************
2344reads or writes a structure.
2345********************************************************************/
2346static BOOL net_io_sam_account_info(const char *desc, SAM_ACCOUNT_INFO *info,
2347 prs_struct *ps, int depth)
2348{
2349 BUFHDR2 hdr_priv_data;
2350 uint32 i;
2351
2352 prs_debug(ps, depth, desc, "net_io_sam_account_info");
2353 depth++;
2354
2355 if (!smb_io_unihdr("hdr_acct_name", &info->hdr_acct_name, ps, depth))
2356 return False;
2357 if (!smb_io_unihdr("hdr_full_name", &info->hdr_full_name, ps, depth))
2358 return False;
2359
2360 if (!prs_uint32("user_rid ", ps, depth, &info->user_rid))
2361 return False;
2362 if (!prs_uint32("group_rid", ps, depth, &info->group_rid))
2363 return False;
2364
2365 if (!smb_io_unihdr("hdr_home_dir ", &info->hdr_home_dir, ps, depth))
2366 return False;
2367 if (!smb_io_unihdr("hdr_dir_drive", &info->hdr_dir_drive, ps, depth))
2368 return False;
2369 if (!smb_io_unihdr("hdr_logon_script", &info->hdr_logon_script, ps,
2370 depth))
2371 return False;
2372
2373 if (!smb_io_unihdr("hdr_acct_desc", &info->hdr_acct_desc, ps, depth))
2374 return False;
2375 if (!smb_io_unihdr("hdr_workstations", &info->hdr_workstations, ps,
2376 depth))
2377 return False;
2378
2379 if (!smb_io_time("logon_time", &info->logon_time, ps, depth))
2380 return False;
2381 if (!smb_io_time("logoff_time", &info->logoff_time, ps, depth))
2382 return False;
2383
2384 if (!prs_uint32("logon_divs ", ps, depth, &info->logon_divs))
2385 return False;
2386 if (!prs_uint32("ptr_logon_hrs", ps, depth, &info->ptr_logon_hrs))
2387 return False;
2388
2389 if (!prs_uint16("bad_pwd_count", ps, depth, &info->bad_pwd_count))
2390 return False;
2391 if (!prs_uint16("logon_count", ps, depth, &info->logon_count))
2392 return False;
2393 if (!smb_io_time("pwd_last_set_time", &info->pwd_last_set_time, ps,
2394 depth))
2395 return False;
2396 if (!smb_io_time("acct_expiry_time", &info->acct_expiry_time, ps,
2397 depth))
2398 return False;
2399
2400 if (!prs_uint32("acb_info", ps, depth, &info->acb_info))
2401 return False;
2402 if (!prs_uint8s(False, "nt_pwd", ps, depth, info->nt_pwd, 16))
2403 return False;
2404 if (!prs_uint8s(False, "lm_pwd", ps, depth, info->lm_pwd, 16))
2405 return False;
2406 if (!prs_uint8("lm_pwd_present", ps, depth, &info->lm_pwd_present))
2407 return False;
2408 if (!prs_uint8("nt_pwd_present", ps, depth, &info->nt_pwd_present))
2409 return False;
2410 if (!prs_uint8("pwd_expired", ps, depth, &info->pwd_expired))
2411 return False;
2412
2413 if (!smb_io_unihdr("hdr_comment", &info->hdr_comment, ps, depth))
2414 return False;
2415 if (!smb_io_unihdr("hdr_parameters", &info->hdr_parameters, ps,
2416 depth))
2417 return False;
2418 if (!prs_uint16("country", ps, depth, &info->country))
2419 return False;
2420 if (!prs_uint16("codepage", ps, depth, &info->codepage))
2421 return False;
2422
2423 if (!smb_io_bufhdr2("hdr_priv_data", &hdr_priv_data, ps, depth))
2424 return False;
2425 if (!smb_io_bufhdr2("hdr_sec_desc", &info->hdr_sec_desc, ps, depth))
2426 return False;
2427 if (!smb_io_unihdr("hdr_profile", &info->hdr_profile, ps, depth))
2428 return False;
2429
2430 for (i = 0; i < 3; i++)
2431 {
2432 if (!smb_io_unihdr("hdr_reserved", &info->hdr_reserved[i],
2433 ps, depth))
2434 return False;
2435 }
2436
2437 for (i = 0; i < 4; i++)
2438 {
2439 if (!prs_uint32("dw_reserved", ps, depth,
2440 &info->dw_reserved[i]))
2441 return False;
2442 }
2443
2444 if (!smb_io_unistr2("uni_acct_name", &info->uni_acct_name,
2445 info->hdr_acct_name.buffer, ps, depth))
2446 return False;
2447 prs_align(ps);
2448 if (!smb_io_unistr2("uni_full_name", &info->uni_full_name,
2449 info->hdr_full_name.buffer, ps, depth))
2450 return False;
2451 prs_align(ps);
2452 if (!smb_io_unistr2("uni_home_dir ", &info->uni_home_dir,
2453 info->hdr_home_dir.buffer, ps, depth))
2454 return False;
2455 prs_align(ps);
2456 if (!smb_io_unistr2("uni_dir_drive", &info->uni_dir_drive,
2457 info->hdr_dir_drive.buffer, ps, depth))
2458 return False;
2459 prs_align(ps);
2460 if (!smb_io_unistr2("uni_logon_script", &info->uni_logon_script,
2461 info->hdr_logon_script.buffer, ps, depth))
2462 return False;
2463 prs_align(ps);
2464 if (!smb_io_unistr2("uni_acct_desc", &info->uni_acct_desc,
2465 info->hdr_acct_desc.buffer, ps, depth))
2466 return False;
2467 prs_align(ps);
2468 if (!smb_io_unistr2("uni_workstations", &info->uni_workstations,
2469 info->hdr_workstations.buffer, ps, depth))
2470 return False;
2471 prs_align(ps);
2472
2473 if (!prs_uint32("unknown1", ps, depth, &info->unknown1))
2474 return False;
2475 if (!prs_uint32("unknown2", ps, depth, &info->unknown2))
2476 return False;
2477
2478 if (!smb_io_rpc_blob("buf_logon_hrs", &info->buf_logon_hrs, ps, depth))
2479 return False;
2480 prs_align(ps);
2481 if (!smb_io_unistr2("uni_comment", &info->uni_comment,
2482 info->hdr_comment.buffer, ps, depth))
2483 return False;
2484 prs_align(ps);
2485 if (!smb_io_unistr2("uni_parameters", &info->uni_parameters,
2486 info->hdr_parameters.buffer, ps, depth))
2487 return False;
2488 prs_align(ps);
2489 if (hdr_priv_data.buffer != 0)
2490 {
2491 int old_offset = 0;
2492 uint32 len = 0x44;
2493 if (!prs_uint32("pwd_len", ps, depth, &len))
2494 return False;
2495 old_offset = ps->data_offset;
2496 if (len > 0)
2497 {
2498 if (ps->io)
2499 {
2500 /* reading */
2501 if (!prs_hash1(ps, ps->data_offset, len))
2502 return False;
2503 }
2504 if (!net_io_sam_passwd_info("pass", &info->pass,
2505 ps, depth))
2506 return False;
2507
2508 if (!ps->io)
2509 {
2510 /* writing */
2511 if (!prs_hash1(ps, old_offset, len))
2512 return False;
2513 }
2514 }
2515 if (old_offset + len > ps->buffer_size)
2516 return False;
2517 ps->data_offset = old_offset + len;
2518 }
2519 if (!smb_io_rpc_blob("buf_sec_desc", &info->buf_sec_desc, ps, depth))
2520 return False;
2521 prs_align(ps);
2522 if (!smb_io_unistr2("uni_profile", &info->uni_profile,
2523 info->hdr_profile.buffer, ps, depth))
2524 return False;
2525
2526 prs_align(ps);
2527
2528 return True;
2529}
2530
2531/*******************************************************************
2532reads or writes a structure.
2533********************************************************************/
2534static BOOL net_io_sam_group_mem_info(const char *desc, SAM_GROUP_MEM_INFO * info,
2535 prs_struct *ps, int depth)
2536{
2537 uint32 i;
2538 fstring tmp;
2539
2540 prs_debug(ps, depth, desc, "net_io_sam_group_mem_info");
2541 depth++;
2542
2543 prs_align(ps);
2544 if (!prs_uint32("ptr_rids ", ps, depth, &info->ptr_rids))
2545 return False;
2546 if (!prs_uint32("ptr_attribs", ps, depth, &info->ptr_attribs))
2547 return False;
2548 if (!prs_uint32("num_members", ps, depth, &info->num_members))
2549 return False;
2550
2551 if (ps->data_offset + 16 > ps->buffer_size)
2552 return False;
2553 ps->data_offset += 16;
2554
2555 if (info->ptr_rids != 0)
2556 {
2557 if (!prs_uint32("num_members2", ps, depth,
2558 &info->num_members2))
2559 return False;
2560
2561 if (info->num_members2 != info->num_members)
2562 {
2563 /* RPC fault */
2564 return False;
2565 }
2566
2567 if (UNMARSHALLING(ps)) {
2568 if (info->num_members2) {
2569 info->rids = TALLOC_ARRAY(ps->mem_ctx, uint32, info->num_members2);
2570
2571 if (info->rids == NULL) {
2572 DEBUG(0, ("out of memory allocating %d rids\n",
2573 info->num_members2));
2574 return False;
2575 }
2576 } else {
2577 info->rids = NULL;
2578 }
2579 }
2580
2581 for (i = 0; i < info->num_members2; i++)
2582 {
2583 slprintf(tmp, sizeof(tmp) - 1, "rids[%02d]", i);
2584 if (!prs_uint32(tmp, ps, depth, &info->rids[i]))
2585 return False;
2586 }
2587 }
2588
2589 if (info->ptr_attribs != 0)
2590 {
2591 if (!prs_uint32("num_members3", ps, depth,
2592 &info->num_members3))
2593 return False;
2594 if (info->num_members3 != info->num_members)
2595 {
2596 /* RPC fault */
2597 return False;
2598 }
2599
2600 if (UNMARSHALLING(ps)) {
2601 if (info->num_members3) {
2602 info->attribs = TALLOC_ARRAY(ps->mem_ctx, uint32, info->num_members3);
2603
2604 if (info->attribs == NULL) {
2605 DEBUG(0, ("out of memory allocating %d attribs\n",
2606 info->num_members3));
2607 return False;
2608 }
2609 } else {
2610 info->attribs = NULL;
2611 }
2612 }
2613
2614 for (i = 0; i < info->num_members3; i++)
2615 {
2616 slprintf(tmp, sizeof(tmp) - 1, "attribs[%02d]", i);
2617 if (!prs_uint32(tmp, ps, depth, &info->attribs[i]))
2618 return False;
2619 }
2620 }
2621
2622 return True;
2623}
2624
2625/*******************************************************************
2626reads or writes a structure.
2627********************************************************************/
2628static BOOL net_io_sam_alias_info(const char *desc, SAM_ALIAS_INFO * info,
2629 prs_struct *ps, int depth)
2630{
2631 prs_debug(ps, depth, desc, "net_io_sam_alias_info");
2632 depth++;
2633
2634 if (!smb_io_unihdr("hdr_als_name", &info->hdr_als_name, ps, depth))
2635 return False;
2636 if (!prs_uint32("als_rid", ps, depth, &info->als_rid))
2637 return False;
2638 if (!smb_io_bufhdr2("hdr_sec_desc", &info->hdr_sec_desc, ps, depth))
2639 return False;
2640 if (!smb_io_unihdr("hdr_als_desc", &info->hdr_als_desc, ps, depth))
2641 return False;
2642
2643 if (ps->data_offset + 40 > ps->buffer_size)
2644 return False;
2645 ps->data_offset += 40;
2646
2647 if (!smb_io_unistr2("uni_als_name", &info->uni_als_name,
2648 info->hdr_als_name.buffer, ps, depth))
2649 return False;
2650 if (!smb_io_rpc_blob("buf_sec_desc", &info->buf_sec_desc, ps, depth))
2651 return False;
2652
2653 if (!smb_io_unistr2("uni_als_desc", &info->uni_als_desc,
2654 info->hdr_als_desc.buffer, ps, depth))
2655 return False;
2656
2657 return True;
2658}
2659
2660/*******************************************************************
2661reads or writes a structure.
2662********************************************************************/
2663static BOOL net_io_sam_alias_mem_info(const char *desc, SAM_ALIAS_MEM_INFO * info,
2664 prs_struct *ps, int depth)
2665{
2666 uint32 i;
2667 fstring tmp;
2668
2669 prs_debug(ps, depth, desc, "net_io_sam_alias_mem_info");
2670 depth++;
2671
2672 prs_align(ps);
2673 if (!prs_uint32("num_members", ps, depth, &info->num_members))
2674 return False;
2675 if (!prs_uint32("ptr_members", ps, depth, &info->ptr_members))
2676 return False;
2677
2678 if (ps->data_offset + 16 > ps->buffer_size)
2679 return False;
2680 ps->data_offset += 16;
2681
2682 if (info->ptr_members != 0)
2683 {
2684 if (!prs_uint32("num_sids", ps, depth, &info->num_sids))
2685 return False;
2686 if (info->num_sids != info->num_members)
2687 {
2688 /* RPC fault */
2689 return False;
2690 }
2691
2692 if (UNMARSHALLING(ps)) {
2693 if (info->num_sids) {
2694 info->ptr_sids = TALLOC_ARRAY(ps->mem_ctx, uint32, info->num_sids);
2695
2696 if (info->ptr_sids == NULL) {
2697 DEBUG(0, ("out of memory allocating %d ptr_sids\n",
2698 info->num_sids));
2699 return False;
2700 }
2701 } else {
2702 info->ptr_sids = NULL;
2703 }
2704 }
2705
2706 for (i = 0; i < info->num_sids; i++)
2707 {
2708 slprintf(tmp, sizeof(tmp) - 1, "ptr_sids[%02d]", i);
2709 if (!prs_uint32(tmp, ps, depth, &info->ptr_sids[i]))
2710 return False;
2711 }
2712
2713 if (UNMARSHALLING(ps)) {
2714 if (info->num_sids) {
2715 info->sids = TALLOC_ARRAY(ps->mem_ctx, DOM_SID2, info->num_sids);
2716
2717 if (info->sids == NULL) {
2718 DEBUG(0, ("error allocating %d sids\n",
2719 info->num_sids));
2720 return False;
2721 }
2722 } else {
2723 info->sids = NULL;
2724 }
2725 }
2726
2727 for (i = 0; i < info->num_sids; i++)
2728 {
2729 if (info->ptr_sids[i] != 0)
2730 {
2731 slprintf(tmp, sizeof(tmp) - 1, "sids[%02d]",
2732 i);
2733 if (!smb_io_dom_sid2(tmp, &info->sids[i],
2734 ps, depth))
2735 return False;
2736 }
2737 }
2738 }
2739
2740 return True;
2741}
2742
2743/*******************************************************************
2744reads or writes a structure.
2745********************************************************************/
2746static BOOL net_io_sam_policy_info(const char *desc, SAM_DELTA_POLICY *info,
2747 prs_struct *ps, int depth)
2748{
2749 unsigned int i;
2750 prs_debug(ps, depth, desc, "net_io_sam_policy_info");
2751 depth++;
2752
2753 if(!prs_align(ps))
2754 return False;
2755
2756 if (!prs_uint32("max_log_size", ps, depth, &info->max_log_size))
2757 return False;
2758 if (!prs_uint64("audit_retention_period", ps, depth,
2759 &info->audit_retention_period))
2760 return False;
2761 if (!prs_uint32("auditing_mode", ps, depth, &info->auditing_mode))
2762 return False;
2763 if (!prs_uint32("num_events", ps, depth, &info->num_events))
2764 return False;
2765 if (!prs_uint32("ptr_events", ps, depth, &info->ptr_events))
2766 return False;
2767
2768 if (!smb_io_unihdr("hdr_dom_name", &info->hdr_dom_name, ps, depth))
2769 return False;
2770
2771 if (!prs_uint32("sid_ptr", ps, depth, &info->sid_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 (!smb_io_time("modify_time", &info->modify_time, ps, depth))
2788 return False;
2789 if (!smb_io_time("create_time", &info->create_time, ps, depth))
2790 return False;
2791 if (!smb_io_bufhdr2("hdr_sec_desc", &info->hdr_sec_desc, ps, depth))
2792 return False;
2793
2794 for (i=0; i<4; i++) {
2795 UNIHDR dummy;
2796 if (!smb_io_unihdr("dummy", &dummy, ps, depth))
2797 return False;
2798 }
2799
2800 for (i=0; i<4; i++) {
2801 uint32 reserved;
2802 if (!prs_uint32("reserved", ps, depth, &reserved))
2803 return False;
2804 }
2805
2806 if (!prs_uint32("num_event_audit_options", ps, depth,
2807 &info->num_event_audit_options))
2808 return False;
2809
2810 for (i=0; i<info->num_event_audit_options; i++)
2811 if (!prs_uint32("event_audit_option", ps, depth,
2812 &info->event_audit_option))
2813 return False;
2814
2815 if (!smb_io_unistr2("domain_name", &info->domain_name, True, ps, depth))
2816 return False;
2817
2818 if(!smb_io_dom_sid2("domain_sid", &info->domain_sid, ps, depth))
2819 return False;
2820
2821 if (!smb_io_rpc_blob("buf_sec_desc", &info->buf_sec_desc, ps, depth))
2822
2823 return False;
2824
2825 return True;
2826}
2827
2828#if 0
2829
2830/* This function is pretty broken - see bug #334 */
2831
2832/*******************************************************************
2833reads or writes a structure.
2834********************************************************************/
2835static BOOL net_io_sam_trustdoms_info(const char *desc, SAM_DELTA_TRUSTDOMS *info,
2836 prs_struct *ps, int depth)
2837{
2838 int i;
2839
2840 prs_debug(ps, depth, desc, "net_io_sam_trustdoms_info");
2841 depth++;
2842
2843 if(!prs_align(ps))
2844 return False;
2845
2846 if(!prs_uint32("buf_size", ps, depth, &info->buf_size))
2847 return False;
2848
2849 if(!sec_io_desc("sec_desc", &info->sec_desc, ps, depth))
2850 return False;
2851
2852 if(!smb_io_dom_sid2("sid", &info->sid, ps, depth))
2853 return False;
2854
2855 if(!smb_io_unihdr("hdr_domain", &info->hdr_domain, ps, depth))
2856 return False;
2857
2858 if(!prs_uint32("unknown0", ps, depth, &info->unknown0))
2859 return False;
2860 if(!prs_uint32("unknown1", ps, depth, &info->unknown1))
2861 return False;
2862 if(!prs_uint32("unknown2", ps, depth, &info->unknown2))
2863 return False;
2864
2865 if(!prs_uint32("buf_size2", ps, depth, &info->buf_size2))
2866 return False;
2867 if(!prs_uint32("ptr", ps, depth, &info->ptr))
2868 return False;
2869
2870 for (i=0; i<12; i++)
2871 if(!prs_uint32("unknown3", ps, depth, &info->unknown3))
2872 return False;
2873
2874 if (!smb_io_unistr2("domain", &info->domain, True, ps, depth))
2875 return False;
2876
2877 return True;
2878}
2879
2880#endif
2881
2882#if 0
2883
2884/* This function doesn't work - see bug #334 */
2885
2886/*******************************************************************
2887reads or writes a structure.
2888********************************************************************/
2889static BOOL net_io_sam_secret_info(const char *desc, SAM_DELTA_SECRET *info,
2890 prs_struct *ps, int depth)
2891{
2892 int i;
2893
2894 prs_debug(ps, depth, desc, "net_io_sam_secret_info");
2895 depth++;
2896
2897 if(!prs_align(ps))
2898 return False;
2899
2900 if(!prs_uint32("buf_size", ps, depth, &info->buf_size))
2901 return False;
2902
2903 if(!sec_io_desc("sec_desc", &info->sec_desc, ps, depth))
2904 return False;
2905
2906 if (!smb_io_unistr2("secret", &info->secret, True, ps, depth))
2907 return False;
2908
2909 if(!prs_align(ps))
2910 return False;
2911
2912 if(!prs_uint32("count1", ps, depth, &info->count1))
2913 return False;
2914 if(!prs_uint32("count2", ps, depth, &info->count2))
2915 return False;
2916 if(!prs_uint32("ptr", ps, depth, &info->ptr))
2917 return False;
2918
2919
2920 if(!smb_io_time("time1", &info->time1, ps, depth)) /* logon time */
2921 return False;
2922 if(!prs_uint32("count3", ps, depth, &info->count3))
2923 return False;
2924 if(!prs_uint32("count4", ps, depth, &info->count4))
2925 return False;
2926 if(!prs_uint32("ptr2", ps, depth, &info->ptr2))
2927 return False;
2928 if(!smb_io_time("time2", &info->time2, ps, depth)) /* logon time */
2929 return False;
2930 if(!prs_uint32("unknow1", ps, depth, &info->unknow1))
2931 return False;
2932
2933
2934 if(!prs_uint32("buf_size2", ps, depth, &info->buf_size2))
2935 return False;
2936 if(!prs_uint32("ptr3", ps, depth, &info->ptr3))
2937 return False;
2938 for(i=0; i<12; i++)
2939 if(!prs_uint32("unknow2", ps, depth, &info->unknow2))
2940 return False;
2941
2942 if(!prs_uint32("chal_len", ps, depth, &info->chal_len))
2943 return False;
2944 if(!prs_uint32("reserved1", ps, depth, &info->reserved1))
2945 return False;
2946 if(!prs_uint32("chal_len2", ps, depth, &info->chal_len2))
2947 return False;
2948
2949 if(!prs_uint8s (False, "chal", ps, depth, info->chal, info->chal_len2))
2950 return False;
2951
2952 if(!prs_uint32("key_len", ps, depth, &info->key_len))
2953 return False;
2954 if(!prs_uint32("reserved2", ps, depth, &info->reserved2))
2955 return False;
2956 if(!prs_uint32("key_len2", ps, depth, &info->key_len2))
2957 return False;
2958
2959 if(!prs_uint8s (False, "key", ps, depth, info->key, info->key_len2))
2960 return False;
2961
2962
2963 if(!prs_uint32("buf_size3", ps, depth, &info->buf_size3))
2964 return False;
2965
2966 if(!sec_io_desc("sec_desc2", &info->sec_desc2, ps, depth))
2967 return False;
2968
2969
2970 return True;
2971}
2972
2973#endif
2974
2975/*******************************************************************
2976reads or writes a structure.
2977********************************************************************/
2978static BOOL net_io_sam_privs_info(const char *desc, SAM_DELTA_PRIVS *info,
2979 prs_struct *ps, int depth)
2980{
2981 unsigned int i;
2982
2983 prs_debug(ps, depth, desc, "net_io_sam_privs_info");
2984 depth++;
2985
2986 if(!prs_align(ps))
2987 return False;
2988
2989 if(!smb_io_dom_sid2("sid", &info->sid, ps, depth))
2990 return False;
2991
2992 if(!prs_uint32("priv_count", ps, depth, &info->priv_count))
2993 return False;
2994 if(!prs_uint32("priv_control", ps, depth, &info->priv_control))
2995 return False;
2996
2997 if(!prs_uint32("priv_attr_ptr", ps, depth, &info->priv_attr_ptr))
2998 return False;
2999 if(!prs_uint32("priv_name_ptr", ps, depth, &info->priv_name_ptr))
3000 return False;
3001
3002 if (!prs_uint32("paged_pool_limit", ps, depth, &info->paged_pool_limit))
3003 return False;
3004 if (!prs_uint32("non_paged_pool_limit", ps, depth,
3005 &info->non_paged_pool_limit))
3006 return False;
3007 if (!prs_uint32("min_workset_size", ps, depth, &info->min_workset_size))
3008 return False;
3009 if (!prs_uint32("max_workset_size", ps, depth, &info->max_workset_size))
3010 return False;
3011 if (!prs_uint32("page_file_limit", ps, depth, &info->page_file_limit))
3012 return False;
3013 if (!prs_uint64("time_limit", ps, depth, &info->time_limit))
3014 return False;
3015 if (!prs_uint32("system_flags", ps, depth, &info->system_flags))
3016 return False;
3017 if (!smb_io_bufhdr2("hdr_sec_desc", &info->hdr_sec_desc, ps, depth))
3018 return False;
3019
3020 for (i=0; i<4; i++) {
3021 UNIHDR dummy;
3022 if (!smb_io_unihdr("dummy", &dummy, ps, depth))
3023 return False;
3024 }
3025
3026 for (i=0; i<4; i++) {
3027 uint32 reserved;
3028 if (!prs_uint32("reserved", ps, depth, &reserved))
3029 return False;
3030 }
3031
3032 if(!prs_uint32("attribute_count", ps, depth, &info->attribute_count))
3033 return False;
3034
3035 if (UNMARSHALLING(ps)) {
3036 if (info->attribute_count) {
3037 info->attributes = TALLOC_ARRAY(ps->mem_ctx, uint32, info->attribute_count);
3038 if (!info->attributes) {
3039 return False;
3040 }
3041 } else {
3042 info->attributes = NULL;
3043 }
3044 }
3045
3046 for (i=0; i<info->attribute_count; i++)
3047 if(!prs_uint32("attributes", ps, depth, &info->attributes[i]))
3048 return False;
3049
3050 if(!prs_uint32("privlist_count", ps, depth, &info->privlist_count))
3051 return False;
3052
3053 if (UNMARSHALLING(ps)) {
3054 if (info->privlist_count) {
3055 info->hdr_privslist = TALLOC_ARRAY(ps->mem_ctx, UNIHDR, info->privlist_count);
3056 info->uni_privslist = TALLOC_ARRAY(ps->mem_ctx, UNISTR2, info->privlist_count);
3057 if (!info->hdr_privslist) {
3058 return False;
3059 }
3060 if (!info->uni_privslist) {
3061 return False;
3062 }
3063 } else {
3064 info->hdr_privslist = NULL;
3065 info->uni_privslist = NULL;
3066 }
3067 }
3068
3069 for (i=0; i<info->privlist_count; i++)
3070 if(!smb_io_unihdr("hdr_privslist", &info->hdr_privslist[i], ps, depth))
3071 return False;
3072
3073 for (i=0; i<info->privlist_count; i++)
3074 if (!smb_io_unistr2("uni_privslist", &info->uni_privslist[i], True, ps, depth))
3075 return False;
3076
3077 if (!smb_io_rpc_blob("buf_sec_desc", &info->buf_sec_desc, ps, depth))
3078 return False;
3079
3080 return True;
3081}
3082
3083/*******************************************************************
3084reads or writes a structure.
3085********************************************************************/
3086static BOOL net_io_sam_delta_ctr(const char *desc,
3087 SAM_DELTA_CTR * delta, uint16 type,
3088 prs_struct *ps, int depth)
3089{
3090 prs_debug(ps, depth, desc, "net_io_sam_delta_ctr");
3091 depth++;
3092
3093 switch (type) {
3094 /* Seen in sam deltas */
3095 case SAM_DELTA_MODIFIED_COUNT:
3096 if (!net_io_sam_delta_mod_count("", &delta->mod_count, ps, depth))
3097 return False;
3098 break;
3099
3100 case SAM_DELTA_DOMAIN_INFO:
3101 if (!net_io_sam_domain_info("", &delta->domain_info, ps, depth))
3102 return False;
3103 break;
3104
3105 case SAM_DELTA_GROUP_INFO:
3106 if (!net_io_sam_group_info("", &delta->group_info, ps, depth))
3107 return False;
3108 break;
3109
3110 case SAM_DELTA_ACCOUNT_INFO:
3111 if (!net_io_sam_account_info("", &delta->account_info, ps, depth))
3112 return False;
3113 break;
3114
3115 case SAM_DELTA_GROUP_MEM:
3116 if (!net_io_sam_group_mem_info("", &delta->grp_mem_info, ps, depth))
3117 return False;
3118 break;
3119
3120 case SAM_DELTA_ALIAS_INFO:
3121 if (!net_io_sam_alias_info("", &delta->alias_info, ps, depth))
3122 return False;
3123 break;
3124
3125 case SAM_DELTA_POLICY_INFO:
3126 if (!net_io_sam_policy_info("", &delta->policy_info, ps, depth))
3127 return False;
3128 break;
3129
3130 case SAM_DELTA_ALIAS_MEM:
3131 if (!net_io_sam_alias_mem_info("", &delta->als_mem_info, ps, depth))
3132 return False;
3133 break;
3134
3135 case SAM_DELTA_PRIVS_INFO:
3136 if (!net_io_sam_privs_info("", &delta->privs_info, ps, depth))
3137 return False;
3138 break;
3139
3140 /* These guys are implemented but broken */
3141
3142 case SAM_DELTA_TRUST_DOMS:
3143 case SAM_DELTA_SECRET_INFO:
3144 break;
3145
3146 /* These guys are not implemented yet */
3147
3148 case SAM_DELTA_RENAME_GROUP:
3149 case SAM_DELTA_RENAME_USER:
3150 case SAM_DELTA_RENAME_ALIAS:
3151 case SAM_DELTA_DELETE_GROUP:
3152 case SAM_DELTA_DELETE_USER:
3153 default:
3154 DEBUG(0, ("Replication error: Unknown delta type 0x%x\n", type));
3155 break;
3156 }
3157
3158 return True;
3159}
3160
3161/*******************************************************************
3162reads or writes a structure.
3163********************************************************************/
3164BOOL net_io_r_sam_sync(const char *desc,
3165 NET_R_SAM_SYNC * r_s, prs_struct *ps, int depth)
3166{
3167 uint32 i;
3168
3169 prs_debug(ps, depth, desc, "net_io_r_sam_sync");
3170 depth++;
3171
3172 if (!smb_io_cred("srv_creds", &r_s->srv_creds, ps, depth))
3173 return False;
3174 if (!prs_uint32("sync_context", ps, depth, &r_s->sync_context))
3175 return False;
3176
3177 if (!prs_uint32("ptr_deltas", ps, depth, &r_s->ptr_deltas))
3178 return False;
3179 if (r_s->ptr_deltas != 0)
3180 {
3181 if (!prs_uint32("num_deltas ", ps, depth, &r_s->num_deltas))
3182 return False;
3183 if (!prs_uint32("ptr_deltas2", ps, depth, &r_s->ptr_deltas2))
3184 return False;
3185 if (r_s->ptr_deltas2 != 0)
3186 {
3187 if (!prs_uint32("num_deltas2", ps, depth,
3188 &r_s->num_deltas2))
3189 return False;
3190
3191 if (r_s->num_deltas2 != r_s->num_deltas)
3192 {
3193 /* RPC fault */
3194 return False;
3195 }
3196
3197 if (UNMARSHALLING(ps)) {
3198 if (r_s->num_deltas2) {
3199 r_s->hdr_deltas = TALLOC_ARRAY(ps->mem_ctx, SAM_DELTA_HDR, r_s->num_deltas2);
3200 if (r_s->hdr_deltas == NULL) {
3201 DEBUG(0, ("error tallocating memory "
3202 "for %d delta headers\n",
3203 r_s->num_deltas2));
3204 return False;
3205 }
3206 } else {
3207 r_s->hdr_deltas = NULL;
3208 }
3209 }
3210
3211 for (i = 0; i < r_s->num_deltas2; i++)
3212 {
3213 if (!net_io_sam_delta_hdr("",
3214 &r_s->hdr_deltas[i],
3215 ps, depth))
3216 return False;
3217 }
3218
3219 if (UNMARSHALLING(ps)) {
3220 if (r_s->num_deltas2) {
3221 r_s->deltas = TALLOC_ARRAY(ps->mem_ctx, SAM_DELTA_CTR, r_s->num_deltas2);
3222 if (r_s->deltas == NULL) {
3223 DEBUG(0, ("error tallocating memory "
3224 "for %d deltas\n",
3225 r_s->num_deltas2));
3226 return False;
3227 }
3228 } else {
3229 r_s->deltas = NULL;
3230 }
3231 }
3232
3233 for (i = 0; i < r_s->num_deltas2; i++)
3234 {
3235 if (!net_io_sam_delta_ctr(
3236 "", &r_s->deltas[i],
3237 r_s->hdr_deltas[i].type3,
3238 ps, depth)) {
3239 DEBUG(0, ("hmm, failed on i=%d\n", i));
3240 return False;
3241 }
3242 }
3243 }
3244 }
3245
3246 prs_align(ps);
3247 if (!prs_ntstatus("status", ps, depth, &(r_s->status)))
3248 return False;
3249
3250 return True;
3251}
3252
3253/*******************************************************************
3254makes a NET_Q_SAM_DELTAS structure.
3255********************************************************************/
3256BOOL init_net_q_sam_deltas(NET_Q_SAM_DELTAS *q_s, const char *srv_name,
3257 const char *cli_name, DOM_CRED *cli_creds,
3258 uint32 database_id, uint64 dom_mod_count)
3259{
3260 DEBUG(5, ("init_net_q_sam_deltas\n"));
3261
3262 init_unistr2(&q_s->uni_srv_name, srv_name, UNI_STR_TERMINATE);
3263 init_unistr2(&q_s->uni_cli_name, cli_name, UNI_STR_TERMINATE);
3264
3265 memcpy(&q_s->cli_creds, cli_creds, sizeof(q_s->cli_creds));
3266 memset(&q_s->ret_creds, 0, sizeof(q_s->ret_creds));
3267
3268 q_s->database_id = database_id;
3269 q_s->dom_mod_count = dom_mod_count;
3270 q_s->max_size = 0xffff;
3271
3272 return True;
3273}
3274
3275/*******************************************************************
3276reads or writes a structure.
3277********************************************************************/
3278BOOL net_io_q_sam_deltas(const char *desc, NET_Q_SAM_DELTAS *q_s, prs_struct *ps,
3279 int depth)
3280{
3281 prs_debug(ps, depth, desc, "net_io_q_sam_deltas");
3282 depth++;
3283
3284 if (!smb_io_unistr2("", &q_s->uni_srv_name, True, ps, depth))
3285 return False;
3286 if (!smb_io_unistr2("", &q_s->uni_cli_name, True, ps, depth))
3287 return False;
3288
3289 if (!smb_io_cred("", &q_s->cli_creds, ps, depth))
3290 return False;
3291 if (!smb_io_cred("", &q_s->ret_creds, ps, depth))
3292 return False;
3293
3294 if (!prs_uint32("database_id ", ps, depth, &q_s->database_id))
3295 return False;
3296 if (!prs_uint64("dom_mod_count", ps, depth, &q_s->dom_mod_count))
3297 return False;
3298 if (!prs_uint32("max_size", ps, depth, &q_s->max_size))
3299 return False;
3300
3301 return True;
3302}
3303
3304/*******************************************************************
3305reads or writes a structure.
3306********************************************************************/
3307BOOL net_io_r_sam_deltas(const char *desc,
3308 NET_R_SAM_DELTAS *r_s, prs_struct *ps, int depth)
3309{
3310 unsigned int i;
3311
3312 prs_debug(ps, depth, desc, "net_io_r_sam_deltas");
3313 depth++;
3314
3315 if (!smb_io_cred("srv_creds", &r_s->srv_creds, ps, depth))
3316 return False;
3317 if (!prs_uint64("dom_mod_count", ps, depth, &r_s->dom_mod_count))
3318 return False;
3319
3320 if (!prs_uint32("ptr_deltas", ps, depth, &r_s->ptr_deltas))
3321 return False;
3322 if (!prs_uint32("num_deltas", ps, depth, &r_s->num_deltas))
3323 return False;
3324 if (!prs_uint32("ptr_deltas2", ps, depth, &r_s->num_deltas2))
3325 return False;
3326
3327 if (r_s->num_deltas2 != 0)
3328 {
3329 if (!prs_uint32("num_deltas2 ", ps, depth, &r_s->num_deltas2))
3330 return False;
3331
3332 if (r_s->ptr_deltas != 0)
3333 {
3334 if (UNMARSHALLING(ps)) {
3335 if (r_s->num_deltas) {
3336 r_s->hdr_deltas = TALLOC_ARRAY(ps->mem_ctx, SAM_DELTA_HDR, r_s->num_deltas);
3337 if (r_s->hdr_deltas == NULL) {
3338 DEBUG(0, ("error tallocating memory "
3339 "for %d delta headers\n",
3340 r_s->num_deltas));
3341 return False;
3342 }
3343 } else {
3344 r_s->hdr_deltas = NULL;
3345 }
3346 }
3347
3348 for (i = 0; i < r_s->num_deltas; i++)
3349 {
3350 net_io_sam_delta_hdr("", &r_s->hdr_deltas[i],
3351 ps, depth);
3352 }
3353
3354 if (UNMARSHALLING(ps)) {
3355 if (r_s->num_deltas) {
3356 r_s->deltas = TALLOC_ARRAY(ps->mem_ctx, SAM_DELTA_CTR, r_s->num_deltas);
3357 if (r_s->deltas == NULL) {
3358 DEBUG(0, ("error tallocating memory "
3359 "for %d deltas\n",
3360 r_s->num_deltas));
3361 return False;
3362 }
3363 } else {
3364 r_s->deltas = NULL;
3365 }
3366 }
3367
3368 for (i = 0; i < r_s->num_deltas; i++)
3369 {
3370 if (!net_io_sam_delta_ctr(
3371 "",
3372 &r_s->deltas[i],
3373 r_s->hdr_deltas[i].type2,
3374 ps, depth))
3375
3376 return False;
3377 }
3378 }
3379 }
3380
3381 prs_align(ps);
3382 if (!prs_ntstatus("status", ps, depth, &r_s->status))
3383 return False;
3384
3385 return True;
3386}
3387
3388/*******************************************************************
3389 Inits a NET_Q_DSR_GETDCNAME structure.
3390********************************************************************/
3391
3392void init_net_q_dsr_getdcname(NET_Q_DSR_GETDCNAME *r_t, const char *server_unc,
3393 const char *domain_name,
3394 struct GUID *domain_guid,
3395 struct GUID *site_guid,
3396 uint32_t flags)
3397{
3398 DEBUG(5, ("init_net_q_dsr_getdcname\n"));
3399
3400 r_t->ptr_server_unc = (server_unc != NULL);
3401 init_unistr2(&r_t->uni_server_unc, server_unc, UNI_STR_TERMINATE);
3402
3403 r_t->ptr_domain_name = (domain_name != NULL);
3404 init_unistr2(&r_t->uni_domain_name, domain_name, UNI_STR_TERMINATE);
3405
3406 r_t->ptr_domain_guid = (domain_guid != NULL);
3407 r_t->domain_guid = domain_guid;
3408
3409 r_t->ptr_site_guid = (site_guid != NULL);
3410 r_t->site_guid = site_guid;
3411
3412 r_t->flags = flags;
3413}
3414
3415/*******************************************************************
3416 Inits a NET_Q_DSR_GETDCNAMEEX structure.
3417********************************************************************/
3418
3419void init_net_q_dsr_getdcnameex(NET_Q_DSR_GETDCNAMEEX *r_t, const char *server_unc,
3420 const char *domain_name,
3421 struct GUID *domain_guid,
3422 const char *site_name,
3423 uint32_t flags)
3424{
3425 DEBUG(5, ("init_net_q_dsr_getdcnameex\n"));
3426
3427 r_t->ptr_server_unc = (server_unc != NULL);
3428 init_unistr2(&r_t->uni_server_unc, server_unc, UNI_STR_TERMINATE);
3429
3430 r_t->ptr_domain_name = (domain_name != NULL);
3431 init_unistr2(&r_t->uni_domain_name, domain_name, UNI_STR_TERMINATE);
3432
3433 r_t->ptr_domain_guid = (domain_guid != NULL);
3434 r_t->domain_guid = domain_guid;
3435
3436 r_t->ptr_site_name = (site_name != NULL);
3437 init_unistr2(&r_t->uni_site_name, site_name, UNI_STR_TERMINATE);
3438
3439 r_t->flags = flags;
3440}
3441
3442/*******************************************************************
3443 Inits a NET_Q_DSR_GETDCNAMEEX2 structure.
3444********************************************************************/
3445
3446void init_net_q_dsr_getdcnameex2(NET_Q_DSR_GETDCNAMEEX2 *r_t, const char *server_unc,
3447 const char *domain_name,
3448 const char *client_account,
3449 uint32 mask,
3450 struct GUID *domain_guid,
3451 const char *site_name,
3452 uint32_t flags)
3453{
3454 DEBUG(5, ("init_net_q_dsr_getdcnameex2\n"));
3455
3456 r_t->ptr_server_unc = (server_unc != NULL);
3457 init_unistr2(&r_t->uni_server_unc, server_unc, UNI_STR_TERMINATE);
3458
3459 r_t->ptr_client_account = (client_account != NULL);
3460 init_unistr2(&r_t->uni_client_account, client_account, UNI_STR_TERMINATE);
3461
3462 r_t->mask = mask;
3463
3464 r_t->ptr_domain_name = (domain_name != NULL);
3465 init_unistr2(&r_t->uni_domain_name, domain_name, UNI_STR_TERMINATE);
3466
3467 r_t->ptr_domain_guid = (domain_guid != NULL);
3468 r_t->domain_guid = domain_guid;
3469
3470 r_t->ptr_site_name = (site_name != NULL);
3471 init_unistr2(&r_t->uni_site_name, site_name, UNI_STR_TERMINATE);
3472
3473 r_t->flags = flags;
3474}
3475
3476/*******************************************************************
3477 Reads or writes an NET_Q_DSR_GETDCNAME structure.
3478********************************************************************/
3479
3480BOOL net_io_q_dsr_getdcname(const char *desc, NET_Q_DSR_GETDCNAME *r_t,
3481 prs_struct *ps, int depth)
3482{
3483 if (r_t == NULL)
3484 return False;
3485
3486 prs_debug(ps, depth, desc, "net_io_q_dsr_getdcname");
3487 depth++;
3488
3489 if (!prs_uint32("ptr_server_unc", ps, depth, &r_t->ptr_server_unc))
3490 return False;
3491
3492 if (!smb_io_unistr2("server_unc", &r_t->uni_server_unc,
3493 r_t->ptr_server_unc, ps, depth))
3494 return False;
3495
3496 if (!prs_align(ps))
3497 return False;
3498
3499 if (!prs_uint32("ptr_domain_name", ps, depth, &r_t->ptr_domain_name))
3500 return False;
3501
3502 if (!smb_io_unistr2("domain_name", &r_t->uni_domain_name,
3503 r_t->ptr_domain_name, ps, depth))
3504 return False;
3505
3506 if (!prs_align(ps))
3507 return False;
3508
3509 if (!prs_uint32("ptr_domain_guid", ps, depth, &r_t->ptr_domain_guid))
3510 return False;
3511
3512 if (UNMARSHALLING(ps) && (r_t->ptr_domain_guid)) {
3513 r_t->domain_guid = PRS_ALLOC_MEM(ps, struct GUID, 1);
3514 if (r_t->domain_guid == NULL)
3515 return False;
3516 }
3517
3518 if ((r_t->ptr_domain_guid) &&
3519 (!smb_io_uuid("domain_guid", r_t->domain_guid, ps, depth)))
3520 return False;
3521
3522 if (!prs_align(ps))
3523 return False;
3524
3525 if (!prs_uint32("ptr_site_guid", ps, depth, &r_t->ptr_site_guid))
3526 return False;
3527
3528 if (UNMARSHALLING(ps) && (r_t->ptr_site_guid)) {
3529 r_t->site_guid = PRS_ALLOC_MEM(ps, struct GUID, 1);
3530 if (r_t->site_guid == NULL)
3531 return False;
3532 }
3533
3534 if ((r_t->ptr_site_guid) &&
3535 (!smb_io_uuid("site_guid", r_t->site_guid, ps, depth)))
3536 return False;
3537
3538 if (!prs_align(ps))
3539 return False;
3540
3541 if (!prs_uint32("flags", ps, depth, &r_t->flags))
3542 return False;
3543
3544 return True;
3545}
3546
3547/*******************************************************************
3548 Reads or writes an NET_Q_DSR_GETDCNAMEEX structure.
3549********************************************************************/
3550
3551BOOL net_io_q_dsr_getdcnameex(const char *desc, NET_Q_DSR_GETDCNAMEEX *r_t,
3552 prs_struct *ps, int depth)
3553{
3554 if (r_t == NULL)
3555 return False;
3556
3557 prs_debug(ps, depth, desc, "net_io_q_dsr_getdcnameex");
3558 depth++;
3559
3560 if (!prs_uint32("ptr_server_unc", ps, depth, &r_t->ptr_server_unc))
3561 return False;
3562
3563 if (!smb_io_unistr2("server_unc", &r_t->uni_server_unc,
3564 r_t->ptr_server_unc, ps, depth))
3565 return False;
3566
3567 if (!prs_align(ps))
3568 return False;
3569
3570 if (!prs_uint32("ptr_domain_name", ps, depth, &r_t->ptr_domain_name))
3571 return False;
3572
3573 if (!smb_io_unistr2("domain_name", &r_t->uni_domain_name,
3574 r_t->ptr_domain_name, ps, depth))
3575 return False;
3576
3577 if (!prs_align(ps))
3578 return False;
3579
3580 if (!prs_uint32("ptr_domain_guid", ps, depth, &r_t->ptr_domain_guid))
3581 return False;
3582
3583 if (UNMARSHALLING(ps) && (r_t->ptr_domain_guid)) {
3584 r_t->domain_guid = PRS_ALLOC_MEM(ps, struct GUID, 1);
3585 if (r_t->domain_guid == NULL)
3586 return False;
3587 }
3588
3589 if ((r_t->ptr_domain_guid) &&
3590 (!smb_io_uuid("domain_guid", r_t->domain_guid, ps, depth)))
3591 return False;
3592
3593 if (!prs_align(ps))
3594 return False;
3595
3596 if (!prs_uint32("ptr_site_name", ps, depth, &r_t->ptr_site_name))
3597 return False;
3598
3599 if (!smb_io_unistr2("site_name", &r_t->uni_site_name,
3600 r_t->ptr_site_name, ps, depth))
3601 return False;
3602
3603 if (!prs_align(ps))
3604 return False;
3605
3606 if (!prs_uint32("flags", ps, depth, &r_t->flags))
3607 return False;
3608
3609 return True;
3610}
3611
3612/*******************************************************************
3613 Reads or writes an NET_Q_DSR_GETDCNAMEEX2 structure.
3614********************************************************************/
3615
3616BOOL net_io_q_dsr_getdcnameex2(const char *desc, NET_Q_DSR_GETDCNAMEEX2 *r_t,
3617 prs_struct *ps, int depth)
3618{
3619 if (r_t == NULL)
3620 return False;
3621
3622 prs_debug(ps, depth, desc, "net_io_q_dsr_getdcnameex2");
3623 depth++;
3624
3625 if (!prs_uint32("ptr_server_unc", ps, depth, &r_t->ptr_server_unc))
3626 return False;
3627
3628 if (!smb_io_unistr2("server_unc", &r_t->uni_server_unc,
3629 r_t->ptr_server_unc, ps, depth))
3630 return False;
3631
3632 if (!prs_align(ps))
3633 return False;
3634
3635 if (!prs_uint32("ptr_client_account", ps, depth, &r_t->ptr_client_account))
3636 return False;
3637
3638 if (!smb_io_unistr2("client_account", &r_t->uni_client_account,
3639 r_t->ptr_client_account, ps, depth))
3640 return False;
3641
3642 if (!prs_align(ps))
3643 return False;
3644
3645 if (!prs_uint32("mask", ps, depth, &r_t->mask))
3646 return False;
3647
3648 if (!prs_align(ps))
3649 return False;
3650
3651 if (!prs_uint32("ptr_domain_name", ps, depth, &r_t->ptr_domain_name))
3652 return False;
3653
3654 if (!smb_io_unistr2("domain_name", &r_t->uni_domain_name,
3655 r_t->ptr_domain_name, ps, depth))
3656 return False;
3657
3658 if (!prs_align(ps))
3659 return False;
3660
3661 if (!prs_uint32("ptr_domain_guid", ps, depth, &r_t->ptr_domain_guid))
3662 return False;
3663
3664 if (UNMARSHALLING(ps) && (r_t->ptr_domain_guid)) {
3665 r_t->domain_guid = PRS_ALLOC_MEM(ps, struct GUID, 1);
3666 if (r_t->domain_guid == NULL)
3667 return False;
3668 }
3669
3670 if ((r_t->ptr_domain_guid) &&
3671 (!smb_io_uuid("domain_guid", r_t->domain_guid, ps, depth)))
3672 return False;
3673
3674 if (!prs_align(ps))
3675 return False;
3676
3677 if (!prs_uint32("ptr_site_name", ps, depth, &r_t->ptr_site_name))
3678 return False;
3679
3680 if (!smb_io_unistr2("site_name", &r_t->uni_site_name,
3681 r_t->ptr_site_name, ps, depth))
3682 return False;
3683
3684 if (!prs_align(ps))
3685 return False;
3686
3687 if (!prs_uint32("flags", ps, depth, &r_t->flags))
3688 return False;
3689
3690 return True;
3691}
3692
3693
3694
3695/*******************************************************************
3696 Inits a NET_R_DSR_GETDCNAME structure.
3697********************************************************************/
3698void init_net_r_dsr_getdcname(NET_R_DSR_GETDCNAME *r_t, const char *dc_unc,
3699 const char *dc_address, int32 dc_address_type,
3700 struct GUID domain_guid, const char *domain_name,
3701 const char *forest_name, uint32 dc_flags,
3702 const char *dc_site_name,
3703 const char *client_site_name)
3704{
3705 DEBUG(5, ("init_net_q_dsr_getdcname\n"));
3706
3707 r_t->ptr_dc_unc = (dc_unc != NULL);
3708 init_unistr2(&r_t->uni_dc_unc, dc_unc, UNI_STR_TERMINATE);
3709
3710 r_t->ptr_dc_address = (dc_address != NULL);
3711 init_unistr2(&r_t->uni_dc_address, dc_address, UNI_STR_TERMINATE);
3712
3713 r_t->dc_address_type = dc_address_type;
3714 r_t->domain_guid = domain_guid;
3715
3716 r_t->ptr_domain_name = (domain_name != NULL);
3717 init_unistr2(&r_t->uni_domain_name, domain_name, UNI_STR_TERMINATE);
3718
3719 r_t->ptr_forest_name = (forest_name != NULL);
3720 init_unistr2(&r_t->uni_forest_name, forest_name, UNI_STR_TERMINATE);
3721
3722 r_t->dc_flags = dc_flags;
3723
3724 r_t->ptr_dc_site_name = (dc_site_name != NULL);
3725 init_unistr2(&r_t->uni_dc_site_name, dc_site_name, UNI_STR_TERMINATE);
3726
3727 r_t->ptr_client_site_name = (client_site_name != NULL);
3728 init_unistr2(&r_t->uni_client_site_name, client_site_name,
3729 UNI_STR_TERMINATE);
3730}
3731
3732/*******************************************************************
3733 Reads or writes an NET_R_DSR_GETDCNAME structure.
3734********************************************************************/
3735
3736BOOL net_io_r_dsr_getdcname(const char *desc, NET_R_DSR_GETDCNAME *r_t,
3737 prs_struct *ps, int depth)
3738{
3739 uint32 info_ptr = 1;
3740
3741 if (r_t == NULL)
3742 return False;
3743
3744 prs_debug(ps, depth, desc, "net_io_r_dsr_getdcname");
3745 depth++;
3746
3747 /* The reply contains *just* an info struct, this is the ptr to it */
3748 if (!prs_uint32("info_ptr", ps, depth, &info_ptr))
3749 return False;
3750
3751 if (info_ptr == 0)
3752 return False;
3753
3754 if (!prs_uint32("ptr_dc_unc", ps, depth, &r_t->ptr_dc_unc))
3755 return False;
3756
3757 if (!prs_uint32("ptr_dc_address", ps, depth, &r_t->ptr_dc_address))
3758 return False;
3759
3760 if (!prs_int32("dc_address_type", ps, depth, &r_t->dc_address_type))
3761 return False;
3762
3763 if (!smb_io_uuid("domain_guid", &r_t->domain_guid, ps, depth))
3764 return False;
3765
3766 if (!prs_uint32("ptr_domain_name", ps, depth, &r_t->ptr_domain_name))
3767 return False;
3768
3769 if (!prs_uint32("ptr_forest_name", ps, depth, &r_t->ptr_forest_name))
3770 return False;
3771
3772 if (!prs_uint32("dc_flags", ps, depth, &r_t->dc_flags))
3773 return False;
3774
3775 if (!prs_uint32("ptr_dc_site_name", ps, depth, &r_t->ptr_dc_site_name))
3776 return False;
3777
3778 if (!prs_uint32("ptr_client_site_name", ps, depth,
3779 &r_t->ptr_client_site_name))
3780 return False;
3781
3782 if (!prs_align(ps))
3783 return False;
3784
3785 if (!smb_io_unistr2("dc_unc", &r_t->uni_dc_unc,
3786 r_t->ptr_dc_unc, ps, depth))
3787 return False;
3788
3789 if (!prs_align(ps))
3790 return False;
3791
3792 if (!smb_io_unistr2("dc_address", &r_t->uni_dc_address,
3793 r_t->ptr_dc_address, ps, depth))
3794 return False;
3795
3796 if (!prs_align(ps))
3797 return False;
3798
3799 if (!smb_io_unistr2("domain_name", &r_t->uni_domain_name,
3800 r_t->ptr_domain_name, ps, depth))
3801 return False;
3802
3803 if (!prs_align(ps))
3804 return False;
3805
3806 if (!smb_io_unistr2("forest_name", &r_t->uni_forest_name,
3807 r_t->ptr_forest_name, ps, depth))
3808 return False;
3809
3810 if (!prs_align(ps))
3811 return False;
3812
3813 if (!smb_io_unistr2("dc_site_name", &r_t->uni_dc_site_name,
3814 r_t->ptr_dc_site_name, ps, depth))
3815 return False;
3816
3817 if (!prs_align(ps))
3818 return False;
3819
3820 if (!smb_io_unistr2("client_site_name", &r_t->uni_client_site_name,
3821 r_t->ptr_client_site_name, ps, depth))
3822 return False;
3823
3824 if (!prs_align(ps))
3825 return False;
3826
3827 if (!prs_werror("result", ps, depth, &r_t->result))
3828 return False;
3829
3830 return True;
3831}
3832
3833/*******************************************************************
3834 Inits a NET_Q_DSR_GETSITENAME structure.
3835********************************************************************/
3836
3837void init_net_q_dsr_getsitename(NET_Q_DSR_GETSITENAME *r_t, const char *computer_name)
3838{
3839 DEBUG(5, ("init_net_q_dsr_getsitename\n"));
3840
3841 r_t->ptr_computer_name = (computer_name != NULL);
3842 init_unistr2(&r_t->uni_computer_name, computer_name, UNI_STR_TERMINATE);
3843}
3844
3845/*******************************************************************
3846 Reads or writes an NET_Q_DSR_GETSITENAME structure.
3847********************************************************************/
3848
3849BOOL net_io_q_dsr_getsitename(const char *desc, NET_Q_DSR_GETSITENAME *r_t,
3850 prs_struct *ps, int depth)
3851{
3852 if (r_t == NULL)
3853 return False;
3854
3855 prs_debug(ps, depth, desc, "net_io_q_dsr_getsitename");
3856 depth++;
3857
3858 if (!prs_uint32("ptr_computer_name", ps, depth, &r_t->ptr_computer_name))
3859 return False;
3860
3861 if (!smb_io_unistr2("computer_name", &r_t->uni_computer_name,
3862 r_t->ptr_computer_name, ps, depth))
3863 return False;
3864
3865 if (!prs_align(ps))
3866 return False;
3867
3868 return True;
3869}
3870
3871/*******************************************************************
3872 Reads or writes an NET_R_DSR_GETSITENAME structure.
3873********************************************************************/
3874
3875BOOL net_io_r_dsr_getsitename(const char *desc, NET_R_DSR_GETSITENAME *r_t,
3876 prs_struct *ps, int depth)
3877{
3878 if (r_t == NULL)
3879 return False;
3880
3881 prs_debug(ps, depth, desc, "net_io_r_dsr_getsitename");
3882 depth++;
3883
3884 if (!prs_uint32("ptr_site_name", ps, depth, &r_t->ptr_site_name))
3885 return False;
3886
3887 if (!prs_align(ps))
3888 return False;
3889
3890 if (!smb_io_unistr2("site_name", &r_t->uni_site_name,
3891 r_t->ptr_site_name, ps, depth))
3892 return False;
3893
3894 if (!prs_align(ps))
3895 return False;
3896
3897 if (!prs_werror("result", ps, depth, &r_t->result))
3898 return False;
3899
3900 return True;
3901}
3902
3903
Note: See TracBrowser for help on using the repository browser.