32e358dd9dea8d44df00f28dd0dc865f07e50df8
[openafs.git] / src / WINNT / afsd / afslogon.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  * 
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 #include "afslogon.h"
11
12 #include <io.h>
13 #include <sys/stat.h>
14 #include <sys/types.h>
15 #include <fcntl.h>
16
17 #include <winsock2.h>
18
19 #include <afs/param.h>
20 #include <afs/stds.h>
21 #include <afs/pioctl_nt.h>
22 #include <afs/kautils.h>
23
24 #include "afsd.h"
25 #include "cm_config.h"
26 #include "krb.h"
27 #include "afskfw.h"
28
29 DWORD TraceOption = 0;
30
31 HANDLE hDLL;
32
33 WSADATA WSAjunk;
34 #define AFS_LOGON_EVENT_NAME TEXT("AFS Logon")
35
36 void DebugEvent0(char *a) 
37 {
38         HANDLE h; char *ptbuf[1];
39         if (!ISLOGONTRACE(TraceOption))
40                 return;
41         h = RegisterEventSource(NULL, AFS_LOGON_EVENT_NAME);
42         ptbuf[0] = a;
43         ReportEvent(h, EVENTLOG_INFORMATION_TYPE, 0, 0, NULL, 1, 0, (const char **)ptbuf, NULL);
44         DeregisterEventSource(h);
45 }
46
47 #define MAXBUF_ 512
48 void DebugEvent(char *b,...) 
49 {
50         HANDLE h; char *ptbuf[1],buf[MAXBUF_+1];
51         va_list marker;
52
53         if (!ISLOGONTRACE(TraceOption))
54                 return;
55
56         h = RegisterEventSource(NULL, AFS_LOGON_EVENT_NAME);
57         va_start(marker,b);
58         StringCbVPrintf(buf, MAXBUF_+1,b,marker);
59     buf[MAXBUF_] = '\0';
60         ptbuf[0] = buf;
61         ReportEvent(h, EVENTLOG_INFORMATION_TYPE, 0, 0, NULL, 1, 0, (const char **)ptbuf, NULL);\
62         DeregisterEventSource(h);
63         va_end(marker);
64 }
65
66 CHAR *GenRandomName(CHAR *pbuf)
67 {
68         int i;
69         srand( (unsigned)time( NULL ) );
70         for (i=0;i<MAXRANDOMNAMELEN-1;i++)
71                 pbuf[i]='a'+(rand() % 26);
72         pbuf[MAXRANDOMNAMELEN-1]=0;
73         return pbuf;
74 }
75
76 BOOLEAN AFSWillAutoStart(void)
77 {
78         SC_HANDLE scm;
79         SC_HANDLE svc;
80         BOOLEAN flag;
81         BOOLEAN result = FALSE;
82         LPQUERY_SERVICE_CONFIG pConfig = NULL;
83         DWORD BufSize;
84         LONG status;
85
86         /* Open services manager */
87         scm = OpenSCManager(NULL, NULL, GENERIC_READ);
88         if (!scm) return FALSE;
89
90         /* Open AFSD service */
91         svc = OpenService(scm, "TransarcAFSDaemon", SERVICE_QUERY_CONFIG);
92         if (!svc)
93                 goto close_scm;
94
95         /* Query AFSD service config, first just to get buffer size */
96         /* Expected to fail, so don't test return value */
97         (void) QueryServiceConfig(svc, NULL, 0, &BufSize);
98         status = GetLastError();
99         if (status != ERROR_INSUFFICIENT_BUFFER)
100                 goto close_svc;
101
102         /* Allocate buffer */
103         pConfig = (LPQUERY_SERVICE_CONFIG)GlobalAlloc(GMEM_FIXED,BufSize);
104         if (!pConfig)
105                 goto close_svc;
106
107         /* Query AFSD service config, this time for real */
108         flag = QueryServiceConfig(svc, pConfig, BufSize, &BufSize);
109         if (!flag)
110                 goto free_pConfig;
111
112         /* Is it autostart? */
113         if (pConfig->dwStartType < SERVICE_DEMAND_START)
114                 result = TRUE;
115
116 free_pConfig:
117         GlobalFree(pConfig);
118 close_svc:
119         CloseServiceHandle(svc);
120 close_scm:
121         CloseServiceHandle(scm);
122
123         return result;
124 }
125
126 DWORD MapAuthError(DWORD code)
127 {
128         switch (code) {
129                 /* Unfortunately, returning WN_NO_NETWORK results in the MPR abandoning
130                  * logon scripts for all credential managers, although they will still
131                  * receive logon notifications.  Since we don't want this, we return
132                  * WN_SUCCESS.  This is highly undesirable, but we also don't want to
133                  * break other network providers.
134                  */
135 /*      case KTC_NOCM:
136         case KTC_NOCMRPC:
137                 return WN_NO_NETWORK; */
138         default: return WN_SUCCESS;
139         }
140 }
141
142 BOOLEAN APIENTRY DllEntryPoint(HANDLE dll, DWORD reason, PVOID reserved)
143 {
144         hDLL = dll;
145         switch (reason) {
146                 case DLL_PROCESS_ATTACH:
147                         /* Initialize AFS libraries */
148                         rx_Init(0);
149             initAFSDirPath();
150                         ka_Init(0);
151                         break;
152
153                 /* Everything else succeeds but does nothing. */
154                 case DLL_PROCESS_DETACH:
155                 case DLL_THREAD_ATTACH:
156                 case DLL_THREAD_DETACH:
157                 default:
158                         break;
159         }
160
161         return TRUE;
162 }
163
164 DWORD APIENTRY NPGetCaps(DWORD index)
165 {
166         switch (index) {
167                 case WNNC_NET_TYPE:
168                         /* Don't have our own type; use somebody else's. */
169                         return WNNC_NET_SUN_PC_NFS;
170
171                 case WNNC_START:
172                         /* Say we are already started, even though we might wait after we receive NPLogonNotify */
173                         return 1;
174
175                 default:
176                         return 0;
177         }
178 }
179
180 BOOL IsServiceRunning (void)
181 {
182     SERVICE_STATUS Status;
183     SC_HANDLE hManager;
184     memset (&Status, 0x00, sizeof(Status));
185     Status.dwCurrentState = SERVICE_STOPPED;
186
187     if ((hManager = OpenSCManager (NULL, NULL, GENERIC_READ)) != NULL)
188     {
189         SC_HANDLE hService;
190         if ((hService = OpenService (hManager, TEXT("TransarcAFSDaemon"), GENERIC_READ)) != NULL)
191         {
192             QueryServiceStatus (hService, &Status);
193             CloseServiceHandle (hService);
194         }
195
196         CloseServiceHandle (hManager);
197     }
198     DebugEvent("AFS AfsLogon - Test Service Running","Return Code[%x] ?Running[%d]",Status.dwCurrentState,(Status.dwCurrentState == SERVICE_RUNNING));
199     return (Status.dwCurrentState == SERVICE_RUNNING);
200 }   
201
202 /* LOOKUPKEYCHAIN: macro to look up the value in the list of keys in order until it's found
203    v:variable to receive value (reference type)
204    t:type
205    d:default, in case the value isn't on any of the keys
206    n:name of value */
207 #define LOOKUPKEYCHAIN(v,t,d,n) \
208         do { \
209                 rv = ~ERROR_SUCCESS; \
210                 dwType = t; \
211                 if(hkDom) { \
212                         dwSize = sizeof(v); \
213                         rv = RegQueryValueEx(hkDom, n, 0, &dwType, (LPBYTE) &(v), &dwSize); \
214                         if(rv == ERROR_SUCCESS) DebugEvent(#v " found in hkDom with type [%d]", dwType); \
215                 } \
216                 if(hkDoms && (rv != ERROR_SUCCESS || dwType != t)) { \
217                         dwSize = sizeof(v); \
218                         rv = RegQueryValueEx(hkDoms, n, 0, &dwType, (LPBYTE) &(v), &dwSize); \
219                         if(rv == ERROR_SUCCESS) DebugEvent(#v " found in hkDoms with type [%d]", dwType); \
220                 } \
221                 if(hkNp && (rv != ERROR_SUCCESS || dwType != t)) { \
222                         dwSize = sizeof(v); \
223                         rv = RegQueryValueEx(hkNp, n, 0, &dwType, (LPBYTE) &(v), &dwSize); \
224                         if(rv == ERROR_SUCCESS) DebugEvent(#v " found in hkNp with type [%d]", dwType); \
225                 } \
226                 if(rv != ERROR_SUCCESS || dwType != t) { \
227                         v = d; \
228                         DebugEvent(#v " being set to default"); \
229                 } \
230         } while(0)
231
232 /* Get domain specific configuration info.  We are returning void because if anything goes wrong
233    we just return defaults.
234  */
235 void GetDomainLogonOptions( PLUID lpLogonId, char * username, char * domain, LogonOptions_t *opt ) {
236         HKEY hkParm = NULL; /* Service parameter */
237         HKEY hkNp = NULL;   /* network provider key */
238         HKEY hkDoms = NULL; /* domains key */
239         HKEY hkDom = NULL;  /* DOMAINS/domain key */
240         HKEY hkTemp = NULL;
241         LONG rv;
242         DWORD dwSize;
243         DWORD dwType;
244         DWORD dwDummy;
245         char computerName[MAX_COMPUTERNAME_LENGTH + 1];
246         char *effDomain;
247
248         DebugEvent("In GetDomainLogonOptions for user [%s] in domain [%s]", username, domain);
249         /* If the domain is the same as the Netbios computer name, we use the LOCALHOST domain name*/
250         opt->flags = LOGON_FLAG_REMOTE;
251         if(domain) {
252                 dwSize = MAX_COMPUTERNAME_LENGTH;
253                 if(GetComputerName(computerName, &dwSize)) {
254                         if(!stricmp(computerName, domain)) {
255                                 effDomain = "LOCALHOST";
256                                 opt->flags = LOGON_FLAG_LOCAL;
257                         }
258                         else
259                                 effDomain = domain;
260                 }
261         } else
262                 effDomain = NULL;
263
264         rv = RegOpenKeyEx( HKEY_LOCAL_MACHINE, REG_CLIENT_PARMS_KEY, 0, KEY_READ, &hkParm );
265         if(rv != ERROR_SUCCESS) {
266                 hkParm = NULL;
267                 DebugEvent("GetDomainLogonOption: Can't open parms key [%d]", rv);
268         }
269
270         rv = RegOpenKeyEx( HKEY_LOCAL_MACHINE, REG_CLIENT_PROVIDER_KEY, 0, KEY_READ, &hkNp );
271         if(rv != ERROR_SUCCESS) {
272                 hkNp = NULL;
273                 DebugEvent("GetDomainLogonOptions: Can't open NP key [%d]", rv);
274         }
275
276         if(hkNp) {
277                 rv = RegOpenKeyEx( hkNp, REG_CLIENT_DOMAINS_SUBKEY, 0, KEY_READ, &hkDoms );
278                 if( rv != ERROR_SUCCESS ) {
279                         hkDoms = NULL;
280                         DebugEvent("GetDomainLogonOptions: Can't open Domains key [%d]", rv);
281                 }
282         }
283
284         if(hkDoms && effDomain) {
285                 rv = RegOpenKeyEx( hkDoms, effDomain, 0, KEY_READ, &hkDom );
286                 if( rv != ERROR_SUCCESS ) {
287                         hkDom = NULL;
288                         DebugEvent("GetDomainLogonOptions: Can't open domain key for [%s] [%d]", effDomain, rv);
289                         /* If none of the domains match, we shouldn't use the domain key either */
290                         RegCloseKey(hkDoms);
291                         hkDoms = NULL;
292                 }
293         } else
294                 DebugEvent("Not opening domain key for [%s]", effDomain);
295
296         /* Each individual can either be specified on the domain key, the domains key or in the
297            net provider key.  They fail over in that order.  If none is found, we just use the 
298            defaults. */
299
300         /* LogonOption */
301         LOOKUPKEYCHAIN(opt->LogonOption, REG_DWORD, DEFAULT_LOGON_OPTION, REG_CLIENT_LOGON_OPTION_PARM);
302
303         /* FailLoginsSilently */
304         dwSize = sizeof(dwDummy);
305         rv = RegQueryValueEx(hkParm, REG_CLIENT_FAIL_SILENTLY_PARM, 0, &dwType, (LPBYTE) &dwDummy, &dwSize);
306         if(rv != ERROR_SUCCESS)
307                 LOOKUPKEYCHAIN(dwDummy, REG_DWORD, DEFAULT_FAIL_SILENTLY, REG_CLIENT_FAIL_SILENTLY_PARM);
308     opt->failSilently = !!dwDummy;
309
310         /* Retry interval */
311         LOOKUPKEYCHAIN(opt->retryInterval, REG_DWORD, DEFAULT_RETRY_INTERVAL, REG_CLIENT_RETRY_INTERVAL_PARM);
312
313         /* Sleep interval */
314         LOOKUPKEYCHAIN(opt->sleepInterval, REG_DWORD, DEFAULT_SLEEP_INTERVAL, REG_CLIENT_SLEEP_INTERVAL_PARM);
315
316         opt->logonScript = NULL;
317         opt->smbName = NULL;
318
319         if(!ISLOGONINTEGRATED(opt->LogonOption)) {
320                 goto cleanup; /* no need to lookup the logon script */
321         }
322
323         /* come up with SMB username */
324         if(ISHIGHSECURITY(opt->LogonOption)) {
325         opt->smbName = malloc( MAXRANDOMNAMELEN );
326                 GenRandomName(opt->smbName);
327         } else {
328                 /* username and domain for logon session is not necessarily the same as
329                    username and domain passed into network provider. */
330                 PSECURITY_LOGON_SESSION_DATA plsd;
331                 char lsaUsername[MAX_USERNAME_LENGTH];
332                 char lsaDomain[MAX_DOMAIN_LENGTH];
333                 size_t len, tlen;
334
335         LsaGetLogonSessionData(lpLogonId, &plsd);
336         
337                 UnicodeStringToANSI(plsd->UserName, lsaUsername, MAX_USERNAME_LENGTH);
338                 UnicodeStringToANSI(plsd->LogonDomain, lsaDomain, MAX_DOMAIN_LENGTH);
339
340                 DebugEvent("PLSD username[%s] domain[%s]",lsaUsername,lsaDomain);
341
342                 if(SUCCEEDED(StringCbLength(lsaUsername, MAX_USERNAME_LENGTH, &tlen)))
343                         len = tlen;
344                 else
345                         goto bad_strings;
346
347                 if(SUCCEEDED(StringCbLength(lsaDomain, MAX_DOMAIN_LENGTH, &tlen)))
348                         len += tlen;
349                 else
350                         goto bad_strings;
351
352                 len += 2;
353
354                 opt->smbName = malloc(len);
355
356                 StringCbCopy(opt->smbName, len, lsaDomain);
357                 StringCbCat(opt->smbName, len, "\\");
358                 StringCbCat(opt->smbName, len, lsaUsername);
359
360                 strlwr(opt->smbName);
361
362 bad_strings:
363                 LsaFreeReturnBuffer(plsd);
364         }
365
366         DebugEvent("Looking up logon script");
367         /* Logon script */
368         /* First find out where the key is */
369         hkTemp = NULL;
370         rv = ~ERROR_SUCCESS;
371         dwType = 0;
372         if(hkDom)
373             rv = RegQueryValueExW(hkDom, REG_CLIENT_LOGON_SCRIPT_PARMW, 0, &dwType, NULL, &dwSize);
374         if(rv == ERROR_SUCCESS && (dwType == REG_SZ || dwType == REG_EXPAND_SZ)) {
375                 hkTemp = hkDom;
376                 DebugEvent("Located logon script in hkDom");
377         }
378         else if(hkDoms)
379             rv = RegQueryValueExW(hkDoms, REG_CLIENT_LOGON_SCRIPT_PARMW, 0, &dwType, NULL, &dwSize);
380         if(rv == ERROR_SUCCESS && !hkTemp && (dwType == REG_SZ || dwType == REG_EXPAND_SZ)) {
381                 hkTemp = hkDoms;
382                 DebugEvent("Located logon script in hkDoms");
383         }
384         /* Note that the LogonScript in the NP key is only used if we are doing high security. */
385         else if(hkNp && ISHIGHSECURITY(opt->LogonOption))
386             rv = RegQueryValueExW(hkNp, REG_CLIENT_LOGON_SCRIPT_PARMW, 0, &dwType, NULL, &dwSize);
387         if(rv == ERROR_SUCCESS && !hkTemp && (dwType == REG_SZ || dwType == REG_EXPAND_SZ)) {
388                 hkTemp = hkNp;
389                 DebugEvent("Located logon script in hkNp");
390         }
391
392         if(hkTemp) {
393                 WCHAR *regscript        = NULL;
394                 WCHAR *regexscript      = NULL;
395                 WCHAR *regexuscript     = NULL;
396                 WCHAR *wuname           = NULL;
397                 HRESULT hr;
398
399                 size_t len;
400                 
401                 StringCbLength(opt->smbName, MAX_USERNAME_LENGTH, &len);
402                 len ++;
403
404                 wuname = malloc(len * sizeof(WCHAR));
405                 MultiByteToWideChar(CP_ACP,0,opt->smbName,-1,wuname,len*sizeof(WCHAR));
406
407                 DebugEvent("Username is set for [%S]", wuname);
408
409                 /* dwSize still has the size of the required buffer in bytes. */
410         regscript = malloc(dwSize);
411                 rv = RegQueryValueExW(hkTemp, REG_CLIENT_LOGON_SCRIPT_PARMW, 0, &dwType, (LPBYTE) regscript, &dwSize);
412                 if(rv != ERROR_SUCCESS) {/* what the ..? */
413                         DebugEvent("Can't look up logon script [%d]",rv);
414                         goto doneLogonScript;
415                 }
416                 
417                 DebugEvent("Found logon script [%S]", regscript);
418
419                 if(dwType == REG_EXPAND_SZ) {
420                         DWORD dwReq;
421
422                         dwSize += MAX_PATH * sizeof(WCHAR);  /* make room for environment expansion. */
423                         regexscript = malloc(dwSize);
424                         dwReq = ExpandEnvironmentStringsW(regscript, regexscript, dwSize / sizeof(WCHAR));
425                         free(regscript);
426                         regscript = regexscript;
427                         regexscript = NULL;
428                         if(dwReq > (dwSize / sizeof(WCHAR))) {
429                                 DebugEvent("Overflow while expanding environment strings.");
430                                 goto doneLogonScript;
431                         }
432                 }
433
434                 DebugEvent("After expanding env strings [%S]", regscript);
435
436                 if(wcsstr(regscript, L"%s")) {
437                 dwSize += len * sizeof(WCHAR); /* make room for username expansion */
438                         regexuscript = (WCHAR *) LocalAlloc(LMEM_FIXED, dwSize);
439                         hr = StringCbPrintfW(regexuscript, dwSize, regscript, wuname);
440                 } else {
441                         regexuscript = (WCHAR *) LocalAlloc(LMEM_FIXED, dwSize);
442                         hr = StringCbCopyW(regexuscript, dwSize, regscript);
443                 }
444
445                 DebugEvent("After expanding username [%S]", regexuscript);
446
447                 if(hr == S_OK)
448                         opt->logonScript = regexuscript;
449                 else
450                         LocalFree(regexuscript);
451
452 doneLogonScript:
453                 if(wuname) free(wuname);
454                 if(regscript) free(regscript);
455                 if(regexscript) free(regexscript);
456         }
457
458 cleanup:
459         if(hkNp) RegCloseKey(hkNp);
460         if(hkDom) RegCloseKey(hkDom);
461         if(hkDoms) RegCloseKey(hkDoms);
462         if(hkParm) RegCloseKey(hkParm);
463 }
464
465 #undef LOOKUPKEYCHAIN
466
467 /* Try to find out which cell the given path is in.  We must retain
468    the contents of *cell in case of failure. *cell is assumed to be
469    at least cellLen chars */
470 DWORD GetFileCellName(char * path, char * cell, size_t cellLen) {
471         struct ViceIoctl blob;
472         char tcell[MAX_PATH];
473         DWORD code;
474
475         blob.in_size = 0;
476         blob.out_size = MAX_PATH;
477         blob.out = tcell;
478
479         code = pioctl(path, VIOC_FILE_CELL_NAME, &blob, 1);
480
481         if(!code) {
482                 strncpy(cell, tcell, cellLen);
483                 cell[cellLen - 1] = '\0';
484         }
485         return code;
486 }
487
488
489 static BOOL
490 WINAPI
491 UnicodeStringToANSI(UNICODE_STRING uInputString, LPSTR lpszOutputString, int nOutStringLen)
492 {
493     CPINFO CodePageInfo;
494
495     GetCPInfo(CP_ACP, &CodePageInfo);
496
497     if (CodePageInfo.MaxCharSize > 1)
498         // Only supporting non-Unicode strings
499         return FALSE;
500     
501     if (uInputString.Buffer && ((LPBYTE) uInputString.Buffer)[1] == '\0')
502     {
503         // Looks like unicode, better translate it
504         // UNICODE_STRING specifies the length of the buffer string in Bytes not WCHARS
505         WideCharToMultiByte(CP_ACP, 0, (LPCWSTR) uInputString.Buffer, uInputString.Length/2,
506                             lpszOutputString, nOutStringLen-1, NULL, NULL);
507         lpszOutputString[min(uInputString.Length/2,nOutStringLen-1)] = '\0';
508         return TRUE;
509     }
510         else
511                 lpszOutputString[0] = '\0';
512     return FALSE;
513 }  // UnicodeStringToANSI
514
515 DWORD APIENTRY NPLogonNotify(
516         PLUID lpLogonId,
517         LPCWSTR lpAuthentInfoType,
518         LPVOID lpAuthentInfo,
519         LPCWSTR lpPreviousAuthentInfoType,
520         LPVOID lpPreviousAuthentInfo,
521         LPWSTR lpStationName,
522         LPVOID StationHandle,
523         LPWSTR *lpLogonScript)
524 {
525         char uname[MAX_USERNAME_LENGTH]="";
526         char password[MAX_PASSWORD_LENGTH]="";
527         char logonDomain[MAX_DOMAIN_LENGTH]="";
528         char cell[256]="<non-integrated logon>";
529         char homePath[MAX_PATH]="";
530
531         MSV1_0_INTERACTIVE_LOGON *IL;
532
533         DWORD code;
534
535         int pw_exp;
536         char *reason;
537         char *ctemp;
538
539         BOOLEAN interactive;
540         BOOLEAN flag;
541         DWORD LSPtype, LSPsize;
542         HKEY NPKey;
543
544         HWND hwndOwner = (HWND)StationHandle;
545
546         BOOLEAN afsWillAutoStart;
547
548     BOOLEAN uppercased_name = TRUE;
549
550         LogonOptions_t opt; /* domain specific logon options */
551         int retryInterval;
552         int sleepInterval;
553
554     /* Initialize Logon Script to none */
555         *lpLogonScript=NULL;
556     
557         /* TODO: We should check the value of lpAuthentInfoType before assuming that it is
558                  MSV1_0_INTERACTIVE_LOGON though for our purposes KERB_INTERACTIVE_LOGON is
559                          co-incidentally equivalent. */
560         IL = (MSV1_0_INTERACTIVE_LOGON *) lpAuthentInfo;
561
562         /* Are we interactive? */
563         interactive = (wcscmp(lpStationName, L"WinSta0") == 0);
564
565         /* Convert from Unicode to ANSI */
566
567         /*TODO: Use SecureZeroMemory to erase passwords */
568         UnicodeStringToANSI(IL->UserName, uname, MAX_USERNAME_LENGTH);
569         UnicodeStringToANSI(IL->Password, password, MAX_PASSWORD_LENGTH);
570         UnicodeStringToANSI(IL->LogonDomainName, logonDomain, MAX_DOMAIN_LENGTH);
571
572         /* Make sure AD-DOMANS sent from login that is sent to us is striped */
573     ctemp = strchr(uname, '@');
574     if (ctemp) *ctemp = 0;
575
576     /* is the name all uppercase? */
577     for ( ctemp = uname; *ctemp ; ctemp++) {
578         if ( islower(*ctemp) ) {
579             uppercased_name = FALSE;
580             break;
581         }
582     }
583
584         (void) RegOpenKeyEx(HKEY_LOCAL_MACHINE, REG_CLIENT_PARMS_KEY,
585                         0, KEY_QUERY_VALUE, &NPKey);
586         LSPsize=sizeof(TraceOption);
587         RegQueryValueEx(NPKey, REG_CLIENT_TRACE_OPTION_PARM, NULL,
588                      &LSPtype, (LPBYTE)&TraceOption, &LSPsize);
589
590         RegCloseKey (NPKey);
591
592         /*
593          * Get Logon options
594          */
595
596         GetDomainLogonOptions( lpLogonId, uname, logonDomain, &opt );
597         retryInterval = opt.retryInterval;
598         sleepInterval = opt.sleepInterval;
599         *lpLogonScript = opt.logonScript;
600
601         DebugEvent("Got logon script: %S",opt.logonScript);
602
603         afsWillAutoStart = AFSWillAutoStart();
604
605         DebugEvent("LogonOption[%x], Service AutoStart[%d]",
606                 opt.LogonOption,afsWillAutoStart);
607     
608     /* Check for zero length password if integrated logon*/
609         if ( ISLOGONINTEGRATED(opt.LogonOption) )  {
610         if ( password[0] == 0 ) {
611             DebugEvent("Password is the empty string");
612             code = GT_PW_NULL;
613             reason = "zero length password is illegal";
614             code=0;
615         }
616
617         /* Get cell name if doing integrated logon.  
618                    We might overwrite this if we are logging into an AD realm and we find out that
619                    the user's home dir is in some other cell. */
620         DebugEvent("About to call cm_GetRootCellName(%s)",cell);
621                 code = cm_GetRootCellName(cell);
622                 if (code < 0) { 
623             DebugEvent("Unable to obtain Root Cell");
624                         code = KTC_NOCELL;
625                         reason = "unknown cell";
626                         code=0;
627                 } else {
628             DebugEvent("Cell is %s",cell);
629         }
630
631                 /* We get the user's home directory path, if applicable, though we can't lookup the
632                    cell right away because the client service may not have started yet. This call
633                    also sets the AD_REALM flag in opt.flags if applicable. */
634                 if(ISREMOTE(opt.flags)) {
635             DebugEvent("Is Remote");
636                         GetAdHomePath(homePath,MAX_PATH,lpLogonId,&opt);
637         }
638     }
639
640     /* loop until AFS is started. */
641     while (TRUE) {
642         DebugEvent("while(TRUE) LogonOption[%x], Service AutoStart[%d]",
643                     opt.LogonOption,afsWillAutoStart);
644
645         if(ISADREALM(opt.flags)) {
646                         code = GetFileCellName(homePath,cell,256);
647                         if(!code) {
648                                 DebugEvent("profile path [%s] is in cell [%s]",homePath,cell);
649                         }
650                         /* Don't bail out if GetFileCellName failed.
651                          * The home dir may not be in AFS after all. 
652                          */
653                 } else
654                 code=0;
655                 
656         /* if Integrated Logon  */
657         if (ISLOGONINTEGRATED(opt.LogonOption))
658                 {                       
659                         if ( KFW_is_available() ) {
660                 code = KFW_AFS_get_cred(uname, cell, password, 0, opt.smbName, &reason);
661                                 DebugEvent("KFW_AFS_get_cred  uname=[%s] smbname=[%s] cell=[%s] code=[%d]",uname,opt.smbName,cell,code);
662                         }
663                         else {
664                 code = ka_UserAuthenticateGeneral2(KA_USERAUTH_VERSION+KA_USERAUTH_AUTHENT_LOGON,
665                                                 uname, "", cell, password, opt.smbName, 0, &pw_exp, 0,
666                                                 &reason);
667                                 DebugEvent("AFS AfsLogon - (INTEGRATED only)ka_UserAuthenticateGeneral2","Code[%x]",
668                                                         code);
669                         }
670             if ( code && code != KTC_NOCM && code != KTC_NOCMRPC && uppercased_name ) {
671                 for ( ctemp = uname; *ctemp ; ctemp++) {
672                     *ctemp = tolower(*ctemp);
673                 }
674                 uppercased_name = FALSE;
675                 continue;
676             }
677                 }
678                 else {  
679             /*JUST check to see if its running*/
680                     if (IsServiceRunning())
681                 break;
682                     code = KTC_NOCM;
683                     if (!afsWillAutoStart)
684                 break;
685                 }
686
687                 /* is service started yet?*/
688         DebugEvent("AFS AfsLogon - ka_UserAuthenticateGeneral2","Code[%x] uname[%s] Cell[%s]",
689                    code,uname,cell);
690
691                 /* If we've failed because the client isn't running yet and the
692          * client is set to autostart (and therefore it makes sense for
693          * us to wait for it to start) then sleep a while and try again. 
694          * If the error was something else, then give up. */
695                 if (code != KTC_NOCM && code != KTC_NOCMRPC || !afsWillAutoStart)
696                         break;
697                 
698         /* If the retry interval has expired and we still aren't
699          * logged in, then just give up if we are not in interactive
700          * mode or the failSilently flag is set, otherwise let the
701          * user know we failed and give them a chance to try again. */
702         if (retryInterval <= 0) {
703             reason = "AFS not running";
704             if (!interactive || opt.failSilently)
705                 break;
706                         flag = MessageBox(hwndOwner,
707                                "AFS is still starting.  Retry?",
708                                "AFS Logon",
709                                MB_ICONQUESTION | MB_RETRYCANCEL);
710                         if (flag == IDCANCEL)
711                 break;
712
713             /* Wait just a little while and try again */
714             retryInterval = sleepInterval = DEFAULT_SLEEP_INTERVAL;
715         }
716
717         if (retryInterval < sleepInterval)
718                         sleepInterval = retryInterval;
719
720                 Sleep(sleepInterval * 1000);
721
722         retryInterval -= sleepInterval;
723     }
724
725     DebugEvent("while loop exited");
726     /* remove any kerberos 5 tickets currently held by the SYSTEM account */
727     if ( KFW_is_available() )
728         KFW_AFS_destroy_tickets_for_cell(cell);
729
730         if (code) {
731         char msg[128];
732
733                 StringCbPrintf(msg, sizeof(msg), "Integrated login failed: %s", reason);
734
735                 if (interactive && !opt.failSilently)
736                         MessageBox(hwndOwner, msg, "AFS Logon", MB_OK);
737                 else {
738             HANDLE h;
739             char *ptbuf[1];
740
741             h = RegisterEventSource(NULL, AFS_LOGON_EVENT_NAME);
742             ptbuf[0] = msg;
743             ReportEvent(h, EVENTLOG_WARNING_TYPE, 0, 1008, NULL,
744                          1, 0, ptbuf, NULL);
745             DeregisterEventSource(h);
746         }
747             code = MapAuthError(code);
748                 SetLastError(code);
749
750                 if (ISLOGONINTEGRATED(opt.LogonOption) && (code!=0))
751                 {
752                         if (*lpLogonScript)
753                                 LocalFree(*lpLogonScript);
754                         *lpLogonScript = NULL;
755                         if (!afsWillAutoStart)  // its not running, so if not autostart or integrated logon then just skip
756                                 code = 0;
757
758                 }
759         }
760
761         if(opt.smbName) free(opt.smbName);
762
763         DebugEvent("AFS AfsLogon - Exit","Return Code[%x]",code);
764         return code;
765 }
766
767 DWORD APIENTRY NPPasswordChangeNotify(
768         LPCWSTR lpAuthentInfoType,
769         LPVOID lpAuthentInfo,
770         LPCWSTR lpPreviousAuthentInfoType,
771         LPVOID lpPreviousAuthentInfo,
772         LPWSTR lpStationName,
773         LPVOID StationHandle,
774         DWORD dwChangeInfo)
775 {
776         DebugEvent0("AFS AfsLogon - NPPasswordChangeNotify");
777         return 0;
778 }
779
780 #include <userenv.h>
781 #include <Winwlx.h>
782 #include <afs/vice.h>
783 #include <afs/fs_utils.h>
784
785 BOOL IsPathInAfs(const CHAR *strPath)
786 {
787     char space[2048];
788     struct ViceIoctl blob;
789     int code;
790
791     blob.in_size = 0;
792     blob.out_size = 2048;
793     blob.out = space;
794
795     code = pioctl((LPTSTR)((LPCTSTR)strPath), VIOC_FILE_CELL_NAME, &blob, 1);
796     if (code)
797         return FALSE;
798     return TRUE;
799 }
800
801 #ifdef COMMENT
802 typedef struct _WLX_NOTIFICATION_INFO {  
803     ULONG Size;  
804     ULONG Flags;  
805     PWSTR UserName;  
806     PWSTR Domain;  
807     PWSTR WindowStation;  
808     HANDLE hToken;  
809     HDESK hDesktop;  
810     PFNMSGECALLBACK pStatusCallback;
811 } WLX_NOTIFICATION_INFO, *PWLX_NOTIFICATION_INFO;
812 #endif
813
814 VOID AFS_Startup_Event( PWLX_NOTIFICATION_INFO pInfo )
815 {
816         DWORD LSPtype, LSPsize;
817         HKEY NPKey;
818
819     (void) RegOpenKeyEx(HKEY_LOCAL_MACHINE, REG_CLIENT_PARMS_KEY,
820                         0, KEY_QUERY_VALUE, &NPKey);
821         LSPsize=sizeof(TraceOption);
822         RegQueryValueEx(NPKey, REG_CLIENT_TRACE_OPTION_PARM, NULL,
823                      &LSPtype, (LPBYTE)&TraceOption, &LSPsize);
824
825         RegCloseKey (NPKey);
826     DebugEvent0("AFS_Startup_Event");
827 }
828
829 VOID AFS_Logoff_Event( PWLX_NOTIFICATION_INFO pInfo )
830 {
831     DWORD code;
832     TCHAR profileDir[256] = TEXT("");
833     DWORD  len = 256;
834     PTOKEN_USER  tokenUser = NULL;
835     DWORD  retLen;
836     HANDLE hToken;
837
838     DebugEvent0("AFS_Logoff_Event - Starting");
839
840     if (!GetTokenInformation(pInfo->hToken, TokenUser, NULL, 0, &retLen))
841     {
842         if ( GetLastError() == ERROR_INSUFFICIENT_BUFFER ) {
843             tokenUser = (PTOKEN_USER) LocalAlloc(LPTR, retLen);
844
845             if (!GetTokenInformation(pInfo->hToken, TokenUser, tokenUser, retLen, &retLen))
846             {
847                 DebugEvent("GetTokenInformation failed: GLE = %lX", GetLastError());
848             }
849         }
850     }
851
852     /* We can't use pInfo->Domain for the domain since in the cross realm case 
853      * this is source domain and not the destination domain.
854      */
855     if (QueryAdHomePathFromSid( profileDir, sizeof(profileDir), tokenUser->User.Sid, pInfo->Domain)) {
856         WCHAR Domain[64]=L"";
857         GetLocalShortDomain(Domain);
858         if (QueryAdHomePathFromSid( profileDir, sizeof(profileDir), tokenUser->User.Sid, Domain))
859             GetUserProfileDirectory(pInfo->hToken, profileDir, &len);
860     }
861     
862     if (strlen(profileDir)) {
863         DebugEvent("Profile Directory: %s", profileDir);
864         if (!IsPathInAfs(profileDir)) {
865             if (code = ktc_ForgetAllTokens())
866                 DebugEvent("AFS_Logoff_Event - ForgetAllTokens failed [%lX]",code);
867             else
868                 DebugEvent0("AFS_Logoff_Event - ForgetAllTokens succeeded");
869         } else {
870             DebugEvent0("AFS_Logoff_Event - Tokens left in place; profile in AFS");
871         }
872     } else {
873         DebugEvent0("AFS_Logoff_Event - Unable to load profile");
874     }
875
876     if ( tokenUser )
877         LocalFree(tokenUser);
878 }   
879