?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Correct PPTP server firewall rules chain.
[tomato/davidwu.git] / release / src / router / samba / source / rpc_parse / parse_net.c
blob9588d1c53b3332a9b1521be5b1cc005b811676ee
1 /*
2 * Unix SMB/Netbios implementation.
3 * Version 1.9.
4 * RPC Pipe client / server routines
5 * Copyright (C) Andrew Tridgell 1992-1997,
6 * Copyright (C) Luke Kenneth Casson Leighton 1996-1997,
7 * Copyright (C) Paul Ashton 1997.
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 */
23
24 #include "includes.h"
25 #include "nterr.h"
26
27 extern int DEBUGLEVEL;
28
29 /*******************************************************************
30 Reads or writes a structure.
31 ********************************************************************/
32
33 static BOOL net_io_neg_flags(char *desc, NEG_FLAGS *neg, prs_struct *ps, int depth)
34 {
35 if (neg == NULL)
36 return False;
37
38 prs_debug(ps, depth, desc, "net_io_neg_flags");
39 depth++;
40
41 if(!prs_align(ps))
42 return False;
43
44 if(!prs_uint32("neg_flags", ps, depth, &neg->neg_flags))
45 return False;
46
47 return True;
48 }
49
50 /*******************************************************************
51 Inits a NETLOGON_INFO_3 structure.
52 ********************************************************************/
53
54 static void init_netinfo_3(NETLOGON_INFO_3 *info, uint32 flags, uint32 logon_attempts)
55 {
56 info->flags = flags;
57 info->logon_attempts = logon_attempts;
58 info->reserved_1 = 0x0;
59 info->reserved_2 = 0x0;
60 info->reserved_3 = 0x0;
61 info->reserved_4 = 0x0;
62 info->reserved_5 = 0x0;
63 }
64
65 /*******************************************************************
66 Reads or writes a NETLOGON_INFO_3 structure.
67 ********************************************************************/
68
69 static BOOL net_io_netinfo_3(char *desc, NETLOGON_INFO_3 *info, prs_struct *ps, int depth)
70 {
71 if (info == NULL)
72 return False;
73
74 prs_debug(ps, depth, desc, "net_io_netinfo_3");
75 depth++;
76
77 if(!prs_align(ps))
78 return False;
79
80 if(!prs_uint32("flags ", ps, depth, &info->flags))
81 return False;
82 if(!prs_uint32("logon_attempts", ps, depth, &info->logon_attempts))
83 return False;
84 if(!prs_uint32("reserved_1 ", ps, depth, &info->reserved_1))
85 return False;
86 if(!prs_uint32("reserved_2 ", ps, depth, &info->reserved_2))
87 return False;
88 if(!prs_uint32("reserved_3 ", ps, depth, &info->reserved_3))
89 return False;
90 if(!prs_uint32("reserved_4 ", ps, depth, &info->reserved_4))
91 return False;
92 if(!prs_uint32("reserved_5 ", ps, depth, &info->reserved_5))
93 return False;
94
95 return True;
96 }
97
98
99 /*******************************************************************
100 Inits a NETLOGON_INFO_1 structure.
101 ********************************************************************/
102
103 static void init_netinfo_1(NETLOGON_INFO_1 *info, uint32 flags, uint32 pdc_status)
104 {
105 info->flags = flags;
106 info->pdc_status = pdc_status;
107 }
108
109 /*******************************************************************
110 Reads or writes a NETLOGON_INFO_1 structure.
111 ********************************************************************/
112
113 static BOOL net_io_netinfo_1(char *desc, NETLOGON_INFO_1 *info, prs_struct *ps, int depth)
114 {
115 if (info == NULL)
116 return False;
117
118 prs_debug(ps, depth, desc, "net_io_netinfo_1");
119 depth++;
120
121 if(!prs_align(ps))
122 return False;
123
124 if(!prs_uint32("flags ", ps, depth, &info->flags))
125 return False;
126 if(!prs_uint32("pdc_status", ps, depth, &info->pdc_status))
127 return False;
128
129 return True;
130 }
131
132 /*******************************************************************
133 Inits a NETLOGON_INFO_2 structure.
134 ********************************************************************/
135
136 static void init_netinfo_2(NETLOGON_INFO_2 *info, uint32 flags, uint32 pdc_status,
137 uint32 tc_status, char *trusted_dc_name)
138 {
139 int len_dc_name = strlen(trusted_dc_name);
140 info->flags = flags;
141 info->pdc_status = pdc_status;
142 info->ptr_trusted_dc_name = 1;
143 info->tc_status = tc_status;
144
145 if (trusted_dc_name != NULL)
146 init_unistr2(&(info->uni_trusted_dc_name), trusted_dc_name, len_dc_name+1);
147 else
148 init_unistr2(&(info->uni_trusted_dc_name), "", 1);
149 }
150
151 /*******************************************************************
152 Reads or writes a NETLOGON_INFO_2 structure.
153 ********************************************************************/
154
155 static BOOL net_io_netinfo_2(char *desc, NETLOGON_INFO_2 *info, prs_struct *ps, int depth)
156 {
157 if (info == NULL)
158 return False;
159
160 prs_debug(ps, depth, desc, "net_io_netinfo_2");
161 depth++;
162
163 if(!prs_align(ps))
164 return False;
165
166 if(!prs_uint32("flags ", ps, depth, &info->flags))
167 return False;
168 if(!prs_uint32("pdc_status ", ps, depth, &info->pdc_status))
169 return False;
170 if(!prs_uint32("ptr_trusted_dc_name", ps, depth, &info->ptr_trusted_dc_name))
171 return False;
172 if(!prs_uint32("tc_status ", ps, depth, &info->tc_status))
173 return False;
174
175 if (info->ptr_trusted_dc_name != 0) {
176 if(!smb_io_unistr2("unistr2", &info->uni_trusted_dc_name, info->ptr_trusted_dc_name, ps, depth))
177 return False;
178 }
179
180 if(!prs_align(ps))
181 return False;
182
183 return True;
184 }
185
186 /*******************************************************************
187 Reads or writes an NET_Q_LOGON_CTRL2 structure.
188 ********************************************************************/
189
190 BOOL net_io_q_logon_ctrl2(char *desc, NET_Q_LOGON_CTRL2 *q_l, prs_struct *ps, int depth)
191 {
192 if (q_l == NULL)
193 return False;
194
195 prs_debug(ps, depth, desc, "net_io_q_logon_ctrl2");
196 depth++;
197
198 if(!prs_align(ps))
199 return False;
200
201 if(!prs_uint32("ptr ", ps, depth, &q_l->ptr))
202 return False;
203
204 if(!smb_io_unistr2 ("", &q_l->uni_server_name, q_l->ptr, ps, depth))
205 return False;
206
207 if(!prs_align(ps))
208 return False;
209
210 if(!prs_uint32("function_code", ps, depth, &q_l->function_code))
211 return False;
212 if(!prs_uint32("query_level ", ps, depth, &q_l->query_level))
213 return False;
214 if(!prs_uint32("switch_value ", ps, depth, &q_l->switch_value))
215 return False;
216
217 return True;
218 }
219
220 /*******************************************************************
221 Inits an NET_R_LOGON_CTRL2 structure.
222 ********************************************************************/
223
224 void init_r_logon_ctrl2(NET_R_LOGON_CTRL2 *r_l, uint32 query_level,
225 uint32 flags, uint32 pdc_status, uint32 logon_attempts,
226 uint32 tc_status, char *trusted_domain_name)
227 {
228 DEBUG(5,("make_r_logon_ctrl2\n"));
229
230 r_l->switch_value = query_level; /* should only be 0x1 */
231
232 switch (query_level) {
233 case 1:
234 r_l->ptr = 1; /* undocumented pointer */
235 init_netinfo_1(&r_l->logon.info1, flags, pdc_status);
236 r_l->status = 0;
237 break;
238 case 2:
239 r_l->ptr = 1; /* undocumented pointer */
240 init_netinfo_2(&r_l->logon.info2, flags, pdc_status,
241 tc_status, trusted_domain_name);
242 r_l->status = 0;
243 break;
244 case 3:
245 r_l->ptr = 1; /* undocumented pointer */
246 init_netinfo_3(&(r_l->logon.info3), flags, logon_attempts);
247 r_l->status = 0;
248 break;
249 default:
250 DEBUG(2,("init_r_logon_ctrl2: unsupported switch value %d\n",
251 r_l->switch_value));
252 r_l->ptr = 0; /* undocumented pointer */
253
254 /* take a guess at an error code... */
255 r_l->status = NT_STATUS_INVALID_INFO_CLASS;
256 break;
257 }
258 }
259
260 /*******************************************************************
261 Reads or writes an NET_R_LOGON_CTRL2 structure.
262 ********************************************************************/
263
264 BOOL net_io_r_logon_ctrl2(char *desc, NET_R_LOGON_CTRL2 *r_l, prs_struct *ps, int depth)
265 {
266 if (r_l == NULL)
267 return False;
268
269 prs_debug(ps, depth, desc, "net_io_r_logon_ctrl2");
270 depth++;
271
272 if(!prs_uint32("switch_value ", ps, depth, &r_l->switch_value))
273 return False;
274 if(!prs_uint32("ptr ", ps, depth, &r_l->ptr))
275 return False;
276
277 if (r_l->ptr != 0) {
278 switch (r_l->switch_value) {
279 case 1:
280 if(!net_io_netinfo_1("", &r_l->logon.info1, ps, depth))
281 return False;
282 break;
283 case 2:
284 if(!net_io_netinfo_2("", &r_l->logon.info2, ps, depth))
285 return False;
286 break;
287 case 3:
288 if(!net_io_netinfo_3("", &r_l->logon.info3, ps, depth))
289 return False;
290 break;
291 default:
292 DEBUG(2,("net_io_r_logon_ctrl2: unsupported switch value %d\n",
293 r_l->switch_value));
294 break;
295 }
296 }
297
298 if(!prs_uint32("status ", ps, depth, &r_l->status))
299 return False;
300
301 return True;
302 }
303
304 /*******************************************************************
305 Inits an NET_R_TRUST_DOM_LIST structure.
306 ********************************************************************/
307
308 void init_r_trust_dom(NET_R_TRUST_DOM_LIST *r_t,
309 uint32 num_doms, char *dom_name)
310 {
311 int i = 0;
312
313 DEBUG(5,("make_r_trust_dom\n"));
314
315 for (i = 0; i < MAX_TRUST_DOMS; i++) {
316 r_t->uni_trust_dom_name[i].uni_str_len = 0;
317 r_t->uni_trust_dom_name[i].uni_max_len = 0;
318 }
319 if (num_doms > MAX_TRUST_DOMS)
320 num_doms = MAX_TRUST_DOMS;
321
322 for (i = 0; i < num_doms; i++) {
323 fstring domain_name;
324 fstrcpy(domain_name, dom_name);
325 strupper(domain_name);
326 init_unistr2(&r_t->uni_trust_dom_name[i], domain_name, strlen(domain_name)+1);
327 /* the use of UNISTR2 here is non-standard. */
328 r_t->uni_trust_dom_name[i].undoc = 0x1;
329 }
330
331 r_t->status = 0;
332 }
333
334 /*******************************************************************
335 Reads or writes an NET_R_TRUST_DOM_LIST structure.
336 ********************************************************************/
337
338 BOOL net_io_r_trust_dom(char *desc, NET_R_TRUST_DOM_LIST *r_t, prs_struct *ps, int depth)
339 {
340 int i;
341 if (r_t == NULL)
342 return False;
343
344 prs_debug(ps, depth, desc, "net_io_r_trust_dom");
345 depth++;
346
347 for (i = 0; i < MAX_TRUST_DOMS; i++) {
348 if (r_t->uni_trust_dom_name[i].uni_str_len == 0)
349 break;
350 if(!smb_io_unistr2("", &r_t->uni_trust_dom_name[i], True, ps, depth))
351 return False;
352 }
353
354 if(!prs_uint32("status", ps, depth, &r_t->status))
355 return False;
356
357 return True;
358 }
359
360
361 /*******************************************************************
362 Reads or writes an NET_Q_TRUST_DOM_LIST structure.
363 ********************************************************************/
364
365 BOOL net_io_q_trust_dom(char *desc, NET_Q_TRUST_DOM_LIST *q_l, prs_struct *ps, int depth)
366 {
367 if (q_l == NULL)
368 return False;
369
370 prs_debug(ps, depth, desc, "net_io_q_trust_dom");
371 depth++;
372
373 if(!prs_uint32("ptr ", ps, depth, &q_l->ptr))
374 return False;
375 if(!smb_io_unistr2 ("", &q_l->uni_server_name, q_l->ptr, ps, depth))
376 return False;
377
378 if(!prs_align(ps))
379 return False;
380
381 if(!prs_uint32("function_code", ps, depth, &q_l->function_code))
382 return False;
383
384 return True;
385 }
386
387 /*******************************************************************
388 Inits an NET_Q_REQ_CHAL structure.
389 ********************************************************************/
390
391 void init_q_req_chal(NET_Q_REQ_CHAL *q_c,
392 char *logon_srv, char *logon_clnt,
393 DOM_CHAL *clnt_chal)
394 {
395 DEBUG(5,("make_q_req_chal: %d\n", __LINE__));
396
397 q_c->undoc_buffer = 1; /* don't know what this buffer is */
398
399 init_unistr2(&q_c->uni_logon_srv, logon_srv , strlen(logon_srv )+1);
400 init_unistr2(&q_c->uni_logon_clnt, logon_clnt, strlen(logon_clnt)+1);
401
402 memcpy(q_c->clnt_chal.data, clnt_chal->data, sizeof(clnt_chal->data));
403
404 DEBUG(5,("make_q_req_chal: %d\n", __LINE__));
405 }
406
407 /*******************************************************************
408 Reads or writes an NET_Q_REQ_CHAL structure.
409 ********************************************************************/
410
411 BOOL net_io_q_req_chal(char *desc, NET_Q_REQ_CHAL *q_c, prs_struct *ps, int depth)
412 {
413 int old_align;
414
415 if (q_c == NULL)
416 return False;
417
418 prs_debug(ps, depth, desc, "net_io_q_req_chal");
419 depth++;
420
421 if(!prs_align(ps))
422 return False;
423
424 if(!prs_uint32("undoc_buffer", ps, depth, &q_c->undoc_buffer))
425 return False;
426
427 if(!smb_io_unistr2("", &q_c->uni_logon_srv, True, ps, depth)) /* logon server unicode string */
428 return False;
429 if(!smb_io_unistr2("", &q_c->uni_logon_clnt, True, ps, depth)) /* logon client unicode string */
430 return False;
431
432 old_align = ps->align;
433 ps->align = 0;
434 /* client challenge is _not_ aligned after the unicode strings */
435 if(!smb_io_chal("", &q_c->clnt_chal, ps, depth)) {
436 /* client challenge */
437 ps->align = old_align;
438 return False;
439 }
440 ps->align = old_align;
441
442 return True;
443 }
444
445 /*******************************************************************
446 Reads or writes a structure.
447 ********************************************************************/
448
449 BOOL net_io_r_req_chal(char *desc, NET_R_REQ_CHAL *r_c, prs_struct *ps, int depth)
450 {
451 if (r_c == NULL)
452 return False;
453
454 prs_debug(ps, depth, desc, "net_io_r_req_chal");
455 depth++;
456
457 if(!prs_align(ps))
458 return False;
459
460 if(!smb_io_chal("", &r_c->srv_chal, ps, depth)) /* server challenge */
461 return False;
462
463 if(!prs_uint32("status", ps, depth, &r_c->status))
464 return False;
465
466 return True;
467 }
468
469
470 /*******************************************************************
471 Inits a NET_Q_AUTH_2 struct.
472 ********************************************************************/
473
474 void init_q_auth_2(NET_Q_AUTH_2 *q_a,
475 char *logon_srv, char *acct_name, uint16 sec_chan, char *comp_name,
476 DOM_CHAL *clnt_chal, uint32 clnt_flgs)
477 {
478 DEBUG(5,("init_q_auth_2: %d\n", __LINE__));
479
480 init_log_info(&q_a->clnt_id, logon_srv, acct_name, sec_chan, comp_name);
481 memcpy(q_a->clnt_chal.data, clnt_chal->data, sizeof(clnt_chal->data));
482 q_a->clnt_flgs.neg_flags = clnt_flgs;
483
484 DEBUG(5,("init_q_auth_2: %d\n", __LINE__));
485 }
486
487 /*******************************************************************
488 Reads or writes a structure.
489 ********************************************************************/
490
491 BOOL net_io_q_auth_2(char *desc, NET_Q_AUTH_2 *q_a, prs_struct *ps, int depth)
492 {
493 int old_align;
494 if (q_a == NULL)
495 return False;
496
497 prs_debug(ps, depth, desc, "net_io_q_auth_2");
498 depth++;
499
500 if(!prs_align(ps))
501 return False;
502
503 if(!smb_io_log_info ("", &q_a->clnt_id, ps, depth)) /* client identification info */
504 return False;
505 /* client challenge is _not_ aligned */
506 old_align = ps->align;
507 ps->align = 0;
508 if(!smb_io_chal("", &q_a->clnt_chal, ps, depth)) {
509 /* client-calculated credentials */
510 ps->align = old_align;
511 return False;
512 }
513 ps->align = old_align;
514 if(!net_io_neg_flags("", &q_a->clnt_flgs, ps, depth))
515 return False;
516
517 return True;
518 }
519
520 /*******************************************************************
521 Reads or writes a structure.
522 ********************************************************************/
523
524 BOOL net_io_r_auth_2(char *desc, NET_R_AUTH_2 *r_a, prs_struct *ps, int depth)
525 {
526 if (r_a == NULL)
527 return False;
528
529 prs_debug(ps, depth, desc, "net_io_r_auth_2");
530 depth++;
531
532 if(!prs_align(ps))
533 return False;
534
535 if(!smb_io_chal("", &r_a->srv_chal, ps, depth)) /* server challenge */
536 return False;
537 if(!net_io_neg_flags("", &r_a->srv_flgs, ps, depth))
538 return False;
539
540 if(!prs_uint32("status", ps, depth, &r_a->status))
541 return False;
542
543 return True;
544 }
545
546
547 /*******************************************************************
548 Inits a NET_Q_SRV_PWSET.
549 ********************************************************************/
550
551 void init_q_srv_pwset(NET_Q_SRV_PWSET *q_s, char *logon_srv, char *acct_name,
552 uint16 sec_chan, char *comp_name, DOM_CRED *cred, char nt_cypher[16])
553 {
554 DEBUG(5,("make_q_srv_pwset\n"));
555
556 init_clnt_info(&q_s->clnt_id, logon_srv, acct_name, sec_chan, comp_name, cred);
557
558 memcpy(q_s->pwd, nt_cypher, sizeof(q_s->pwd));
559 }
560
561 /*******************************************************************
562 Reads or writes a structure.
563 ********************************************************************/
564
565 BOOL net_io_q_srv_pwset(char *desc, NET_Q_SRV_PWSET *q_s, prs_struct *ps, int depth)
566 {
567 if (q_s == NULL)
568 return False;
569
570 prs_debug(ps, depth, desc, "net_io_q_srv_pwset");
571 depth++;
572
573 if(!prs_align(ps))
574 return False;
575
576 if(!smb_io_clnt_info("", &q_s->clnt_id, ps, depth)) /* client identification/authentication info */
577 return False;
578 if(!prs_uint8s (False, "pwd", ps, depth, q_s->pwd, 16)) /* new password - undocumented */
579 return False;
580
581 return True;
582 }
583
584 /*******************************************************************
585 Reads or writes a structure.
586 ********************************************************************/
587
588 BOOL net_io_r_srv_pwset(char *desc, NET_R_SRV_PWSET *r_s, prs_struct *ps, int depth)
589 {
590 if (r_s == NULL)
591 return False;
592
593 prs_debug(ps, depth, desc, "net_io_r_srv_pwset");
594 depth++;
595
596 if(!prs_align(ps))
597 return False;
598
599 if(!smb_io_cred("", &r_s->srv_cred, ps, depth)) /* server challenge */
600 return False;
601
602 if(!prs_uint32("status", ps, depth, &r_s->status))
603 return False;
604
605 return True;
606 }
607
608 /*************************************************************************
609 Init DOM_SID2 array from a string containing multiple sids
610 *************************************************************************/
611
612 static int init_dom_sid2s(char *sids_str, DOM_SID2 *sids, int max_sids)
613 {
614 char *ptr;
615 pstring s2;
616 int count = 0;
617
618 DEBUG(4,("init_dom_sid2s: %s\n", sids_str ? sids_str:""));
619
620 if(sids_str) {
621 for (count = 0, ptr = sids_str;
622 next_token(&ptr, s2, NULL, sizeof(s2)) && count < max_sids; count++) {
623 DOM_SID tmpsid;
624 string_to_sid(&tmpsid, s2);
625 init_dom_sid2(&sids[count], &tmpsid);
626 }
627 }
628
629 return count;
630 }
631
632 /*******************************************************************
633 Inits a NET_ID_INFO_1 structure.
634 ********************************************************************/
635
636 void init_id_info1(NET_ID_INFO_1 *id, char *domain_name,
637 uint32 param_ctrl, uint32 log_id_low, uint32 log_id_high,
638 char *user_name, char *wksta_name,
639 char sess_key[16],
640 unsigned char lm_cypher[16], unsigned char nt_cypher[16])
641 {
642 int len_domain_name = strlen(domain_name);
643 int len_user_name = strlen(user_name );
644 int len_wksta_name = strlen(wksta_name );
645
646 unsigned char lm_owf[16];
647 unsigned char nt_owf[16];
648
649 DEBUG(5,("make_id_info1: %d\n", __LINE__));
650
651 id->ptr_id_info1 = 1;
652
653 init_uni_hdr(&id->hdr_domain_name, len_domain_name);
654
655 id->param_ctrl = param_ctrl;
656 init_logon_id(&id->logon_id, log_id_low, log_id_high);
657
658 init_uni_hdr(&id->hdr_user_name, len_user_name);
659 init_uni_hdr(&id->hdr_wksta_name, len_wksta_name);
660
661 if (lm_cypher && nt_cypher) {
662 unsigned char key[16];
663 #ifdef DEBUG_PASSWORD
664 DEBUG(100,("lm cypher:"));
665 dump_data(100, (char *)lm_cypher, 16);
666
667 DEBUG(100,("nt cypher:"));
668 dump_data(100, (char *)nt_cypher, 16);
669 #endif
670
671 memset(key, 0, 16);
672 memcpy(key, sess_key, 8);
673
674 memcpy(lm_owf, lm_cypher, 16);
675 SamOEMhash(lm_owf, key, False);
676 memcpy(nt_owf, nt_cypher, 16);
677 SamOEMhash(nt_owf, key, False);
678
679 #ifdef DEBUG_PASSWORD
680 DEBUG(100,("encrypt of lm owf password:"));
681 dump_data(100, (char *)lm_owf, 16);
682
683 DEBUG(100,("encrypt of nt owf password:"));
684 dump_data(100, (char *)nt_owf, 16);
685 #endif
686 /* set up pointers to cypher blocks */
687 lm_cypher = lm_owf;
688 nt_cypher = nt_owf;
689 }
690
691 init_owf_info(&id->lm_owf, lm_cypher);
692 init_owf_info(&id->nt_owf, nt_cypher);
693
694 init_unistr2(&id->uni_domain_name, domain_name, len_domain_name);
695 init_unistr2(&id->uni_user_name, user_name, len_user_name);
696 init_unistr2(&id->uni_wksta_name, wksta_name, len_wksta_name);
697 }
698
699 /*******************************************************************
700 Reads or writes an NET_ID_INFO_1 structure.
701 ********************************************************************/
702
703 static BOOL net_io_id_info1(char *desc, NET_ID_INFO_1 *id, prs_struct *ps, int depth)
704 {
705 if (id == NULL)
706 return False;
707
708 prs_debug(ps, depth, desc, "net_io_id_info1");
709 depth++;
710
711 if(!prs_align(ps))
712 return False;
713
714 if(!prs_uint32("ptr_id_info1", ps, depth, &id->ptr_id_info1))
715 return False;
716
717 if (id->ptr_id_info1 != 0) {
718 if(!smb_io_unihdr("unihdr", &id->hdr_domain_name, ps, depth))
719 return False;
720
721 if(!prs_uint32("param_ctrl", ps, depth, &id->param_ctrl))
722 return False;
723 if(!smb_io_logon_id("", &id->logon_id, ps, depth))
724 return False;
725
726 if(!smb_io_unihdr("unihdr", &id->hdr_user_name, ps, depth))
727 return False;
728 if(!smb_io_unihdr("unihdr", &id->hdr_wksta_name, ps, depth))
729 return False;
730
731 if(!smb_io_owf_info("", &id->lm_owf, ps, depth))
732 return False;
733 if(!smb_io_owf_info("", &id->nt_owf, ps, depth))
734 return False;
735
736 if(!smb_io_unistr2("unistr2", &id->uni_domain_name,
737 id->hdr_domain_name.buffer, ps, depth))
738 return False;
739 if(!smb_io_unistr2("unistr2", &id->uni_user_name,
740 id->hdr_user_name.buffer, ps, depth))
741 return False;
742 if(!smb_io_unistr2("unistr2", &id->uni_wksta_name,
743 id->hdr_wksta_name.buffer, ps, depth))
744 return False;
745 }
746
747 return True;
748 }
749
750 /*******************************************************************
751 Inits a NET_ID_INFO_2 structure.
752
753 This is a network logon packet. The log_id parameters
754 are what an NT server would generate for LUID once the
755 user is logged on. I don't think we care about them.
756
757 Note that this has no access to the NT and LM hashed passwords,
758 so it forwards the challenge, and the NT and LM responses (24
759 bytes each) over the secure channel to the Domain controller
760 for it to say yea or nay. This is the preferred method of
761 checking for a logon as it doesn't export the password
762 hashes to anyone who has compromised the secure channel. JRA.
763 ********************************************************************/
764
765 void init_id_info2(NET_ID_INFO_2 *id, char *domain_name,
766 uint32 param_ctrl, uint32 log_id_low, uint32 log_id_high,
767 char *user_name, char *wksta_name,
768 unsigned char lm_challenge[8],
769 unsigned char lm_chal_resp[24],
770 unsigned char nt_chal_resp[24])
771 {
772 int len_domain_name = strlen(domain_name);
773 int len_user_name = strlen(user_name );
774 int len_wksta_name = strlen(wksta_name );
775 int nt_chal_resp_len = ((nt_chal_resp != NULL) ? 24 : 0);
776 int lm_chal_resp_len = ((lm_chal_resp != NULL) ? 24 : 0);
777 unsigned char lm_owf[24];
778 unsigned char nt_owf[24];
779
780 DEBUG(5,("init_id_info2: %d\n", __LINE__));
781
782 id->ptr_id_info2 = 1;
783
784 init_uni_hdr(&id->hdr_domain_name, len_domain_name);
785
786 id->param_ctrl = param_ctrl;
787 init_logon_id(&id->logon_id, log_id_low, log_id_high);
788
789 init_uni_hdr(&id->hdr_user_name, len_user_name);
790 init_uni_hdr(&id->hdr_wksta_name, len_wksta_name);
791
792 if (nt_chal_resp) {
793 /* oops. can only send what-ever-it-is direct */
794 memcpy(nt_owf, nt_chal_resp, 24);
795 nt_chal_resp = nt_owf;
796 }
797 if (lm_chal_resp) {
798 /* oops. can only send what-ever-it-is direct */
799 memcpy(lm_owf, lm_chal_resp, 24);
800 lm_chal_resp = lm_owf;
801 }
802
803 memcpy(id->lm_chal, lm_challenge, sizeof(id->lm_chal));
804 init_str_hdr(&id->hdr_nt_chal_resp, 24, nt_chal_resp_len, (nt_chal_resp != NULL) ? 1 : 0);
805 init_str_hdr(&id->hdr_lm_chal_resp, 24, lm_chal_resp_len, (lm_chal_resp != NULL) ? 1 : 0);
806
807 init_unistr2(&id->uni_domain_name, domain_name, len_domain_name);
808 init_unistr2(&id->uni_user_name, user_name, len_user_name);
809 init_unistr2(&id->uni_wksta_name, wksta_name, len_wksta_name);
810
811 init_string2(&id->nt_chal_resp, (char *)nt_chal_resp, nt_chal_resp_len);
812 init_string2(&id->lm_chal_resp, (char *)lm_chal_resp, lm_chal_resp_len);
813 }
814
815 /*******************************************************************
816 Reads or writes an NET_ID_INFO_2 structure.
817 ********************************************************************/
818
819 static BOOL net_io_id_info2(char *desc, NET_ID_INFO_2 *id, prs_struct *ps, int depth)
820 {
821 if (id == NULL)
822 return False;
823
824 prs_debug(ps, depth, desc, "net_io_id_info2");
825 depth++;
826
827 if(!prs_align(ps))
828 return False;
829
830 if(!prs_uint32("ptr_id_info2", ps, depth, &id->ptr_id_info2))
831 return False;
832
833 if (id->ptr_id_info2 != 0) {
834 if(!smb_io_unihdr("unihdr", &id->hdr_domain_name, ps, depth))
835 return False;
836
837 if(!prs_uint32("param_ctrl", ps, depth, &id->param_ctrl))
838 return False;
839 if(!smb_io_logon_id("", &id->logon_id, ps, depth))
840 return False;
841
842 if(!smb_io_unihdr("unihdr", &id->hdr_user_name, ps, depth))
843 return False;
844 if(!smb_io_unihdr("unihdr", &id->hdr_wksta_name, ps, depth))
845 return False;
846
847 if(!prs_uint8s (False, "lm_chal", ps, depth, id->lm_chal, 8)) /* lm 8 byte challenge */
848 return False;
849
850 if(!smb_io_strhdr("hdr_nt_chal_resp", &id->hdr_nt_chal_resp, ps, depth))
851 return False;
852 if(!smb_io_strhdr("hdr_lm_chal_resp", &id->hdr_lm_chal_resp, ps, depth))
853 return False;
854
855 if(!smb_io_unistr2("uni_domain_name", &id->uni_domain_name,
856 id->hdr_domain_name.buffer, ps, depth))
857 return False;
858 if(!smb_io_unistr2("uni_user_name ", &id->uni_user_name,
859 id->hdr_user_name.buffer, ps, depth))
860 return False;
861 if(!smb_io_unistr2("uni_wksta_name ", &id->uni_wksta_name,
862 id->hdr_wksta_name.buffer, ps, depth))
863 return False;
864 if(!smb_io_string2("nt_chal_resp", &id->nt_chal_resp,
865 id->hdr_nt_chal_resp.buffer, ps, depth))
866 return False;
867 if(!smb_io_string2("lm_chal_resp", &id->lm_chal_resp,
868 id->hdr_lm_chal_resp.buffer, ps, depth))
869 return False;
870 }
871
872 return True;
873 }
874
875
876 /*******************************************************************
877 Inits a DOM_SAM_INFO structure.
878 ********************************************************************/
879
880 void init_sam_info(DOM_SAM_INFO *sam,
881 char *logon_srv, char *comp_name, DOM_CRED *clnt_cred,
882 DOM_CRED *rtn_cred, uint16 logon_level,
883 NET_ID_INFO_CTR *ctr)
884 {
885 DEBUG(5,("init_sam_info: %d\n", __LINE__));
886
887 init_clnt_info2(&(sam->client), logon_srv, comp_name, clnt_cred);
888
889 if (rtn_cred != NULL) {
890 sam->ptr_rtn_cred = 1;
891 memcpy(&sam->rtn_cred, rtn_cred, sizeof(sam->rtn_cred));
892 } else {
893 sam->ptr_rtn_cred = 0;
894 }
895
896 sam->logon_level = logon_level;
897 sam->ctr = ctr;
898 }
899
900 /*******************************************************************
901 Reads or writes a DOM_SAM_INFO structure.
902 ********************************************************************/
903
904 static BOOL net_io_id_info_ctr(char *desc, NET_ID_INFO_CTR *ctr, prs_struct *ps, int depth)
905 {
906 if (ctr == NULL)
907 return False;
908
909 prs_debug(ps, depth, desc, "smb_io_sam_info");
910 depth++;
911
912 /* don't 4-byte align here! */
913
914 if(!prs_uint16("switch_value ", ps, depth, &ctr->switch_value))
915 return False;
916
917 switch (ctr->switch_value) {
918 case 1:
919 if(!net_io_id_info1("", &ctr->auth.id1, ps, depth))
920 return False;
921 break;
922 case 2:
923 if(!net_io_id_info2("", &ctr->auth.id2, ps, depth))
924 return False;
925 break;
926 default:
927 /* PANIC! */
928 DEBUG(4,("smb_io_sam_info: unknown switch_value!\n"));
929 break;
930 }
931
932 return True;
933 }
934
935 /*******************************************************************
936 Reads or writes a DOM_SAM_INFO structure.
937 ********************************************************************/
938
939 static BOOL smb_io_sam_info(char *desc, DOM_SAM_INFO *sam, prs_struct *ps, int depth)
940 {
941 if (sam == NULL)
942 return False;
943
944 prs_debug(ps, depth, desc, "smb_io_sam_info");
945 depth++;
946
947 if(!prs_align(ps))
948 return False;
949
950 if(!smb_io_clnt_info2("", &sam->client, ps, depth))
951 return False;
952
953 if(!prs_uint32("ptr_rtn_cred ", ps, depth, &sam->ptr_rtn_cred))
954 return False;
955 if(!smb_io_cred("", &sam->rtn_cred, ps, depth))
956 return False;
957
958 if(!prs_uint16("logon_level ", ps, depth, &sam->logon_level))
959 return False;
960
961 if (sam->logon_level != 0 && sam->ctr != NULL) {
962 if(!net_io_id_info_ctr("logon_info", sam->ctr, ps, depth))
963 return False;
964 }
965
966 return True;
967 }
968
969 /*************************************************************************
970 Init
971 *************************************************************************/
972
973 void init_net_user_info3(NET_USER_INFO_3 *usr,
974
975 NTTIME *logon_time,
976 NTTIME *logoff_time,
977 NTTIME *kickoff_time,
978 NTTIME *pass_last_set_time,
979 NTTIME *pass_can_change_time,
980 NTTIME *pass_must_change_time,
981
982 char *user_name,
983 char *full_name,
984 char *logon_script,
985 char *profile_path,
986 char *home_dir,
987 char *dir_drive,
988
989 uint16 logon_count,
990 uint16 bad_pw_count,
991
992 uint32 user_id,
993 uint32 group_id,
994 uint32 num_groups,
995 DOM_GID *gids,
996 uint32 user_flgs,
997
998 char sess_key[16],
999
1000 char *logon_srv,
1001 char *logon_dom,
1002
1003 DOM_SID *dom_sid,
1004 char *other_sids)
1005 {
1006 /* only cope with one "other" sid, right now. */
1007 /* need to count the number of space-delimited sids */
1008 int i;
1009 int num_other_sids = 0;
1010
1011 int len_user_name = strlen(user_name );
1012 int len_full_name = strlen(full_name );
1013 int len_logon_script = strlen(logon_script);
1014 int len_profile_path = strlen(profile_path);
1015 int len_home_dir = strlen(home_dir );
1016 int len_dir_drive = strlen(dir_drive );
1017
1018 int len_logon_srv = strlen(logon_srv);
1019 int len_logon_dom = strlen(logon_dom);
1020
1021 memset(usr, '\0', sizeof(*usr));
1022
1023 usr->ptr_user_info = 1; /* yes, we're bothering to put USER_INFO data here */
1024
1025 usr->logon_time = *logon_time;
1026 usr->logoff_time = *logoff_time;
1027 usr->kickoff_time = *kickoff_time;
1028 usr->pass_last_set_time = *pass_last_set_time;
1029 usr->pass_can_change_time = *pass_can_change_time;
1030 usr->pass_must_change_time = *pass_must_change_time;
1031
1032 init_uni_hdr(&usr->hdr_user_name, len_user_name);
1033 init_uni_hdr(&usr->hdr_full_name, len_full_name);
1034 init_uni_hdr(&usr->hdr_logon_script, len_logon_script);
1035 init_uni_hdr(&usr->hdr_profile_path, len_profile_path);
1036 init_uni_hdr(&usr->hdr_home_dir, len_home_dir);
1037 init_uni_hdr(&usr->hdr_dir_drive, len_dir_drive);
1038
1039 usr->logon_count = logon_count;
1040 usr->bad_pw_count = bad_pw_count;
1041
1042 usr->user_id = user_id;
1043 usr->group_id = group_id;
1044 usr->num_groups = num_groups;
1045 usr->buffer_groups = 1; /* indicates fill in groups, below, even if there are none */
1046 usr->user_flgs = user_flgs;
1047
1048 if (sess_key != NULL)
1049 memcpy(usr->user_sess_key, sess_key, sizeof(usr->user_sess_key));
1050 else
1051 memset((char *)usr->user_sess_key, '\0', sizeof(usr->user_sess_key));
1052
1053 init_uni_hdr(&usr->hdr_logon_srv, len_logon_srv);
1054 init_uni_hdr(&usr->hdr_logon_dom, len_logon_dom);
1055
1056 usr->buffer_dom_id = dom_sid ? 1 : 0; /* yes, we're bothering to put a domain SID in */
1057
1058 memset((char *)usr->padding, '\0', sizeof(usr->padding));
1059
1060 num_other_sids = init_dom_sid2s(other_sids, usr->other_sids, LSA_MAX_SIDS);
1061
1062 usr->num_other_sids = num_other_sids;
1063 usr->buffer_other_sids = (num_other_sids != 0) ? 1 : 0;
1064
1065 init_unistr2(&usr->uni_user_name, user_name, len_user_name);
1066 init_unistr2(&usr->uni_full_name, full_name, len_full_name);
1067 init_unistr2(&usr->uni_logon_script, logon_script, len_logon_script);
1068 init_unistr2(&usr->uni_profile_path, profile_path, len_profile_path);
1069 init_unistr2(&usr->uni_home_dir, home_dir, len_home_dir);
1070 init_unistr2(&usr->uni_dir_drive, dir_drive, len_dir_drive);
1071
1072 usr->num_groups2 = num_groups;
1073
1074 SMB_ASSERT_ARRAY(usr->gids, num_groups);
1075
1076 for (i = 0; i < num_groups; i++)
1077 usr->gids[i] = gids[i];
1078
1079 init_unistr2(&usr->uni_logon_srv, logon_srv, len_logon_srv);
1080 init_unistr2(&usr->uni_logon_dom, logon_dom, len_logon_dom);
1081
1082 init_dom_sid2(&usr->dom_sid, dom_sid);
1083 /* "other" sids are set up above */
1084 }
1085
1086
1087 /*******************************************************************
1088 Reads or writes a structure.
1089 ********************************************************************/
1090
1091 static BOOL net_io_user_info3(char *desc, NET_USER_INFO_3 *usr, prs_struct *ps, int depth)
1092 {
1093 int i;
1094
1095 if (usr == NULL)
1096 return False;
1097
1098 prs_debug(ps, depth, desc, "lsa_io_lsa_user_info");
1099 depth++;
1100
1101 if(!prs_align(ps))
1102 return False;
1103
1104 if(!prs_uint32("ptr_user_info ", ps, depth, &usr->ptr_user_info))
1105 return False;
1106
1107 if (usr->ptr_user_info == 0)
1108 return True;
1109
1110 if(!smb_io_time("time", &usr->logon_time, ps, depth)) /* logon time */
1111 return False;
1112 if(!smb_io_time("time", &usr->logoff_time, ps, depth)) /* logoff time */
1113 return False;
1114 if(!smb_io_time("time", &usr->kickoff_time, ps, depth)) /* kickoff time */
1115 return False;
1116 if(!smb_io_time("time", &usr->pass_last_set_time, ps, depth)) /* password last set time */
1117 return False;
1118 if(!smb_io_time("time", &usr->pass_can_change_time , ps, depth)) /* password can change time */
1119 return False;
1120 if(!smb_io_time("time", &usr->pass_must_change_time, ps, depth)) /* password must change time */
1121 return False;
1122
1123 if(!smb_io_unihdr("unihdr", &usr->hdr_user_name, ps, depth)) /* username unicode string header */
1124 return False;
1125 if(!smb_io_unihdr("unihdr", &usr->hdr_full_name, ps, depth)) /* user's full name unicode string header */
1126 return False;
1127 if(!smb_io_unihdr("unihdr", &usr->hdr_logon_script, ps, depth)) /* logon script unicode string header */
1128 return False;
1129 if(!smb_io_unihdr("unihdr", &usr->hdr_profile_path, ps, depth)) /* profile path unicode string header */
1130 return False;
1131 if(!smb_io_unihdr("unihdr", &usr->hdr_home_dir, ps, depth)) /* home directory unicode string header */
1132 return False;
1133 if(!smb_io_unihdr("unihdr", &usr->hdr_dir_drive, ps, depth)) /* home directory drive unicode string header */
1134 return False;
1135
1136 if(!prs_uint16("logon_count ", ps, depth, &usr->logon_count)) /* logon count */
1137 return False;
1138 if(!prs_uint16("bad_pw_count ", ps, depth, &usr->bad_pw_count)) /* bad password count */
1139 return False;
1140
1141 if(!prs_uint32("user_id ", ps, depth, &usr->user_id)) /* User ID */
1142 return False;
1143 if(!prs_uint32("group_id ", ps, depth, &usr->group_id)) /* Group ID */
1144 return False;
1145 if(!prs_uint32("num_groups ", ps, depth, &usr->num_groups)) /* num groups */
1146 return False;
1147 if(!prs_uint32("buffer_groups ", ps, depth, &usr->buffer_groups)) /* undocumented buffer pointer to groups. */
1148 return False;
1149 if(!prs_uint32("user_flgs ", ps, depth, &usr->user_flgs)) /* user flags */
1150 return False;
1151
1152 if(!prs_uint8s(False, "user_sess_key", ps, depth, usr->user_sess_key, 16)) /* unused user session key */
1153 return False;
1154
1155 if(!smb_io_unihdr("unihdr", &usr->hdr_logon_srv, ps, depth)) /* logon server unicode string header */
1156 return False;
1157 if(!smb_io_unihdr("unihdr", &usr->hdr_logon_dom, ps, depth)) /* logon domain unicode string header */
1158 return False;
1159
1160 if(!prs_uint32("buffer_dom_id ", ps, depth, &usr->buffer_dom_id)) /* undocumented logon domain id pointer */
1161 return False;
1162 if(!prs_uint8s (False, "padding ", ps, depth, usr->padding, 40)) /* unused padding bytes? */
1163 return False;
1164
1165 if(!prs_uint32("num_other_sids", ps, depth, &usr->num_other_sids)) /* 0 - num_sids */
1166 return False;
1167 if(!prs_uint32("buffer_other_sids", ps, depth, &usr->buffer_other_sids)) /* NULL - undocumented pointer to SIDs. */
1168 return False;
1169
1170 if(!smb_io_unistr2("unistr2", &usr->uni_user_name, usr->hdr_user_name.buffer, ps, depth)) /* username unicode string */
1171 return False;
1172 if(!smb_io_unistr2("unistr2", &usr->uni_full_name, usr->hdr_full_name.buffer, ps, depth)) /* user's full name unicode string */
1173 return False;
1174 if(!smb_io_unistr2("unistr2", &usr->uni_logon_script, usr->hdr_logon_script.buffer, ps, depth)) /* logon script unicode string */
1175 return False;
1176 if(!smb_io_unistr2("unistr2", &usr->uni_profile_path, usr->hdr_profile_path.buffer, ps, depth)) /* profile path unicode string */
1177 return False;
1178 if(!smb_io_unistr2("unistr2", &usr->uni_home_dir, usr->hdr_home_dir.buffer, ps, depth)) /* home directory unicode string */
1179 return False;
1180 if(!smb_io_unistr2("unistr2", &usr->uni_dir_drive, usr->hdr_dir_drive.buffer, ps, depth)) /* home directory drive unicode string */
1181 return False;
1182
1183 if(!prs_align(ps))
1184 return False;
1185 if(!prs_uint32("num_groups2 ", ps, depth, &usr->num_groups2)) /* num groups */
1186 return False;
1187 SMB_ASSERT_ARRAY(usr->gids, usr->num_groups2);
1188 for (i = 0; i < usr->num_groups2; i++) {
1189 if(!smb_io_gid("", &usr->gids[i], ps, depth)) /* group info */
1190 return False;
1191 }
1192
1193 if(!smb_io_unistr2("unistr2", &usr->uni_logon_srv, usr->hdr_logon_srv.buffer, ps, depth)) /* logon server unicode string */
1194 return False;
1195 if(!smb_io_unistr2("unistr2", &usr->uni_logon_dom, usr->hdr_logon_srv.buffer, ps, depth)) /* logon domain unicode string */
1196 return False;
1197
1198 if(!smb_io_dom_sid2("", &usr->dom_sid, ps, depth)) /* domain SID */
1199 return False;
1200
1201 SMB_ASSERT_ARRAY(usr->other_sids, usr->num_other_sids);
1202
1203 for (i = 0; i < usr->num_other_sids; i++) {
1204 if(!smb_io_dom_sid2("", &usr->other_sids[i], ps, depth)) /* other domain SIDs */
1205 return False;
1206 }
1207
1208 return True;
1209 }
1210
1211 /*******************************************************************
1212 Reads or writes a structure.
1213 ********************************************************************/
1214
1215 BOOL net_io_q_sam_logon(char *desc, NET_Q_SAM_LOGON *q_l, prs_struct *ps, int depth)
1216 {
1217 if (q_l == NULL)
1218 return False;
1219
1220 prs_debug(ps, depth, desc, "net_io_q_sam_logon");
1221 depth++;
1222
1223 if(!prs_align(ps))
1224 return False;
1225
1226 if(!smb_io_sam_info("", &q_l->sam_id, ps, depth)) /* domain SID */
1227 return False;
1228
1229 if(!prs_uint16("validation_level", ps, depth, &q_l->validation_level))
1230 return False;
1231
1232 return True;
1233 }
1234
1235 /*******************************************************************
1236 Reads or writes a structure.
1237 ********************************************************************/
1238
1239 BOOL net_io_r_sam_logon(char *desc, NET_R_SAM_LOGON *r_l, prs_struct *ps, int depth)
1240 {
1241 if (r_l == NULL)
1242 return False;
1243
1244 prs_debug(ps, depth, desc, "net_io_r_sam_logon");
1245 depth++;
1246
1247 if(!prs_uint32("buffer_creds", ps, depth, &r_l->buffer_creds)) /* undocumented buffer pointer */
1248 return False;
1249 if(!smb_io_cred("", &r_l->srv_creds, ps, depth)) /* server credentials. server time stamp appears to be ignored. */
1250 return False;
1251
1252 if(!prs_uint16("switch_value", ps, depth, &r_l->switch_value))
1253 return False;
1254 if(!prs_align(ps))
1255 return False;
1256
1257 if (r_l->switch_value != 0) {
1258 if(!net_io_user_info3("", r_l->user, ps, depth))
1259 return False;
1260 }
1261
1262 if(!prs_uint32("auth_resp ", ps, depth, &r_l->auth_resp)) /* 1 - Authoritative response; 0 - Non-Auth? */
1263 return False;
1264
1265 if(!prs_uint32("status ", ps, depth, &r_l->status))
1266 return False;
1267
1268 if(!prs_align(ps))
1269 return False;
1270
1271 return True;
1272 }
1273
1274 /*******************************************************************
1275 Reads or writes a structure.
1276 ********************************************************************/
1277
1278 BOOL net_io_q_sam_logoff(char *desc, NET_Q_SAM_LOGOFF *q_l, prs_struct *ps, int depth)
1279 {
1280 if (q_l == NULL)
1281 return False;
1282
1283 prs_debug(ps, depth, desc, "net_io_q_sam_logoff");
1284 depth++;
1285
1286 if(!prs_align(ps))
1287 return False;
1288
1289 if(!smb_io_sam_info("", &q_l->sam_id, ps, depth)) /* domain SID */
1290 return False;
1291
1292 return True;
1293 }
1294
1295 /*******************************************************************
1296 Reads or writes a structure.
1297 ********************************************************************/
1298
1299 BOOL net_io_r_sam_logoff(char *desc, NET_R_SAM_LOGOFF *r_l, prs_struct *ps, int depth)
1300 {
1301 if (r_l == NULL)
1302 return False;
1303
1304 prs_debug(ps, depth, desc, "net_io_r_sam_logoff");
1305 depth++;
1306
1307 if(!prs_align(ps))
1308 return False;
1309
1310 if(!prs_uint32("buffer_creds", ps, depth, &r_l->buffer_creds)) /* undocumented buffer pointer */
1311 return False;
1312 if(!smb_io_cred("", &r_l->srv_creds, ps, depth)) /* server credentials. server time stamp appears to be ignored. */
1313 return False;
1314
1315 if(!prs_uint32("status ", ps, depth, &r_l->status))
1316 return False;
1317
1318 return True;
1319 }