0554eed6df5f8046eddee3d81cead120152171fd
[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 #include <lm.h>
19 #include <nb30.h>
20
21 #include <afs/param.h>
22 #include <afs/stds.h>
23 #include <afs/pioctl_nt.h>
24 #include <afs/kautils.h>
25
26 #include "afsd.h"
27 #include "cm_config.h"
28 #include "krb.h"
29 #include "afskfw.h"
30 #include "lanahelper.h"
31
32 /* Allocated in Windows Driver Kit */
33 #ifndef WNNC_NET_OPENAFS
34 #define WNNC_NET_OPENAFS     0x00390000
35 #endif
36
37 #include <WINNT\afsreg.h>
38
39 DWORD TraceOption = 0;
40
41 HANDLE hDLL;
42
43 #define AFS_LOGON_EVENT_NAME TEXT("AFS Logon")
44
45 void DebugEvent0(char *a) 
46 {
47     HANDLE h; char *ptbuf[1];
48     
49     if (!ISLOGONTRACE(TraceOption))
50         return;
51     
52     h = RegisterEventSource(NULL, AFS_LOGON_EVENT_NAME);
53     if (h != INVALID_HANDLE_VALUE) {
54         ptbuf[0] = a;
55         ReportEvent(h, EVENTLOG_INFORMATION_TYPE, 0, 1008, NULL, 1, 0, (const char **)ptbuf, NULL);
56         DeregisterEventSource(h);
57     }
58 }
59
60 #define MAXBUF_ 512
61 void DebugEvent(char *b,...) 
62 {
63     HANDLE h; char *ptbuf[1],buf[MAXBUF_+1];
64     va_list marker;
65
66     if (!ISLOGONTRACE(TraceOption))
67         return;
68
69     h = RegisterEventSource(NULL, AFS_LOGON_EVENT_NAME);
70     if (h != INVALID_HANDLE_VALUE) {
71         va_start(marker,b);
72         StringCbVPrintf(buf, MAXBUF_+1,b,marker);
73         buf[MAXBUF_] = '\0';
74         ptbuf[0] = buf;
75         ReportEvent(h, EVENTLOG_INFORMATION_TYPE, 0, 1008, NULL, 1, 0, (const char **)ptbuf, NULL);
76         DeregisterEventSource(h);
77         va_end(marker);
78     }
79 }
80
81 static HANDLE hInitMutex = NULL;
82 static BOOL bInit = FALSE;
83
84 BOOLEAN APIENTRY DllEntryPoint(HANDLE dll, DWORD reason, PVOID reserved)
85 {
86     WSADATA wsaData;
87     hDLL = dll;
88
89     switch (reason) {
90     case DLL_PROCESS_ATTACH:
91         /* Initialization Mutex */
92         if (!hInitMutex)
93             hInitMutex = CreateMutex(NULL, FALSE, NULL);
94
95         WSAStartup( MAKEWORD(2,2), &wsaData );
96         break;
97
98     case DLL_PROCESS_DETACH:
99         WSACleanup();
100         CloseHandle(hInitMutex);
101         hInitMutex = NULL;
102         bInit = FALSE;
103         break;
104
105     case DLL_THREAD_ATTACH:
106     case DLL_THREAD_DETACH:
107     default:
108         /* Everything else succeeds but does nothing. */
109         break;
110     }
111
112     return TRUE;
113 }
114
115 void AfsLogonInit(void)
116 {
117     if ( bInit == FALSE ) {
118         if ( WaitForSingleObject( hInitMutex, INFINITE ) == WAIT_OBJECT_0 ) {
119             /* initAFSDirPath() initializes an array and sets a 
120              * flag so that the initialization can only occur
121              * once.  No cleanup will be done when the DLL is 
122              * unloaded so the initialization will not be 
123              * performed again on a subsequent reload
124              */
125             initAFSDirPath();
126
127             /* ka_Init initializes a number of error tables.
128              * and then calls ka_CellConfig() which grabs 
129              * an afsconf_dir structure via afsconf_Open().
130              * Upon a second attempt to call ka_CellConfig()
131              * the structure will be released with afsconf_Close()
132              * and then re-opened.  Could this corrupt memory?
133              * 
134              * We only need this if we are not using KFW.
135              */
136             if (!KFW_is_available())
137                 ka_Init(0);
138             bInit = TRUE;
139         }
140         ReleaseMutex(hInitMutex);
141     }
142 }
143
144 CHAR *GenRandomName(CHAR *pbuf)
145 {
146     int i;
147     srand( (unsigned)time( NULL ) );
148     for (i=0;i<MAXRANDOMNAMELEN-1;i++)
149         pbuf[i]='a'+(rand() % 26);
150     pbuf[MAXRANDOMNAMELEN-1]=0;
151     return pbuf;
152 }
153
154 BOOLEAN AFSWillAutoStart(void)
155 {
156     SC_HANDLE scm;
157     SC_HANDLE svc;
158     BOOLEAN flag;
159     BOOLEAN result = FALSE;
160     LPQUERY_SERVICE_CONFIG pConfig = NULL;
161     DWORD BufSize;
162     LONG status;
163
164     /* Open services manager */
165     scm = OpenSCManager(NULL, NULL, GENERIC_READ);
166     if (!scm) return FALSE;
167
168     /* Open AFSD service */
169     svc = OpenService(scm, "TransarcAFSDaemon", SERVICE_QUERY_CONFIG);
170     if (!svc)
171         goto close_scm;
172
173     /* Query AFSD service config, first just to get buffer size */
174     /* Expected to fail, so don't test return value */
175     (void) QueryServiceConfig(svc, NULL, 0, &BufSize);
176     status = GetLastError();
177     if (status != ERROR_INSUFFICIENT_BUFFER)
178         goto close_svc;
179
180     /* Allocate buffer */
181     pConfig = (LPQUERY_SERVICE_CONFIG)GlobalAlloc(GMEM_FIXED,BufSize);
182     if (!pConfig)
183         goto close_svc;
184
185     /* Query AFSD service config, this time for real */
186     flag = QueryServiceConfig(svc, pConfig, BufSize, &BufSize);
187     if (!flag)
188         goto free_pConfig;
189
190     /* Is it autostart? */
191     if (pConfig->dwStartType < SERVICE_DEMAND_START)
192         result = TRUE;
193
194   free_pConfig:
195     GlobalFree(pConfig);
196   close_svc:
197     CloseServiceHandle(svc);
198   close_scm:
199     CloseServiceHandle(scm);
200
201     return result;
202 }
203
204 DWORD MapAuthError(DWORD code)
205 {
206     switch (code) {
207         /* Unfortunately, returning WN_NO_NETWORK results in the MPR abandoning
208          * logon scripts for all credential managers, although they will still
209          * receive logon notifications.  Since we don't want this, we return
210          * WN_SUCCESS.  This is highly undesirable, but we also don't want to
211          * break other network providers.
212          */
213  /* case KTC_NOCM:
214     case KTC_NOCMRPC:
215     return WN_NO_NETWORK; */
216     default: return WN_SUCCESS;
217   }
218 }
219
220 DWORD APIENTRY NPGetCaps(DWORD index)
221 {
222     switch (index) {
223     case WNNC_NET_TYPE:
224         /* Don't have our own type; use somebody else's. */
225         return WNNC_NET_OPENAFS;
226
227     case WNNC_START:
228         /* Say we are already started, even though we might wait after we receive NPLogonNotify */
229         return 1;
230
231     default:
232         return 0;
233     }
234 }       
235
236 NET_API_STATUS 
237 NetUserGetProfilePath( LPCWSTR Domain, LPCWSTR UserName, char * profilePath, 
238                        DWORD profilePathLen )
239 {
240     NET_API_STATUS code;
241     LPWSTR ServerName = NULL;
242     LPUSER_INFO_3 p3 = NULL;
243
244     NetGetAnyDCName(NULL, Domain, (LPBYTE *)&ServerName);
245     /* if NetGetAnyDCName fails, ServerName == NULL
246      * NetUserGetInfo will obtain local user information 
247      */
248     code = NetUserGetInfo(ServerName, UserName, 3, (LPBYTE *)&p3);
249     if (code == NERR_Success)
250     {
251         code = NERR_UserNotFound;
252         if (p3) {
253             if (p3->usri3_profile) {
254                 DWORD len = lstrlenW(p3->usri3_profile);
255                 if (len > 0) {
256                     /* Convert From Unicode to ANSI (UTF-8 for future) */
257                     len = len < profilePathLen ? len : profilePathLen - 1;
258                     WideCharToMultiByte(CP_UTF8, 0, p3->usri3_profile, len, profilePath, len, NULL, NULL);
259                     profilePath[len] = '\0';
260                     code = NERR_Success;
261                 }
262             }
263             NetApiBufferFree(p3);
264         }
265     }
266     if (ServerName) 
267         NetApiBufferFree(ServerName);
268     return code;
269 }
270
271 BOOL IsServiceRunning (void)
272 {
273     SERVICE_STATUS Status;
274     SC_HANDLE hManager;
275     memset (&Status, 0x00, sizeof(Status));
276     Status.dwCurrentState = SERVICE_STOPPED;
277
278     if ((hManager = OpenSCManager (NULL, NULL, GENERIC_READ)) != NULL)
279     {
280         SC_HANDLE hService;
281         if ((hService = OpenService (hManager, TEXT("TransarcAFSDaemon"), GENERIC_READ)) != NULL)
282         {
283             QueryServiceStatus (hService, &Status);
284             CloseServiceHandle (hService);
285         }
286
287         CloseServiceHandle (hManager);
288     }
289     DebugEvent("AFS AfsLogon - Test Service Running Return Code[%x] ?Running[%d]",Status.dwCurrentState,(Status.dwCurrentState == SERVICE_RUNNING));
290     return (Status.dwCurrentState == SERVICE_RUNNING);
291 }   
292
293 BOOL IsServiceStartPending (void)
294 {
295     SERVICE_STATUS Status;
296     SC_HANDLE hManager;
297     memset (&Status, 0x00, sizeof(Status));
298     Status.dwCurrentState = SERVICE_STOPPED;
299
300     if ((hManager = OpenSCManager (NULL, NULL, GENERIC_READ)) != NULL)
301     {
302         SC_HANDLE hService;
303         if ((hService = OpenService (hManager, TEXT("TransarcAFSDaemon"), GENERIC_READ)) != NULL)
304         {
305             QueryServiceStatus (hService, &Status);
306             CloseServiceHandle (hService);
307         }
308
309         CloseServiceHandle (hManager);
310     }
311     DebugEvent("AFS AfsLogon - Test Service Start Pending Return Code[%x] ?Start Pending[%d]",Status.dwCurrentState,(Status.dwCurrentState == SERVICE_START_PENDING));
312     return (Status.dwCurrentState == SERVICE_START_PENDING);
313 }   
314
315 /* LOOKUPKEYCHAIN: macro to look up the value in the list of keys in order until it's found
316    v:variable to receive value (reference type)
317    t:type
318    d:default, in case the value isn't on any of the keys
319    n:name of value */
320 #define LOOKUPKEYCHAIN(v,t,d,n) \
321         do { \
322                 rv = ~ERROR_SUCCESS; \
323                 dwType = t; \
324                 if(hkDom) { \
325                         dwSize = sizeof(v); \
326                         rv = RegQueryValueEx(hkDom, n, 0, &dwType, (LPBYTE) &(v), &dwSize); \
327                         if(rv == ERROR_SUCCESS || rv == ERROR_MORE_DATA) \
328                             DebugEvent(#v " found in hkDom with type [%d]", dwType); \
329                 } \
330                 if(hkDoms && ((rv != ERROR_SUCCESS && rv != ERROR_MORE_DATA) || dwType != t)) { \
331                         dwSize = sizeof(v); \
332                         rv = RegQueryValueEx(hkDoms, n, 0, &dwType, (LPBYTE) &(v), &dwSize); \
333                         if(rv == ERROR_SUCCESS || rv == ERROR_MORE_DATA) \
334                             DebugEvent(#v " found in hkDoms with type [%d]", dwType); \
335                 } \
336                 if(hkNp && ((rv != ERROR_SUCCESS && rv != ERROR_MORE_DATA) || dwType != t)) { \
337                         dwSize = sizeof(v); \
338                         rv = RegQueryValueEx(hkNp, n, 0, &dwType, (LPBYTE) &(v), &dwSize); \
339                         if(rv == ERROR_SUCCESS || rv == ERROR_MORE_DATA) \
340                             DebugEvent(#v " found in hkNp with type [%d]", dwType); \
341                 } \
342                 if((rv != ERROR_SUCCESS && rv != ERROR_MORE_DATA) || dwType != t) { \
343                         v = d; \
344                         DebugEvent0(#v " being set to default"); \
345                 } \
346         } while(0)
347
348 /* Get domain specific configuration info.  We are returning void because if anything goes wrong
349    we just return defaults.
350  */
351 void 
352 GetDomainLogonOptions( PLUID lpLogonId, char * username, char * domain, LogonOptions_t *opt ) {
353     HKEY hkParm = NULL; /* Service parameter */
354     HKEY hkNp = NULL;   /* network provider key */
355     HKEY hkDoms = NULL; /* domains key */
356     HKEY hkDom = NULL;  /* DOMAINS/domain key */
357     HKEY hkTemp = NULL;
358     LONG rv;
359     DWORD dwSize;
360     DWORD dwType;
361     DWORD dwDummy;
362     char computerName[MAX_COMPUTERNAME_LENGTH + 1]="";
363     char *effDomain = NULL;
364
365     memset(opt, 0, sizeof(LogonOptions_t));
366
367     DebugEvent("In GetDomainLogonOptions for user [%s] in domain [%s]", username, domain);
368     /* If the domain is the same as the Netbios computer name, we use the LOCALHOST domain name*/
369     opt->flags = LOGON_FLAG_REMOTE;
370     if(domain) {
371         dwSize = MAX_COMPUTERNAME_LENGTH + 1;
372         if(GetComputerName(computerName, &dwSize)) {
373             if(!cm_stricmp_utf8(computerName, domain)) {
374                 effDomain = "LOCALHOST";
375                 opt->flags = LOGON_FLAG_LOCAL;
376             }
377         }
378         if (effDomain == NULL)
379             effDomain = domain;
380     }
381
382     rv = RegOpenKeyEx( HKEY_LOCAL_MACHINE, AFSREG_CLT_SVC_PARAM_SUBKEY, 0, KEY_READ, &hkParm );
383     if(rv != ERROR_SUCCESS) {
384         hkParm = NULL;
385         DebugEvent("GetDomainLogonOption: Can't open parms key [%d]", rv);
386     }
387
388     rv = RegOpenKeyEx( HKEY_LOCAL_MACHINE, AFSREG_CLT_SVC_PROVIDER_SUBKEY, 0, KEY_READ, &hkNp );
389     if(rv != ERROR_SUCCESS) {
390         hkNp = NULL;
391         DebugEvent("GetDomainLogonOptions: Can't open NP key [%d]", rv);
392     }
393
394     if(hkNp) {
395         rv = RegOpenKeyEx( hkNp, REG_CLIENT_DOMAINS_SUBKEY, 0, KEY_READ, &hkDoms );
396         if( rv != ERROR_SUCCESS ) {
397             hkDoms = NULL;
398             DebugEvent("GetDomainLogonOptions: Can't open Domains key [%d]", rv);
399         }
400     }
401
402     if(hkDoms && effDomain) {
403         rv = RegOpenKeyEx( hkDoms, effDomain, 0, KEY_READ, &hkDom );
404         if( rv != ERROR_SUCCESS ) {
405             hkDom = NULL;
406             DebugEvent("GetDomainLogonOptions: Can't open domain key for [%s] [%d]", effDomain, rv);
407             /* If none of the domains match, we shouldn't use the domain key either */
408             RegCloseKey(hkDoms);
409             hkDoms = NULL;
410         }
411     } else
412         DebugEvent0("Not opening domain key");
413
414     /* Each individual can either be specified on the domain key, the domains key or in the
415        net provider key.  They fail over in that order.  If none is found, we just use the 
416        defaults. */
417
418     /* LogonOption */
419     LOOKUPKEYCHAIN(opt->LogonOption, REG_DWORD, DEFAULT_LOGON_OPTION, REG_CLIENT_LOGON_OPTION_PARM);
420
421     /* FailLoginsSilently */
422     dwSize = sizeof(dwDummy);
423     rv = RegQueryValueEx(hkParm, REG_CLIENT_FAIL_SILENTLY_PARM, 0, &dwType, (LPBYTE) &dwDummy, &dwSize);
424     if (rv != ERROR_SUCCESS)
425         LOOKUPKEYCHAIN(dwDummy, REG_DWORD, DEFAULT_FAIL_SILENTLY, REG_CLIENT_FAIL_SILENTLY_PARM);
426     opt->failSilently = dwDummy ? 1 :0;
427
428     /* Retry interval */
429     LOOKUPKEYCHAIN(opt->retryInterval, REG_DWORD, DEFAULT_RETRY_INTERVAL, REG_CLIENT_RETRY_INTERVAL_PARM);
430
431     /* Sleep interval */
432     LOOKUPKEYCHAIN(opt->sleepInterval, REG_DWORD, DEFAULT_SLEEP_INTERVAL, REG_CLIENT_SLEEP_INTERVAL_PARM);
433
434     if(!ISLOGONINTEGRATED(opt->LogonOption)) {
435         DebugEvent0("Integrated logon disabled");
436         goto cleanup; /* no need to lookup the logon script */
437     }
438
439     /* come up with SMB username */
440     if(ISHIGHSECURITY(opt->LogonOption)) {
441         DebugEvent0("High Security Mode active");
442         opt->smbName = malloc( MAXRANDOMNAMELEN );
443         if (opt->smbName == NULL)
444             goto cleanup;
445         GenRandomName(opt->smbName);
446     } else if (lpLogonId) {
447         /* username and domain for logon session is not necessarily the same as
448            username and domain passed into network provider. */
449         PSECURITY_LOGON_SESSION_DATA plsd=NULL;
450         char lsaUsername[MAX_USERNAME_LENGTH]="";
451         char lsaDomain[MAX_DOMAIN_LENGTH]="";
452         size_t len, tlen;
453         NTSTATUS Status;
454
455         Status = LsaGetLogonSessionData(lpLogonId, &plsd);
456         if ( FAILED(Status) || plsd == NULL ) {
457             DebugEvent("LsaGetLogonSessionData failed [0x%x]", Status);
458             goto bad_strings;
459         }
460         
461         if (!UnicodeStringToANSI(plsd->UserName, lsaUsername, MAX_USERNAME_LENGTH))
462             goto bad_strings;
463
464         if (!UnicodeStringToANSI(plsd->LogonDomain, lsaDomain, MAX_DOMAIN_LENGTH))
465             goto bad_strings;
466
467         DebugEvent("PLSD username[%s] domain[%s]",lsaUsername,lsaDomain);
468
469         if(SUCCEEDED(StringCbLength(lsaUsername, MAX_USERNAME_LENGTH, &tlen)))
470             len = tlen;
471         else
472             goto bad_strings;
473
474         if(SUCCEEDED(StringCbLength(lsaDomain, MAX_DOMAIN_LENGTH, &tlen)))
475             len += tlen;
476         else
477             goto bad_strings;
478
479         len += 2;
480
481         opt->smbName = malloc(len);
482         if (opt->smbName == NULL)
483             goto cleanup;
484
485         StringCbCopy(opt->smbName, len, lsaDomain);
486         StringCbCat(opt->smbName, len, "\\");
487         StringCbCat(opt->smbName, len, lsaUsername);
488
489         strlwr(opt->smbName);
490
491       bad_strings:
492         if (plsd)
493             LsaFreeReturnBuffer(plsd);
494     }
495     if (opt->smbName == NULL) {
496         size_t len;
497
498         DebugEvent("Constructing username using [%s] and [%s]",
499                    username, domain);
500  
501         len = strlen(username) + strlen(domain) + 2;
502
503         opt->smbName = malloc(len);
504         if (opt->smbName == NULL)
505             goto cleanup;
506
507         StringCbCopy(opt->smbName, len, domain);
508         StringCbCat(opt->smbName, len, "\\");
509         StringCbCat(opt->smbName, len, username);
510
511         strlwr(opt->smbName);
512     }
513
514     DebugEvent0("Looking up logon script");
515     /* Logon script */
516     /* First find out where the key is */
517     hkTemp = NULL;
518     rv = ~ERROR_SUCCESS;
519     dwType = 0;
520     if(hkDom)
521         rv = RegQueryValueExW(hkDom, REG_CLIENT_LOGON_SCRIPT_PARMW, 0, &dwType, NULL, &dwSize);
522     if(rv == ERROR_SUCCESS && (dwType == REG_SZ || dwType == REG_EXPAND_SZ)) {
523         hkTemp = hkDom;
524         DebugEvent0("Located logon script in hkDom");
525     }
526     else if(hkDoms) {
527         rv = RegQueryValueExW(hkDoms, REG_CLIENT_LOGON_SCRIPT_PARMW, 0, &dwType, NULL, &dwSize);
528         if(rv == ERROR_SUCCESS && !hkTemp && (dwType == REG_SZ || dwType == REG_EXPAND_SZ)) {
529             hkTemp = hkDoms;
530             DebugEvent0("Located logon script in hkDoms");
531         }
532         /* Note that the LogonScript in the NP key is only used if we are doing high security. */
533         else if(hkNp && ISHIGHSECURITY(opt->LogonOption)) {
534             rv = RegQueryValueExW(hkNp, REG_CLIENT_LOGON_SCRIPT_PARMW, 0, &dwType, NULL, &dwSize);
535             if(rv == ERROR_SUCCESS && !hkTemp && (dwType == REG_SZ || dwType == REG_EXPAND_SZ)) {
536                 hkTemp = hkNp;
537                 DebugEvent0("Located logon script in hkNp");
538             }
539         }
540     }
541
542     if(hkTemp) {
543         WCHAR *regscript        = NULL;
544         WCHAR *regexscript      = NULL;
545         WCHAR *regexuscript     = NULL;
546         WCHAR *wuname           = NULL;
547         HRESULT hr;
548
549         size_t len;
550
551         StringCbLength(opt->smbName, MAX_USERNAME_LENGTH, &len);
552         len ++;
553
554         wuname = malloc(len * sizeof(WCHAR));
555         if (!wuname)
556             goto doneLogonScript;
557         MultiByteToWideChar(CP_ACP,0,opt->smbName,-1,wuname,(int)(len*sizeof(WCHAR)));
558
559         DebugEvent("Username is set for [%S]", wuname);
560
561         /* dwSize still has the size of the required buffer in bytes. */
562         regscript = malloc(dwSize);
563         if (!regscript)
564             goto doneLogonScript;
565         rv = RegQueryValueExW(hkTemp, REG_CLIENT_LOGON_SCRIPT_PARMW, 0, &dwType, (LPBYTE) regscript, &dwSize);
566         if(rv != ERROR_SUCCESS) {/* what the ..? */
567             DebugEvent("Can't look up logon script rv [%d] size [%d] gle %d",rv, dwSize, GetLastError());
568             goto doneLogonScript;
569         }
570
571         DebugEvent("Found logon script [%S]", regscript);
572
573         if(dwType == REG_EXPAND_SZ) {
574             DWORD dwReq;
575
576             dwSize += MAX_PATH * sizeof(WCHAR);  /* make room for environment expansion. */
577             regexscript = malloc(dwSize);
578             if (!regexscript)
579                 goto doneLogonScript;
580             dwReq = ExpandEnvironmentStringsW(regscript, regexscript, dwSize / sizeof(WCHAR));
581             free(regscript);
582             regscript = regexscript;
583             regexscript = NULL;
584             if(dwReq > (dwSize / sizeof(WCHAR))) {
585                 DebugEvent0("Overflow while expanding environment strings.");
586                 goto doneLogonScript;
587             }
588         }
589
590         DebugEvent("After expanding env strings [%S]", regscript);
591
592         if(wcsstr(regscript, L"%s")) {
593             dwSize += (DWORD)(len * sizeof(WCHAR)); /* make room for username expansion */
594             regexuscript = (WCHAR *) LocalAlloc(LMEM_FIXED, dwSize);
595             if (!regexuscript)
596                 goto doneLogonScript;
597             hr = StringCbPrintfW(regexuscript, dwSize, regscript, wuname);
598         } else {
599             regexuscript = (WCHAR *) LocalAlloc(LMEM_FIXED, dwSize);
600             if (!regexuscript)
601                 goto doneLogonScript;
602             hr = StringCbCopyW(regexuscript, dwSize, regscript);
603         }
604
605         DebugEvent("After expanding username [%S]", regexuscript);
606
607         if(hr == S_OK)
608             opt->logonScript = regexuscript;
609         else
610             LocalFree(regexuscript);
611
612       doneLogonScript:
613         if(wuname) free(wuname);
614         if(regscript) free(regscript);
615         if(regexscript) free(regexscript);
616     }
617
618     DebugEvent0("Looking up TheseCells");
619     /* TheseCells */
620     /* First find out where the key is */
621     hkTemp = NULL;
622     rv = ~ERROR_SUCCESS;
623     dwSize = 0;
624     if (hkDom)
625         rv = RegQueryValueEx(hkDom, REG_CLIENT_THESE_CELLS_PARM, 0, &dwType, NULL, &dwSize);
626     if (rv == ERROR_SUCCESS && dwType == REG_MULTI_SZ) {
627         hkTemp = hkDom;
628         DebugEvent("Located TheseCells in hkDom size %d", dwSize);
629     } else if (hkDoms) {
630         rv = RegQueryValueEx(hkDoms, REG_CLIENT_THESE_CELLS_PARM, 0, &dwType, NULL, &dwSize);
631         if (rv == ERROR_SUCCESS && !hkTemp && dwType == REG_MULTI_SZ) {
632             hkTemp = hkDoms;
633             DebugEvent("Located TheseCells in hkDoms size %d", dwSize);
634         } else if (hkNp) {
635             rv = RegQueryValueEx(hkNp, REG_CLIENT_THESE_CELLS_PARM, 0, &dwType, NULL, &dwSize);
636             if (rv == ERROR_SUCCESS && !hkTemp && dwType == REG_MULTI_SZ) {
637                 hkTemp = hkNp;
638                 DebugEvent("Located TheseCells in hkNp size %d", dwSize);
639             }
640         }
641     }
642
643     if (hkTemp) {
644         CHAR * thesecells = NULL;
645
646         /* dwSize still has the size of the required buffer in bytes. */
647         thesecells = malloc(dwSize*2);
648         if (!thesecells)
649             goto doneTheseCells;
650         dwSize *= 2;
651         SetLastError(0);
652         rv = RegQueryValueEx(hkTemp, REG_CLIENT_THESE_CELLS_PARM, 0, NULL, (LPBYTE) thesecells, &dwSize);
653         if(rv != ERROR_SUCCESS) {/* what the ..? */
654             DebugEvent("Can't look up TheseCells rv [%d] size [%d] gle [%d]",rv, dwSize, GetLastError());
655             goto doneTheseCells;
656         }
657
658         DebugEvent("Found TheseCells [%s]", thesecells);
659         opt->theseCells = thesecells;
660         thesecells = NULL;
661
662       doneTheseCells:
663         if (thesecells) free(thesecells);
664     }
665
666     DebugEvent0("Looking up Realm");
667     /* Realm */
668     /* First find out where the key is */
669     hkTemp = NULL;
670     rv = ~ERROR_SUCCESS;
671     dwSize = 0;
672     if (hkDom)
673         rv = RegQueryValueEx(hkDom, REG_CLIENT_REALM_PARM, 0, &dwType, NULL, &dwSize);
674     if (rv == ERROR_SUCCESS && dwType == REG_SZ) {
675         hkTemp = hkDom;
676         DebugEvent("Located Realm in hkDom size %d", dwSize);
677     } else if (hkDoms) {
678         rv = RegQueryValueEx(hkDoms, REG_CLIENT_REALM_PARM, 0, &dwType, NULL, &dwSize);
679         if (rv == ERROR_SUCCESS && !hkTemp && dwType == REG_SZ) {
680             hkTemp = hkDoms;
681             DebugEvent("Located Realm in hkDoms size %d", dwSize);
682         } else if (hkNp) {
683             rv = RegQueryValueEx(hkNp, REG_CLIENT_REALM_PARM, 0, &dwType, NULL, &dwSize);
684             if (rv == ERROR_SUCCESS && !hkTemp && dwType == REG_SZ) {
685                 hkTemp = hkNp;
686                 DebugEvent("Located Realm in hkNp size %d", dwSize);
687             }
688         }
689     }
690
691     if (hkTemp) {
692         CHAR * realm = NULL;
693
694         /* dwSize still has the size of the required buffer in bytes. */
695         realm = malloc(dwSize*2);
696         if (!realm)
697             goto doneRealm;
698         dwSize *=2;
699         SetLastError(0);
700         rv = RegQueryValueEx(hkTemp, REG_CLIENT_REALM_PARM, 0, NULL, (LPBYTE) realm, &dwSize);
701         if(rv != ERROR_SUCCESS) {/* what the ..? */
702             DebugEvent("Can't look up Realm rv [%d] size [%d] gle [%d]",rv, dwSize, GetLastError());
703             goto doneRealm;
704         }
705
706         DebugEvent("Found Realm [%s]", realm);
707         opt->realm = realm;
708         realm = NULL;
709
710       doneRealm:
711         if (realm) free(realm);
712     }
713
714   cleanup:
715     if(hkNp) RegCloseKey(hkNp);
716     if(hkDom) RegCloseKey(hkDom);
717     if(hkDoms) RegCloseKey(hkDoms);
718     if(hkParm) RegCloseKey(hkParm);
719 }       
720
721 #undef LOOKUPKEYCHAIN
722
723 /* Try to find out which cell the given path is in.  We must retain
724    the contents of *cell in case of failure. *cell is assumed to be
725    at least cellLen chars */
726 DWORD GetFileCellName(char * path, char * cell, size_t cellLen) {
727     struct ViceIoctl blob;
728     char tcell[MAX_PATH];
729     DWORD code;
730
731     blob.in_size = 0;
732     blob.out_size = MAX_PATH;
733     blob.out = tcell;
734
735     code = pioctl(path, VIOC_FILE_CELL_NAME, &blob, 1);
736
737     if(!code) {
738         strncpy(cell, tcell, cellLen);
739         cell[cellLen - 1] = '\0';
740     }
741     return code;
742 }       
743
744
745 static BOOL
746 WINAPI
747 UnicodeStringToANSI(UNICODE_STRING uInputString, LPSTR lpszOutputString, int nOutStringLen)
748 {
749     CPINFO CodePageInfo;
750
751     GetCPInfo(CP_ACP, &CodePageInfo);
752
753     if (CodePageInfo.MaxCharSize > 1)
754         // Only supporting non-Unicode strings
755         return FALSE;
756     
757     if (uInputString.Buffer && ((LPBYTE) uInputString.Buffer)[1] == '\0')
758     {
759         // Looks like unicode, better translate it
760         // UNICODE_STRING specifies the length of the buffer string in Bytes not WCHARS
761         WideCharToMultiByte(CP_ACP, 0, (LPCWSTR) uInputString.Buffer, uInputString.Length/2,
762                             lpszOutputString, nOutStringLen-1, NULL, NULL);
763         lpszOutputString[min(uInputString.Length/2,nOutStringLen-1)] = '\0';
764         return TRUE;
765     }
766       
767     lpszOutputString[0] = '\0';
768     return FALSE;
769 }  // UnicodeStringToANSI
770
771 DWORD APIENTRY NPLogonNotify(
772         PLUID lpLogonId,
773         LPCWSTR lpAuthentInfoType,
774         LPVOID lpAuthentInfo,
775         LPCWSTR lpPreviousAuthentInfoType,
776         LPVOID lpPreviousAuthentInfo,
777         LPWSTR lpStationName,
778         LPVOID StationHandle,
779         LPWSTR *lpLogonScript)
780 {
781     char uname[MAX_USERNAME_LENGTH]="";
782     char password[MAX_PASSWORD_LENGTH]="";
783     char logonDomain[MAX_DOMAIN_LENGTH]="";
784     char cell[256]="<non-integrated logon>";
785     char homePath[MAX_PATH]="";
786     char szLogonId[128] = "";
787
788     MSV1_0_INTERACTIVE_LOGON *IL;
789
790     DWORD code = 0, code2;
791
792     int pw_exp;
793     char *reason;
794     char *ctemp;
795
796     BOOLEAN interactive;
797     BOOLEAN flag;
798     DWORD LSPtype, LSPsize;
799     HKEY NPKey;
800
801     HWND hwndOwner = (HWND)StationHandle;
802
803     BOOLEAN afsWillAutoStart;
804
805     BOOLEAN lowercased_name = TRUE;
806
807     LogonOptions_t opt; /* domain specific logon options */
808     int retryInterval;
809     int sleepInterval;
810
811     /* Are we interactive? */
812     interactive = (wcsicmp(lpStationName, L"WinSta0") == 0);
813
814 #ifdef DISABLE_NON_INTERACTIVE
815     /* Do not do anything if the logon session is not interactive. */
816     if (!interactive)
817         return 0;
818 #endif
819
820     (void) RegOpenKeyEx(HKEY_LOCAL_MACHINE, AFSREG_CLT_SVC_PARAM_SUBKEY,
821                          0, KEY_QUERY_VALUE, &NPKey);
822     LSPsize=sizeof(TraceOption);
823     RegQueryValueEx(NPKey, REG_CLIENT_TRACE_OPTION_PARM, NULL,
824                      &LSPtype, (LPBYTE)&TraceOption, &LSPsize);
825
826     RegCloseKey (NPKey);
827
828     DebugEvent("NPLogonNotify - LoginId(%d,%d)", lpLogonId->HighPart, lpLogonId->LowPart);
829
830     /* Make sure the AFS Libraries are initialized */
831     AfsLogonInit();
832
833     /* Initialize Logon Script to none */
834     *lpLogonScript=NULL;
835     
836     /* MSV1_0_INTERACTIVE_LOGON and KERB_INTERACTIVE_LOGON are equivalent for
837      * our purposes */
838
839     if ( wcsicmp(lpAuthentInfoType,L"MSV1_0:Interactive") && 
840          wcsicmp(lpAuthentInfoType,L"Kerberos:Interactive") )
841     {
842         DebugEvent("Unsupported Authentication Info Type: %S",
843                    lpAuthentInfoType);
844         return 0;
845     }
846
847     IL = (MSV1_0_INTERACTIVE_LOGON *) lpAuthentInfo;
848
849     /* Convert from Unicode to ANSI */
850
851     /*TODO: Use SecureZeroMemory to erase passwords */
852     if (!UnicodeStringToANSI(IL->UserName, uname, MAX_USERNAME_LENGTH) ||
853          !UnicodeStringToANSI(IL->Password, password, MAX_PASSWORD_LENGTH) ||
854          !UnicodeStringToANSI(IL->LogonDomainName, logonDomain, MAX_DOMAIN_LENGTH))
855         return 0;
856
857     /* Make sure AD-DOMANS sent from login that is sent to us is striped */
858     ctemp = strchr(uname, '@');
859     if (ctemp) *ctemp = 0;
860
861     /* is the name all lowercase? */
862     for ( ctemp = uname; *ctemp ; ctemp++) {
863         if ( !islower(*ctemp) ) {
864             lowercased_name = FALSE;
865             break;
866         }
867     }
868
869     /*
870      * Get Logon options
871      */
872
873     GetDomainLogonOptions( lpLogonId, uname, logonDomain, &opt );
874     retryInterval = opt.retryInterval;
875     sleepInterval = opt.sleepInterval;
876     *lpLogonScript = opt.logonScript;
877
878     if (retryInterval < sleepInterval)
879         sleepInterval = retryInterval;
880
881     DebugEvent("Got logon script: %S",opt.logonScript);
882
883     afsWillAutoStart = AFSWillAutoStart();
884
885     DebugEvent("LogonOption[%x], Service AutoStart[%d]",
886                 opt.LogonOption,afsWillAutoStart);
887     
888     /* Check for zero length password if integrated logon*/
889     if ( ISLOGONINTEGRATED(opt.LogonOption) )  {
890         if ( password[0] == 0 ) {
891             DebugEvent0("Password is the empty string");
892             code = GT_PW_NULL;
893             reason = "zero length password is illegal";
894             code=0;
895         }
896
897         /* Get cell name if doing integrated logon.  
898            We might overwrite this if we are logging into an AD realm and we find out that
899            the user's home dir is in some other cell. */
900         DebugEvent("About to call cm_GetRootCellName(%s)",cell);
901         code = cm_GetRootCellName(cell);
902         if (code < 0) { 
903             DebugEvent0("Unable to obtain Root Cell");
904             code = KTC_NOCELL;
905             reason = "unknown cell";
906             code=0;
907         } else {
908             DebugEvent("Cell is %s",cell);
909         }       
910
911         /* We get the user's home directory path, if applicable, though we can't lookup the
912            cell right away because the client service may not have started yet. This call
913            also sets the AD_REALM flag in opt.flags if applicable. */
914         if (ISREMOTE(opt.flags)) {
915             DebugEvent0("Is Remote");
916             GetAdHomePath(homePath,MAX_PATH,lpLogonId,&opt);
917         }
918     }
919
920     /* loop until AFS is started. */
921     if (afsWillAutoStart) {
922         while (IsServiceRunning() || IsServiceStartPending()) {
923             DebugEvent("while(autostart) LogonOption[%x], Service AutoStart[%d]",
924                         opt.LogonOption,afsWillAutoStart);
925
926             if (ISADREALM(opt.flags)) {
927                 code = GetFileCellName(homePath,cell,256);
928                 if (!code) {
929                     DebugEvent("profile path [%s] is in cell [%s]",homePath,cell);
930                 }
931                 /* Don't bail out if GetFileCellName failed.
932                  * The home dir may not be in AFS after all. 
933                  */
934             } else
935                 code=0;
936                 
937             /* if Integrated Logon  */
938             if (ISLOGONINTEGRATED(opt.LogonOption))
939             {                   
940                 if ( KFW_is_available() ) {
941                     SetEnvironmentVariable(DO_NOT_REGISTER_VARNAME, "");
942                     if (opt.realm) {
943                         char * principal, *p;
944                         size_t len, tlen;
945
946                         StringCchLength(opt.realm, MAX_DOMAIN_LENGTH, &tlen);
947                         len = tlen;
948                         StringCchLength(uname, MAX_USERNAME_LENGTH, &tlen);
949                         len += tlen + 2;
950
951                         /* tlen is now the length of uname in characters */
952                         principal = (char *)malloc(len * sizeof(char));
953                         if ( principal ) {
954                             StringCchCopy(principal, len, uname);
955                             p = principal + tlen;
956                             *p++ = '@';
957                             StringCchCopy(p, len - tlen -1, opt.realm);
958                             code = KFW_AFS_get_cred(principal, cell, password, 0, opt.smbName, &reason);
959                             DebugEvent("KFW_AFS_get_cred  uname=[%s] smbname=[%s] cell=[%s] code=[%d]",
960                                             principal,opt.smbName,cell,code);
961                             free(principal);
962                         }
963                     } else {
964                         code = KFW_AFS_get_cred(uname, cell, password, 0, opt.smbName, &reason);
965                         DebugEvent("KFW_AFS_get_cred  uname=[%s] smbname=[%s] cell=[%s] code=[%d]",
966                                     uname,opt.smbName,cell,code);
967                     }
968                     SetEnvironmentVariable(DO_NOT_REGISTER_VARNAME, NULL);
969                     if (code == 0 && opt.theseCells) { 
970                         char * principal, *p;
971                         size_t len, tlen;
972
973                         StringCchLength(opt.realm ? opt.realm : cell, MAX_DOMAIN_LENGTH, &tlen);
974                         len = tlen;
975                         StringCchLength(uname, MAX_USERNAME_LENGTH, &tlen);
976                         len += tlen + 2;
977
978                         /* tlen is now the length of uname in characters */
979                         principal = (char *)malloc(len * sizeof(char));
980                         if ( principal ) {
981                             StringCchCopy(principal, len, uname);
982                             p = principal + tlen;
983                             *p++ = '@';
984                             if (opt.realm) {
985                                 StringCchCopy(p, len - tlen -1, opt.realm);
986                             } else {
987                                 StringCchCopy(p, len - tlen - 1, cell);
988                                 for ( ;*p; p++) {
989                                     *p = toupper(*p);
990                                 }
991                             }
992                             p = opt.theseCells;
993                             while ( *p ) {
994                                 if ( cm_stricmp_utf8(p, cell) ) {
995                                     SetEnvironmentVariable(DO_NOT_REGISTER_VARNAME, "");
996                                     code2 = KFW_AFS_get_cred(principal, p, 0, 0, opt.smbName, &reason);
997                                     SetEnvironmentVariable(DO_NOT_REGISTER_VARNAME, NULL);
998                                     DebugEvent("KFW_AFS_get_cred  uname=[%s] smbname=[%s] cell=[%s] code=[%d]",
999                                                principal,opt.smbName,p,code2);
1000                                 }
1001                                 p += strlen(p) + 1;
1002                             }
1003                             free(principal);
1004                         }
1005                     }
1006                 } else {
1007                     code = ka_UserAuthenticateGeneral2(KA_USERAUTH_VERSION+KA_USERAUTH_AUTHENT_LOGON,
1008                                                         uname, "", cell, password, opt.smbName, 0, &pw_exp, 0,
1009                                                         &reason);
1010                     DebugEvent("AFS AfsLogon - (INTEGRATED only)ka_UserAuthenticateGeneral2 Code[%x] uname[%s] smbname=[%s] Cell[%s] PwExp=[%d] Reason=[%s]",
1011                                 code,uname,opt.smbName,cell,pw_exp,reason?reason:"");
1012                 }       
1013                 if ( code && code != KTC_NOCM && code != KTC_NOCMRPC && !lowercased_name ) {
1014                     for ( ctemp = uname; *ctemp ; ctemp++) {
1015                         *ctemp = tolower(*ctemp);
1016                     }
1017                     lowercased_name = TRUE;
1018                     goto sleeping;
1019                 }
1020
1021                 /* is service started yet?*/
1022
1023                 /* If we've failed because the client isn't running yet and the
1024                  * client is set to autostart (and therefore it makes sense for
1025                  * us to wait for it to start) then sleep a while and try again. 
1026                  * If the error was something else, then give up. */
1027                 if (code != KTC_NOCM && code != KTC_NOCMRPC)
1028                     break;
1029             }
1030             else {  
1031                 /*JUST check to see if its running*/
1032                 if (IsServiceRunning())
1033                     break;
1034                 if (!IsServiceStartPending()) {
1035                     code = KTC_NOCMRPC;
1036                     reason = "AFS Service start failed";
1037                     break;
1038                 }
1039             }
1040
1041             /* If the retry interval has expired and we still aren't
1042              * logged in, then just give up if we are not in interactive
1043              * mode or the failSilently flag is set, otherwise let the
1044              * user know we failed and give them a chance to try again. */
1045             if (retryInterval <= 0) {
1046                 reason = "AFS not running";
1047                 if (!interactive || opt.failSilently)
1048                     break;
1049                 flag = MessageBox(hwndOwner,
1050                                    "AFS is still starting.  Retry?",
1051                                    "AFS Logon",
1052                                    MB_ICONQUESTION | MB_RETRYCANCEL);
1053                 if (flag == IDCANCEL)
1054                     break;
1055
1056                 /* Wait just a little while and try again */
1057                 retryInterval = opt.retryInterval;
1058             }
1059
1060           sleeping:
1061             Sleep(sleepInterval * 1000);
1062             retryInterval -= sleepInterval;
1063         }
1064     }
1065     DebugEvent0("while loop exited");
1066
1067     /* remove any kerberos 5 tickets currently held by the SYSTEM account
1068      * for this user 
1069      */
1070
1071     if (ISLOGONINTEGRATED(opt.LogonOption) && KFW_is_available()) {
1072 #ifdef KFW_LOGON
1073         sprintf(szLogonId,"%d.%d",lpLogonId->HighPart, lpLogonId->LowPart);
1074         KFW_AFS_copy_cache_to_system_file(uname, szLogonId);
1075 #endif
1076         KFW_AFS_destroy_tickets_for_principal(uname);
1077     }
1078
1079     if (code) {
1080         char msg[128];
1081         HANDLE h;
1082         char *ptbuf[1];
1083
1084         StringCbPrintf(msg, sizeof(msg), "Integrated login failed: %s", reason);
1085
1086         if (ISLOGONINTEGRATED(opt.LogonOption) && interactive && !opt.failSilently)
1087             MessageBox(hwndOwner, msg, "AFS Logon", MB_OK);
1088
1089         h = RegisterEventSource(NULL, AFS_LOGON_EVENT_NAME);
1090         ptbuf[0] = msg;
1091         ReportEvent(h, EVENTLOG_WARNING_TYPE, 0, 1008, NULL,
1092                      1, 0, ptbuf, NULL);
1093         DeregisterEventSource(h);
1094             
1095         code = MapAuthError(code);
1096         SetLastError(code);
1097
1098         if (ISLOGONINTEGRATED(opt.LogonOption) && (code!=0))
1099         {
1100             if (*lpLogonScript)
1101                 LocalFree(*lpLogonScript);
1102             *lpLogonScript = NULL;
1103             if (!afsWillAutoStart)      // its not running, so if not autostart or integrated logon then just skip
1104                 code = 0;
1105         }
1106     }
1107
1108     if (opt.theseCells) free(opt.theseCells);
1109     if (opt.smbName) free(opt.smbName);
1110     if (opt.realm) free(opt.realm);
1111
1112     DebugEvent("AFS AfsLogon - Exit","Return Code[%x]",code);
1113     return code;
1114 }       
1115
1116 DWORD APIENTRY NPPasswordChangeNotify(
1117         LPCWSTR lpAuthentInfoType,
1118         LPVOID lpAuthentInfo,
1119         LPCWSTR lpPreviousAuthentInfoType,
1120         LPVOID lpPreviousAuthentInfo,
1121         LPWSTR lpStationName,
1122         LPVOID StationHandle,
1123         DWORD dwChangeInfo)
1124 {
1125     BOOLEAN interactive;
1126
1127     /* Are we interactive? */
1128     interactive = (wcsicmp(lpStationName, L"WinSta0") == 0);
1129
1130     /* Do not do anything if the logon session is not interactive. */
1131     if (!interactive)
1132         return 0;
1133
1134     /* Make sure the AFS Libraries are initialized */
1135     AfsLogonInit();
1136
1137     DebugEvent0("AFS AfsLogon - NPPasswordChangeNotify");
1138     return 0;
1139 }
1140
1141 #include <userenv.h>
1142 #include <Winwlx.h>
1143 #include <afs/vice.h>
1144 #include <afs/fs_utils.h>
1145
1146 BOOL IsPathInAfs(const CHAR *strPath)
1147 {
1148     char space[2048];
1149     struct ViceIoctl blob;
1150     int code;
1151
1152     blob.in_size = 0;
1153     blob.out_size = 2048;
1154     blob.out = space;
1155
1156     code = pioctl((LPTSTR)((LPCTSTR)strPath), VIOC_FILE_CELL_NAME, &blob, 1);
1157     if (code)
1158         return FALSE;
1159     return TRUE;
1160 }
1161
1162 #ifdef COMMENT
1163 typedef struct _WLX_NOTIFICATION_INFO {  
1164     ULONG Size;  
1165     ULONG Flags;  
1166     PWSTR UserName;  
1167     PWSTR Domain;  
1168     PWSTR WindowStation;  
1169     HANDLE hToken;  
1170     HDESK hDesktop;  
1171     PFNMSGECALLBACK pStatusCallback;
1172 } WLX_NOTIFICATION_INFO, *PWLX_NOTIFICATION_INFO;
1173 #endif
1174
1175 VOID AFS_Startup_Event( PWLX_NOTIFICATION_INFO pInfo )
1176 {
1177     DWORD LSPtype, LSPsize;
1178     HKEY NPKey;
1179
1180     /* Make sure the AFS Libraries are initialized */
1181     AfsLogonInit();
1182
1183     (void) RegOpenKeyEx(HKEY_LOCAL_MACHINE, AFSREG_CLT_SVC_PARAM_SUBKEY,
1184                         0, KEY_QUERY_VALUE, &NPKey);
1185     LSPsize=sizeof(TraceOption);
1186     RegQueryValueEx(NPKey, REG_CLIENT_TRACE_OPTION_PARM, NULL,
1187                      &LSPtype, (LPBYTE)&TraceOption, &LSPsize);
1188
1189     RegCloseKey (NPKey);
1190     DebugEvent0("AFS_Startup_Event");
1191 }
1192
1193 VOID AFS_Logoff_Event( PWLX_NOTIFICATION_INFO pInfo )
1194 {
1195     DWORD code;
1196     TCHAR profileDir[1024] = TEXT("");
1197     DWORD  len = 1024;
1198     PTOKEN_USER  tokenUser = NULL;
1199     DWORD  retLen;
1200     DWORD LSPtype, LSPsize;
1201     HKEY NPKey;
1202     DWORD LogoffPreserveTokens = 0;
1203     LogonOptions_t opt;
1204
1205     /* Make sure the AFS Libraries are initialized */
1206     AfsLogonInit();
1207
1208     DebugEvent0("AFS_Logoff_Event - Start");
1209
1210     (void) RegOpenKeyEx(HKEY_LOCAL_MACHINE, AFSREG_CLT_SVC_PARAM_SUBKEY,
1211                          0, KEY_QUERY_VALUE, &NPKey);
1212     LSPsize=sizeof(LogoffPreserveTokens);
1213     RegQueryValueEx(NPKey, REG_CLIENT_LOGOFF_TOKENS_PARM, NULL,
1214                      &LSPtype, (LPBYTE)&LogoffPreserveTokens, &LSPsize);
1215     RegCloseKey (NPKey);
1216
1217     if (!LogoffPreserveTokens) {
1218         memset(&opt, 0, sizeof(LogonOptions_t));
1219
1220         if (pInfo->UserName && pInfo->Domain) {
1221             char username[MAX_USERNAME_LENGTH] = "";
1222             char domain[MAX_DOMAIN_LENGTH] = "";
1223             size_t szlen = 0;
1224
1225             StringCchLengthW(pInfo->UserName, MAX_USERNAME_LENGTH, &szlen);
1226             WideCharToMultiByte(CP_UTF8, 0, pInfo->UserName, szlen,
1227                                  username, sizeof(username), NULL, NULL);
1228
1229             StringCchLengthW(pInfo->Domain, MAX_DOMAIN_LENGTH, &szlen);
1230             WideCharToMultiByte(CP_UTF8, 0, pInfo->Domain, szlen,
1231                                  domain, sizeof(domain), NULL, NULL);
1232
1233             GetDomainLogonOptions(NULL, username, domain, &opt);
1234         }
1235
1236         if (ISREMOTE(opt.flags)) {
1237             if (!GetTokenInformation(pInfo->hToken, TokenUser, NULL, 0, &retLen))
1238             {
1239                 if ( GetLastError() == ERROR_INSUFFICIENT_BUFFER ) {
1240                     tokenUser = (PTOKEN_USER) LocalAlloc(LPTR, retLen);
1241
1242                     if (!GetTokenInformation(pInfo->hToken, TokenUser, tokenUser, retLen, &retLen))
1243                     {
1244                         DebugEvent("AFS_Logoff_Event - GetTokenInformation failed: GLE = %lX", GetLastError());
1245                     }
1246                 }
1247             }
1248
1249             /* We can't use pInfo->Domain for the domain since in the cross realm case 
1250              * this is source domain and not the destination domain.
1251              */
1252             if (tokenUser && QueryAdHomePathFromSid( profileDir, sizeof(profileDir), tokenUser->User.Sid, pInfo->Domain)) {
1253                 WCHAR Domain[64]=L"";
1254                 GetLocalShortDomain(Domain, sizeof(Domain));
1255                 if (QueryAdHomePathFromSid( profileDir, sizeof(profileDir), tokenUser->User.Sid, Domain)) {
1256                     if (NetUserGetProfilePath(pInfo->Domain, pInfo->UserName, profileDir, len))
1257                         GetUserProfileDirectory(pInfo->hToken, profileDir, &len);
1258                 }
1259             }
1260
1261             if (strlen(profileDir)) {
1262                 DebugEvent("AFS_Logoff_Event - Profile Directory: %s", profileDir);
1263                 if (!IsPathInAfs(profileDir)) {
1264                     if (code = ktc_ForgetAllTokens())
1265                         DebugEvent("AFS_Logoff_Event - ForgetAllTokens failed [%lX]",code);
1266                     else
1267                         DebugEvent0("AFS_Logoff_Event - ForgetAllTokens succeeded");
1268                 } else {
1269                     DebugEvent0("AFS_Logoff_Event - Tokens left in place; profile in AFS");
1270                 }
1271             } else {
1272                 DebugEvent0("AFS_Logoff_Event - Unable to load profile");
1273             }
1274
1275             if ( tokenUser )
1276                 LocalFree(tokenUser);
1277         } else {
1278             DebugEvent0("AFS_Logoff_Event - Local Logon");
1279             if (code = ktc_ForgetAllTokens())
1280                 DebugEvent("AFS_Logoff_Event - ForgetAllTokens failed [%lX]",code);
1281             else
1282                 DebugEvent0("AFS_Logoff_Event - ForgetAllTokens succeeded");
1283         }
1284     } else {
1285         DebugEvent0("AFS_Logoff_Event - Preserving Tokens");
1286     }
1287
1288     DebugEvent0("AFS_Logoff_Event - End");
1289 }   
1290
1291 VOID AFS_Logon_Event( PWLX_NOTIFICATION_INFO pInfo )
1292 {
1293     TCHAR profileDir[1024] = TEXT("");
1294     DWORD  len = 1024;
1295     PTOKEN_USER  tokenUser = NULL;
1296     DWORD  retLen;
1297     WCHAR szUserW[128] = L"";
1298     char  szUserA[128] = "";
1299     char  szClient[MAX_PATH];
1300     char szPath[MAX_PATH] = "";
1301     NETRESOURCE nr;
1302     DWORD res;
1303     DWORD dwSize;
1304     LogonOptions_t opt;
1305
1306     /* Make sure the AFS Libraries are initialized */
1307     AfsLogonInit();
1308
1309     DebugEvent0("AFS_Logon_Event - Start");
1310
1311     DebugEvent("AFS_Logon_Event Process ID: %d",GetCurrentProcessId());
1312
1313     memset(&opt, 0, sizeof(LogonOptions_t));
1314
1315     if (pInfo->UserName && pInfo->Domain) {
1316         char username[MAX_USERNAME_LENGTH] = "";
1317         char domain[MAX_DOMAIN_LENGTH] = "";
1318         size_t szlen = 0;
1319
1320         DebugEvent0("AFS_Logon_Event - pInfo UserName and Domain");
1321
1322         StringCchLengthW(pInfo->UserName, MAX_USERNAME_LENGTH, &szlen);
1323         WideCharToMultiByte(CP_UTF8, 0, pInfo->UserName, szlen,
1324                             username, sizeof(username), NULL, NULL);
1325         
1326         StringCchLengthW(pInfo->Domain, MAX_DOMAIN_LENGTH, &szlen);
1327         WideCharToMultiByte(CP_UTF8, 0, pInfo->Domain, szlen,
1328                             domain, sizeof(domain), NULL, NULL);
1329
1330         DebugEvent0("AFS_Logon_Event - Calling GetDomainLogonOptions");
1331         GetDomainLogonOptions(NULL, username, domain, &opt);
1332     } else {
1333         if (!pInfo->UserName)
1334             DebugEvent0("AFS_Logon_Event - No pInfo->UserName");
1335         if (!pInfo->Domain)
1336             DebugEvent0("AFS_Logon_Event - No pInfo->Domain");
1337     }
1338
1339     DebugEvent("AFS_Logon_Event - opt.LogonOption = %lX opt.flags = %lX", 
1340                 opt.LogonOption, opt.flags);
1341
1342     if (!ISLOGONINTEGRATED(opt.LogonOption) || !ISREMOTE(opt.flags)) {
1343         DebugEvent0("AFS_Logon_Event - Logon is not integrated or not remote");
1344         goto done_logon_event;
1345     }
1346
1347     DebugEvent0("AFS_Logon_Event - Calling GetTokenInformation");
1348
1349     if (!GetTokenInformation(pInfo->hToken, TokenUser, NULL, 0, &retLen))
1350     {
1351         if ( GetLastError() == ERROR_INSUFFICIENT_BUFFER ) {
1352             tokenUser = (PTOKEN_USER) LocalAlloc(LPTR, retLen);
1353
1354             if (!GetTokenInformation(pInfo->hToken, TokenUser, tokenUser, retLen, &retLen))
1355             {
1356                 DebugEvent("AFS_Logon_Event - GetTokenInformation failed: GLE = %lX", GetLastError());
1357             }
1358         }
1359     }
1360
1361     /* We can't use pInfo->Domain for the domain since in the cross realm case 
1362      * this is source domain and not the destination domain.
1363      */
1364     if (tokenUser && QueryAdHomePathFromSid( profileDir, sizeof(profileDir), tokenUser->User.Sid, pInfo->Domain)) {
1365         WCHAR Domain[64]=L"";
1366         GetLocalShortDomain(Domain, sizeof(Domain));
1367         if (QueryAdHomePathFromSid( profileDir, sizeof(profileDir), tokenUser->User.Sid, Domain)) {
1368             if (NetUserGetProfilePath(pInfo->Domain, pInfo->UserName, profileDir, len))
1369                 GetUserProfileDirectory(pInfo->hToken, profileDir, &len);
1370         }
1371     }
1372     
1373     if (strlen(profileDir)) {
1374         DebugEvent("AFS_Logon_Event - Profile Directory: %s", profileDir);
1375     } else {
1376         DebugEvent0("AFS_Logon_Event - Unable to load profile");
1377     }
1378
1379   done_logon_event:
1380     dwSize = sizeof(szUserA);
1381     if (!KFW_AFS_get_lsa_principal(szUserA, &dwSize)) {
1382         StringCbPrintfW(szUserW, sizeof(szUserW), L"%s\\%s", pInfo->Domain, pInfo->UserName);
1383         WideCharToMultiByte(CP_ACP, 0, szUserW, -1, szUserA, MAX_PATH, NULL, NULL);
1384     }
1385
1386     if (szUserA[0])
1387     {
1388         lana_GetNetbiosName(szClient, LANA_NETBIOS_NAME_FULL);
1389         StringCbPrintf(szPath, sizeof(szPath), "\\\\%s", szClient);
1390
1391         DebugEvent("AFS_Logon_Event - Logon Name: %s", szUserA);
1392
1393         memset (&nr, 0x00, sizeof(NETRESOURCE));
1394         nr.dwType=RESOURCETYPE_DISK;
1395         nr.lpLocalName=0;
1396         nr.lpRemoteName=szPath;
1397         res = WNetAddConnection2(&nr,NULL,szUserA,0);
1398         if (res)
1399             DebugEvent("AFS_Logon_Event - WNetAddConnection2(%s,%s) failed: 0x%X",
1400                         szPath, szUserA,res);
1401         else
1402             DebugEvent0("AFS_Logon_Event - WNetAddConnection2() succeeded");
1403     } else 
1404         DebugEvent("AFS_Logon_Event - User name conversion failed: GLE = 0x%X",GetLastError());
1405
1406     if ( tokenUser )
1407         LocalFree(tokenUser);
1408
1409     DebugEvent0("AFS_Logon_Event - End");
1410 }
1411
1412 static BOOL
1413 GetSecurityLogonSessionData(HANDLE hToken, PSECURITY_LOGON_SESSION_DATA * ppSessionData)
1414 {
1415     NTSTATUS Status = 0;
1416     TOKEN_STATISTICS Stats;
1417     DWORD   ReqLen;
1418     BOOL    Success;
1419
1420     if (!ppSessionData)
1421         return FALSE;
1422     *ppSessionData = NULL;
1423
1424     Success = GetTokenInformation( hToken, TokenStatistics, &Stats, sizeof(TOKEN_STATISTICS), &ReqLen );
1425     if ( !Success )
1426         return FALSE;
1427
1428     Status = LsaGetLogonSessionData( &Stats.AuthenticationId, ppSessionData );
1429     if ( FAILED(Status) || !ppSessionData )
1430         return FALSE;
1431
1432     return TRUE;
1433 }
1434
1435 VOID KFW_Logon_Event( PWLX_NOTIFICATION_INFO pInfo )
1436 {
1437 #ifdef KFW_LOGON
1438     WCHAR szUserW[128] = L"";
1439     char  szUserA[128] = "";
1440     char szPath[MAX_PATH] = "";
1441     char szLogonId[128] = "";
1442     DWORD count;
1443     char filename[MAX_PATH] = "";
1444     char newfilename[MAX_PATH] = "";
1445     char commandline[MAX_PATH+256] = "";
1446     STARTUPINFO startupinfo;
1447     PROCESS_INFORMATION procinfo;
1448     HANDLE hf = INVALID_HANDLE_VALUE;
1449
1450     LUID LogonId = {0, 0};
1451     PSECURITY_LOGON_SESSION_DATA pLogonSessionData = NULL;
1452
1453     HKEY hKey1 = NULL, hKey2 = NULL;
1454
1455     /* Make sure the KFW Libraries are initialized */
1456     AfsLogonInit();
1457
1458     DebugEvent0("KFW_Logon_Event - Start");
1459
1460     GetSecurityLogonSessionData( pInfo->hToken, &pLogonSessionData );
1461
1462     if ( pLogonSessionData ) {
1463         LogonId = pLogonSessionData->LogonId;
1464         DebugEvent("KFW_Logon_Event - LogonId(%d,%d)", LogonId.HighPart, LogonId.LowPart);
1465
1466         sprintf(szLogonId,"%d.%d",LogonId.HighPart, LogonId.LowPart);
1467         LsaFreeReturnBuffer( pLogonSessionData );
1468     } else {
1469         DebugEvent0("KFW_Logon_Event - Unable to determine LogonId");
1470         return;
1471     }
1472
1473     count = GetEnvironmentVariable("TEMP", filename, sizeof(filename));
1474     if ( count > sizeof(filename) || count == 0 ) {
1475         GetWindowsDirectory(filename, sizeof(filename));
1476     }
1477
1478     count = GetEnvironmentVariable("TEMP", filename, sizeof(filename));
1479     if ( count > sizeof(filename) || count == 0 ) {
1480         GetWindowsDirectory(filename, sizeof(filename));
1481     }
1482
1483     if ( strlen(filename) + strlen(szLogonId) + 2 > sizeof(filename) ) {
1484         DebugEvent0("KFW_Logon_Event - filename too long");
1485         return;
1486     }
1487
1488     strcat(filename, "\\");
1489     strcat(filename, szLogonId);    
1490
1491     hf = CreateFile(filename, FILE_ALL_ACCESS, 0, NULL, OPEN_EXISTING, 
1492                      FILE_ATTRIBUTE_NORMAL, NULL);
1493     if (hf == INVALID_HANDLE_VALUE) {
1494         DebugEvent0("KFW_Logon_Event - file cannot be opened");
1495         return;
1496     }
1497     CloseHandle(hf);
1498  
1499     if (KFW_AFS_set_file_cache_dacl(filename, pInfo->hToken)) {
1500         DebugEvent0("KFW_Logon_Event - unable to set dacl");
1501         DeleteFile(filename);
1502         return;
1503     }
1504  
1505     if (KFW_AFS_obtain_user_temp_directory(pInfo->hToken, newfilename, sizeof(newfilename))) {
1506         DebugEvent0("KFW_Logon_Event - unable to obtain temp directory");
1507         return;
1508     }
1509
1510     if ( strlen(newfilename) + strlen(szLogonId) + 2 > sizeof(newfilename) ) {
1511         DebugEvent0("KFW_Logon_Event - new filename too long");
1512         return;
1513     }
1514
1515     strcat(newfilename, "\\");
1516     strcat(newfilename, szLogonId);    
1517
1518     if (!MoveFileEx(filename, newfilename, 
1519                      MOVEFILE_COPY_ALLOWED | MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH)) {
1520         DebugEvent("KFW_Logon_Event - MoveFileEx failed GLE = 0x%x", GetLastError());
1521         return;
1522     }
1523
1524     sprintf(commandline, "afscpcc.exe \"%s\"", newfilename);
1525
1526     GetStartupInfo(&startupinfo);
1527     if (CreateProcessAsUser( pInfo->hToken,
1528                              "afscpcc.exe",
1529                              commandline,
1530                              NULL,
1531                              NULL,
1532                              FALSE,
1533                              CREATE_NEW_PROCESS_GROUP | DETACHED_PROCESS,
1534                              NULL,
1535                              NULL,
1536                              &startupinfo,
1537                              &procinfo)) 
1538     {
1539         DebugEvent("KFW_Logon_Event - CommandLine %s", commandline);
1540
1541         WaitForSingleObject(procinfo.hProcess, 30000);
1542
1543         CloseHandle(procinfo.hThread);
1544         CloseHandle(procinfo.hProcess);
1545     } else {
1546         DebugEvent0("KFW_Logon_Event - CreateProcessFailed");
1547     }
1548
1549     DeleteFile(filename);
1550
1551     DebugEvent0("KFW_Logon_Event - End");
1552 #endif
1553 }
1554