Changes from APPLIANCE_HEAD:
[ira/wip.git] / source3 / smbd / password.c
1 #define OLD_NTDOMAIN 1
2
3 /* 
4    Unix SMB/Netbios implementation.
5    Version 1.9.
6    Password and authentication handling
7    Copyright (C) Andrew Tridgell 1992-1998
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 extern int DEBUGLEVEL;
27 extern int Protocol;
28 extern struct in_addr ipzero;
29
30 /* users from session setup */
31 static pstring session_users="";
32
33 extern pstring global_myname;
34 extern fstring global_myworkgroup;
35
36 /* Data to do lanman1/2 password challenge. */
37 static unsigned char saved_challenge[8];
38 static BOOL challenge_sent=False;
39
40 /*******************************************************************
41 Get the next challenge value - no repeats.
42 ********************************************************************/
43 void generate_next_challenge(char *challenge)
44 {
45 #if 0
46         /* 
47          * Leave this ifdef'd out while we test
48          * the new crypto random number generator.
49          * JRA.
50          */
51         unsigned char buf[16];
52         static int counter = 0;
53         struct timeval tval;
54         int v1,v2;
55
56         /* get a sort-of random number */
57         GetTimeOfDay(&tval);
58         v1 = (counter++) + sys_getpid() + tval.tv_sec;
59         v2 = (counter++) * sys_getpid() + tval.tv_usec;
60         SIVAL(challenge,0,v1);
61         SIVAL(challenge,4,v2);
62
63         /* mash it up with md4 */
64         mdfour(buf, (unsigned char *)challenge, 8);
65 #else
66         unsigned char buf[8];
67
68         generate_random_buffer(buf,8,False);
69 #endif 
70         memcpy(saved_challenge, buf, 8);
71         memcpy(challenge,buf,8);
72         challenge_sent = True;
73 }
74
75 /*******************************************************************
76 set the last challenge sent, usually from a password server
77 ********************************************************************/
78 BOOL set_challenge(unsigned char *challenge)
79 {
80   memcpy(saved_challenge,challenge,8);
81   challenge_sent = True;
82   return(True);
83 }
84
85 /*******************************************************************
86 get the last challenge sent
87 ********************************************************************/
88 static BOOL last_challenge(unsigned char *challenge)
89 {
90   if (!challenge_sent) return(False);
91   memcpy(challenge,saved_challenge,8);
92   return(True);
93 }
94
95 /* this holds info on user ids that are already validated for this VC */
96 static user_struct *validated_users;
97 static int next_vuid = VUID_OFFSET;
98 static int num_validated_vuids;
99
100 /****************************************************************************
101 check if a uid has been validated, and return an pointer to the user_struct
102 if it has. NULL if not. vuid is biased by an offset. This allows us to
103 tell random client vuid's (normally zero) from valid vuids.
104 ****************************************************************************/
105 user_struct *get_valid_user_struct(uint16 vuid)
106 {
107         user_struct *usp;
108         int count=0;
109
110         if (vuid == UID_FIELD_INVALID)
111                 return NULL;
112
113         for (usp=validated_users;usp;usp=usp->next,count++) {
114                 if (vuid == usp->vuid) {
115                         if (count > 10)
116                 DLIST_PROMOTE(validated_users, usp);
117                         return usp;
118                 }
119         }
120
121         return NULL;
122 }
123
124 /****************************************************************************
125 invalidate a uid
126 ****************************************************************************/
127 void invalidate_vuid(uint16 vuid)
128 {
129         user_struct *vuser = get_valid_user_struct(vuid);
130
131         if (vuser == NULL)
132                 return;
133
134         DLIST_REMOVE(validated_users, vuser);
135
136         safe_free(vuser->groups);
137         delete_nt_token(&vuser->nt_user_token);
138         safe_free(vuser);
139         num_validated_vuids--;
140 }
141
142 /****************************************************************************
143 return a validated username
144 ****************************************************************************/
145 char *validated_username(uint16 vuid)
146 {
147         user_struct *vuser = get_valid_user_struct(vuid);
148         if (vuser == NULL)
149                 return 0;
150         return(vuser->user.unix_name);
151 }
152
153 /****************************************************************************
154 return a validated domain
155 ****************************************************************************/
156 char *validated_domain(uint16 vuid)
157 {
158         user_struct *vuser = get_valid_user_struct(vuid);
159         if (vuser == NULL)
160                 return 0;
161         return(vuser->user.domain);
162 }
163
164
165 /****************************************************************************
166  Create the SID list for this user.
167 ****************************************************************************/
168
169 NT_USER_TOKEN *create_nt_token(uid_t uid, gid_t gid, int ngroups, gid_t *groups, BOOL is_guest)
170 {
171         extern DOM_SID global_sid_World;
172         extern DOM_SID global_sid_Network;
173         extern DOM_SID global_sid_Builtin_Guests;
174         extern DOM_SID global_sid_Authenticated_Users;
175         NT_USER_TOKEN *token;
176         DOM_SID *psids;
177         int i, psid_ndx = 0;
178         size_t num_sids = 0;
179         fstring sid_str;
180
181         if ((token = (NT_USER_TOKEN *)malloc( sizeof(NT_USER_TOKEN) ) ) == NULL)
182                 return NULL;
183
184         ZERO_STRUCTP(token);
185
186         /* We always have uid/gid plus World and Network and Authenticated Users or Guest SIDs. */
187         num_sids = 5 + ngroups;
188
189         if ((token->user_sids = (DOM_SID *)malloc( num_sids*sizeof(DOM_SID))) == NULL) {
190                 free(token);
191                 return NULL;
192         }
193
194         psids = token->user_sids;
195
196         /*
197          * Note - user SID *MUST* be first in token !
198          * se_access_check depends on this.
199          */
200
201         uid_to_sid( &psids[psid_ndx++], uid);
202
203         /*
204          * Primary group SID is second in token. Convention.
205          */
206
207         gid_to_sid( &psids[psid_ndx++], gid);
208
209         /* Now add the group SIDs. */
210
211         for (i = 0; i < ngroups; i++) {
212                 if (groups[i] != gid) {
213                         gid_to_sid( &psids[psid_ndx++], groups[i]);
214                 }
215         }
216
217         /*
218          * Finally add the "standard" SIDs.
219          * The only difference between guest and "anonymous" (which we
220          * don't really support) is the addition of Authenticated_Users.
221          */
222
223         sid_copy( &psids[psid_ndx++], &global_sid_World);
224         sid_copy( &psids[psid_ndx++], &global_sid_Network);
225
226         if (is_guest)
227                 sid_copy( &psids[psid_ndx++], &global_sid_Builtin_Guests);
228         else
229                 sid_copy( &psids[psid_ndx++], &global_sid_Authenticated_Users);
230
231         token->num_sids = psid_ndx;
232
233         /* Dump list of sids in token */
234
235         for (i = 0; i < token->num_sids; i++) {
236                 DEBUG(5, ("user token sid %s\n", 
237                           sid_to_string(sid_str, &token->user_sids[i])));
238         }
239
240         return token;
241 }
242
243 /****************************************************************************
244 register a uid/name pair as being valid and that a valid password
245 has been given. vuid is biased by an offset. This allows us to
246 tell random client vuid's (normally zero) from valid vuids.
247 ****************************************************************************/
248
249 uint16 register_vuid(uid_t uid,gid_t gid, char *unix_name, char *requested_name, 
250                      char *domain,BOOL guest)
251 {
252         user_struct *vuser = NULL;
253         struct passwd *pwfile; /* for getting real name from passwd file */
254
255         /* Ensure no vuid gets registered in share level security. */
256         if(lp_security() == SEC_SHARE)
257                 return UID_FIELD_INVALID;
258
259         /* Limit allowed vuids to 16bits - VUID_OFFSET. */
260         if (num_validated_vuids >= 0xFFFF-VUID_OFFSET)
261                 return UID_FIELD_INVALID;
262
263         if((vuser = (user_struct *)malloc( sizeof(user_struct) )) == NULL) {
264                 DEBUG(0,("Failed to malloc users struct!\n"));
265                 return UID_FIELD_INVALID;
266         }
267
268         ZERO_STRUCTP(vuser);
269
270         DEBUG(10,("register_vuid: (%u,%u) %s %s %s guest=%d\n", (unsigned int)uid, (unsigned int)gid,
271                                 unix_name, requested_name, domain, guest ));
272
273         /* Allocate a free vuid. Yes this is a linear search... :-) */
274         while( get_valid_user_struct(next_vuid) != NULL ) {
275                 next_vuid++;
276                 /* Check for vuid wrap. */
277                 if (next_vuid == UID_FIELD_INVALID)
278                         next_vuid = VUID_OFFSET;
279         }
280
281         DEBUG(10,("register_vuid: allocated vuid = %u\n", (unsigned int)next_vuid ));
282
283         vuser->vuid = next_vuid;
284         vuser->uid = uid;
285         vuser->gid = gid;
286         vuser->guest = guest;
287         fstrcpy(vuser->user.unix_name,unix_name);
288         fstrcpy(vuser->user.smb_name,requested_name);
289         fstrcpy(vuser->user.domain,domain);
290
291         vuser->n_groups = 0;
292         vuser->groups  = NULL;
293
294         /* Find all the groups this uid is in and store them. 
295                 Used by become_user() */
296         initialise_groups(unix_name, uid, gid);
297         get_current_groups( &vuser->n_groups, &vuser->groups);
298
299         /* Create an NT_USER_TOKEN struct for this user. */
300         vuser->nt_user_token = create_nt_token(uid,gid, vuser->n_groups, vuser->groups, guest);
301
302         next_vuid++;
303         num_validated_vuids++;
304
305         DLIST_ADD(validated_users, vuser);
306
307         DEBUG(3,("uid %d registered to name %s\n",(int)uid,unix_name));
308
309         DEBUG(3, ("Clearing default real name\n"));
310         fstrcpy(vuser->user.full_name, "<Full Name>");
311         if (lp_unix_realname()) {
312                 if ((pwfile=sys_getpwnam(vuser->user.unix_name))!= NULL) {
313                         DEBUG(3, ("User name: %s\tReal name: %s\n",vuser->user.unix_name,pwfile->pw_gecos));
314                         fstrcpy(vuser->user.full_name, pwfile->pw_gecos);
315                 }
316         }
317
318         memset(&vuser->dc, '\0', sizeof(vuser->dc));
319
320         return vuser->vuid;
321 }
322
323
324 /****************************************************************************
325 add a name to the session users list
326 ****************************************************************************/
327 void add_session_user(char *user)
328 {
329   fstring suser;
330   StrnCpy(suser,user,sizeof(suser)-1);
331
332   if (!Get_Pwnam(suser,True)) return;
333
334   if (suser && *suser && !in_list(suser,session_users,False))
335     {
336       if (strlen(suser) + strlen(session_users) + 2 >= sizeof(pstring))
337         DEBUG(1,("Too many session users??\n"));
338       else
339         {
340           pstrcat(session_users," ");
341           pstrcat(session_users,suser);
342         }
343     }
344 }
345
346
347 /****************************************************************************
348 update the encrypted smbpasswd file from the plaintext username and password
349 *****************************************************************************/
350 static BOOL update_smbpassword_file(char *user, char *password)
351 {
352         SAM_ACCOUNT     *sampass = NULL;
353         BOOL            ret;
354         
355         become_root();
356         sampass = pdb_getsampwnam(user);
357         unbecome_root();
358
359         if(sampass == NULL) {
360                 DEBUG(0,("pdb_getsampwnam returned NULL\n"));
361                 return False;
362         }
363
364         /*
365          * Remove the account disabled flag - we are updating the
366          * users password from a login.
367          */
368         pdb_set_acct_ctrl(sampass, pdb_get_acct_ctrl(sampass) & ~ACB_DISABLED);
369
370         /* Here, the flag is one, because we want to ignore the
371            XXXXXXX'd out password */
372         ret = change_oem_password( sampass, password, True);
373         if (ret == False) {
374                 DEBUG(3,("change_oem_password returned False\n"));
375         }
376
377         return ret;
378 }
379
380 /****************************************************************************
381 core of smb password checking routine.
382 ****************************************************************************/
383 BOOL smb_password_check(char *password, unsigned char *part_passwd, unsigned char *c8)
384 {
385   /* Finish the encryption of part_passwd. */
386   unsigned char p21[21];
387   unsigned char p24[24];
388
389   if (part_passwd == NULL) 
390   {
391     DEBUG(10,("No password set - allowing access\n"));
392
393     /* No password set - always true ! */
394     return 1;
395   }
396
397   memset(p21,'\0',21);
398   memcpy(p21,part_passwd,16);
399   E_P24(p21, c8, p24);
400 #if DEBUG_PASSWORD
401   {
402     int i;
403     DEBUG(100,("Part password (P16) was |"));
404     for(i = 0; i < 16; i++)
405       DEBUG(100,("%X ", (unsigned char)part_passwd[i]));
406     DEBUG(100,("|\n"));
407     DEBUG(100,("Password from client was |"));
408     for(i = 0; i < 24; i++)
409       DEBUG(100,("%X ", (unsigned char)password[i]));
410     DEBUG(100,("|\n"));
411     DEBUG(100,("Given challenge was |"));
412     for(i = 0; i < 8; i++)
413       DEBUG(100,("%X ", (unsigned char)c8[i]));
414     DEBUG(100,("|\n"));
415     DEBUG(100,("Value from encryption was |"));
416     for(i = 0; i < 24; i++)
417       DEBUG(100,("%X ", (unsigned char)p24[i]));
418     DEBUG(100,("|\n"));
419   }
420 #endif
421   return (memcmp(p24, password, 24) == 0);
422 }
423
424 /****************************************************************************
425  Do a specific test for an smb password being correct, given a smb_password and
426  the lanman and NT responses.
427 ****************************************************************************/
428 BOOL smb_password_ok(SAM_ACCOUNT *sampass, uchar chal[8],
429                      uchar lm_pass[24], uchar nt_pass[24])
430 {
431         uchar challenge[8];
432         char* user_name;
433         BYTE *nt_pw, *lm_pw;
434
435         if (!lm_pass || !sampass) 
436                 return(False);
437
438         user_name = pdb_get_username(sampass);
439         
440         DEBUG(4,("Checking SMB password for user %s\n",user_name));
441
442         if(pdb_get_acct_ctrl(sampass) & ACB_DISABLED) {
443                 DEBUG(1,("account for user %s was disabled.\n", user_name));
444                 return(False);
445         }
446
447         if (chal == NULL)
448         {
449                 DEBUG(5,("use last SMBnegprot challenge\n"));
450                 if (!last_challenge(challenge))
451                 {
452                         DEBUG(1,("no challenge done - password failed\n"));
453                         return False;
454                 }
455         }
456         else
457         {
458                 DEBUG(5,("challenge received\n"));
459                 memcpy(challenge, chal, 8);
460         }
461
462         nt_pw = pdb_get_nt_passwd(sampass);
463         
464         if ((Protocol >= PROTOCOL_NT1) && (nt_pw != NULL)) {
465                 /* We have the NT MD4 hash challenge available - see if we can
466                    use it (ie. does it exist in the smbpasswd file).
467                 */
468                 DEBUG(4,("smb_password_ok: Checking NT MD4 password\n"));
469                 if (smb_password_check((char *)nt_pass, (uchar *)nt_pw, challenge)) 
470                 {
471                         DEBUG(4,("NT MD4 password check succeeded\n"));
472                         return(True);
473                 }
474                 DEBUG(4,("NT MD4 password check failed\n"));
475         }
476
477         /* Try against the lanman password. pdb_get_lanman_passwd(sampass) == NULL 
478            means no password, allow access. */
479
480         DEBUG(4,("Checking LM MD4 password\n"));
481
482         lm_pw = pdb_get_lanman_passwd(sampass);
483         
484         if((lm_pw == NULL) && (pdb_get_acct_ctrl(sampass) & ACB_PWNOTREQ)) 
485         {
486                 DEBUG(4,("no password required for user %s\n",user_name));
487                 return True;
488         }
489
490         if((lm_pw != NULL) && smb_password_check((char *)lm_pass,(uchar *)lm_pw, challenge)) 
491         {
492                 DEBUG(4,("LM MD4 password check succeeded\n"));
493                 return(True);
494         }
495
496         DEBUG(4,("LM MD4 password check failed\n"));
497
498         return False;
499 }
500
501
502 /****************************************************************************
503 check if a username/password is OK assuming the password is a 24 byte
504 SMB hash
505 return True if the password is correct, False otherwise
506 ****************************************************************************/
507
508 BOOL pass_check_smb(char *user, char *domain, uchar *chal, 
509                     uchar *lm_pwd, uchar *nt_pwd, struct passwd *pwd)
510 {
511         struct passwd *pass;
512         SAM_ACCOUNT *sampass;
513
514         if (!lm_pwd || !nt_pwd)
515         {
516                 return(False);
517         }
518
519         /* FIXME! this code looks to be unnecessary now that the passdb
520            validates that the username exists and has a valid uid */
521         if (pwd != NULL && user == NULL)
522         {
523                 pass = (struct passwd *) pwd;
524                 user = pass->pw_name;
525         }
526         else
527         {
528                 /* I don't get this call here.  I think it should be moved.
529                    Need to check on it.     --jerry */
530                 pass = smb_getpwnam(user,True);
531         }
532
533         if (pass == NULL)
534         {
535                 DEBUG(1,("Couldn't find user '%s' in UNIX password database.\n",user));
536                 return(False);
537         }
538
539         /* get the account information */
540         sampass = pdb_getsampwnam(user);
541         if (sampass == NULL)
542         {
543                 DEBUG(1,("Couldn't find user '%s' in passdb file.\n", user));
544                 return(False);
545         }
546
547         /* Quit if the account was disabled. */
548         if(pdb_get_acct_ctrl(sampass) & ACB_DISABLED) {
549                 DEBUG(1,("Account for user '%s' was disabled.\n", user));
550                 return(False);
551         }
552
553         /* Ensure the uid's match 
554            FIXME!  This also seems unnecessary --jerry */
555 #if 0   /* GWC */
556         if (smb_pass->smb_userid != pass->pw_uid)
557         {
558                 DEBUG(0,("Error : UNIX and SMB uids in password files do not match for user '%s'!\n", user));
559                 return(False);
560         }
561 #endif
562
563         if (pdb_get_acct_ctrl(sampass) & ACB_PWNOTREQ) 
564         {
565                 if (lp_null_passwords()) 
566                 {
567                         DEBUG(3,("Account for user '%s' has no password and null passwords are allowed.\n", user));
568                         return(True);
569                 } 
570                 else 
571                 {
572                         DEBUG(3,("Account for user '%s' has no password and null passwords are NOT allowed.\n", user));
573                         return(False);
574                 }               
575         }
576
577         if (smb_password_ok(sampass, chal, lm_pwd, nt_pwd))
578         {
579                 return(True);
580         }
581         
582         DEBUG(2,("pass_check_smb failed - invalid password for user [%s]\n", user));
583         return False;
584 }
585
586 /****************************************************************************
587 check if a username/password pair is OK either via the system password
588 database or the encrypted SMB password database
589 return True if the password is correct, False otherwise
590 ****************************************************************************/
591 BOOL password_ok(char *user, char *password, int pwlen, struct passwd *pwd)
592 {
593         if (pwlen == 24 || (lp_encrypted_passwords() && (pwlen == 0) && lp_null_passwords()))
594         {
595                 /* if 24 bytes long assume it is an encrypted password */
596                 uchar challenge[8];
597
598                 if (!last_challenge(challenge))
599                 {
600                         DEBUG(0,("Error: challenge not done for user=%s\n", user));
601                         return False;
602                 }
603
604                 return pass_check_smb(user, global_myworkgroup,
605                                       challenge, (uchar *)password, (uchar *)password, pwd);
606         } 
607
608         return pass_check(user, password, pwlen, pwd, 
609                           lp_update_encrypted() ? 
610                           update_smbpassword_file : NULL);
611 }
612
613 /****************************************************************************
614 check if a username is valid
615 ****************************************************************************/
616 BOOL user_ok(char *user,int snum)
617 {
618         pstring valid, invalid;
619         BOOL ret;
620
621         StrnCpy(valid, lp_valid_users(snum), sizeof(pstring)-1);
622         StrnCpy(invalid, lp_invalid_users(snum), sizeof(pstring)-1);
623
624         pstring_sub(valid,"%S",lp_servicename(snum));
625         pstring_sub(invalid,"%S",lp_servicename(snum));
626         
627         ret = !user_in_list(user,invalid);
628         
629         if (ret && valid && *valid) {
630                 ret = user_in_list(user,valid);
631         }
632
633         if (ret && lp_onlyuser(snum)) {
634                 char *user_list = lp_username(snum);
635                 pstring_sub(user_list,"%S",lp_servicename(snum));
636                 ret = user_in_list(user,user_list);
637         }
638
639         return(ret);
640 }
641
642
643
644
645 /****************************************************************************
646 validate a group username entry. Return the username or NULL
647 ****************************************************************************/
648 static char *validate_group(char *group,char *password,int pwlen,int snum)
649 {
650 #ifdef HAVE_NETGROUP
651         {
652                 char *host, *user, *domain;
653                 setnetgrent(group);
654                 while (getnetgrent(&host, &user, &domain)) {
655                         if (user) {
656                                 if (user_ok(user, snum) && 
657                                     password_ok(user,password,pwlen,NULL)) {
658                                         endnetgrent();
659                                         return(user);
660                                 }
661                         }
662                 }
663                 endnetgrent();
664         }
665 #endif
666   
667 #ifdef HAVE_GETGRENT
668         {
669                 struct group *gptr;
670                 setgrent();
671                 while ((gptr = (struct group *)getgrent())) {
672                         if (strequal(gptr->gr_name,group))
673                                 break;
674                 }
675
676                 /*
677                  * As user_ok can recurse doing a getgrent(), we must
678                  * copy the member list into a pstring on the stack before
679                  * use. Bug pointed out by leon@eatworms.swmed.edu.
680                  */
681
682                 if (gptr) {
683                         pstring member_list;
684                         char *member;
685                         size_t copied_len = 0;
686                         int i;
687
688                         *member_list = '\0';
689                         member = member_list;
690
691                         for(i = 0; gptr->gr_mem && gptr->gr_mem[i]; i++) {
692                                 size_t member_len = strlen(gptr->gr_mem[i]) + 1;
693                                 if( copied_len + member_len < sizeof(pstring)) { 
694
695                                         DEBUG(10,("validate_group: = gr_mem = %s\n", gptr->gr_mem[i]));
696
697                                         safe_strcpy(member, gptr->gr_mem[i], sizeof(pstring) - copied_len - 1);
698                                         copied_len += member_len;
699                                         member += copied_len;
700                                 } else {
701                                         *member = '\0';
702                                 }
703                         }
704
705                         endgrent();
706
707                         member = member_list;
708                         while (*member) {
709                                 static fstring name;
710                                 fstrcpy(name,member);
711                                 if (user_ok(name,snum) &&
712                                     password_ok(name,password,pwlen,NULL)) {
713                                         endgrent();
714                                         return(&name[0]);
715                                 }
716
717                                 DEBUG(10,("validate_group = member = %s\n", member));
718
719                                 member += strlen(member) + 1;
720                         }
721                 } else {
722                         endgrent();
723                         return NULL;
724                 }
725         }
726 #endif
727         return(NULL);
728 }
729
730
731
732 /****************************************************************************
733 check for authority to login to a service with a given username/password
734 ****************************************************************************/
735 BOOL authorise_login(int snum,char *user,char *password, int pwlen, 
736                      BOOL *guest,BOOL *force,uint16 vuid)
737 {
738   BOOL ok = False;
739   
740   *guest = False;
741   
742 #if DEBUG_PASSWORD
743   DEBUG(100,("checking authorisation on user=%s pass=%s\n",user,password));
744 #endif
745
746   /* there are several possibilities:
747      1) login as the given user with given password
748      2) login as a previously registered username with the given password
749      3) login as a session list username with the given password
750      4) login as a previously validated user/password pair
751      5) login as the "user =" user with given password
752      6) login as the "user =" user with no password (guest connection)
753      7) login as guest user with no password
754
755      if the service is guest_only then steps 1 to 5 are skipped
756   */
757
758   if (GUEST_ONLY(snum)) *force = True;
759
760   if (!(GUEST_ONLY(snum) && GUEST_OK(snum)))
761     {
762
763       user_struct *vuser = get_valid_user_struct(vuid);
764
765       /* check the given username and password */
766       if (!ok && (*user) && user_ok(user,snum)) {
767         ok = password_ok(user,password, pwlen, NULL);
768         if (ok) DEBUG(3,("ACCEPTED: given username password ok\n"));
769       }
770
771       /* check for a previously registered guest username */
772       if (!ok && (vuser != 0) && vuser->guest) {          
773         if (user_ok(vuser->user.unix_name,snum) &&
774             password_ok(vuser->user.unix_name, password, pwlen, NULL)) {
775           fstrcpy(user, vuser->user.unix_name);
776           vuser->guest = False;
777           DEBUG(3,("ACCEPTED: given password with registered user %s\n", user));
778           ok = True;
779         }
780       }
781
782
783       /* now check the list of session users */
784     if (!ok)
785     {
786       char *auser;
787       char *user_list = strdup(session_users);
788       if (!user_list) return(False);
789
790       for (auser=strtok(user_list,LIST_SEP); 
791            !ok && auser; 
792            auser = strtok(NULL,LIST_SEP))
793       {
794         fstring user2;
795         fstrcpy(user2,auser);
796         if (!user_ok(user2,snum)) continue;
797                   
798         if (password_ok(user2,password, pwlen, NULL)) {
799           ok = True;
800           fstrcpy(user,user2);
801           DEBUG(3,("ACCEPTED: session list username and given password ok\n"));
802         }
803       }
804       free(user_list);
805     }
806
807     /* check for a previously validated username/password pair */
808     if (!ok && (lp_security() > SEC_SHARE) &&
809         (vuser != 0) && !vuser->guest &&
810         user_ok(vuser->user.unix_name,snum)) {
811       fstrcpy(user,vuser->user.unix_name);
812       *guest = False;
813       DEBUG(3,("ACCEPTED: validated uid ok as non-guest\n"));
814       ok = True;
815     }
816
817       /* check for a rhosts entry */
818       if (!ok && user_ok(user,snum) && check_hosts_equiv(user)) {
819         ok = True;
820         DEBUG(3,("ACCEPTED: hosts equiv or rhosts entry\n"));
821       }
822
823       /* check the user= fields and the given password */
824       if (!ok && lp_username(snum)) {
825         char *auser;
826         pstring user_list;
827         StrnCpy(user_list,lp_username(snum),sizeof(pstring));
828
829         pstring_sub(user_list,"%S",lp_servicename(snum));
830           
831         for (auser=strtok(user_list,LIST_SEP);
832              auser && !ok;
833              auser = strtok(NULL,LIST_SEP))
834           {
835             if (*auser == '@')
836               {
837                 auser = validate_group(auser+1,password,pwlen,snum);
838                 if (auser)
839                   {
840                     ok = True;
841                     fstrcpy(user,auser);
842                     DEBUG(3,("ACCEPTED: group username and given password ok\n"));
843                   }
844               }
845             else
846               {
847                 fstring user2;
848                 fstrcpy(user2,auser);
849                 if (user_ok(user2,snum) && 
850                     password_ok(user2,password,pwlen,NULL))
851                   {
852                     ok = True;
853                     fstrcpy(user,user2);
854                     DEBUG(3,("ACCEPTED: user list username and given password ok\n"));
855                   }
856               }
857           }
858       }      
859     } /* not guest only */
860
861   /* check for a normal guest connection */
862   if (!ok && GUEST_OK(snum))
863     {
864       fstring guestname;
865       StrnCpy(guestname,lp_guestaccount(snum),sizeof(guestname)-1);
866       if (Get_Pwnam(guestname,True))
867         {
868           fstrcpy(user,guestname);
869           ok = True;
870           DEBUG(3,("ACCEPTED: guest account and guest ok\n"));
871         }
872       else
873         DEBUG(0,("Invalid guest account %s??\n",guestname));
874       *guest = True;
875     }
876
877   if (ok && !user_ok(user,snum))
878     {
879       DEBUG(0,("rejected invalid user %s\n",user));
880       ok = False;
881     }
882
883   return(ok);
884 }
885
886
887 /****************************************************************************
888 read the a hosts.equiv or .rhosts file and check if it
889 allows this user from this machine
890 ****************************************************************************/
891 static BOOL check_user_equiv(char *user, char *remote, char *equiv_file)
892 {
893   int plus_allowed = 1;
894   char *file_host;
895   char *file_user;
896   char **lines = file_lines_load(equiv_file, NULL, False);
897   int i;
898
899   DEBUG(5, ("check_user_equiv %s %s %s\n", user, remote, equiv_file));
900   if (! lines) return False;
901   for (i=0; lines[i]; i++) {
902     char *buf = lines[i];
903     trim_string(buf," "," ");
904
905     if (buf[0] != '#' && buf[0] != '\n') 
906     {
907       BOOL is_group = False;
908       int plus = 1;
909       char *bp = buf;
910       if (strcmp(buf, "NO_PLUS\n") == 0)
911       {
912         DEBUG(6, ("check_user_equiv NO_PLUS\n"));
913         plus_allowed = 0;
914       }
915       else {
916         if (buf[0] == '+') 
917         {
918           bp++;
919           if (*bp == '\n' && plus_allowed) 
920           {
921             /* a bare plus means everbody allowed */
922             DEBUG(6, ("check_user_equiv everybody allowed\n"));
923             file_lines_free(lines);
924             return True;
925           }
926         }
927         else if (buf[0] == '-')
928         {
929           bp++;
930           plus = 0;
931         }
932         if (*bp == '@') 
933         {
934           is_group = True;
935           bp++;
936         }
937         file_host = strtok(bp, " \t\n");
938         file_user = strtok(NULL, " \t\n");
939         DEBUG(7, ("check_user_equiv %s %s\n", file_host ? file_host : "(null)", 
940                  file_user ? file_user : "(null)" ));
941         if (file_host && *file_host) 
942         {
943           BOOL host_ok = False;
944
945 #if defined(HAVE_NETGROUP) && defined(HAVE_YP_GET_DEFAULT_DOMAIN)
946           if (is_group)
947             {
948               static char *mydomain = NULL;
949               if (!mydomain)
950                 yp_get_default_domain(&mydomain);
951               if (mydomain && innetgr(file_host,remote,user,mydomain))
952                 host_ok = True;
953             }
954 #else
955           if (is_group)
956             {
957               DEBUG(1,("Netgroups not configured\n"));
958               continue;
959             }
960 #endif
961
962           /* is it this host */
963           /* the fact that remote has come from a call of gethostbyaddr
964            * means that it may have the fully qualified domain name
965            * so we could look up the file version to get it into
966            * a canonical form, but I would rather just type it
967            * in full in the equiv file
968            */
969           if (!host_ok && !is_group && strequal(remote, file_host))
970             host_ok = True;
971
972           if (!host_ok)
973             continue;
974
975           /* is it this user */
976           if (file_user == 0 || strequal(user, file_user)) 
977             {
978               DEBUG(5, ("check_user_equiv matched %s%s %s\n",
979                         (plus ? "+" : "-"), file_host,
980                         (file_user ? file_user : "")));
981               file_lines_free(lines);
982               return (plus ? True : False);
983             }
984         }
985       }
986     }
987   }
988   file_lines_free(lines);
989   return False;
990 }
991
992
993 /****************************************************************************
994 check for a possible hosts equiv or rhosts entry for the user
995 ****************************************************************************/
996 BOOL check_hosts_equiv(char *user)
997 {
998   char *fname = NULL;
999   pstring rhostsfile;
1000   struct passwd *pass = Get_Pwnam(user,True);
1001
1002   if (!pass) 
1003     return(False);
1004
1005   fname = lp_hosts_equiv();
1006
1007   /* note: don't allow hosts.equiv on root */
1008   if (fname && *fname && (pass->pw_uid != 0)) {
1009           if (check_user_equiv(user,client_name(),fname))
1010                   return(True);
1011   }
1012   
1013   if (lp_use_rhosts())
1014     {
1015       char *home = get_user_home_dir(user);
1016       if (home) {
1017               slprintf(rhostsfile, sizeof(rhostsfile)-1, "%s/.rhosts", home);
1018               if (check_user_equiv(user,client_name(),rhostsfile))
1019                       return(True);
1020       }
1021     }
1022
1023   return(False);
1024 }
1025
1026
1027 /****************************************************************************
1028  Return the client state structure.
1029 ****************************************************************************/
1030
1031 struct cli_state *server_client(void)
1032 {
1033         static struct cli_state pw_cli;
1034         return &pw_cli;
1035 }
1036
1037 /****************************************************************************
1038  Support for server level security.
1039 ****************************************************************************/
1040
1041 struct cli_state *server_cryptkey(void)
1042 {
1043         struct cli_state *cli;
1044         fstring desthost;
1045         struct in_addr dest_ip;
1046         char *p, *pserver;
1047         BOOL connected_ok = False;
1048
1049         cli = server_client();
1050
1051         if (!cli_initialise(cli))
1052                 return NULL;
1053
1054         pserver = strdup(lp_passwordserver());
1055         p = pserver;
1056
1057         while(next_token( &p, desthost, LIST_SEP, sizeof(desthost))) {
1058                 standard_sub_basic(desthost);
1059                 strupper(desthost);
1060
1061                 if(!resolve_name( desthost, &dest_ip, 0x20)) {
1062                         DEBUG(1,("server_cryptkey: Can't resolve address for %s\n",desthost));
1063                         continue;
1064                 }
1065
1066                 if (ismyip(dest_ip)) {
1067                         DEBUG(1,("Password server loop - disabling password server %s\n",desthost));
1068                         continue;
1069                 }
1070
1071                 if (cli_connect(cli, desthost, &dest_ip)) {
1072                         DEBUG(3,("connected to password server %s\n",desthost));
1073                         connected_ok = True;
1074                         break;
1075                 }
1076         }
1077
1078         free(pserver);
1079
1080         if (!connected_ok) {
1081                 DEBUG(0,("password server not available\n"));
1082                 cli_shutdown(cli);
1083                 return NULL;
1084         }
1085
1086         if (!attempt_netbios_session_request(cli, global_myname, desthost, &dest_ip))
1087                 return NULL;
1088
1089         DEBUG(3,("got session\n"));
1090
1091         if (!cli_negprot(cli)) {
1092                 DEBUG(1,("%s rejected the negprot\n",desthost));
1093                 cli_shutdown(cli);
1094                 return NULL;
1095         }
1096
1097         if (cli->protocol < PROTOCOL_LANMAN2 ||
1098             !(cli->sec_mode & 1)) {
1099                 DEBUG(1,("%s isn't in user level security mode\n",desthost));
1100                 cli_shutdown(cli);
1101                 return NULL;
1102         }
1103
1104         DEBUG(3,("password server OK\n"));
1105
1106         return cli;
1107 }
1108
1109 /****************************************************************************
1110  Validate a password with the password server.
1111 ****************************************************************************/
1112
1113 BOOL server_validate(char *user, char *domain, 
1114                      char *pass, int passlen,
1115                      char *ntpass, int ntpasslen)
1116 {
1117   struct cli_state *cli;
1118   static unsigned char badpass[24];
1119   static BOOL tested_password_server = False;
1120   static BOOL bad_password_server = False;
1121
1122   cli = server_client();
1123
1124   if (!cli->initialised) {
1125     DEBUG(1,("password server %s is not connected\n", cli->desthost));
1126     return(False);
1127   }  
1128
1129   if(badpass[0] == 0)
1130     memset(badpass, 0x1f, sizeof(badpass));
1131
1132   if((passlen == sizeof(badpass)) && !memcmp(badpass, pass, passlen)) {
1133     /* 
1134      * Very unlikely, our random bad password is the same as the users
1135      * password. */
1136     memset(badpass, badpass[0]+1, sizeof(badpass));
1137   }
1138
1139   /*
1140    * Attempt a session setup with a totally incorrect password.
1141    * If this succeeds with the guest bit *NOT* set then the password
1142    * server is broken and is not correctly setting the guest bit. We
1143    * need to detect this as some versions of NT4.x are broken. JRA.
1144    */
1145
1146   if(!tested_password_server) {
1147     if (cli_session_setup(cli, user, (char *)badpass, sizeof(badpass), 
1148                               (char *)badpass, sizeof(badpass), domain)) {
1149
1150       /*
1151        * We connected to the password server so we
1152        * can say we've tested it.
1153        */
1154       tested_password_server = True;
1155
1156       if ((SVAL(cli->inbuf,smb_vwv2) & 1) == 0) {
1157         DEBUG(0,("server_validate: password server %s allows users as non-guest \
1158 with a bad password.\n", cli->desthost));
1159         DEBUG(0,("server_validate: This is broken (and insecure) behaviour. Please do not \
1160 use this machine as the password server.\n"));
1161         cli_ulogoff(cli);
1162
1163         /*
1164          * Password server has the bug.
1165          */
1166         bad_password_server = True;
1167         return False;
1168       }
1169       cli_ulogoff(cli);
1170     }
1171   } else {
1172
1173     /*
1174      * We have already tested the password server.
1175      * Fail immediately if it has the bug.
1176      */
1177
1178     if(bad_password_server) {
1179       DEBUG(0,("server_validate: [1] password server %s allows users as non-guest \
1180 with a bad password.\n", cli->desthost));
1181       DEBUG(0,("server_validate: [1] This is broken (and insecure) behaviour. Please do not \
1182 use this machine as the password server.\n"));
1183       return False;
1184     }
1185   }
1186
1187   /*
1188    * Now we know the password server will correctly set the guest bit, or is
1189    * not guest enabled, we can try with the real password.
1190    */
1191
1192   if (!cli_session_setup(cli, user, pass, passlen, ntpass, ntpasslen, domain)) {
1193     DEBUG(1,("password server %s rejected the password\n", cli->desthost));
1194     return False;
1195   }
1196
1197   /* if logged in as guest then reject */
1198   if ((SVAL(cli->inbuf,smb_vwv2) & 1) != 0) {
1199     DEBUG(1,("password server %s gave us guest only\n", cli->desthost));
1200     cli_ulogoff(cli);
1201     return(False);
1202   }
1203
1204   cli_ulogoff(cli);
1205
1206   return(True);
1207 }
1208
1209 /***********************************************************************
1210  Connect to a remote machine for domain security authentication
1211  given a name or IP address.
1212 ************************************************************************/
1213
1214 static BOOL connect_to_domain_password_server(struct cli_state *pcli, char *remote_machine,
1215                                               unsigned char *trust_passwd)
1216 {
1217   struct in_addr dest_ip;
1218
1219   if(cli_initialise(pcli) == False) {
1220     DEBUG(0,("connect_to_domain_password_server: unable to initialize client connection.\n"));
1221     return False;
1222   }
1223
1224   standard_sub_basic(remote_machine);
1225   strupper(remote_machine);
1226
1227   if(!resolve_name( remote_machine, &dest_ip, 0x20)) {
1228     DEBUG(1,("connect_to_domain_password_server: Can't resolve address for %s\n", remote_machine));
1229     cli_shutdown(pcli);
1230     return False;
1231   }
1232   
1233   if (ismyip(dest_ip)) {
1234     DEBUG(1,("connect_to_domain_password_server: Password server loop - not using password server %s\n",
1235          remote_machine));
1236     cli_shutdown(pcli);
1237     return False;
1238   }
1239   
1240   if (!cli_connect(pcli, remote_machine, &dest_ip)) {
1241     DEBUG(0,("connect_to_domain_password_server: unable to connect to SMB server on \
1242 machine %s. Error was : %s.\n", remote_machine, cli_errstr(pcli) ));
1243     cli_shutdown(pcli);
1244     return False;
1245   }
1246   
1247   if (!attempt_netbios_session_request(pcli, global_myname, remote_machine, &dest_ip)) {
1248     DEBUG(0,("connect_to_password_server: machine %s rejected the NetBIOS \
1249 session request. Error was : %s.\n", remote_machine, cli_errstr(pcli) ));
1250     return False;
1251   }
1252   
1253   pcli->protocol = PROTOCOL_NT1;
1254
1255   if (!cli_negprot(pcli)) {
1256     DEBUG(0,("connect_to_domain_password_server: machine %s rejected the negotiate protocol. \
1257 Error was : %s.\n", remote_machine, cli_errstr(pcli) ));
1258     cli_shutdown(pcli);
1259     return False;
1260   }
1261
1262   if (pcli->protocol != PROTOCOL_NT1) {
1263     DEBUG(0,("connect_to_domain_password_server: machine %s didn't negotiate NT protocol.\n",
1264                    remote_machine));
1265     cli_shutdown(pcli);
1266     return False;
1267   }
1268
1269   /*
1270    * Do an anonymous session setup.
1271    */
1272
1273   if (!cli_session_setup(pcli, "", "", 0, "", 0, "")) {
1274     DEBUG(0,("connect_to_domain_password_server: machine %s rejected the session setup. \
1275 Error was : %s.\n", remote_machine, cli_errstr(pcli) ));
1276     cli_shutdown(pcli);
1277     return False;
1278   }
1279
1280   if (!(pcli->sec_mode & 1)) {
1281     DEBUG(1,("connect_to_domain_password_server: machine %s isn't in user level security mode\n",
1282                remote_machine));
1283     cli_shutdown(pcli);
1284     return False;
1285   }
1286
1287   if (!cli_send_tconX(pcli, "IPC$", "IPC", "", 1)) {
1288     DEBUG(0,("connect_to_domain_password_server: machine %s rejected the tconX on the IPC$ share. \
1289 Error was : %s.\n", remote_machine, cli_errstr(pcli) ));
1290     cli_shutdown(pcli);
1291     return False;
1292   }
1293
1294   /*
1295    * We now have an anonymous connection to IPC$ on the domain password server.
1296    */
1297
1298   /*
1299    * Even if the connect succeeds we need to setup the netlogon
1300    * pipe here. We do this as we may just have changed the domain
1301    * account password on the PDC and yet we may be talking to
1302    * a BDC that doesn't have this replicated yet. In this case
1303    * a successful connect to a DC needs to take the netlogon connect
1304    * into account also. This patch from "Bjart Kvarme" <bjart.kvarme@usit.uio.no>.
1305    */
1306
1307   if(cli_nt_session_open(pcli, PIPE_NETLOGON) == False) {
1308     DEBUG(0,("connect_to_domain_password_server: unable to open the domain client session to \
1309 machine %s. Error was : %s.\n", remote_machine, cli_errstr(pcli)));
1310     cli_nt_session_close(pcli);
1311     cli_ulogoff(pcli);
1312     cli_shutdown(pcli);
1313     return False;
1314   }
1315
1316   if (cli_nt_setup_creds(pcli, trust_passwd) == False) {
1317     DEBUG(0,("connect_to_domain_password_server: unable to setup the PDC credentials to machine \
1318 %s. Error was : %s.\n", remote_machine, cli_errstr(pcli)));
1319     cli_nt_session_close(pcli);
1320     cli_ulogoff(pcli);
1321     cli_shutdown(pcli);
1322     return(False);
1323   }
1324
1325   return True;
1326 }
1327
1328 /***********************************************************************
1329  Utility function to attempt a connection to an IP address of a DC.
1330 ************************************************************************/
1331
1332 static BOOL attempt_connect_to_dc(struct cli_state *pcli, struct in_addr *ip, unsigned char *trust_passwd)
1333 {
1334   fstring dc_name;
1335
1336   /*
1337    * Ignore addresses we have already tried.
1338    */
1339
1340   if (ip_equal(ipzero, *ip))
1341           return False;
1342
1343   if (!lookup_pdc_name(global_myname, lp_workgroup(), ip, dc_name))
1344           return False;
1345
1346   return connect_to_domain_password_server(pcli, dc_name, trust_passwd);
1347 }
1348
1349
1350
1351 /***********************************************************************
1352  We have been asked to dynamcially determine the IP addresses of
1353  the PDC and BDC's for this DOMAIN, and query them in turn.
1354 ************************************************************************/
1355 static BOOL find_connect_pdc(struct cli_state *pcli, unsigned char *trust_passwd, time_t last_change_time)
1356 {
1357         struct in_addr *ip_list = NULL;
1358         int count = 0;
1359         int i;
1360         BOOL connected_ok = False;
1361         time_t time_now = time(NULL);
1362         BOOL use_pdc_only = False;
1363
1364         /*
1365          * If the time the machine password has changed
1366          * was less than an hour ago then we need to contact
1367          * the PDC only, as we cannot be sure domain replication
1368          * has yet taken place. Bug found by Gerald (way to go
1369          * Gerald !). JRA.
1370          */
1371
1372         if (time_now - last_change_time < 3600)
1373                 use_pdc_only = True;
1374
1375         if (!get_dc_list(use_pdc_only, lp_workgroup(), &ip_list, &count))
1376                 return False;
1377
1378         /*
1379          * Firstly try and contact a PDC/BDC who has the same
1380          * network address as any of our interfaces.
1381          */
1382         for(i = 0; i < count; i++) {
1383                 if(!is_local_net(ip_list[i]))
1384                         continue;
1385
1386                 if((connected_ok = attempt_connect_to_dc(pcli, &ip_list[i], trust_passwd))) 
1387                         break;
1388                 
1389                 ip_list[i] = ipzero; /* Tried and failed. */
1390         }
1391
1392         /*
1393          * Secondly try and contact a random PDC/BDC.
1394          */
1395         if(!connected_ok) {
1396                 i = (sys_random() % count);
1397
1398                 if (!(connected_ok = attempt_connect_to_dc(pcli, &ip_list[i], trust_passwd)))
1399                         ip_list[i] = ipzero; /* Tried and failed. */
1400         }
1401
1402         /*
1403          * Finally go through the IP list in turn, ignoring any addresses
1404          * we have already tried.
1405          */
1406         if(!connected_ok) {
1407                 /*
1408                  * Try and connect to any of the other IP addresses in the PDC/BDC list.
1409                  * Note that from a WINS server the #1 IP address is the PDC.
1410                  */
1411                 for(i = 0; i < count; i++) {
1412                         if((connected_ok = attempt_connect_to_dc(pcli, &ip_list[i], trust_passwd)))
1413                                 break;
1414                 }
1415         }
1416
1417         if(ip_list != NULL)
1418                 free((char *)ip_list);
1419
1420
1421         return connected_ok;
1422 }
1423
1424
1425
1426 /***********************************************************************
1427  Do the same as security=server, but using NT Domain calls and a session
1428  key from the machine password.
1429 ************************************************************************/
1430
1431 BOOL domain_client_validate( char *user, char *domain, 
1432                              char *smb_apasswd, int smb_apasslen, 
1433                              char *smb_ntpasswd, int smb_ntpasslen,
1434                              BOOL *user_exists)
1435 {
1436   unsigned char local_challenge[8];
1437   unsigned char local_lm_response[24];
1438   unsigned char local_nt_response[24];
1439   unsigned char trust_passwd[16];
1440   fstring remote_machine;
1441   char *p, *pserver;
1442   NET_ID_INFO_CTR ctr;
1443   NET_USER_INFO_3 info3;
1444   struct cli_state cli;
1445   uint32 smb_uid_low;
1446   BOOL connected_ok = False;
1447   time_t last_change_time;
1448
1449   if(user_exists != NULL)
1450     *user_exists = True; /* Only set false on a very specific error. */
1451  
1452   /* 
1453    * Check that the requested domain is not our own machine name.
1454    * If it is, we should never check the PDC here, we use our own local
1455    * password file.
1456    */
1457
1458   if(strequal( domain, global_myname)) {
1459     DEBUG(3,("domain_client_validate: Requested domain was for this machine.\n"));
1460     return False;
1461   }
1462
1463   /*
1464    * Next, check that the passwords given were encrypted.
1465    */
1466
1467   if(((smb_apasslen != 24) && (smb_apasslen != 0)) || 
1468      ((smb_ntpasslen != 24) && (smb_ntpasslen != 0))) {
1469
1470     /*
1471      * Not encrypted - do so.
1472      */
1473
1474     DEBUG(3,("domain_client_validate: User passwords not in encrypted format.\n"));
1475     generate_random_buffer( local_challenge, 8, False);
1476     SMBencrypt( (uchar *)smb_apasswd, local_challenge, local_lm_response);
1477     SMBNTencrypt((uchar *)smb_ntpasswd, local_challenge, local_nt_response);
1478     smb_apasslen = 24;
1479     smb_ntpasslen = 24;
1480     smb_apasswd = (char *)local_lm_response;
1481     smb_ntpasswd = (char *)local_nt_response;
1482   } else {
1483
1484     /*
1485      * Encrypted - get the challenge we sent for these
1486      * responses.
1487      */
1488
1489     if (!last_challenge(local_challenge)) {
1490       DEBUG(0,("domain_client_validate: no challenge done - password failed\n"));
1491       return False;
1492     }
1493   }
1494
1495   /*
1496    * Get the machine account password for our primary domain
1497    */
1498   if (!secrets_fetch_trust_account_password(lp_workgroup(), trust_passwd, &last_change_time))
1499   {
1500           DEBUG(0, ("domain_client_validate: could not fetch trust account password for domain %s\n", lp_workgroup()));
1501           return False;
1502   }
1503
1504   /*
1505    * At this point, smb_apasswd points to the lanman response to
1506    * the challenge in local_challenge, and smb_ntpasswd points to
1507    * the NT response to the challenge in local_challenge. Ship
1508    * these over the secure channel to a domain controller and
1509    * see if they were valid.
1510    */
1511
1512   ZERO_STRUCT(cli);
1513
1514   /*
1515    * Treat each name in the 'password server =' line as a potential
1516    * PDC/BDC. Contact each in turn and try and authenticate.
1517    */
1518
1519   pserver = lp_passwordserver();
1520   if (! *pserver) pserver = "*";
1521   p = pserver;
1522
1523   while (!connected_ok &&
1524          next_token(&p,remote_machine,LIST_SEP,sizeof(remote_machine))) {
1525           if(strequal(remote_machine, "*")) {
1526                   connected_ok = find_connect_pdc(&cli, trust_passwd, last_change_time);
1527           } else {
1528                   connected_ok = connect_to_domain_password_server(&cli, remote_machine, trust_passwd);
1529           }
1530   }
1531
1532   if (!connected_ok) {
1533     DEBUG(0,("domain_client_validate: Domain password server not available.\n"));
1534     cli_shutdown(&cli);
1535     return False;
1536   }
1537
1538   /* We really don't care what LUID we give the user. */
1539   generate_random_buffer( (unsigned char *)&smb_uid_low, 4, False);
1540
1541   ZERO_STRUCT(info3);
1542
1543   if(cli_nt_login_network(&cli, domain, user, smb_uid_low, (char *)local_challenge,
1544                           ((smb_apasslen != 0) ? smb_apasswd : NULL),
1545                           ((smb_ntpasslen != 0) ? smb_ntpasswd : NULL),
1546                           &ctr, &info3) == False) {
1547     uint32 nt_rpc_err;
1548
1549     cli_error(&cli, NULL, NULL, &nt_rpc_err);
1550     DEBUG(0,("domain_client_validate: unable to validate password for user %s in domain \
1551 %s to Domain controller %s. Error was %s.\n", user, domain, remote_machine, cli_errstr(&cli)));
1552     cli_nt_session_close(&cli);
1553     cli_ulogoff(&cli);
1554     cli_shutdown(&cli);
1555
1556     if((nt_rpc_err == NT_STATUS_NO_SUCH_USER) && (user_exists != NULL))
1557       *user_exists = False;
1558
1559     return False;
1560   }
1561
1562   /*
1563    * Here, if we really want it, we have lots of info about the user in info3.
1564    */
1565
1566 #if 0
1567   /* 
1568    * We don't actually need to do this - plus it fails currently with
1569    * NT_STATUS_INVALID_INFO_CLASS - we need to know *exactly* what to
1570    * send here. JRA.
1571    */
1572
1573   if(cli_nt_logoff(&cli, &ctr) == False) {
1574     DEBUG(0,("domain_client_validate: unable to log off user %s in domain \
1575 %s to Domain controller %s. Error was %s.\n", user, domain, remote_machine, cli_errstr(&cli)));        
1576     cli_nt_session_close(&cli);
1577     cli_ulogoff(&cli);
1578     cli_shutdown(&cli);
1579     return False;
1580   }
1581 #endif /* 0 */
1582
1583   /* Note - once the cli stream is shutdown the mem_ctx used
1584    to allocate the other_sids and gids structures has been deleted - so
1585    these pointers are no longer valid..... */
1586
1587   cli_nt_session_close(&cli);
1588   cli_ulogoff(&cli);
1589   cli_shutdown(&cli);
1590   return True;
1591 }
1592
1593 #undef OLD_NTDOMAIN