56e9ef1663bf6af0abca5da150ca9793cc08b3e0
[openafs.git] / src / WINNT / afsrdr / npdll / AFS_Npdll.c
1 /*
2  * Copyright (c) 2008, 2009, 2010, 2011 Kernel Drivers, LLC.
3  * Copyright (c) 2009, 2010, 2011 Your File System, Inc.
4  * All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  *
10  * - Redistributions of source code must retain the above copyright notice,
11  *   this list of conditions and the following disclaimer.
12  * - Redistributions in binary form must reproduce the above copyright
13  *   notice,
14  *   this list of conditions and the following disclaimer in the
15  *   documentation
16  *   and/or other materials provided with the distribution.
17  * - Neither the names of Kernel Drivers, LLC and Your File System, Inc.
18  *   nor the names of their contributors may be used to endorse or promote
19  *   products derived from this software without specific prior written
20  *   permission from Kernel Drivers, LLC and Your File System, Inc.
21  *
22  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
23  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
24  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
25  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
26  * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
27  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
28  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
29  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
30  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
31  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
32  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33  */
34
35 #ifndef _WIN32_WINNT
36 #define _WIN32_WINNT 0x0500
37 #endif
38
39 #include <windows.h>
40 #include <windef.h>
41 #include <winbase.h>
42 #include <winreg.h>
43 #include <winsvc.h>
44 #include <winnetwk.h>
45 #include <npapi.h>
46 #include <winioctl.h>
47 #include <strsafe.h>
48
49 #define AFS_DEBUG_TRACE 1
50
51 #ifndef WNNC_NET_OPENAFS
52 #define WNNC_NET_OPENAFS     0x00390000
53 #endif
54
55 #include "AFSUserDefines.h"
56 #include "AFSUserIoctl.h"
57 #include "AFSUserStructs.h"
58 #include "AFSProvider.h"
59 #include "AFS_Npdll.h"
60
61 #include "stdio.h"
62
63 #ifndef MAX_PATH
64 #define MAX_PATH 260
65 #endif
66
67 #define SCRATCHSZ 1024
68
69 //
70 // Common information
71 //
72
73 ULONG _cdecl AFSDbgPrint( PWCHAR Format, ... );
74
75 #define WNNC_DRIVER( major, minor ) ( major * 0x00010000 + minor )
76
77 #define OPENAFS_PROVIDER_NAME           L"OpenAFS Network"
78 #define OPENAFS_PROVIDER_NAME_LENGTH    30
79
80 #define MAX_PROVIDER_NAME_LENGTH        256
81
82 static ULONG cbProviderNameLength = OPENAFS_PROVIDER_NAME_LENGTH;
83
84 static wchar_t wszProviderName[MAX_PROVIDER_NAME_LENGTH+1] = OPENAFS_PROVIDER_NAME;
85
86 static BOOL bProviderNameRead = FALSE;
87
88 #define OPENAFS_SERVER_NAME             L"AFS"
89 #define OPENAFS_SERVER_NAME_LENGTH      6
90
91 #define OPENAFS_SERVER_COMMENT          L"AFS Root"
92 #define OPENAFS_SERVER_COMMENT_LENGTH   16
93
94 #define MAX_SERVER_NAME_LENGTH         30
95
96 static ULONG cbServerNameLength = 0;
97
98 static ULONG cbServerNameUNCLength = 0;
99
100 static ULONG cbServerCommentLength = OPENAFS_SERVER_COMMENT_LENGTH;
101
102 static wchar_t wszServerName[MAX_SERVER_NAME_LENGTH+1];
103
104 static wchar_t wszServerNameUNC[MAX_SERVER_NAME_LENGTH+3];
105
106 static wchar_t wszServerComment[] = OPENAFS_SERVER_COMMENT;
107
108 static BOOL bServerNameRead = FALSE;
109
110 LARGE_INTEGER
111 AFSRetrieveAuthId( void);
112
113 void
114 ReadProviderNameString( void)
115 {
116     HKEY hk;
117     DWORD code;
118     DWORD dwLen = 0;
119
120     if ( bProviderNameRead )
121         return;
122
123     code = RegOpenKeyExW( HKEY_LOCAL_MACHINE,
124                          L"SYSTEM\\CurrentControlSet\\Services\\AFSRedirector\\NetworkProvider",
125                          0, KEY_QUERY_VALUE, &hk);
126
127     if ( code == ERROR_SUCCESS) {
128
129         dwLen = sizeof(wszProviderName);
130
131         code = RegQueryValueExW( hk, L"Name", NULL, NULL,
132                                  (LPBYTE) wszProviderName, &dwLen);
133
134         if ( code == ERROR_SUCCESS)
135         {
136
137             wszProviderName[MAX_PROVIDER_NAME_LENGTH] = '\0';
138
139             cbProviderNameLength = wcslen( wszProviderName) * sizeof( WCHAR);
140         }
141
142         RegCloseKey( hk);
143     }
144
145     bProviderNameRead = TRUE;
146 }
147
148 void
149 ReadServerNameString( void)
150 {
151     HKEY hk;
152     DWORD code;
153     DWORD dwLen = 0;
154
155     if ( bServerNameRead )
156         return;
157
158     code = RegOpenKeyExW( HKEY_LOCAL_MACHINE,
159                          L"SYSTEM\\CurrentControlSet\\Services\\TransarcAFSDaemon\\Parameters",
160                          0, KEY_QUERY_VALUE, &hk);
161
162     if ( code == ERROR_SUCCESS) {
163
164         dwLen = sizeof(wszProviderName);
165
166         code = RegQueryValueExW( hk, L"NetbiosName", NULL, NULL,
167                                  (LPBYTE) wszServerName, &dwLen);
168
169         if ( code == ERROR_SUCCESS)
170         {
171
172             wszServerName[MAX_SERVER_NAME_LENGTH] = '\0';
173
174             cbServerNameLength = wcslen( wszServerName) * sizeof( WCHAR);
175
176             wszServerNameUNC[0] = wszServerNameUNC[1] = L'\\';
177
178             memcpy(&wszServerNameUNC[2], wszServerName, (cbServerNameLength + 1) * sizeof( WCHAR));
179
180             cbServerNameUNCLength = cbServerNameLength + 2 * sizeof( WCHAR);
181         }
182
183         RegCloseKey( hk);
184     }
185
186     bServerNameRead = TRUE;
187 }
188
189
190
191 /* returns TRUE if the file system is disabled or not installed */
192 BOOL
193 NPIsFSDisabled( void)
194 {
195     HKEY hk;
196     DWORD code;
197     DWORD dwLen = 0;
198     DWORD dwStart = SERVICE_DISABLED;
199
200     code = RegOpenKeyExW( HKEY_LOCAL_MACHINE,
201                          L"SYSTEM\\CurrentControlSet\\Services\\AFSRedirector",
202                          0, KEY_QUERY_VALUE, &hk);
203
204     if ( code != ERROR_SUCCESS)
205
206         return TRUE;
207
208
209     dwLen = sizeof(dwStart);
210
211     code = RegQueryValueExW( hk, L"Start", NULL, NULL,
212                              (LPBYTE) &dwStart, &dwLen);
213
214     RegCloseKey( hk);
215
216     return ( dwStart == SERVICE_DISABLED);
217 }
218
219
220 #define try_return(S) { S; goto try_exit; }
221
222 #define __Enter
223
224 #define NOTHING
225
226 typedef struct _UNICODE_STRING {
227     USHORT Length;
228     USHORT MaximumLength;
229     PWSTR Buffer;
230 } UNICODE_STRING, *PUNICODE_STRING;
231
232 HANDLE
233 OpenRedirector( void);
234
235 typedef struct _AFS_ENUM_CB
236 {
237
238     DWORD       CurrentIndex;
239
240     DWORD       Scope;
241
242     DWORD       Type;
243
244     WCHAR      *RemoteName;
245
246 } AFSEnumerationCB;
247
248
249 //
250 // Recursively evaluate drivestr to find the final
251 // dos drive letter to which the source is mapped.
252 //
253 static BOOL
254 DriveSubstitution(LPCWSTR drivestr, LPWSTR subststr, size_t substlen)
255 {
256     WCHAR drive[3];
257     WCHAR device[MAX_PATH + 1];
258     HRESULT hr = S_OK;
259
260     memset( subststr, 0, substlen);
261     drive[0] = drivestr[0];
262     drive[1] = drivestr[1];
263     drive[2] = 0;
264
265     if ( QueryDosDevice(drive, device, MAX_PATH) )
266     {
267 #ifdef AFS_DEBUG_TRACE
268         AFSDbgPrint( L"DriveSubstitution QueryDosDevice %s [%s -> %s]\n",
269                      drivestr,
270                      drive,
271                      device);
272 #endif
273         if ( device[0] == L'\\' &&
274              device[1] == L'?' &&
275              device[2] == L'?' &&
276              device[3] == L'\\' &&
277              iswalpha(device[4]) &&
278              device[5] == L':')
279         {
280             drive[0] = device[4];
281             drive[1] = L':';
282             drive[2] = L'\0';
283
284             if ( !DriveSubstitution(drive, subststr, substlen) )
285             {
286
287                 subststr[0] = drive[0];
288                 subststr[1] = L':';
289                 subststr[2] = L'\0';
290
291             }
292
293             hr = S_OK;
294
295             if ( device[6] )
296             {
297                 hr = StringCchCat( subststr, substlen, &device[6]);
298             }
299             if ( SUCCEEDED(hr) && drivestr[2] )
300             {
301                 hr = StringCchCat( subststr, substlen, &drivestr[2]);
302             }
303
304             if ( SUCCEEDED(hr) || hr == STRSAFE_E_INSUFFICIENT_BUFFER)
305             {
306
307 #ifdef AFS_DEBUG_TRACE
308                     AFSDbgPrint( L"DriveSubstitution %s -> %s\n",
309                                  drivestr,
310                                  subststr);
311 #endif
312                 return TRUE;
313             }
314         }
315         else if ( device[0] == L'\\' &&
316                   device[1] == L'?' &&
317                   device[2] == L'?' &&
318                   device[3] == L'\\' &&
319                   device[4] == L'U' &&
320                   device[5] == L'N' &&
321                   device[6] == L'C' &&
322                   device[7] == L'\\')
323         {
324
325             subststr[0] = L'\\';
326
327             hr = StringCbCopyN(&subststr[1], substlen - sizeof(WCHAR), &device[7], MAX_PATH);
328
329             if ( SUCCEEDED(hr) || hr == STRSAFE_E_INSUFFICIENT_BUFFER)
330             {
331                 if ( drivestr[2] )
332                 {
333                     hr = StringCchCat( subststr, substlen, &drivestr[2]);
334                 }
335                 else
336                 {
337                     hr = S_OK;
338                 }
339
340                 if ( SUCCEEDED(hr) || hr == STRSAFE_E_INSUFFICIENT_BUFFER)
341                 {
342
343 #ifdef AFS_DEBUG_TRACE
344                     AFSDbgPrint( L"DriveSubstitution %s -> %s\n",
345                                  drivestr,
346                                  subststr);
347 #endif
348                     return TRUE;
349                 }
350             }
351
352 #ifdef AFS_DEBUG_TRACE
353             AFSDbgPrint( L"DriveSubstitution StringCbCopyN 1 hr 0x%X\n",
354                          hr);
355 #endif
356         }
357         else if ( _wcsnicmp( AFS_RDR_DEVICE_NAME, device, sizeof( AFS_RDR_DEVICE_NAME) / sizeof( WCHAR) - 1) == 0)
358         {
359             //
360             // \Device\AFSRedirector\;X:\\afs\cellname
361             //
362
363             hr = StringCbCopyN( subststr, substlen,
364                                  &device[3 + sizeof( AFS_RDR_DEVICE_NAME) / sizeof( WCHAR)],
365                                  MAX_PATH * sizeof( WCHAR));
366
367             if ( SUCCEEDED(hr) || hr == STRSAFE_E_INSUFFICIENT_BUFFER)
368             {
369
370                 if ( drivestr[2] )
371                 {
372                     hr = StringCchCat( subststr, substlen, &drivestr[2]);
373                 }
374                 else
375                 {
376                     hr = S_OK;
377                 }
378
379                 if ( SUCCEEDED(hr) || hr == STRSAFE_E_INSUFFICIENT_BUFFER)
380                 {
381
382 #ifdef AFS_DEBUG_TRACE
383                     AFSDbgPrint( L"DriveSubstitution %s -> %s\n",
384                                  drivestr,
385                                  subststr);
386 #endif
387                     return TRUE;
388                 }
389             }
390
391 #ifdef AFS_DEBUG_TRACE
392             AFSDbgPrint( L"DriveSubstitution StringCbCopyN 2 hr 0x%X\n",
393                          hr);
394 #endif
395         }
396
397 #ifdef AFS_DEBUG_TRACE
398         AFSDbgPrint( L"DriveSubstitution no substitution or match %s !! %s\n",
399                      drivestr,
400                      device);
401 #endif
402     }
403     else
404     {
405 #ifdef AFS_DEBUG_TRACE
406         AFSDbgPrint( L"DriveSubstitution QueryDosDevice failed %s gle 0x%X\n",
407                      drivestr,
408                      GetLastError());
409 #endif
410     }
411
412
413
414     return FALSE;
415 }
416
417
418 static const WCHAR *
419 NPGetCapsQueryString( DWORD nIndex)
420 {
421     switch ( nIndex) {
422     case WNNC_SPEC_VERSION:
423         return L"WNNC_SPEC_VERSION";
424
425     case WNNC_NET_TYPE:
426         return L"WNNC_NET_TYPE";
427
428     case WNNC_DRIVER_VERSION:
429         return L"WNNC_DRIVER_VERSION";
430
431     case WNNC_USER:
432         return L"WNNC_USER";
433
434     case WNNC_CONNECTION:
435         return L"WNNC_CONNECTION";
436
437     case WNNC_DIALOG:
438         return L"WNNC_DIALOG";
439
440     case WNNC_ADMIN:
441         return L"WNNC_ADMIN";
442
443     case WNNC_ENUMERATION:
444         return L"WNNC_ENUMERATION";
445
446     case WNNC_START:
447         return L"WNNC_START";
448
449     case WNNC_CONNECTION_FLAGS:
450         return L"WNNC_CONNECTION_FLAGS";
451
452     default:
453         return L"UNKNOWN";
454     }
455 }
456
457 //
458 // This is the only function which must be exported, everything else is optional
459 //
460
461 DWORD
462 APIENTRY
463 NPGetCaps( DWORD nIndex )
464 {
465
466     DWORD rc = 0;
467
468 #ifdef AFS_DEBUG_TRACE
469     AFSDbgPrint( L"NPGetCaps Index %u %s\n", nIndex,
470                  NPGetCapsQueryString( nIndex));
471 #endif
472     switch( nIndex)
473     {
474         case WNNC_SPEC_VERSION:
475         {
476
477             rc = WNNC_SPEC_VERSION51;
478             break;
479         }
480
481         case WNNC_NET_TYPE:
482         {
483             rc = WNNC_NET_OPENAFS;
484             break;
485         }
486
487         case WNNC_DRIVER_VERSION:
488         {
489
490             rc = WNNC_DRIVER(1, 0);
491             break;
492         }
493
494         case WNNC_CONNECTION:
495         {
496
497             //
498             // No support for:
499             //   WNNC_CON_GETPERFORMANCE
500             //   WNNC_CON_DEFER
501             //
502
503             rc = WNNC_CON_GETCONNECTIONS |
504                  WNNC_CON_CANCELCONNECTION |
505                  WNNC_CON_ADDCONNECTION |
506                  WNNC_CON_ADDCONNECTION3;
507
508             break;
509         }
510
511         case WNNC_ENUMERATION:
512         {
513             rc = WNNC_ENUM_LOCAL |
514                  WNNC_ENUM_CONTEXT |
515                  WNNC_ENUM_GLOBAL |
516                  WNNC_ENUM_SHAREABLE;
517             break;
518         }
519
520         case WNNC_START:
521         {
522
523             rc = WNNC_WAIT_FOR_START;
524
525             break;
526         }
527
528         case WNNC_DIALOG:
529         {
530
531             //
532             // No support for:
533             //    WNNC_DLG_DEVICEMODE
534             //    WNNC_DLG_PROPERTYDIALOG
535             //    WNNC_DLG_SEARCHDIALOG
536             //    WNNC_DLG_PERMISSIONEDITOR
537             //
538
539             rc = WNNC_DLG_FORMATNETWORKNAME |
540                  WNNC_DLG_GETRESOURCEINFORMATION |
541                  WNNC_DLG_GETRESOURCEPARENT;
542
543             break;
544         }
545
546         case WNNC_USER:
547         {
548             //
549             // No support for:
550             //    WNNC_USR_GETUSER
551             //
552
553             break;
554         }
555
556         case WNNC_ADMIN:
557         {
558             //
559             // No support for:
560             //    WNNC_ADM_GETDIRECTORYTYPE
561             //    WNNC_ADM_DIRECTORYNOTIFY
562             // used by the old File Manager
563             //
564             break;
565         }
566     }
567
568     return rc;
569 }
570
571 DWORD
572 APIENTRY
573 NPAddConnection( LPNETRESOURCE   lpNetResource,
574                  LPWSTR          lpPassword,
575                  LPWSTR          lpUserName )
576 {
577
578 #ifdef AFS_DEBUG_TRACE
579     AFSDbgPrint( L"NPAddConnection forwarding to NPAddConnection3\n");
580 #endif
581     return NPAddConnection3( NULL, lpNetResource, lpPassword, lpUserName, 0 );
582 }
583
584 DWORD
585 APIENTRY
586 NPAddConnection3( HWND            hwndOwner,
587                   LPNETRESOURCE   lpNetResource,
588                   LPWSTR          lpPassword,
589                   LPWSTR          lpUserName,
590                   DWORD           dwFlags )
591 {
592
593     DWORD    dwStatus = WN_SUCCESS;
594     WCHAR    wchRemoteName[MAX_PATH+1];
595     WCHAR    wchLocalName[3];
596     DWORD    dwCopyBytes = 0;
597     AFSNetworkProviderConnectionCB   *pConnectCB = NULL;
598     DWORD    dwError = 0;
599     DWORD    dwBufferSize = 0;
600     HANDLE   hControlDevice = NULL;
601     HANDLE   hToken = NULL;
602     LARGE_INTEGER liAuthId = {0,0};
603
604     __Enter
605     {
606         if ( NPIsFSDisabled())
607         {
608
609 #ifdef AFS_DEBUG_TRACE
610             AFSDbgPrint( L"NPAddConnection3 AFSRDFS is disabled, returning WN_BAD_NETNAME\n");
611 #endif
612
613             return WN_BAD_NETNAME;
614         }
615
616         if ((lpNetResource->lpRemoteName == NULL) ||
617             (lpNetResource->lpRemoteName[0] != L'\\') ||
618             (lpNetResource->lpRemoteName[1] != L'\\') ||
619             ((lpNetResource->dwType != RESOURCETYPE_DISK) &&
620              (lpNetResource->dwType != RESOURCETYPE_ANY)))
621         {
622
623 #ifdef AFS_DEBUG_TRACE
624             AFSDbgPrint( L"NPAddConnection3 invalid input, returning WN_BAD_NETNAME\n");
625 #endif
626             return WN_BAD_NETNAME;
627         }
628
629 #ifdef AFS_DEBUG_TRACE
630         AFSDbgPrint( L"NPAddConnection3 processing\n");
631 #endif
632         if( lpNetResource->lpLocalName != NULL)
633         {
634
635             wchLocalName[0] = towupper(lpNetResource->lpLocalName[0]);
636             wchLocalName[1] = L':';
637             wchLocalName[2] = L'\0';
638         }
639
640         StringCchCopy(wchRemoteName, MAX_PATH+1, lpNetResource->lpRemoteName);
641         wchRemoteName[MAX_PATH] = L'\0';
642
643         //
644         // Allocate our buffer to pass to the redirector filter
645         //
646
647         dwBufferSize = sizeof( AFSNetworkProviderConnectionCB) + (wcslen( wchRemoteName) * sizeof( WCHAR));
648
649         pConnectCB = (AFSNetworkProviderConnectionCB *)HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, dwBufferSize);
650
651         if( pConnectCB == NULL)
652         {
653
654             try_return( dwStatus = WN_OUT_OF_MEMORY);
655         }
656
657         if( lpNetResource->lpLocalName != NULL)
658         {
659
660             pConnectCB->LocalName = towupper(wchLocalName[0]);
661
662 #ifdef AFS_DEBUG_TRACE
663             AFSDbgPrint( L"NPAddConnection3 Adding mapping for drive %s remote name %s\n",
664                          wchLocalName,
665                          wchRemoteName);
666 #endif
667         }
668         else
669         {
670
671             pConnectCB->LocalName = L'\0';
672
673 #ifdef AFS_DEBUG_TRACE
674             AFSDbgPrint( L"NPAddConnection3 Adding mapping for NO drive remote name %s\n",
675                          wchRemoteName);
676 #endif
677         }
678
679         pConnectCB->Version = AFS_NETWORKPROVIDER_INTERFACE_VERSION_1;
680
681         pConnectCB->RemoteNameLength = wcslen( wchRemoteName) * sizeof( WCHAR);
682
683         memcpy( pConnectCB->RemoteName,
684                 wchRemoteName,
685                 pConnectCB->RemoteNameLength);
686
687         pConnectCB->Type = lpNetResource->dwType;
688
689         pConnectCB->AuthenticationId = AFSRetrieveAuthId();
690
691 #ifdef AFS_DEBUG_TRACE
692         AFSDbgPrint( L"NPAddConnection3 Retrieved authentication id %08lX-%08lX\n",
693                      pConnectCB->AuthenticationId.HighPart,
694                      pConnectCB->AuthenticationId.LowPart);
695 #endif
696
697         hControlDevice = OpenRedirector();
698
699         if( hControlDevice == NULL)
700         {
701
702 #ifdef AFS_DEBUG_TRACE
703             AFSDbgPrint( L"NPAddConnection3 OpenRedirector failure, returning WN_NET_ERROR\n");
704 #endif
705
706             try_return( dwStatus = WN_NET_ERROR);
707         }
708
709         dwError = DeviceIoControl( hControlDevice,
710                                    IOCTL_AFS_ADD_CONNECTION,
711                                    pConnectCB,
712                                    dwBufferSize,
713                                    &dwStatus,
714                                    sizeof( DWORD),
715                                    &dwCopyBytes,
716                                    NULL);
717
718         if( !dwError)
719         {
720 #ifdef AFS_DEBUG_TRACE
721             AFSDbgPrint( L"NPAddConnection3 Failed to add connection to file system %d\n", GetLastError());
722 #endif
723             try_return( dwStatus = WN_OUT_OF_MEMORY);
724         }
725
726         //
727         // The status returned from the driver will indicate how it was handled
728         //
729
730         if( dwStatus == WN_SUCCESS &&
731             lpNetResource->lpLocalName != NULL)
732         {
733
734             WCHAR TempBuf[MAX_PATH+1];
735
736             if( !QueryDosDeviceW( wchLocalName,
737                                   TempBuf,
738                                   MAX_PATH+1))
739             {
740
741                 if( GetLastError() != ERROR_FILE_NOT_FOUND)
742                 {
743
744 #ifdef AFS_DEBUG_TRACE
745                     AFSDbgPrint( L"NPAddConnection3 QueryDosDeviceW failed with file not found\n");
746 #endif
747                     NPCancelConnection( wchLocalName, TRUE);
748
749                     dwStatus = ERROR_ALREADY_ASSIGNED;
750                 }
751                 else
752                 {
753
754                     UNICODE_STRING uniConnectionName;
755                     UNICODE_STRING uniDeviceName;
756
757                     uniDeviceName.Length = (wcslen( AFS_RDR_DEVICE_NAME) * sizeof( WCHAR));
758                     uniDeviceName.MaximumLength = uniDeviceName.Length;
759                     uniDeviceName.Buffer = AFS_RDR_DEVICE_NAME;
760
761                     //
762                     // Create a symbolic link object to the device we are redirecting
763                     //
764
765                     uniConnectionName.MaximumLength = (USHORT)( uniDeviceName.Length +
766                                                                 pConnectCB->RemoteNameLength +
767                                                                 8 +              // Local name and \;
768                                                                 sizeof(WCHAR));   //  Space for NULL-termination.
769
770                     //
771                     //  Don't include NULL-termination.
772                     //
773
774                     uniConnectionName.Length = uniConnectionName.MaximumLength - sizeof(WCHAR);
775
776                     uniConnectionName.Buffer = LocalAlloc( LMEM_ZEROINIT,
777                                                            uniConnectionName.MaximumLength);
778
779                     if( uniConnectionName.Buffer == NULL)
780                     {
781
782                         try_return( dwStatus = GetLastError());
783                     }
784
785                     CopyMemory( uniConnectionName.Buffer,
786                                 uniDeviceName.Buffer,
787                                 uniDeviceName.Length);
788
789                     StringCchCatW( uniConnectionName.Buffer,
790                                    uniConnectionName.MaximumLength,
791                                    L"\\;" );
792
793                     StringCchCatW( uniConnectionName.Buffer,
794                                    uniConnectionName.MaximumLength,
795                                    wchLocalName);
796
797                     StringCchCatW( uniConnectionName.Buffer,
798                                    uniConnectionName.MaximumLength,
799                                    wchRemoteName);
800
801 #ifdef AFS_DEBUG_TRACE
802                     AFSDbgPrint( L"NPAddConnection3 DefineDosDevice Local %s connection name %s\n",
803                                  wchLocalName,
804                                  uniConnectionName.Buffer);
805 #endif
806
807                     if( !DefineDosDeviceW( DDD_RAW_TARGET_PATH |
808                                            DDD_NO_BROADCAST_SYSTEM,
809                                            wchLocalName,
810                                            uniConnectionName.Buffer))
811                     {
812 #ifdef AFS_DEBUG_TRACE
813                         AFSDbgPrint( L"NPAddConnection3 Failed to assign drive\n");
814 #endif
815                         dwStatus = GetLastError();
816                     }
817                     else
818                     {
819
820                         dwStatus = WN_SUCCESS;
821                     }
822
823                     LocalFree( uniConnectionName.Buffer);
824                 }
825             }
826             else
827             {
828
829 #ifdef AFS_DEBUG_TRACE
830                 AFSDbgPrint( L"NPAddConnection3 QueryDosDeviceW %Z already existed\n", TempBuf);
831 #endif
832                 NPCancelConnection( wchLocalName, TRUE);
833
834                 dwStatus = ERROR_ALREADY_ASSIGNED;
835             }
836         }
837
838 try_exit:
839
840         if ( hControlDevice != NULL)
841         {
842
843             CloseHandle( hControlDevice);
844         }
845
846         if( pConnectCB != NULL)
847         {
848
849             HeapFree( GetProcessHeap( ), 0, (PVOID) pConnectCB);
850         }
851     }
852
853     return dwStatus;
854 }
855
856 DWORD
857 APIENTRY
858 NPCancelConnection( LPWSTR  lpName,
859                     BOOL    fForce)
860 {
861
862     WCHAR    wchRemoteName[MAX_PATH+1];
863     DWORD    dwRemoteNameLength = (MAX_PATH+1) * sizeof(WCHAR);
864     DWORD    dwStatus = WN_NOT_CONNECTED;
865     DWORD    dwCopyBytes = 0;
866     AFSNetworkProviderConnectionCB   *pConnectCB = NULL;
867     AFSCancelConnectionResultCB stCancelConn;
868     DWORD    dwError = 0;
869     DWORD    dwBufferSize = 0;
870     BOOL     bLocalName = TRUE;
871     HANDLE   hControlDevice = NULL;
872     WCHAR   *pwchLocalName = NULL;
873
874     __Enter
875     {
876
877         if ( NPIsFSDisabled())
878         {
879
880 #ifdef AFS_DEBUG_TRACE
881             AFSDbgPrint( L"NPCancelConnection AFSRDFS is disabled, returning WN_NOT_CONNECTED\n");
882 #endif
883
884             try_return( dwStatus = WN_NOT_CONNECTED);
885         }
886
887         if( *lpName == L'\\' &&
888             *(lpName + 1) == L'\\')
889         {
890
891             bLocalName = FALSE;
892         }
893
894         if( bLocalName)
895         {
896
897             //
898             // Get the remote name for the connection, if we are handling it
899             //
900
901             dwStatus = NPGetConnection( lpName,
902                                         wchRemoteName,
903                                         &dwRemoteNameLength);
904
905             if( dwStatus != WN_SUCCESS ||
906                 dwRemoteNameLength == 0)
907             {
908
909 #ifdef AFS_DEBUG_TRACE
910                 AFSDbgPrint( L"NPCancelConnection Status 0x%x NameLength %u, returning WN_NOT_CONNECTED\n",
911                              dwStatus, dwRemoteNameLength);
912 #endif
913                 try_return( dwStatus = WN_NOT_CONNECTED);
914             }
915         }
916         else
917         {
918
919             StringCchCopyW( wchRemoteName, MAX_PATH+1, lpName);
920
921             dwRemoteNameLength = (wcslen( wchRemoteName) * sizeof( WCHAR));
922         }
923
924         wchRemoteName[ dwRemoteNameLength/sizeof( WCHAR)] = L'\0';
925
926         dwBufferSize = sizeof( AFSNetworkProviderConnectionCB) + dwRemoteNameLength;
927
928         pConnectCB = (AFSNetworkProviderConnectionCB *)HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, dwBufferSize);
929
930         if( pConnectCB == NULL)
931         {
932
933             try_return( dwStatus = WN_OUT_OF_MEMORY);
934         }
935
936         if( bLocalName)
937         {
938
939             pConnectCB->LocalName = towupper(lpName[0]);
940         }
941         else
942         {
943
944             pConnectCB->LocalName = L'\0';
945         }
946
947         pConnectCB->RemoteNameLength = (USHORT)dwRemoteNameLength;
948
949         StringCchCopyW( pConnectCB->RemoteName,
950                         MAX_PATH+1,
951                         wchRemoteName);
952
953         pConnectCB->Version = AFS_NETWORKPROVIDER_INTERFACE_VERSION_1;
954
955         pConnectCB->AuthenticationId = AFSRetrieveAuthId();
956
957 #ifdef AFS_DEBUG_TRACE
958         AFSDbgPrint( L"NPCancelConnection Retrieved authentication id %08lX-%08lX\n",
959                      pConnectCB->AuthenticationId.HighPart,
960                      pConnectCB->AuthenticationId.LowPart);
961 #endif
962
963         hControlDevice = OpenRedirector();
964
965         if( hControlDevice == NULL)
966         {
967
968 #ifdef AFS_DEBUG_TRACE
969             AFSDbgPrint( L"NPCancelConnection OpenRedirector failure, returning WN_NET_ERROR\n");
970 #endif
971
972             try_return( dwStatus = WN_NET_ERROR);
973         }
974
975         memset( &stCancelConn,
976                 '\0',
977                 sizeof( AFSCancelConnectionResultCB));
978
979         dwError = DeviceIoControl( hControlDevice,
980                                    IOCTL_AFS_CANCEL_CONNECTION,
981                                    pConnectCB,
982                                    dwBufferSize,
983                                    &stCancelConn,
984                                    sizeof( AFSCancelConnectionResultCB),
985                                    &dwCopyBytes,
986                                    NULL);
987
988         if( !dwError)
989         {
990 #ifdef AFS_DEBUG_TRACE
991             DWORD gle = GetLastError();
992
993             AFSDbgPrint( L"NPCancelConnection Failed to cancel connection to file system - gle 0x%x\n", gle);
994 #endif
995             try_return( dwStatus = WN_NOT_CONNECTED);
996         }
997
998         dwStatus = stCancelConn.Status;
999
1000 #ifdef AFS_DEBUG_TRACE
1001
1002         AFSDbgPrint( L"NPCancelConnection Cancel connection to file system - Name %s Status %08lX\n",
1003                      lpName,
1004                      dwStatus);
1005 #endif
1006
1007         if( dwStatus == WN_SUCCESS &&
1008             ( bLocalName ||
1009               stCancelConn.LocalName != L'\0'))
1010         {
1011
1012             UNICODE_STRING uniConnectionName;
1013             UNICODE_STRING uniDeviceName;
1014
1015             uniDeviceName.Length = (wcslen( AFS_RDR_DEVICE_NAME) * sizeof( WCHAR));
1016             uniDeviceName.MaximumLength = uniDeviceName.Length;
1017             uniDeviceName.Buffer = AFS_RDR_DEVICE_NAME;
1018
1019             //
1020             // Create a symbolic link object to the device we are redirecting
1021             //
1022
1023             uniConnectionName.MaximumLength = (USHORT)( uniDeviceName.Length +
1024                                                         dwRemoteNameLength +
1025                                                         8 +             // Local name and \;
1026                                                         sizeof(WCHAR)); //  Space for NULL-termination.
1027
1028             //
1029             //  Don't include NULL-termination.
1030             //
1031
1032             uniConnectionName.Length = uniConnectionName.MaximumLength - sizeof(WCHAR);
1033
1034             uniConnectionName.Buffer = LocalAlloc( LMEM_ZEROINIT,
1035                                                    uniConnectionName.MaximumLength);
1036
1037             if( uniConnectionName.Buffer == NULL)
1038             {
1039
1040                 try_return( dwStatus = GetLastError());
1041             }
1042
1043             CopyMemory( uniConnectionName.Buffer,
1044                         uniDeviceName.Buffer,
1045                         uniDeviceName.Length);
1046
1047             StringCchCatW( uniConnectionName.Buffer,
1048                            uniConnectionName.MaximumLength,
1049                            L"\\;" );
1050
1051             if( !bLocalName)
1052             {
1053
1054                 WCHAR wchLocalName[ 3];
1055
1056                 wchLocalName[ 0] = stCancelConn.LocalName;
1057
1058                 wchLocalName[ 1] = L':';
1059
1060                 wchLocalName[ 2] = L'\0';
1061
1062                 StringCchCatW( uniConnectionName.Buffer,
1063                                uniConnectionName.MaximumLength,
1064                                wchLocalName);
1065
1066                 pwchLocalName = wchLocalName;
1067             }
1068             else
1069             {
1070
1071                 StringCchCatW( uniConnectionName.Buffer,
1072                                uniConnectionName.MaximumLength,
1073                                lpName);
1074
1075                 pwchLocalName = lpName;
1076             }
1077
1078             StringCchCatW( uniConnectionName.Buffer,
1079                            uniConnectionName.MaximumLength,
1080                            wchRemoteName);
1081
1082             if( !DefineDosDevice( DDD_REMOVE_DEFINITION | DDD_RAW_TARGET_PATH | DDD_EXACT_MATCH_ON_REMOVE,
1083                                   pwchLocalName,
1084                                   uniConnectionName.Buffer))
1085             {
1086
1087 #ifdef AFS_DEBUG_TRACE
1088                 DWORD gle = GetLastError();
1089
1090                 AFSDbgPrint( L"NPCancelConnection Failed to cancel connection to system - gle 0x%x Name %s connection %wZ\n",
1091                              gle,
1092                              pwchLocalName,
1093                              &uniConnectionName);
1094 #endif
1095             }
1096             else
1097             {
1098 #ifdef AFS_DEBUG_TRACE
1099
1100                 AFSDbgPrint( L"NPCancelConnection Canceled connection to system - Name %s connection %wZ\n",
1101                              pwchLocalName,
1102                              &uniConnectionName);
1103 #endif
1104             }
1105         }
1106
1107 try_exit:
1108
1109         if ( hControlDevice != NULL)
1110         {
1111
1112             CloseHandle( hControlDevice);
1113         }
1114
1115
1116         if( pConnectCB != NULL)
1117         {
1118
1119             HeapFree( GetProcessHeap( ), 0, (PVOID) pConnectCB);
1120         }
1121
1122     }
1123
1124     return dwStatus;
1125 }
1126
1127 DWORD
1128 APIENTRY
1129 NPGetConnection( LPWSTR  lpLocalName,
1130                  LPWSTR  lpRemoteName,
1131                  LPDWORD lpBufferSize)
1132 {
1133
1134     DWORD    dwStatus = WN_NOT_CONNECTED;
1135     WCHAR    wchLocalName[3];
1136     WCHAR    wchSubstName[MAX_PATH + 1];
1137     AFSNetworkProviderConnectionCB   *pConnectCB = NULL;
1138     DWORD    dwError = 0;
1139     DWORD    dwBufferSize = 0;
1140     HANDLE   hControlDevice = NULL;
1141     DWORD    dwPassedSize;
1142
1143     __Enter
1144     {
1145
1146         if ( NPIsFSDisabled())
1147         {
1148
1149 #ifdef AFS_DEBUG_TRACE
1150             AFSDbgPrint( L"NPGetConnection AFSRDFS is disabled, returning WN_NOT_CONNECTED\n");
1151 #endif
1152
1153             try_return( dwStatus = WN_NOT_CONNECTED);
1154         }
1155
1156         if( lstrlen( lpLocalName) == 0)
1157         {
1158 #ifdef AFS_DEBUG_TRACE
1159             AFSDbgPrint( L"NPGetConnection No local name, returning WN_BAD_LOCALNAME\n");
1160 #endif
1161             try_return( dwStatus = WN_BAD_LOCALNAME);
1162         }
1163
1164         if ( lpBufferSize == NULL)
1165         {
1166 #ifdef AFS_DEBUG_TRACE
1167             AFSDbgPrint( L"NPGetConnection No output size, returning WN_BAD_LOCALNAME\n");
1168 #endif
1169             try_return( dwStatus = WN_BAD_VALUE);
1170         }
1171
1172         dwPassedSize = *lpBufferSize;
1173
1174         if ( !DriveSubstitution( lpLocalName, wchSubstName, sizeof( wchSubstName)))
1175         {
1176             wchLocalName[0] = towupper(lpLocalName[0]);
1177             wchLocalName[1] = L':';
1178             wchLocalName[2] = L'\0';
1179
1180 #ifdef AFS_DEBUG_TRACE
1181             AFSDbgPrint( L"NPGetConnection Requesting connection for %s\n",
1182                          wchLocalName);
1183 #endif
1184         }
1185         else
1186         {
1187             ReadServerNameString();
1188
1189             if ( wchSubstName[0] != L'\\' &&
1190                  wchSubstName[1] == L':')
1191             {
1192
1193                 wchLocalName[0] = towupper(wchSubstName[0]);
1194                 wchLocalName[1] = L':';
1195                 wchLocalName[2] = L'\0';
1196
1197 #ifdef AFS_DEBUG_TRACE
1198                 AFSDbgPrint( L"NPGetConnection Requesting connection for drive substitution %s -> %s\n",
1199                              wchSubstName,
1200                              wchLocalName);
1201 #endif
1202             }
1203             else if ( _wcsnicmp( wchSubstName, wszServerNameUNC, cbServerNameUNCLength / sizeof( WCHAR)) == 0 &&
1204                       ( wchSubstName[cbServerNameUNCLength / sizeof( WCHAR)] == L'\\' ||
1205                         wchSubstName[cbServerNameUNCLength / sizeof( WCHAR)] == 0))
1206             {
1207                 HRESULT hr;
1208                 WCHAR  *pwch;
1209                 DWORD   dwCount = 0;
1210
1211 #ifdef AFS_DEBUG_TRACE
1212                 AFSDbgPrint( L"NPGetConnection drive substitution %s is AFS\n",
1213                              wchSubstName);
1214 #endif
1215
1216                 if ( lpRemoteName == NULL ||
1217                      dwPassedSize == 0)
1218                 {
1219
1220                     *lpBufferSize = wcslen( wchSubstName) * sizeof( WCHAR) + sizeof( WCHAR);
1221
1222                     try_return( dwStatus = WN_MORE_DATA);
1223
1224                 }
1225
1226                 hr = StringCbCopyN(lpRemoteName, *lpBufferSize, wchSubstName, sizeof( wchSubstName));
1227
1228                 if ( SUCCEEDED(hr))
1229                 {
1230
1231                     for ( dwCount = 0, pwch = lpRemoteName; *pwch; pwch++ )
1232                     {
1233                         if ( *pwch == L'\\' )
1234                         {
1235                             dwCount++;
1236
1237                             if ( dwCount == 4)
1238                             {
1239                                 *pwch = L'\0';
1240
1241                                 break;
1242                             }
1243                         }
1244
1245                     }
1246
1247                     *lpBufferSize = wcslen( lpRemoteName) * sizeof( WCHAR) + sizeof( WCHAR);
1248
1249                     try_return( dwStatus = WN_SUCCESS);
1250                 }
1251                 else if ( hr == STRSAFE_E_INSUFFICIENT_BUFFER)
1252                 {
1253
1254                     *lpBufferSize = wcslen( wchSubstName) * sizeof( WCHAR) + sizeof( WCHAR);
1255
1256                     for ( dwCount = 0, pwch = lpRemoteName; *pwch; pwch++ )
1257                     {
1258                         if ( *pwch == L'\\' )
1259                         {
1260                             dwCount++;
1261
1262                             if ( dwCount == 4)
1263                             {
1264                                 *pwch = L'\0';
1265
1266                                 *lpBufferSize = wcslen( lpRemoteName) * sizeof( WCHAR) + sizeof( WCHAR);
1267
1268                                 try_return( dwStatus = WN_SUCCESS);
1269                             }
1270                         }
1271
1272                     }
1273
1274                     try_return( dwStatus = WN_MORE_DATA);
1275                 }
1276                 else
1277                 {
1278
1279 #ifdef AFS_DEBUG_TRACE
1280                     AFSDbgPrint( L"NPGetConnection StringCbCopyN failure 0x%X\n",
1281                                  hr);
1282 #endif
1283                     try_return( dwStatus = WN_NET_ERROR);
1284                 }
1285             }
1286             else
1287             {
1288
1289 #ifdef AFS_DEBUG_TRACE
1290                 AFSDbgPrint( L"NPGetConnection drive substitution %s is not AFS\n",
1291                              wchSubstName);
1292 #endif
1293                 try_return( dwStatus = WN_NOT_CONNECTED);
1294             }
1295         }
1296
1297 #ifdef AFS_DEBUG_TRACE
1298         AFSDbgPrint( L"NPGetConnection Requesting connection for %s\n",
1299                      wchLocalName);
1300 #endif
1301
1302         dwBufferSize = 0x1000;
1303
1304         pConnectCB = (AFSNetworkProviderConnectionCB *)HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, dwBufferSize);
1305
1306         if( pConnectCB == NULL)
1307         {
1308
1309             try_return( dwStatus = WN_OUT_OF_MEMORY);
1310         }
1311
1312         pConnectCB->LocalName = towupper(wchLocalName[0]);
1313
1314         pConnectCB->RemoteNameLength = 0;
1315
1316         pConnectCB->Version = AFS_NETWORKPROVIDER_INTERFACE_VERSION_1;
1317
1318         pConnectCB->AuthenticationId = AFSRetrieveAuthId();
1319
1320 #ifdef AFS_DEBUG_TRACE
1321         AFSDbgPrint( L"NPGetConnection Retrieved authentication id %08lX-%08lX\n",
1322                      pConnectCB->AuthenticationId.HighPart,
1323                      pConnectCB->AuthenticationId.LowPart);
1324 #endif
1325
1326         hControlDevice = OpenRedirector();
1327
1328         if( hControlDevice == NULL)
1329         {
1330
1331 #ifdef AFS_DEBUG_TRACE
1332             AFSDbgPrint( L"NPGetConnection OpenRedirector failure, returning WN_NET_ERROR\n");
1333 #endif
1334
1335             try_return( dwStatus = WN_NET_ERROR);
1336         }
1337
1338         dwError = DeviceIoControl( hControlDevice,
1339                                    IOCTL_AFS_GET_CONNECTION,
1340                                    pConnectCB,
1341                                    dwBufferSize,
1342                                    pConnectCB,
1343                                    dwBufferSize,
1344                                    lpBufferSize,
1345                                    NULL);
1346
1347         if( !dwError)
1348         {
1349 #ifdef AFS_DEBUG_TRACE
1350             DWORD gle = GetLastError();
1351
1352             AFSDbgPrint( L"NPGetConnection Failed to get connection from file system for local %s gle 0x%x\n",
1353                          wchLocalName, gle);
1354 #endif
1355             try_return( dwStatus = WN_NOT_CONNECTED);
1356         }
1357
1358         //
1359         // IOCTL_AFS_GET_CONNECTION returns a counted string
1360         //
1361
1362         if( lpRemoteName == NULL ||
1363             *lpBufferSize + sizeof( WCHAR) > dwPassedSize)
1364         {
1365
1366             *lpBufferSize += sizeof( WCHAR);
1367
1368             try_return( dwStatus = WN_MORE_DATA);
1369         }
1370
1371         memcpy( lpRemoteName,
1372                 (void *)pConnectCB,
1373                 *lpBufferSize);
1374
1375         lpRemoteName[ *lpBufferSize/sizeof( WCHAR)] = L'\0';
1376
1377         *lpBufferSize += sizeof( WCHAR);
1378
1379 #ifdef AFS_DEBUG_TRACE
1380         AFSDbgPrint( L"NPGetConnection local %s remote %s\n",
1381                      wchLocalName,
1382                      lpRemoteName);
1383 #endif
1384         dwStatus = WN_SUCCESS;
1385
1386 try_exit:
1387
1388         if ( hControlDevice != NULL)
1389         {
1390
1391             CloseHandle( hControlDevice);
1392         }
1393
1394         if( pConnectCB != NULL)
1395         {
1396
1397             HeapFree( GetProcessHeap( ), 0, (PVOID) pConnectCB);
1398         }
1399     }
1400
1401     return dwStatus;
1402 }
1403
1404 DWORD
1405 APIENTRY
1406 NPGetConnection3( IN     LPCWSTR lpLocalName,
1407                   IN     DWORD dwLevel,
1408                   OUT    LPVOID lpBuffer,
1409                   IN OUT LPDWORD lpBufferSize)
1410 {
1411
1412     DWORD    dwStatus = WN_NOT_CONNECTED;
1413     WCHAR    wchLocalName[3];
1414     WCHAR    wchSubstName[MAX_PATH + 1];
1415     AFSNetworkProviderConnectionCB   *pConnectCB = NULL;
1416     DWORD    dwError = 0;
1417     DWORD    dwBufferSize = 0;
1418     HANDLE   hControlDevice = NULL;
1419     DWORD    dwPassedSize;
1420     DWORD   *pConnectState =(DWORD *)lpBuffer;
1421
1422     __Enter
1423     {
1424
1425         if ( NPIsFSDisabled())
1426         {
1427
1428 #ifdef AFS_DEBUG_TRACE
1429             AFSDbgPrint( L"NPGetConnection3 AFSRDFS is disabled, returning WN_NOT_CONNECTED\n");
1430 #endif
1431
1432             try_return( dwStatus = WN_NOT_CONNECTED);
1433         }
1434
1435         if( lstrlen( lpLocalName) == 0)
1436         {
1437 #ifdef AFS_DEBUG_TRACE
1438             AFSDbgPrint( L"NPGetConnection3 No local name, returning WN_BAD_LOCALNAME\n");
1439 #endif
1440             try_return( dwStatus = WN_BAD_LOCALNAME);
1441         }
1442
1443         //
1444         // LanMan NPGetConnection3 only responds to level 1
1445         //
1446
1447         if ( dwLevel != 0x1)
1448         {
1449 #ifdef AFS_DEBUG_TRACE
1450             AFSDbgPrint( L"NPGetConnection3 Level 0x%X returning WN_BAD_LEVEL\n", dwLevel);
1451 #endif
1452             try_return( dwStatus = WN_BAD_LEVEL);
1453         }
1454
1455         if ( lpBufferSize == NULL)
1456         {
1457 #ifdef AFS_DEBUG_TRACE
1458             AFSDbgPrint( L"NPGetConnection3 No output size, returning WN_BAD_VALUE\n");
1459 #endif
1460             try_return( dwStatus = WN_BAD_VALUE);
1461         }
1462
1463         dwPassedSize = *lpBufferSize;
1464
1465         if ( dwPassedSize == 0 ||
1466              lpBuffer == NULL)
1467         {
1468
1469             *lpBufferSize = sizeof( DWORD);
1470
1471             try_return( dwStatus = WN_MORE_DATA);
1472         }
1473
1474         if ( !DriveSubstitution( lpLocalName, wchSubstName, sizeof( wchSubstName)))
1475         {
1476             wchLocalName[0] = towupper(lpLocalName[0]);
1477             wchLocalName[1] = L':';
1478             wchLocalName[2] = L'\0';
1479
1480 #ifdef AFS_DEBUG_TRACE
1481             AFSDbgPrint( L"NPGetConnection3 Requesting connection for %s level 0x%X\n",
1482                          wchLocalName,
1483                          dwLevel);
1484 #endif
1485         }
1486         else
1487         {
1488
1489             ReadServerNameString();
1490
1491             if ( wchSubstName[0] != L'\\' &&
1492                  wchSubstName[1] == L':')
1493             {
1494
1495                 wchLocalName[0] = towupper(wchSubstName[0]);
1496                 wchLocalName[1] = L':';
1497                 wchLocalName[2] = L'\0';
1498
1499 #ifdef AFS_DEBUG_TRACE
1500                 AFSDbgPrint( L"NPGetConnection3 Requesting connection for drive substitution %s -> %s level 0x%x\n",
1501                              wchSubstName,
1502                              wchLocalName,
1503                              dwLevel);
1504 #endif
1505             }
1506             else if ( _wcsnicmp( wchSubstName, wszServerNameUNC, cbServerNameUNCLength / sizeof( WCHAR)) == 0 &&
1507                       ( wchSubstName[cbServerNameUNCLength / sizeof( WCHAR)] == L'\\' ||
1508                         wchSubstName[cbServerNameUNCLength / sizeof( WCHAR)] == 0))
1509             {
1510
1511 #ifdef AFS_DEBUG_TRACE
1512                 AFSDbgPrint( L"NPGetConnection3 drive substitution %s is AFS return connected\n",
1513                              wchSubstName);
1514 #endif
1515                 *pConnectState = WNGETCON_CONNECTED;
1516
1517                 *lpBufferSize = sizeof( DWORD);
1518
1519                 try_return( dwStatus = WN_SUCCESS);
1520             }
1521             else
1522             {
1523
1524 #ifdef AFS_DEBUG_TRACE
1525                 AFSDbgPrint( L"NPGetConnection3 drive substitution %s is not AFS return not connected\n",
1526                              wchSubstName);
1527 #endif
1528                 try_return( dwStatus = WN_NOT_CONNECTED);
1529             }
1530         }
1531
1532         dwBufferSize = 0x1000;
1533
1534         pConnectCB = (AFSNetworkProviderConnectionCB *)HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, dwBufferSize);
1535
1536         if( pConnectCB == NULL)
1537         {
1538
1539             try_return( dwStatus = WN_OUT_OF_MEMORY);
1540         }
1541
1542         pConnectCB->LocalName = towupper(wchLocalName[0]);
1543
1544         pConnectCB->RemoteNameLength = 0;
1545
1546         pConnectCB->Version = AFS_NETWORKPROVIDER_INTERFACE_VERSION_1;
1547
1548         pConnectCB->AuthenticationId = AFSRetrieveAuthId();
1549
1550 #ifdef AFS_DEBUG_TRACE
1551         AFSDbgPrint( L"NPGetConnection3 Retrieved authentication id %08lX-%08lX\n",
1552                      pConnectCB->AuthenticationId.HighPart,
1553                      pConnectCB->AuthenticationId.LowPart);
1554 #endif
1555
1556         hControlDevice = OpenRedirector();
1557
1558         if( hControlDevice == NULL)
1559         {
1560
1561 #ifdef AFS_DEBUG_TRACE
1562             AFSDbgPrint( L"NPGetConnection3 OpenRedirector failure, returning WN_NET_ERROR\n");
1563 #endif
1564
1565             try_return( dwStatus = WN_NET_ERROR);
1566         }
1567
1568         dwError = DeviceIoControl( hControlDevice,
1569                                    IOCTL_AFS_GET_CONNECTION,
1570                                    pConnectCB,
1571                                    dwBufferSize,
1572                                    pConnectCB,
1573                                    dwBufferSize,
1574                                    &dwBufferSize,
1575                                    NULL);
1576
1577         if( !dwError)
1578         {
1579 #ifdef AFS_DEBUG_TRACE
1580             DWORD gle = GetLastError();
1581
1582             AFSDbgPrint( L"NPGetConnection3 Failed to get connection from file system for local %s gle 0x%x\n",
1583                          wchLocalName, gle);
1584 #endif
1585             try_return( dwStatus = WN_NOT_CONNECTED);
1586         }
1587
1588         *lpBufferSize = sizeof( DWORD);
1589
1590         if( sizeof( DWORD) > dwPassedSize)
1591         {
1592
1593             try_return( dwStatus = WN_MORE_DATA);
1594         }
1595
1596         *pConnectState = WNGETCON_CONNECTED;
1597
1598 #ifdef AFS_DEBUG_TRACE
1599         AFSDbgPrint( L"NPGetConnection3 local %s connect-state 0x%x\n",
1600                      wchLocalName,
1601                      *pConnectState);
1602 #endif
1603         dwStatus = WN_SUCCESS;
1604
1605 try_exit:
1606
1607         if ( hControlDevice != NULL)
1608         {
1609
1610             CloseHandle( hControlDevice);
1611         }
1612
1613         if( pConnectCB != NULL)
1614         {
1615
1616             HeapFree( GetProcessHeap( ), 0, (PVOID) pConnectCB);
1617         }
1618     }
1619
1620     return dwStatus;
1621 }
1622
1623 DWORD
1624 APIENTRY
1625 NPGetConnectionPerformance( LPCWSTR lpRemoteName,
1626                             LPNETCONNECTINFOSTRUCT lpNetConnectInfo)
1627 {
1628
1629     DWORD dwReturn = WN_SUCCESS;
1630     AFSNetworkProviderConnectionCB *pConnectCB = NULL;
1631     DWORD dwBufferSize = 0;
1632     HANDLE hControlDevice = NULL;
1633     DWORD dwError = 0;
1634
1635     __Enter
1636     {
1637
1638         if ( NPIsFSDisabled())
1639         {
1640
1641 #ifdef AFS_DEBUG_TRACE
1642             AFSDbgPrint( L"NPGetConnectionPerformance AFSRDFS is disabled, returning WN_BAD_NETNAME\n");
1643 #endif
1644
1645             return WN_NO_NETWORK;
1646         }
1647
1648         AFSDbgPrint( L"NPGetConnectionPerformance Entry for remote connection %S\n",
1649                      lpRemoteName);
1650
1651         dwBufferSize = 0x1000;
1652
1653         pConnectCB = (AFSNetworkProviderConnectionCB *)HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, dwBufferSize);
1654
1655         if( pConnectCB == NULL)
1656         {
1657             try_return( dwReturn = WN_OUT_OF_MEMORY);
1658         }
1659
1660         pConnectCB->RemoteNameLength = wcslen( lpRemoteName) * sizeof( WCHAR);
1661
1662         StringCbCopy( pConnectCB->RemoteName,
1663                       dwBufferSize - sizeof(AFSNetworkProviderConnectionCB),
1664                       lpRemoteName);
1665
1666         pConnectCB->Version = AFS_NETWORKPROVIDER_INTERFACE_VERSION_1;
1667
1668         pConnectCB->AuthenticationId = AFSRetrieveAuthId();
1669
1670         hControlDevice = OpenRedirector();
1671
1672         if( hControlDevice == NULL)
1673         {
1674             AFSDbgPrint( L"NPGetConnectionPerformance OpenRedirector failure, returning WN_NET_ERROR\n");
1675
1676             try_return( dwReturn = WN_NET_ERROR);
1677         }
1678
1679         dwError = DeviceIoControl( hControlDevice,
1680                                    IOCTL_AFS_GET_CONNECTION_INFORMATION,
1681                                    pConnectCB,
1682                                    dwBufferSize,
1683                                    pConnectCB,
1684                                    dwBufferSize,
1685                                    &dwBufferSize,
1686                                    NULL);
1687
1688         if( !dwError)
1689         {
1690 #ifdef AFS_DEBUG_TRACE
1691             DWORD gle = GetLastError();
1692
1693             AFSDbgPrint( L"NPGetConnectionPerformance Failed to get connection info from file system for remote %S gle 0x%x\n",
1694                          lpRemoteName,
1695                          gle);
1696 #endif
1697             try_return( dwReturn = WN_NOT_CONNECTED);
1698         }
1699
1700         lpNetConnectInfo->dwFlags = WNCON_DYNAMIC;
1701
1702         lpNetConnectInfo->dwSpeed = 500;
1703
1704         lpNetConnectInfo->dwDelay = 0;
1705
1706         lpNetConnectInfo->dwOptDataSize = 0x1000;
1707
1708         AFSDbgPrint( L"NPGetConnectionPerformance Successfully returned information for remote connection %S\n",
1709                      lpRemoteName);
1710
1711 try_exit:
1712
1713         if ( hControlDevice != NULL)
1714         {
1715             CloseHandle( hControlDevice);
1716         }
1717
1718         if( pConnectCB != NULL)
1719         {
1720             HeapFree( GetProcessHeap( ), 0, (PVOID) pConnectCB);
1721         }
1722     }
1723
1724     return dwReturn;
1725 }
1726
1727 static LPCWSTR
1728 GetUsageString( DWORD dwUsage)
1729 {
1730     static WCHAR Buffer[128] = L"";
1731     //
1732     // RESOURCEUSAGE_CONNECTABLE   0x00000001
1733     // RESOURCEUSAGE_CONTAINER     0x00000002
1734     // RESOURCEUSAGE_NOLOCALDEVICE 0x00000004
1735     // RESOURCEUSAGE_SIBLING       0x00000008
1736     // RESOURCEUSAGE_ATTACHED      0x00000010
1737     // RESOURCEUSAGE_ALL           (RESOURCEUSAGE_CONNECTABLE | RESOURCEUSAGE_CONTAINER | RESOURCEUSAGE_ATTACHED)
1738     // RESOURCEUSAGE_RESERVED      0x80000000
1739     //
1740
1741     Buffer[0] = L'\0';
1742
1743     if ( dwUsage == RESOURCEUSAGE_ALL )
1744     {
1745         return L"ALL";
1746     }
1747
1748     if ( dwUsage == 0 )
1749     {
1750         return L"NONE";
1751     }
1752
1753     if ( dwUsage & RESOURCEUSAGE_CONNECTABLE )
1754     {
1755         StringCbCat( Buffer, sizeof(Buffer), L"CONNECTABLE|");
1756     }
1757
1758     if ( dwUsage & RESOURCEUSAGE_CONTAINER )
1759     {
1760         StringCbCat( Buffer, sizeof(Buffer), L"CONTAINER|");
1761     }
1762
1763     if ( dwUsage & RESOURCEUSAGE_NOLOCALDEVICE )
1764     {
1765         StringCbCat( Buffer, sizeof(Buffer), L"NOLOCALDEVICE|");
1766     }
1767
1768     if ( dwUsage & RESOURCEUSAGE_SIBLING )
1769     {
1770         StringCbCat( Buffer, sizeof(Buffer), L"SIBLING|");
1771     }
1772
1773     if ( dwUsage & RESOURCEUSAGE_ATTACHED )
1774     {
1775         StringCbCat( Buffer, sizeof(Buffer), L"ATTACHED|");
1776     }
1777
1778     if ( dwUsage & RESOURCEUSAGE_RESERVED )
1779     {
1780         StringCbCat( Buffer, sizeof(Buffer), L"RESERVED|");
1781     }
1782
1783     if ( dwUsage & ~(RESOURCEUSAGE_ALL|RESOURCEUSAGE_NOLOCALDEVICE|RESOURCEUSAGE_SIBLING|RESOURCEUSAGE_RESERVED) )
1784     {
1785         StringCbCat( Buffer, sizeof(Buffer), L"UNKNOWN|");
1786     }
1787
1788     Buffer[lstrlen(Buffer)-1] = L'\0';
1789
1790     return Buffer;
1791 }
1792
1793 static LPCWSTR
1794 GetTypeString( DWORD dwType)
1795 {
1796     static WCHAR Buffer[128] = L"";
1797
1798     //
1799     // RESOURCETYPE_ANY        0x00000000
1800     // RESOURCETYPE_DISK       0x00000001
1801     // RESOURCETYPE_PRINT      0x00000002
1802     // RESOURCETYPE_RESERVED   0x00000008
1803     // RESOURCETYPE_UNKNOWN    0xFFFFFFFF
1804     //
1805
1806     Buffer[0] = L'\0';
1807
1808     if ( dwType == RESOURCETYPE_ANY )
1809     {
1810         return L"ANY";
1811     }
1812
1813     if ( dwType == RESOURCETYPE_UNKNOWN )
1814     {
1815         return L"UNKNOWN";
1816     }
1817
1818     if ( dwType & RESOURCETYPE_DISK )
1819     {
1820         StringCbCat( Buffer, sizeof(Buffer), L"DISK|");
1821     }
1822
1823     if ( dwType & RESOURCETYPE_PRINT )
1824     {
1825         StringCbCat( Buffer, sizeof(Buffer), L"PRINT|");
1826     }
1827
1828     if ( dwType & RESOURCETYPE_RESERVED )
1829     {
1830         StringCbCat( Buffer, sizeof(Buffer), L"RESERVED|");
1831     }
1832
1833     if ( dwType & ~(RESOURCETYPE_DISK|RESOURCETYPE_PRINT|RESOURCETYPE_RESERVED) )
1834     {
1835         StringCbCat( Buffer, sizeof(Buffer), L"UNKNOWN|");
1836     }
1837
1838     Buffer[lstrlen(Buffer)-1] = L'\0';
1839
1840     return Buffer;
1841 }
1842
1843 static LPCWSTR
1844 GetScopeString( DWORD dwScope)
1845 {
1846     static WCHAR Buffer[128] = L"";
1847
1848     //
1849     // RESOURCE_CONNECTED      0x00000001
1850     // RESOURCE_GLOBALNET      0x00000002
1851     // RESOURCE_REMEMBERED     0x00000003
1852     // RESOURCE_RECENT         0x00000004
1853     // RESOURCE_CONTEXT        0x00000005
1854     //
1855
1856     Buffer[0] = L'\0';
1857
1858     if ( dwScope == RESOURCE_CONNECTED )
1859     {
1860         StringCbCat( Buffer, sizeof(Buffer), L"CONNECTED|");
1861     }
1862
1863     if ( dwScope == RESOURCE_GLOBALNET )
1864     {
1865         StringCbCat( Buffer, sizeof(Buffer), L"GLOBALNET|");
1866     }
1867
1868     if ( dwScope == RESOURCE_REMEMBERED )
1869     {
1870         StringCbCat( Buffer, sizeof(Buffer), L"REMEMBERED|");
1871     }
1872
1873     if ( dwScope == RESOURCE_RECENT )
1874     {
1875         StringCbCat( Buffer, sizeof(Buffer), L"RECENT|");
1876     }
1877
1878     if ( dwScope == RESOURCE_CONTEXT )
1879     {
1880         StringCbCat( Buffer, sizeof(Buffer), L"CONTEXT|");
1881     }
1882
1883     if ( dwScope & ~(RESOURCE_CONNECTED|RESOURCE_GLOBALNET|RESOURCE_REMEMBERED|RESOURCE_RECENT|RESOURCE_CONTEXT) )
1884     {
1885         StringCbCat( Buffer, sizeof(Buffer), L"UNKNOWN|");
1886     }
1887
1888     Buffer[lstrlen(Buffer)-1] = L'\0';
1889
1890     return Buffer;
1891 }
1892
1893 static LPCWSTR
1894 GetDisplayString( DWORD dwDisplay)
1895 {
1896     //
1897     // RESOURCEDISPLAYTYPE_GENERIC        0x00000000
1898     // RESOURCEDISPLAYTYPE_DOMAIN         0x00000001
1899     // RESOURCEDISPLAYTYPE_SERVER         0x00000002
1900     // RESOURCEDISPLAYTYPE_SHARE          0x00000003
1901     // RESOURCEDISPLAYTYPE_FILE           0x00000004
1902     // RESOURCEDISPLAYTYPE_GROUP          0x00000005
1903     // RESOURCEDISPLAYTYPE_NETWORK        0x00000006
1904     // RESOURCEDISPLAYTYPE_ROOT           0x00000007
1905     // RESOURCEDISPLAYTYPE_SHAREADMIN     0x00000008
1906     // RESOURCEDISPLAYTYPE_DIRECTORY      0x00000009
1907     // RESOURCEDISPLAYTYPE_TREE           0x0000000A
1908     // RESOURCEDISPLAYTYPE_NDSCONTAINER   0x0000000B
1909     //
1910
1911     switch ( dwDisplay ) {
1912     case RESOURCEDISPLAYTYPE_GENERIC:
1913         return L"GENERIC";
1914     case RESOURCEDISPLAYTYPE_DOMAIN:
1915         return L"DOMAIN";
1916     case RESOURCEDISPLAYTYPE_SERVER:
1917         return L"SERVER";
1918     case RESOURCEDISPLAYTYPE_SHARE:
1919         return L"SHARE";
1920     case RESOURCEDISPLAYTYPE_FILE:
1921         return L"FILE";
1922     case RESOURCEDISPLAYTYPE_GROUP:
1923         return L"GROUP";
1924     case RESOURCEDISPLAYTYPE_NETWORK:
1925         return L"NETWORK";
1926     case RESOURCEDISPLAYTYPE_ROOT:
1927         return L"ROOT";
1928     case RESOURCEDISPLAYTYPE_SHAREADMIN:
1929         return L"SHAREADMIN";
1930     case RESOURCEDISPLAYTYPE_DIRECTORY:
1931         return L"DIRECTORY";
1932     case RESOURCEDISPLAYTYPE_TREE:
1933         return L"TREE";
1934     case RESOURCEDISPLAYTYPE_NDSCONTAINER:
1935         return L"NDSCONTAINER";
1936     default:
1937         return L"UNKNOWN";
1938     }
1939 }
1940
1941 DWORD
1942 APIENTRY
1943 NPOpenEnum( DWORD          dwScope,
1944             DWORD          dwType,
1945             DWORD          dwUsage,
1946             LPNETRESOURCE  lpNetResource,
1947             LPHANDLE       lphEnum )
1948 {
1949
1950     DWORD   dwStatus = WN_SUCCESS;
1951     AFSEnumerationCB *pEnumCB = NULL;
1952
1953 #ifdef AFS_DEBUG_TRACE
1954     if ( lpNetResource == NULL)
1955     {
1956         AFSDbgPrint( L"NPOpenEnum Scope %s Type %s Usage %s NetResource: (Null)\n",
1957                      GetScopeString(dwScope), GetTypeString(dwType), GetUsageString(dwUsage));
1958     }
1959     else
1960     {
1961         AFSDbgPrint( L"NPOpenEnum Scope %s Type %s Usage %s NetResource (0x%p): Scope %s Type %s Display %s Usage %s Local %s Remote \"%s\" Comment \"%s\"\n",
1962                      GetScopeString(dwScope),
1963                      GetTypeString(dwType),
1964                      GetUsageString(dwUsage),
1965                      lpNetResource,
1966                      GetScopeString(lpNetResource->dwScope),
1967                      GetTypeString(lpNetResource->dwType),
1968                      GetDisplayString(lpNetResource->dwDisplayType),
1969                      GetUsageString(lpNetResource->dwUsage),
1970                      lpNetResource->lpLocalName,
1971                      lpNetResource->lpRemoteName,
1972                      lpNetResource->lpComment);
1973     }
1974 #endif
1975
1976     if ( dwUsage == 0 )
1977     {
1978         dwUsage = RESOURCEUSAGE_ALL;
1979     }
1980
1981 #if 0
1982     if ( dwType == 0 || dwType == RESOURCEUSAGE_ATTACHED)
1983     {
1984         dwType |= RESOURCETYPE_DISK | RESOURCETYPE_PRINT;
1985     }
1986 #endif
1987
1988     *lphEnum = HeapAlloc( GetProcessHeap( ), HEAP_ZERO_MEMORY, sizeof( AFSEnumerationCB));
1989
1990     if( *lphEnum == NULL)
1991     {
1992
1993         return WN_OUT_OF_MEMORY;
1994     }
1995
1996     pEnumCB = (AFSEnumerationCB *)*lphEnum;
1997
1998     pEnumCB->CurrentIndex = 0;
1999
2000     pEnumCB->Type = dwType;
2001
2002     switch( dwScope )
2003     {
2004         case RESOURCE_CONNECTED:
2005         {
2006
2007             pEnumCB->Scope = RESOURCE_CONNECTED;
2008
2009             break;
2010         }
2011
2012         case RESOURCE_CONTEXT:
2013         {
2014
2015             pEnumCB->Scope = RESOURCE_CONTEXT;
2016
2017             break;
2018         }
2019
2020         case RESOURCE_GLOBALNET:
2021         {
2022
2023             if( lpNetResource != NULL &&
2024                 lpNetResource->lpRemoteName != NULL)
2025             {
2026
2027                 pEnumCB->RemoteName = (WCHAR *)HeapAlloc( GetProcessHeap( ), HEAP_ZERO_MEMORY, 0x1000);
2028
2029                 if( pEnumCB->RemoteName == NULL)
2030                 {
2031
2032                     dwStatus = WN_OUT_OF_MEMORY;
2033                     HeapFree( GetProcessHeap( ), 0, (PVOID) *lphEnum );
2034                     *lphEnum = NULL;
2035                 }
2036                 else
2037                 {
2038
2039                     StringCbCopy( pEnumCB->RemoteName,
2040                                   0x1000,
2041                                   lpNetResource->lpRemoteName);
2042
2043                 }
2044             }
2045
2046             pEnumCB->Scope = RESOURCE_GLOBALNET;
2047
2048             break;
2049         }
2050
2051         default:
2052
2053 #ifdef AFS_DEBUG_TRACE
2054             AFSDbgPrint( L"NPOpenEnum Processing (Scope %s 0x%x) Type %s Usage %s, returning WN_NOT_SUPPORTED\n",
2055                          GetScopeString(dwScope), dwScope, GetTypeString(dwType), GetUsageString(dwUsage));
2056 #endif
2057
2058             dwStatus  = WN_NOT_SUPPORTED;
2059             HeapFree( GetProcessHeap( ), 0, (PVOID) *lphEnum );
2060             *lphEnum = NULL;
2061
2062             break;
2063     }
2064
2065     return dwStatus;
2066 }
2067
2068
2069 DWORD
2070 APIENTRY
2071 NPEnumResource( HANDLE  hEnum,
2072                 LPDWORD lpcCount,
2073                 LPVOID  lpBuffer,
2074                 LPDWORD lpBufferSize)
2075 {
2076
2077     DWORD            dwStatus = WN_NO_MORE_ENTRIES; //WN_SUCCESS;
2078     ULONG            dwCopyBytes;
2079     ULONG            EntriesCopied;
2080     ULONG            EntriesRequested;
2081     ULONG            dwIndex;
2082     LPNETRESOURCE    pNetResource;
2083     ULONG            SpaceNeeded;
2084     ULONG            SpaceAvailable;
2085     PWCHAR           StringZone;
2086     AFSNetworkProviderConnectionCB *pConnectionCB = NULL;
2087     void            *pConnectionCBBase = NULL;
2088     DWORD            dwError = 0;
2089     UNICODE_STRING   uniRemoteName;
2090     HANDLE           hControlDevice = NULL;
2091     AFSEnumerationCB *pEnumCB = (AFSEnumerationCB *)hEnum;
2092
2093     __Enter
2094     {
2095
2096         if ( lpBufferSize == NULL)
2097         {
2098 #ifdef AFS_DEBUG_TRACE
2099             AFSDbgPrint( L"NPEnumResource No output size, returning WN_BAD_VALUE\n");
2100 #endif
2101             try_return( dwStatus = WN_BAD_VALUE);
2102         }
2103
2104         ReadProviderNameString();
2105
2106         pNetResource = (LPNETRESOURCE) lpBuffer;
2107         SpaceAvailable = *lpBufferSize;
2108         EntriesRequested = *lpcCount;
2109         *lpcCount = EntriesCopied = 0;
2110         StringZone = (PWCHAR) ((char *)lpBuffer + *lpBufferSize);
2111
2112 #ifdef AFS_DEBUG_TRACE
2113         AFSDbgPrint( L"NPEnumResource Processing Remote name %s Scope %s Type %s Usage %s Index %d SpaceAvailable 0x%lX RequestedEntries %lu\n",
2114                      pEnumCB->RemoteName ? pEnumCB->RemoteName : L"(Null)",
2115                      GetScopeString(pEnumCB->Scope),
2116                      GetTypeString(pEnumCB->Type),
2117                      GetUsageString(pEnumCB->Type),
2118                      pEnumCB->CurrentIndex,
2119                      SpaceAvailable,
2120                      EntriesRequested);
2121 #endif
2122
2123         if ( NPIsFSDisabled())
2124         {
2125
2126 #ifdef AFS_DEBUG_TRACE
2127             AFSDbgPrint( L"NPEnumResource AFSRDFS is disabled, returning WN_NO_MORE_ENTRIES\n");
2128 #endif
2129
2130             try_return( dwStatus = WN_NO_MORE_ENTRIES);
2131         }
2132
2133         pConnectionCB = (AFSNetworkProviderConnectionCB *)HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, 0x1000);
2134
2135         if( pConnectionCB == NULL)
2136         {
2137
2138 #ifdef AFS_DEBUG_TRACE
2139             AFSDbgPrint( L"NPEnumResource Out of Memory\n");
2140 #endif
2141
2142             try_return( dwStatus = WN_OUT_OF_MEMORY);
2143         }
2144
2145         pConnectionCBBase = (void *)pConnectionCB;
2146
2147         hControlDevice = OpenRedirector();
2148
2149         if( hControlDevice == NULL)
2150         {
2151
2152 #ifdef AFS_DEBUG_TRACE
2153             AFSDbgPrint( L"NPEnumResource OpenRedirector failure, returning WN_NET_ERROR\n");
2154 #endif
2155
2156             try_return( dwStatus = WN_NET_ERROR);
2157         }
2158
2159         //
2160         // Handle the special cases here
2161         //   0. Provider Network Root
2162         //   1. Server Root
2163         //
2164
2165 #if 0
2166         if ( pEnumCB->Scope == RESOURCE_GLOBALNET)
2167         {
2168
2169             ReadServerNameString();
2170
2171             if ( pEnumCB->CurrentIndex == 0 &&
2172                  pEnumCB->RemoteName == NULL)
2173             {
2174
2175                 // Determine the space needed for this entry...
2176
2177                 SpaceNeeded = 2 * ( cbProviderNameLength + sizeof( WCHAR));
2178
2179                 uniRemoteName.Length = (USHORT)cbProviderNameLength;
2180                 uniRemoteName.MaximumLength = uniRemoteName.Length;
2181                 uniRemoteName.Buffer = wszProviderName;
2182
2183                 if( SpaceNeeded + sizeof( NETRESOURCE) > SpaceAvailable)
2184                 {
2185
2186                     *lpBufferSize = SpaceNeeded + sizeof( NETRESOURCE);
2187
2188 #ifdef AFS_DEBUG_TRACE
2189                     AFSDbgPrint( L"NPEnumResource Request MORE_DATA for entry %s Len %d\n",
2190                                  &uniRemoteName,
2191                                  *lpBufferSize);
2192 #endif
2193                     try_return( dwStatus = WN_MORE_DATA);
2194                 }
2195
2196 #ifdef AFS_DEBUG_TRACE
2197                 AFSDbgPrint( L"NPEnumResource Processing Entry %wZ\n",
2198                              &uniRemoteName);
2199 #endif
2200
2201                 SpaceAvailable -= (SpaceNeeded + sizeof( NETRESOURCE));
2202
2203                 pNetResource->dwScope       = RESOURCE_GLOBALNET;
2204                 pNetResource->dwType        = RESOURCETYPE_ANY;
2205                 pNetResource->dwDisplayType = RESOURCEDISPLAYTYPE_NETWORK;
2206                 pNetResource->dwUsage       = RESOURCEUSAGE_CONTAINER | RESOURCEUSAGE_RESERVED;
2207
2208                 // setup string area at opposite end of buffer
2209                 StringZone = (PWCHAR)( (PBYTE) StringZone - SpaceNeeded);
2210
2211                 pNetResource->lpLocalName = NULL;
2212
2213                 // copy remote name
2214                 pNetResource->lpRemoteName = StringZone;
2215
2216                 StringCbCopy( StringZone,
2217                               cbProviderNameLength + sizeof( WCHAR),
2218                               wszProviderName);
2219
2220                 StringZone += cbProviderNameLength / sizeof(WCHAR) + 1;
2221
2222                 pNetResource->lpComment = NULL;
2223
2224                 // copy provider name
2225                 pNetResource->lpProvider = StringZone;
2226                 StringCbCopy( StringZone,
2227                               cbProviderNameLength + sizeof( WCHAR),
2228                               wszProviderName);
2229
2230                 StringZone += cbProviderNameLength / sizeof( WCHAR) + 1;
2231
2232 #ifdef AFS_DEBUG_TRACE
2233                 AFSDbgPrint( L"NPEnumResource Entry (0x%p) Scope %s Type %s Display %s Usage %s Local %s Remote \"%s\" Comment \"%s\"\n",
2234                              pNetResource,
2235                              GetScopeString(pNetResource->dwScope),
2236                              GetTypeString(pNetResource->dwType),
2237                              GetDisplayString(pNetResource->dwDisplayType),
2238                              GetUsageString(pNetResource->dwUsage),
2239                              pNetResource->lpLocalName,
2240                              pNetResource->lpRemoteName,
2241                              pNetResource->lpComment);
2242 #endif
2243
2244                 // setup the new end of buffer
2245                 StringZone = (PWCHAR)( (PBYTE) StringZone - SpaceNeeded);
2246
2247                 EntriesCopied++;
2248
2249                 pNetResource++;
2250
2251                 // do not change the index since we did not query the redirector
2252                 pEnumCB->CurrentIndex = 0;
2253
2254                 // remember that we returned the provider name
2255                 pEnumCB->RemoteName = (WCHAR *)HeapAlloc( GetProcessHeap( ), HEAP_ZERO_MEMORY, 0x1000);
2256
2257                 if( pEnumCB->RemoteName == NULL)
2258                 {
2259
2260                     try_return( dwStatus = WN_OUT_OF_MEMORY);
2261                 }
2262                 else
2263                 {
2264
2265                     StringCbCopy( pEnumCB->RemoteName,
2266                                    0x1000,
2267                                    wszProviderName);
2268                 }
2269             }
2270
2271             if ( pEnumCB->CurrentIndex == 0 &&
2272                  lstrlen( pEnumCB->RemoteName) == cbProviderNameLength / sizeof( WCHAR) &&
2273                  _wcsnicmp( pEnumCB->RemoteName, wszProviderName, cbProviderNameLength / sizeof( WCHAR)) == 0 &&
2274                  EntriesCopied < EntriesRequested)
2275             {
2276
2277                 //
2278                 // After the network provider entry comes the server entry
2279                 //
2280
2281                 // Determine the space needed for this entry...
2282
2283                 SpaceNeeded = cbProviderNameLength + cbServerNameUNCLength + cbServerCommentLength + 3 * sizeof( WCHAR);
2284
2285                 uniRemoteName.Length = (USHORT)cbServerNameUNCLength;
2286                 uniRemoteName.MaximumLength = uniRemoteName.Length;
2287                 uniRemoteName.Buffer = wszServerNameUNC;
2288
2289                 if( SpaceNeeded + sizeof( NETRESOURCE) > SpaceAvailable)
2290                 {
2291
2292                     *lpBufferSize = SpaceNeeded + sizeof( NETRESOURCE);
2293
2294 #ifdef AFS_DEBUG_TRACE
2295                     AFSDbgPrint( L"NPEnumResource Request MORE_DATA for entry %s Len %d\n",
2296                                  &uniRemoteName,
2297                                  *lpBufferSize);
2298 #endif
2299                     try_return( dwStatus = WN_MORE_DATA);
2300                 }
2301
2302 #ifdef AFS_DEBUG_TRACE
2303                 AFSDbgPrint( L"NPEnumResource Processing Entry %wZ\n",
2304                              &uniRemoteName);
2305 #endif
2306
2307                 SpaceAvailable -= (SpaceNeeded + sizeof( NETRESOURCE));
2308
2309                 pNetResource->dwScope       = 0;
2310                 pNetResource->dwType        = RESOURCETYPE_ANY;
2311                 pNetResource->dwDisplayType = RESOURCEDISPLAYTYPE_SERVER;
2312                 pNetResource->dwUsage       = RESOURCEUSAGE_CONTAINER;
2313
2314                 // setup string area at opposite end of buffer
2315                 StringZone = (PWCHAR)( (PBYTE) StringZone - SpaceNeeded);
2316
2317                 pNetResource->lpLocalName = NULL;
2318
2319                 // copy remote name
2320                 pNetResource->lpRemoteName = StringZone;
2321
2322                 StringCbCopy( StringZone,
2323                               cbServerNameUNCLength + sizeof( WCHAR),
2324                               wszServerNameUNC);
2325
2326                 StringZone += cbServerNameUNCLength / sizeof(WCHAR) + 1;
2327
2328                 // copy comment
2329                 pNetResource->lpComment = StringZone;
2330
2331                 StringCbCopy( StringZone,
2332                               cbServerCommentLength + sizeof( WCHAR),
2333                               wszServerComment);
2334
2335                 StringZone += cbServerCommentLength / sizeof( WCHAR) + 1;
2336
2337                 // copy provider name
2338                 pNetResource->lpProvider = StringZone;
2339                 StringCbCopy( StringZone,
2340                               cbProviderNameLength + sizeof( WCHAR),
2341                               wszProviderName);
2342
2343                 StringZone += cbProviderNameLength / sizeof( WCHAR) + 1;
2344
2345 #ifdef AFS_DEBUG_TRACE
2346                 AFSDbgPrint( L"NPEnumResource Entry (0x%p) Scope %s Type %s Display %s Usage %s Local %s Remote \"%s\" Comment \"%s\"\n",
2347                              pNetResource,
2348                              GetScopeString(pNetResource->dwScope),
2349                              GetTypeString(pNetResource->dwType),
2350                              GetDisplayString(pNetResource->dwDisplayType),
2351                              GetUsageString(pNetResource->dwUsage),
2352                              pNetResource->lpLocalName,
2353                              pNetResource->lpRemoteName,
2354                              pNetResource->lpComment);
2355 #endif
2356
2357                 // setup the new end of buffer
2358                 StringZone = (PWCHAR)( (PBYTE) StringZone - SpaceNeeded);
2359
2360                 EntriesCopied++;
2361
2362                 pNetResource++;
2363
2364                 // do not update the index because we did not query the redirector
2365                 pEnumCB->CurrentIndex = 0;
2366
2367                 // remember that we returned the server
2368                 StringCbCopy( pEnumCB->RemoteName,
2369                               0x1000,
2370                               wszServerNameUNC);
2371             }
2372         }
2373 #endif
2374
2375         //
2376         // Setup what we are going to ask for
2377         //
2378
2379         pConnectionCB->Scope = pEnumCB->Scope;
2380
2381         pConnectionCB->Type = pEnumCB->Type;
2382
2383         pConnectionCB->CurrentIndex = pEnumCB->CurrentIndex;
2384
2385         pConnectionCB->Version = AFS_NETWORKPROVIDER_INTERFACE_VERSION_1;
2386
2387         //
2388         // If this is a RESOURCE_GLOBALNET enumeration then pass down the remote name if
2389         // there is one
2390         //
2391
2392         pConnectionCB->RemoteNameLength = 0;
2393
2394         if( pEnumCB->Scope == RESOURCE_GLOBALNET &&
2395             pEnumCB->RemoteName != NULL)
2396         {
2397
2398             pConnectionCB->RemoteNameLength = wcslen( pEnumCB->RemoteName) * sizeof( WCHAR);
2399
2400             StringCbCopy( pConnectionCB->RemoteName,
2401                           (0x1000 - sizeof(AFSNetworkProviderConnectionCB)) + sizeof(WCHAR),
2402                           pEnumCB->RemoteName);
2403         }
2404
2405         pConnectionCB->AuthenticationId = AFSRetrieveAuthId();
2406
2407 #ifdef AFS_DEBUG_TRACE
2408         AFSDbgPrint( L"NPEnumResource Retrieved authentication id %08lX-%08lX\n",
2409                      pConnectionCB->AuthenticationId.HighPart,
2410                      pConnectionCB->AuthenticationId.LowPart);
2411 #endif
2412
2413         dwError = DeviceIoControl( hControlDevice,
2414                                    IOCTL_AFS_LIST_CONNECTIONS,
2415                                    pConnectionCB,
2416                                    0x1000,
2417                                    pConnectionCB,
2418                                    0x1000,
2419                                    &dwCopyBytes,
2420                                    NULL);
2421
2422         if( !dwError)
2423         {
2424 #ifdef AFS_DEBUG_TRACE
2425             DWORD gle = GetLastError();
2426
2427             AFSDbgPrint( L"NPEnumResource Failed to list connections from file system - gle 0x%x\n",
2428                          gle);
2429 #endif
2430             try_return( dwStatus = WN_NOT_CONNECTED);
2431         }
2432
2433         if( dwCopyBytes == 0)
2434         {
2435
2436 #ifdef AFS_DEBUG_TRACE
2437             AFSDbgPrint( L"NPEnumResource No More Entries\n");
2438 #endif
2439             try_return( dwStatus = WN_NO_MORE_ENTRIES);
2440         }
2441
2442         dwIndex = pEnumCB->CurrentIndex;
2443
2444         while( EntriesCopied < EntriesRequested)
2445         {
2446
2447             uniRemoteName.Length = (USHORT)pConnectionCB->RemoteNameLength;
2448             uniRemoteName.MaximumLength = uniRemoteName.Length;
2449             uniRemoteName.Buffer = pConnectionCB->RemoteName;
2450
2451             // Determine the space needed for this entry...
2452
2453             SpaceNeeded  = 0;
2454
2455             if( pConnectionCB->LocalName != 0)
2456             {
2457
2458                 SpaceNeeded += 3 * sizeof(WCHAR);                // local name
2459             }
2460
2461             SpaceNeeded += pConnectionCB->RemoteNameLength + sizeof( WCHAR);        // remote name
2462
2463             if( pConnectionCB->CommentLength > 0)
2464             {
2465
2466                 SpaceNeeded += pConnectionCB->CommentLength + sizeof( WCHAR);           // comment
2467             }
2468
2469             SpaceNeeded += cbProviderNameLength + sizeof( WCHAR);           // provider name
2470
2471             if( SpaceNeeded + sizeof( NETRESOURCE) > SpaceAvailable)
2472             {
2473
2474                 if (EntriesCopied == 0) {
2475
2476                     dwStatus = WN_MORE_DATA;
2477
2478                     *lpBufferSize = SpaceNeeded + sizeof( NETRESOURCE);
2479
2480 #ifdef AFS_DEBUG_TRACE
2481                     AFSDbgPrint( L"NPEnumResource Request MORE_DATA for entry %s Len %d\n",
2482                                  &uniRemoteName,
2483                                  *lpBufferSize);
2484 #endif
2485
2486                 } else {
2487
2488 #ifdef AFS_DEBUG_TRACE
2489                     AFSDbgPrint( L"NPEnumResource Return SUCCESS but more entries Index %d\n",
2490                                  dwIndex);
2491 #endif
2492
2493                     dwStatus = WN_SUCCESS;
2494                 }
2495
2496                 break;
2497             }
2498
2499             SpaceAvailable -= (SpaceNeeded + sizeof( NETRESOURCE));
2500
2501             pNetResource->dwScope       = pConnectionCB->Scope;
2502             pNetResource->dwType        = pConnectionCB->Type;
2503
2504             pNetResource->dwDisplayType = pConnectionCB->DisplayType;
2505
2506             if ( pNetResource->dwType == RESOURCETYPE_ANY &&
2507                  pNetResource->dwDisplayType == RESOURCEDISPLAYTYPE_SHARE)
2508             {
2509
2510                 pNetResource->dwType = RESOURCETYPE_DISK;
2511             }
2512             pNetResource->dwUsage       = pConnectionCB->Usage;
2513
2514             // setup string area at opposite end of buffer
2515             StringZone = (PWCHAR)( (PBYTE) StringZone - SpaceNeeded);
2516
2517             // copy local name
2518             if( pConnectionCB->LocalName != 0)
2519             {
2520
2521                 pNetResource->lpLocalName = StringZone;
2522                 *StringZone++ = towupper(pConnectionCB->LocalName);
2523                 *StringZone++ = L':';
2524                 *StringZone++ = L'\0';
2525             }
2526             else
2527             {
2528
2529                 pNetResource->lpLocalName = NULL;
2530             }
2531
2532 #ifdef AFS_DEBUG_TRACE
2533             AFSDbgPrint( L"NPEnumResource Processing Entry %wZ\n",
2534                          &uniRemoteName);
2535 #endif
2536
2537             // copy remote name
2538             pNetResource->lpRemoteName = StringZone;
2539
2540             CopyMemory( StringZone,
2541                         pConnectionCB->RemoteName,
2542                         pConnectionCB->RemoteNameLength);
2543
2544             StringZone += (pConnectionCB->RemoteNameLength / sizeof(WCHAR));
2545
2546             *StringZone++ = L'\0';
2547
2548             // copy comment
2549             if( pConnectionCB->CommentLength > 0)
2550             {
2551
2552                 pNetResource->lpComment = StringZone;
2553
2554                 CopyMemory( StringZone,
2555                             (void *)((char *)pConnectionCB + pConnectionCB->CommentOffset),
2556                             pConnectionCB->CommentLength);
2557
2558                 StringZone += (pConnectionCB->CommentLength / sizeof(WCHAR));
2559
2560                 *StringZone++ = L'\0';
2561             }
2562             else
2563             {
2564
2565                 pNetResource->lpComment = NULL;
2566             }
2567
2568             // copy provider name
2569             pNetResource->lpProvider = StringZone;
2570             StringCbCopy( StringZone,
2571                           cbProviderNameLength + sizeof( WCHAR),
2572                           wszProviderName);
2573
2574             StringZone += (cbProviderNameLength / sizeof( WCHAR) + 1);
2575
2576 #ifdef AFS_DEBUG_TRACE
2577             AFSDbgPrint( L"NPEnumResource Entry (0x%p) Scope %s Type %s Display %s Usage %s Local %s Remote \"%s\" Comment \"%s\"\n",
2578                          pNetResource,
2579                          GetScopeString(pNetResource->dwScope),
2580                          GetTypeString(pNetResource->dwType),
2581                          GetDisplayString(pNetResource->dwDisplayType),
2582                          GetUsageString(pNetResource->dwUsage),
2583                          pNetResource->lpLocalName,
2584                          pNetResource->lpRemoteName,
2585                          pNetResource->lpComment);
2586 #endif
2587
2588             // setup the new end of buffer
2589             StringZone = (PWCHAR)( (PBYTE) StringZone - SpaceNeeded);
2590
2591             EntriesCopied++;
2592
2593             pNetResource++;
2594
2595             dwIndex++;
2596
2597             dwCopyBytes -= FIELD_OFFSET( AFSNetworkProviderConnectionCB, RemoteName) +
2598                            pConnectionCB->RemoteNameLength +
2599                            pConnectionCB->CommentLength;
2600
2601             if( dwCopyBytes == 0)
2602             {
2603
2604                 dwStatus = WN_SUCCESS;
2605
2606                 break;
2607             }
2608
2609             pConnectionCB = (AFSNetworkProviderConnectionCB *)((char *)pConnectionCB +
2610                             FIELD_OFFSET( AFSNetworkProviderConnectionCB, RemoteName) +
2611                             pConnectionCB->RemoteNameLength +
2612                             pConnectionCB->CommentLength);
2613         }
2614
2615         *lpcCount = EntriesCopied;
2616
2617         // update entry index
2618         pEnumCB->CurrentIndex = dwIndex;
2619
2620 #ifdef AFS_DEBUG_TRACE
2621         AFSDbgPrint( L"NPEnumResource Completed Count %d Index %d\n",
2622                      EntriesCopied,
2623                      dwIndex);
2624 #endif
2625
2626 try_exit:
2627
2628         if ( hControlDevice != NULL)
2629         {
2630
2631             CloseHandle( hControlDevice);
2632         }
2633
2634         if( pConnectionCBBase != NULL)
2635         {
2636
2637             HeapFree( GetProcessHeap( ), 0, (PVOID) pConnectionCBBase);
2638         }
2639     }
2640
2641     return dwStatus;
2642 }
2643
2644 /*++
2645
2646 Routine Description:
2647
2648     This routine closes the handle for enumeration of resources.
2649
2650 Arguments:
2651
2652     hEnum  - the enumeration handle
2653
2654 Return Value:
2655
2656     WN_SUCCESS if successful, otherwise the appropriate error
2657
2658 Notes:
2659
2660     The sample only supports the notion of enumerating connected shares
2661
2662 --*/
2663
2664 DWORD APIENTRY
2665 NPCloseEnum( HANDLE hEnum )
2666 {
2667
2668     AFSEnumerationCB *pEnumCB = (AFSEnumerationCB *)hEnum;
2669
2670 #ifdef AFS_DEBUG_TRACE
2671     AFSDbgPrint( L"NPCloseEnum\n");
2672 #endif
2673
2674     if( pEnumCB->RemoteName != NULL)
2675     {
2676
2677         HeapFree( GetProcessHeap( ), 0, (PVOID) pEnumCB->RemoteName);
2678     }
2679
2680     HeapFree( GetProcessHeap( ), 0, (PVOID) hEnum );
2681
2682     return WN_SUCCESS;
2683 }
2684
2685 DWORD APIENTRY
2686 NPGetResourceParent( LPNETRESOURCE   lpNetResource,
2687                      LPVOID  lpBuffer,
2688                      LPDWORD lpBufferSize )
2689 {
2690
2691     DWORD    dwStatus = WN_ACCESS_DENIED;
2692     WCHAR   *pwchRemoteName = NULL, *pwchSearch = NULL, *pwchSystem = NULL;
2693     LPNETRESOURCE lpOutResource = (LPNETRESOURCE) lpBuffer;
2694
2695     if ( lpNetResource == NULL)
2696     {
2697 #ifdef AFS_DEBUG_TRACE
2698         AFSDbgPrint( L"NPGetResourceParent NULL NETRESOURCE\n");
2699 #endif
2700         return WN_MORE_DATA;
2701     }
2702
2703     if( lpNetResource->lpRemoteName == NULL)
2704     {
2705 #ifdef AFS_DEBUG_TRACE
2706         AFSDbgPrint( L"NPGetResourceParent NULL NETRESOURCE\n");
2707 #endif
2708         return WN_BAD_NETNAME;
2709     }
2710
2711     if ( lpNetResource->dwType != 0 &&
2712          lpNetResource->dwType != RESOURCETYPE_DISK)
2713     {
2714 #ifdef AFS_DEBUG_TRACE
2715         AFSDbgPrint( L"NPGetResourceParent Bad dwType\n");
2716 #endif
2717         return WN_BAD_VALUE;
2718     }
2719
2720     if ( lpBufferSize == NULL )
2721     {
2722
2723 #ifdef AFS_DEBUG_TRACE
2724         AFSDbgPrint( L"NPGetResourceParent Null lpBufferSize\n");
2725 #endif
2726         return WN_BAD_VALUE;
2727     }
2728
2729 #ifdef AFS_DEBUG_TRACE
2730     AFSDbgPrint( L"NPGetResourceParent For remote name %s\n",
2731                  lpNetResource->lpRemoteName);
2732 #endif
2733
2734     pwchRemoteName = lpNetResource->lpRemoteName;
2735
2736     pwchSearch = pwchRemoteName + (wcslen( pwchRemoteName) - 1);
2737
2738     while( pwchSearch != pwchRemoteName)
2739     {
2740
2741         if( *pwchSearch == L'\\')
2742         {
2743
2744             *pwchSearch = L'\0';
2745
2746             break;
2747         }
2748
2749         pwchSearch--;
2750     }
2751
2752     if( pwchSearch != pwchRemoteName)
2753     {
2754
2755 #ifdef AFS_DEBUG_TRACE
2756         AFSDbgPrint( L"NPGetResourceParent Processing parent %s\n",
2757                      lpNetResource->lpRemoteName);
2758 #endif
2759
2760         dwStatus = NPGetResourceInformation( lpNetResource,
2761                                              lpBuffer,
2762                                              lpBufferSize,
2763                                              &pwchSystem);
2764     }
2765     else
2766     {
2767         if ( lpOutResource == NULL ||
2768              *lpBufferSize < sizeof( NETRESOURCE) )
2769         {
2770             *lpBufferSize = sizeof( NETRESOURCE);
2771
2772             return WN_MORE_DATA;
2773         }
2774
2775         memset( lpOutResource, 0, sizeof( NETRESOURCE));
2776
2777         return WN_SUCCESS;
2778
2779     }
2780
2781     return dwStatus;
2782 }
2783
2784 DWORD APIENTRY
2785 NPGetResourceInformation( LPNETRESOURCE   lpNetResource,
2786                           LPVOID  lpBuffer,
2787                           LPDWORD lpBufferSize,
2788                           LPWSTR  *lplpSystem )
2789 {
2790
2791     DWORD    dwStatus = WN_NOT_CONNECTED;
2792     AFSNetworkProviderConnectionCB   *pConnectCB = NULL;
2793     DWORD    dwError = 0;
2794     DWORD    dwBufferSize = 0;
2795     HANDLE   hControlDevice = NULL;
2796     NETRESOURCE *pNetResource = (NETRESOURCE *)lpBuffer;
2797     PWCHAR   pStringZone = NULL;
2798     UNICODE_STRING uniRemoteName;
2799     DWORD    ulRequiredLen = 0;
2800     DWORD    dwPassedSize;
2801
2802
2803     __Enter
2804     {
2805         if ( lplpSystem)
2806         {
2807             *lplpSystem = NULL;
2808         }
2809
2810         ReadProviderNameString();
2811
2812         if ( NPIsFSDisabled())
2813         {
2814
2815 #ifdef AFS_DEBUG_TRACE
2816             AFSDbgPrint( L"NPGetResourceInformation AFSRDFS is disabled, returning WN_BAD_NETNAME\n");
2817 #endif
2818
2819             try_return( dwStatus = WN_BAD_NETNAME);
2820         }
2821
2822         if ( lpNetResource == NULL ||
2823              lpBufferSize == NULL )
2824         {
2825
2826 #ifdef AFS_DEBUG_TRACE
2827             AFSDbgPrint( L"NPGetResourceInformaton Null lpNetResource or lpBufferSize\n");
2828 #endif
2829             return WN_BAD_VALUE;
2830         }
2831
2832         if( lpNetResource->lpRemoteName == NULL)
2833         {
2834 #ifdef AFS_DEBUG_TRACE
2835             AFSDbgPrint( L"NPGetResourceInformation No resource name\n");
2836 #endif
2837
2838             try_return( dwStatus = WN_NOT_CONNECTED);
2839         }
2840
2841         dwPassedSize = *lpBufferSize;
2842
2843         dwBufferSize = 0x1000;
2844
2845         pConnectCB = (AFSNetworkProviderConnectionCB *)HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, dwBufferSize);
2846
2847         if( pConnectCB == NULL)
2848         {
2849
2850             try_return( dwStatus = WN_OUT_OF_MEMORY);
2851         }
2852
2853         pConnectCB->RemoteNameLength = wcslen( lpNetResource->lpRemoteName) * sizeof( WCHAR);
2854
2855         StringCbCopy( pConnectCB->RemoteName,
2856                       dwBufferSize - sizeof(AFSNetworkProviderConnectionCB),
2857                       lpNetResource->lpRemoteName);
2858
2859         pConnectCB->Version = AFS_NETWORKPROVIDER_INTERFACE_VERSION_1;
2860
2861         pConnectCB->AuthenticationId = AFSRetrieveAuthId();
2862
2863 #ifdef AFS_DEBUG_TRACE
2864         AFSDbgPrint( L"NPGetResourceInformation Retrieved authentication id %08lX-%08lX\n",
2865                      pConnectCB->AuthenticationId.HighPart,
2866                      pConnectCB->AuthenticationId.LowPart);
2867 #endif
2868
2869         hControlDevice = OpenRedirector();
2870
2871         if( hControlDevice == NULL)
2872         {
2873
2874 #ifdef AFS_DEBUG_TRACE
2875             AFSDbgPrint( L"NPGetResourceInformation OpenRedirector failure, returning WN_NET_ERROR\n");
2876 #endif
2877
2878             try_return( dwStatus = WN_NET_ERROR);
2879         }
2880
2881         dwError = DeviceIoControl( hControlDevice,
2882                                    IOCTL_AFS_GET_CONNECTION_INFORMATION,
2883                                    pConnectCB,
2884                                    dwBufferSize,
2885                                    pConnectCB,
2886                                    dwBufferSize,
2887                                    lpBufferSize,
2888                                    NULL);
2889
2890         if( !dwError)
2891         {
2892 #ifdef AFS_DEBUG_TRACE
2893             DWORD gle = GetLastError();
2894
2895             AFSDbgPrint( L"NPGetResourceInformation Failed to get connection info from file system for local %s gle 0x%x\n",
2896                          lpNetResource->lpRemoteName, gle);
2897 #endif
2898             try_return( dwStatus = WN_BAD_NETNAME);
2899         }
2900
2901         uniRemoteName.Length = (USHORT)pConnectCB->RemoteNameLength;
2902         uniRemoteName.MaximumLength = uniRemoteName.Length;
2903         uniRemoteName.Buffer = pConnectCB->RemoteName;
2904
2905 #ifdef AFS_DEBUG_TRACE
2906         AFSDbgPrint( L"NPGetResourceInformation For remote name %wZ Scope %08lX Type %08lX Usage %08lX\n",
2907                      &uniRemoteName,
2908                      pConnectCB->Scope,
2909                      pConnectCB->Type,
2910                      pConnectCB->Usage);
2911 #endif
2912
2913         // Determine the space needed for this entry...
2914
2915         ulRequiredLen = sizeof( NETRESOURCE);
2916
2917         ulRequiredLen += pConnectCB->RemoteNameLength + sizeof( WCHAR);
2918
2919         ulRequiredLen += pConnectCB->CommentLength + sizeof( WCHAR);
2920
2921         ulRequiredLen += cbProviderNameLength + sizeof( WCHAR);
2922
2923         ulRequiredLen += pConnectCB->RemainingPathLength + sizeof( WCHAR);
2924
2925         if( pNetResource == NULL ||
2926             ulRequiredLen > dwPassedSize)
2927         {
2928
2929             *lpBufferSize = ulRequiredLen;
2930
2931             try_return( dwStatus = WN_MORE_DATA);
2932         }
2933
2934         pStringZone = (PWCHAR) ((char *)lpBuffer + sizeof( NETRESOURCE));
2935
2936         pNetResource->dwScope       = 0 /* pConnectCB->Scope*/;
2937         pNetResource->dwType        = 0 /* pConnectCB->Type */;
2938
2939         pNetResource->dwDisplayType = pConnectCB->DisplayType;
2940
2941         pNetResource->dwUsage       = pConnectCB->Usage;
2942
2943         pNetResource->lpLocalName = NULL;
2944
2945         // copy remote name
2946         pNetResource->lpRemoteName = pStringZone;
2947
2948         CopyMemory( pStringZone,
2949                     pConnectCB->RemoteName,
2950                     pConnectCB->RemoteNameLength);
2951
2952         pStringZone += (pConnectCB->RemoteNameLength / sizeof(WCHAR));
2953
2954         *pStringZone++ = L'\0';
2955
2956         // copy comment
2957         pNetResource->lpComment = pStringZone;
2958
2959         CopyMemory( pStringZone,
2960                     (void *)((char *)pConnectCB + pConnectCB->CommentOffset),
2961                     pConnectCB->CommentLength);
2962
2963         pStringZone += (pConnectCB->CommentLength / sizeof(WCHAR));
2964
2965         *pStringZone++ = L'\0';
2966
2967         // copy remaining path
2968         if (pConnectCB->RemainingPathLength > 0)
2969         {
2970             *lplpSystem = pStringZone;
2971
2972             CopyMemory( pStringZone,
2973                         (void *)((char *)pConnectCB + pConnectCB->RemainingPathOffset),
2974                         pConnectCB->RemainingPathLength);
2975
2976             pStringZone += (pConnectCB->RemainingPathLength / sizeof(WCHAR));
2977
2978             *pStringZone++ = L'\0';
2979
2980 #ifdef AFS_DEBUG_TRACE
2981             AFSDbgPrint( L"NPGetResourceInformation For remote name %s returning remaining path %s\n",
2982                          pNetResource->lpRemoteName,
2983                          *lplpSystem);
2984 #endif
2985         }
2986
2987         // copy provider name
2988         pNetResource->lpProvider = pStringZone;
2989
2990         StringCbCopy( pStringZone,
2991                       cbProviderNameLength + sizeof( WCHAR),
2992                       wszProviderName);
2993
2994         pStringZone += (cbProviderNameLength / sizeof( WCHAR) + 1);
2995
2996         *lpBufferSize = ulRequiredLen;
2997
2998         dwStatus = WN_SUCCESS;
2999
3000 try_exit:
3001
3002         if ( hControlDevice != NULL)
3003         {
3004
3005             CloseHandle( hControlDevice);
3006         }
3007
3008         if( pConnectCB != NULL)
3009         {
3010
3011             HeapFree( GetProcessHeap( ), 0, (PVOID) pConnectCB);
3012         }
3013     }
3014
3015     return dwStatus;
3016 }
3017
3018 static VOID
3019 SeparateRemainingPath( WCHAR * lpConnectionName, WCHAR **lppRemainingPath)
3020 {
3021     WCHAR *pwch;
3022     WCHAR wch1, wch2;
3023     DWORD  dwCount;
3024
3025     //
3026     // at this point the lpConnectionName contains the full name.  We need to
3027     // truncate it to \\server\share and move the remaining path back one position.
3028     //
3029
3030     for ( pwch = lpConnectionName, dwCount = 0; *pwch; pwch++)
3031     {
3032         if ( *pwch == L'\\')
3033         {
3034             dwCount++;
3035         }
3036
3037         if ( dwCount == 4)
3038         {
3039             break;
3040         }
3041     }
3042
3043     if (*pwch == L'\\')
3044     {
3045         //
3046         // Found the remaining path that must be moved
3047         //
3048
3049         *lppRemainingPath = pwch + 1;
3050
3051         *pwch++ = 0;
3052
3053         //
3054         // Find the end
3055         //
3056         for ( ; *pwch; pwch++);
3057
3058         //
3059         // and work backwards moving the string
3060         // and then make sure that there is at least
3061         // a path separator.
3062         //
3063
3064         *(pwch + 1) = 0;
3065
3066         for ( ;pwch > *lppRemainingPath; pwch--)
3067         {
3068             *pwch = *(pwch - 1);
3069         }
3070
3071         *pwch = L'\\';
3072     }
3073 }
3074
3075 DWORD APIENTRY
3076 NPGetUniversalName( LPCWSTR lpLocalPath,
3077                     DWORD   dwInfoLevel,
3078                     LPVOID  lpBuffer,
3079                     LPDWORD lpBufferSize )
3080 {
3081     DWORD    dwStatus = WN_NOT_CONNECTED;
3082     WCHAR    wchLocalName[3];
3083     WCHAR    wchSubstName[MAX_PATH + 1];
3084     AFSNetworkProviderConnectionCB   *pConnectCB = NULL;
3085     DWORD    dwError = 0;
3086     DWORD    dwBufferSize = 0;
3087     DWORD    dwPassedSize = *lpBufferSize;
3088     DWORD    dwRemainingLength = *lpBufferSize;
3089     HANDLE   hControlDevice = NULL;
3090     DWORD    dwLocalPathLength = 0;
3091     DWORD    dwRemainingPathLength = 0;
3092     CHAR    *pch;
3093
3094     __Enter
3095     {
3096
3097 #ifdef AFS_DEBUG_TRACE
3098         AFSDbgPrint( L"NPGetUniversalName local path %s level 0x%X\n",
3099                      lpLocalPath ? lpLocalPath : L"(Null)",
3100                      dwInfoLevel);
3101 #endif
3102
3103         if ( NPIsFSDisabled())
3104         {
3105
3106 #ifdef AFS_DEBUG_TRACE
3107             AFSDbgPrint( L"NPGetUniversalName AFSRDFS is disabled, returning WN_NOT_CONNECTED\n");
3108 #endif
3109
3110             try_return( dwStatus = WN_NOT_CONNECTED);
3111         }
3112
3113         dwLocalPathLength = lstrlen( lpLocalPath);
3114
3115         dwRemainingPathLength = dwLocalPathLength - 2;          // no drive letter
3116
3117         if( dwLocalPathLength == 0)
3118         {
3119
3120 #ifdef AFS_DEBUG_TRACE
3121             AFSDbgPrint( L"NPGetUniversalName AFSRDFS is disabled, returning WN_BAD_LOCALNAME\n");
3122 #endif
3123
3124             try_return( dwStatus = WN_BAD_LOCALNAME);
3125         }
3126
3127         if( lpBuffer == NULL ||
3128             lpBufferSize == NULL)
3129         {
3130 #ifdef AFS_DEBUG_TRACE
3131             AFSDbgPrint( L"NPGetUniversalName No output buffer or size\n");
3132 #endif
3133             try_return( dwStatus = WN_BAD_VALUE);
3134         }
3135
3136         memset(lpBuffer, 0, dwPassedSize);
3137
3138         if ( !DriveSubstitution( lpLocalPath, wchSubstName, sizeof( wchSubstName)))
3139         {
3140             wchLocalName[0] = towupper(lpLocalPath[0]);
3141             wchLocalName[1] = L':';
3142             wchLocalName[2] = L'\0';
3143
3144 #ifdef AFS_DEBUG_TRACE
3145             AFSDbgPrint( L"NPGetUniversalName Requesting UNC for %s level 0x%X\n",
3146                          wchLocalName,
3147                          dwInfoLevel);
3148 #endif
3149         }
3150         else
3151         {
3152
3153             ReadServerNameString();
3154
3155             if ( wchSubstName[0] != L'\\' &&
3156                  wchSubstName[1] == L':')
3157             {
3158
3159                 wchLocalName[0] = towupper(wchSubstName[0]);
3160                 wchLocalName[1] = L':';
3161                 wchLocalName[2] = L'\0';
3162
3163 #ifdef AFS_DEBUG_TRACE
3164                 AFSDbgPrint( L"NPGetUniversalName Requesting UNC for drive substitution %s -> %s\n",
3165                              wchSubstName,
3166                              wchLocalName);
3167 #endif
3168             }
3169             else if ( _wcsnicmp( wchSubstName, wszServerNameUNC, cbServerNameUNCLength / sizeof( WCHAR)) == 0 &&
3170                       ( wchSubstName[cbServerNameUNCLength / sizeof( WCHAR)] == L'\\' ||
3171                         wchSubstName[cbServerNameUNCLength / sizeof( WCHAR)] == 0))
3172             {
3173                 HRESULT hr;
3174
3175 #ifdef AFS_DEBUG_TRACE
3176                 AFSDbgPrint( L"NPGetUniversalName drive substitution %s is AFS; Level 0x%x BufferSize 0x%x\n",
3177                              wchSubstName,
3178                              dwInfoLevel,
3179                              dwPassedSize);
3180 #endif
3181
3182                 dwBufferSize = (wcslen( wchSubstName) + 1) * sizeof( WCHAR);
3183
3184                 switch( dwInfoLevel)
3185                 {
3186
3187                 case UNIVERSAL_NAME_INFO_LEVEL:
3188                 {
3189
3190                     UNIVERSAL_NAME_INFO *pUniversalInfo = (UNIVERSAL_NAME_INFO *)lpBuffer;
3191
3192                     *lpBufferSize = sizeof( UNIVERSAL_NAME_INFO) + dwBufferSize;
3193
3194                     if( dwPassedSize <= sizeof( UNIVERSAL_NAME_INFO))
3195                     {
3196
3197 #ifdef AFS_DEBUG_TRACE
3198                         AFSDbgPrint( L"NPGetUniversalName (UNIVERSAL_NAME_INFO) WN_MORE_DATA\n");
3199 #endif
3200
3201                         try_return( dwStatus = WN_MORE_DATA);
3202                     }
3203
3204                     dwRemainingLength -= sizeof( UNIVERSAL_NAME_INFO);
3205
3206                     pUniversalInfo->lpUniversalName = (LPTSTR)((char *)lpBuffer + sizeof( UNIVERSAL_NAME_INFO));
3207
3208                     memcpy( pUniversalInfo->lpUniversalName,
3209                             wchSubstName,
3210                             min( dwBufferSize, dwRemainingLength));
3211
3212                     dwRemainingLength -= min( dwBufferSize, dwRemainingLength);
3213
3214 #ifdef AFS_DEBUG_TRACE
3215                     AFSDbgPrint( L"NPGetUniversalName (UNIVERSAL_NAME_INFO_LEVEL) lpBuffer: %p Name: (%p) \"%s\"\n",
3216                                  lpBuffer,
3217                                  pUniversalInfo->lpUniversalName,
3218                                  pUniversalInfo->lpUniversalName);
3219 #endif
3220
3221                     if ( dwPassedSize < *lpBufferSize)
3222                     {
3223
3224                         try_return( dwStatus = WN_MORE_DATA);
3225                     }
3226
3227                     try_return( dwStatus = WN_SUCCESS);
3228                 }
3229
3230                 case REMOTE_NAME_INFO_LEVEL:
3231                 {
3232
3233                     REMOTE_NAME_INFO *pRemoteInfo = (REMOTE_NAME_INFO *)lpBuffer;
3234
3235                     *lpBufferSize = sizeof( REMOTE_NAME_INFO) + 2 * dwBufferSize + sizeof( WCHAR);
3236
3237                     if( dwPassedSize <= sizeof( REMOTE_NAME_INFO))
3238                     {
3239
3240 #ifdef AFS_DEBUG_TRACE
3241                         AFSDbgPrint( L"NPGetUniversalName (REMOTE_NAME_INFO) WN_MORE_DATA\n");
3242 #endif
3243
3244                         try_return( dwStatus = WN_MORE_DATA);
3245                     }
3246
3247                     dwRemainingLength -= sizeof( REMOTE_NAME_INFO);
3248
3249                     pRemoteInfo->lpUniversalName = (LPTSTR)((char *)lpBuffer + sizeof( REMOTE_NAME_INFO));
3250
3251                     memcpy( pRemoteInfo->lpUniversalName,
3252                             wchSubstName,
3253                             min( dwRemainingLength, dwBufferSize));
3254
3255                     dwRemainingLength -= min( dwRemainingLength, dwBufferSize);
3256
3257 #ifdef AFS_DEBUG_TRACE
3258                     AFSDbgPrint( L"NPGetUniversalName (REMOTE_NAME_INFO_LEVEL) UNI lpBuffer: %p Name: (%p) \"%s\"\n",
3259                                  lpBuffer,
3260                                  pRemoteInfo->lpUniversalName,
3261                                  pRemoteInfo->lpUniversalName);
3262 #endif
3263
3264                     if ( dwRemainingLength > dwBufferSize + sizeof( WCHAR))
3265                     {
3266                         pRemoteInfo->lpConnectionName = (LPTSTR)((char *)pRemoteInfo->lpUniversalName + dwBufferSize);
3267
3268                         memcpy( pRemoteInfo->lpConnectionName,
3269                                 wchSubstName,
3270                                 min( dwRemainingLength, dwBufferSize));
3271
3272                         dwRemainingLength -= min( dwRemainingLength, dwBufferSize) - sizeof( WCHAR);
3273
3274                         SeparateRemainingPath( pRemoteInfo->lpConnectionName,
3275                                                &pRemoteInfo->lpRemainingPath);
3276                     }
3277
3278 #ifdef AFS_DEBUG_TRACE
3279                     AFSDbgPrint( L"NPGetUniversalName (REMOTE_NAME_INFO_LEVEL) CONN lpBuffer: %p Name: (%p) \"%s\"\n",
3280                                  lpBuffer,
3281                                  pRemoteInfo->lpConnectionName,
3282                                  pRemoteInfo->lpConnectionName ? pRemoteInfo->lpConnectionName : L"(null)");
3283
3284                     AFSDbgPrint( L"NPGetUniversalName (REMOTE_NAME_INFO_LEVEL) REMAIN lpBuffer: %p Name: (%p) \"%s\"\n",
3285                                  lpBuffer,
3286                                  pRemoteInfo->lpRemainingPath,
3287                                  pRemoteInfo->lpRemainingPath ? pRemoteInfo->lpRemainingPath : L"(null)");
3288 #endif
3289
3290                     if ( dwPassedSize < *lpBufferSize)
3291                     {
3292
3293                         try_return( dwStatus = WN_MORE_DATA);
3294                     }
3295
3296                     try_return( dwStatus = WN_SUCCESS);
3297                 }
3298
3299                 default:
3300 #ifdef AFS_DEBUG_TRACE
3301                     AFSDbgPrint( L"NPGetUniversalName (UNKNOWN: 0x%X) WN_BAD_VALUE\n",
3302                                  dwInfoLevel);
3303 #endif
3304                     try_return( dwStatus = WN_BAD_VALUE);
3305                 }
3306             }
3307             else
3308             {
3309
3310 #ifdef AFS_DEBUG_TRACE
3311                 AFSDbgPrint( L"NPGetUniversalName drive substitution %s is not AFS\n",
3312                              wchSubstName);
3313 #endif
3314                 try_return( dwStatus = WN_NOT_CONNECTED);
3315             }
3316         }
3317
3318         dwBufferSize = 0x1000;
3319
3320         pConnectCB = (AFSNetworkProviderConnectionCB *)HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, dwBufferSize);
3321
3322         if( pConnectCB == NULL)
3323         {
3324             try_return( dwStatus = WN_OUT_OF_MEMORY);
3325         }
3326
3327         pConnectCB->LocalName = towupper(wchLocalName[0]);
3328
3329         pConnectCB->RemoteNameLength = 0;
3330
3331         pConnectCB->Version = AFS_NETWORKPROVIDER_INTERFACE_VERSION_1;
3332
3333         pConnectCB->AuthenticationId = AFSRetrieveAuthId();
3334
3335 #ifdef AFS_DEBUG_TRACE
3336         AFSDbgPrint( L"NPGetUniversalName Retrieved authentication id %08lX-%08lX\n",
3337                      pConnectCB->AuthenticationId.HighPart,
3338                      pConnectCB->AuthenticationId.LowPart);
3339 #endif
3340
3341         hControlDevice = OpenRedirector();
3342
3343         if( hControlDevice == NULL)
3344         {
3345
3346             try_return( dwStatus = WN_NET_ERROR);
3347         }
3348
3349         dwError = DeviceIoControl( hControlDevice,
3350                                    IOCTL_AFS_GET_CONNECTION,
3351                                    pConnectCB,
3352                                    dwBufferSize,
3353                                    pConnectCB,
3354                                    dwBufferSize,
3355                                    &dwBufferSize,
3356                                    NULL);
3357
3358         if( !dwError)
3359         {
3360 #ifdef AFS_DEBUG_TRACE
3361             DWORD gle = GetLastError();
3362
3363             AFSDbgPrint( L"NPGetUniversalName Failed to get connection from file system for local %s gle 0x%x\n",
3364                          wchLocalName, gle);
3365 #endif
3366             try_return( dwStatus = WN_NOT_CONNECTED);
3367         }
3368
3369         switch( dwInfoLevel)
3370         {
3371
3372             case UNIVERSAL_NAME_INFO_LEVEL:
3373             {
3374
3375                 UNIVERSAL_NAME_INFO *pUniversalInfo = (UNIVERSAL_NAME_INFO *)lpBuffer;
3376
3377                 *lpBufferSize = sizeof( UNIVERSAL_NAME_INFO) + dwBufferSize + sizeof( WCHAR);
3378
3379                 *lpBufferSize += dwRemainingPathLength * sizeof( WCHAR);
3380
3381                 if( dwPassedSize <= sizeof( UNIVERSAL_NAME_INFO))
3382                 {
3383
3384 #ifdef AFS_DEBUG_TRACE
3385                     AFSDbgPrint( L"NPGetUniversalName (UNIVERSAL_NAME_INFO) WN_MORE_DATA\n");
3386 #endif
3387
3388                     try_return( dwStatus = WN_MORE_DATA);
3389                 }
3390
3391                 dwRemainingLength -= sizeof( UNIVERSAL_NAME_INFO);
3392
3393                 pUniversalInfo->lpUniversalName = (LPTSTR)((char *)lpBuffer + sizeof( UNIVERSAL_NAME_INFO));
3394
3395                 pch = (char *)pUniversalInfo->lpUniversalName;
3396
3397                 memcpy( pch,
3398                         pConnectCB,
3399                         min( dwBufferSize, dwRemainingLength));
3400
3401                 pch += min( dwBufferSize, dwRemainingLength);
3402
3403                 dwRemainingLength -= min( dwBufferSize + sizeof(WCHAR), dwRemainingLength);
3404
3405                 memcpy( pch,
3406                         &lpLocalPath[2],
3407                         min(dwRemainingPathLength * sizeof( WCHAR), dwRemainingLength));
3408
3409                 pch += min(dwRemainingPathLength * sizeof( WCHAR), dwRemainingLength);
3410
3411                 dwRemainingLength -= min(dwRemainingPathLength * sizeof( WCHAR), dwRemainingLength);
3412
3413 #ifdef AFS_DEBUG_TRACE
3414                 AFSDbgPrint( L"NPGetUniversalName (UNIVERSAL_NAME_INFO_LEVEL) lpBuffer: %p Name: (%p) \"%s\"\n",
3415                              lpBuffer,
3416                              pUniversalInfo->lpUniversalName,
3417                              pUniversalInfo->lpUniversalName);
3418 #endif
3419
3420                 if ( dwPassedSize < *lpBufferSize)
3421                 {
3422
3423                     try_return( dwStatus = WN_MORE_DATA);
3424                 }
3425
3426                 try_return( dwStatus = WN_SUCCESS);
3427             }
3428
3429             case REMOTE_NAME_INFO_LEVEL:
3430             {
3431
3432                 REMOTE_NAME_INFO *pRemoteInfo = (REMOTE_NAME_INFO *)lpBuffer;
3433
3434                 *lpBufferSize = sizeof( REMOTE_NAME_INFO) + (2 * dwBufferSize + sizeof( WCHAR)) + 2 * sizeof( WCHAR);
3435
3436                 *lpBufferSize += 2 * dwRemainingPathLength * sizeof( WCHAR);
3437
3438                 if( dwPassedSize <= sizeof( REMOTE_NAME_INFO))
3439                 {
3440
3441 #ifdef AFS_DEBUG_TRACE
3442                     AFSDbgPrint( L"NPGetUniversalName (REMOTE_NAME_INFO) WN_MORE_DATA\n");
3443 #endif
3444
3445                     try_return( dwStatus = WN_MORE_DATA);
3446                 }
3447
3448                 dwRemainingLength -= sizeof( REMOTE_NAME_INFO);
3449
3450                 pRemoteInfo->lpUniversalName = (LPTSTR)((char *)lpBuffer + sizeof( REMOTE_NAME_INFO));
3451
3452                 pch = (char *)pRemoteInfo->lpUniversalName;
3453
3454                 memcpy( pch,
3455                         pConnectCB,
3456                         min( dwBufferSize, dwRemainingLength));
3457
3458                 pch += min( dwBufferSize, dwRemainingLength);
3459
3460                 dwRemainingLength -= min( dwBufferSize + sizeof( WCHAR), dwRemainingLength);
3461
3462                 memcpy( pch,
3463                         &lpLocalPath[2],
3464                         min(dwRemainingPathLength * sizeof( WCHAR), dwRemainingLength));
3465
3466                 pch += min((dwRemainingPathLength + 1) * sizeof( WCHAR), dwRemainingLength);
3467
3468                 dwRemainingLength -= min((dwRemainingPathLength + 1) * sizeof( WCHAR), dwRemainingLength);
3469
3470 #ifdef AFS_DEBUG_TRACE
3471                 AFSDbgPrint( L"NPGetUniversalName (REMOTE_NAME_INFO_LEVEL) UNI lpBuffer: %p Name: (%p) \"%s\"\n",
3472                              lpBuffer,
3473                              pRemoteInfo->lpUniversalName,
3474                              pRemoteInfo->lpUniversalName);
3475 #endif
3476
3477                 if ( dwRemainingLength > dwBufferSize + sizeof( WCHAR))
3478                 {
3479                     pRemoteInfo->lpConnectionName = (LPWSTR)pch;
3480
3481                     memcpy( pch,
3482                             pConnectCB,
3483                             min( dwBufferSize, dwRemainingLength));
3484
3485                     pch += min( dwBufferSize + sizeof( WCHAR), dwRemainingLength);
3486
3487                     dwRemainingLength -= min( dwBufferSize + sizeof( WCHAR), dwRemainingLength);
3488                 }
3489
3490
3491                 if ( dwRemainingLength > dwRemainingPathLength + sizeof( WCHAR))
3492                 {
3493                     pRemoteInfo->lpRemainingPath = (LPWSTR)pch;
3494
3495                     memcpy( pch,
3496                             &lpLocalPath[2],
3497                             min((dwRemainingPathLength + 1) * sizeof( WCHAR), dwRemainingLength));
3498
3499                     pch += min((dwRemainingPathLength + 1) * sizeof( WCHAR), dwRemainingLength);
3500
3501                     dwRemainingLength -= min((dwLocalPathLength + 1) * sizeof( WCHAR), dwRemainingLength);
3502                 }
3503
3504 #ifdef AFS_DEBUG_TRACE
3505                 AFSDbgPrint( L"NPGetUniversalName (REMOTE_NAME_INFO_LEVEL) CONN lpBuffer: %p Name: (%p) \"%s\"\n",
3506                              lpBuffer,
3507                              pRemoteInfo->lpConnectionName,
3508                              pRemoteInfo->lpConnectionName ? pRemoteInfo->lpConnectionName : L"(null)");
3509
3510                 AFSDbgPrint( L"NPGetUniversalName (REMOTE_NAME_INFO_LEVEL) REMAIN lpBuffer: %p Name: (%p) \"%s\"\n",
3511                              lpBuffer,
3512                              pRemoteInfo->lpRemainingPath,
3513                              pRemoteInfo->lpRemainingPath ? pRemoteInfo->lpRemainingPath : L"(null)");
3514 #endif
3515
3516                 if ( dwPassedSize < *lpBufferSize)
3517                 {
3518
3519                     try_return( dwStatus = WN_MORE_DATA);
3520                 }
3521
3522                 try_return( dwStatus = WN_SUCCESS);
3523             }
3524
3525             default:
3526 #ifdef AFS_DEBUG_TRACE
3527                 AFSDbgPrint( L"NPGetUniversalName (UNKNOWN: 0x%X) WN_BAD_VALUE\n",
3528                              dwInfoLevel);
3529 #endif
3530                 try_return( dwStatus = WN_BAD_VALUE);
3531         }
3532
3533 try_exit:
3534
3535 #ifdef AFS_DEBUG_TRACE
3536         AFSDbgPrint( L"NPGetUniversalName BufferSize 0x%X\n",
3537                      *lpBufferSize);
3538 #endif
3539         if ( hControlDevice != NULL)
3540         {
3541
3542             CloseHandle( hControlDevice);
3543         }
3544
3545         if( pConnectCB != NULL)
3546         {
3547
3548             HeapFree( GetProcessHeap( ), 0, (PVOID) pConnectCB);
3549         }
3550     }
3551
3552     return dwStatus;
3553 }
3554
3555
3556 static LPCWSTR
3557 GetFormatFlags( DWORD dwFlags)
3558 {
3559     static WCHAR Buffer[128] = L"";
3560
3561     //
3562     // WNFMT_MULTILINE         0x01
3563     // WNFMT_ABBREVIATED       0x02
3564     // WNFMT_INENUM            0x10
3565     // WNFMT_CONNECTION        0x20
3566     //
3567
3568     Buffer[0] = L'\0';
3569
3570     if ( dwFlags & WNFMT_MULTILINE )
3571     {
3572         StringCbCat( Buffer, sizeof(Buffer), L"MULTILINE|");
3573     }
3574
3575     if ( dwFlags & WNFMT_INENUM )
3576     {
3577         StringCbCat( Buffer, sizeof(Buffer), L"ABBREVIATED|");
3578     }
3579
3580     if ( dwFlags & WNFMT_INENUM )
3581     {
3582         StringCbCat( Buffer, sizeof(Buffer), L"INENUM|");
3583     }
3584
3585     if ( dwFlags & WNFMT_CONNECTION )
3586     {
3587         StringCbCat( Buffer, sizeof(Buffer), L"CONNECTION|");
3588     }
3589
3590     if ( dwFlags & ~(WNFMT_MULTILINE|WNFMT_ABBREVIATED|WNFMT_INENUM|WNFMT_CONNECTION) )
3591     {
3592         StringCbCat( Buffer, sizeof(Buffer), L"UNKNOWN|");
3593     }
3594
3595     Buffer[lstrlen(Buffer)-1] = L'\0';
3596
3597     return Buffer;
3598 }
3599
3600 DWORD
3601 NPFormatNetworkName( LPTSTR  lpRemoteName,
3602                      LPTSTR  lpFormattedName,
3603                      LPDWORD lpnLength,
3604                      DWORD dwFlags,
3605                      DWORD dwAveCharPerLine)
3606 {
3607
3608     DWORD dwLen = 0, dwCurrentLen = 0;
3609     LPTSTR pCurrentName = lpRemoteName;
3610
3611 #ifdef AFS_DEBUG_TRACE
3612     AFSDbgPrint( L"NPFormatNetworkName Remote %s Flags %s (0x%x) CharsPerLine %u\n",
3613                  lpRemoteName,
3614                  dwFlags,
3615                  GetFormatFlags( dwFlags),
3616                  dwAveCharPerLine);
3617 #endif
3618
3619
3620     //
3621     // Walk back in the name until we hit a \
3622     //
3623
3624     dwLen = wcslen( lpRemoteName);
3625
3626     pCurrentName += (dwLen - 1);
3627
3628     if ( pCurrentName[ 0] != L'\\')
3629     {
3630
3631         while( dwLen > 0)
3632         {
3633
3634             if( pCurrentName[ 0] == L'\\')
3635             {
3636
3637                 pCurrentName++;
3638
3639                 break;
3640             }
3641
3642             pCurrentName--;
3643
3644             dwLen--;
3645
3646             dwCurrentLen++;
3647         }
3648     }
3649
3650     if( *lpnLength  < dwCurrentLen * sizeof( WCHAR))
3651     {
3652
3653         *lpnLength = dwCurrentLen * sizeof( WCHAR);
3654
3655 #ifdef AFS_DEBUG_TRACE
3656         AFSDbgPrint( L"NPFormatNetworkName remote name %s WN_MORE_DATA\n",
3657                      lpRemoteName);
3658 #endif
3659
3660         return WN_MORE_DATA;
3661     }
3662
3663     StringCbCopy( lpFormattedName,
3664                   *lpnLength,
3665                   pCurrentName);
3666
3667     *lpnLength = dwCurrentLen * sizeof( WCHAR);
3668
3669 #ifdef AFS_DEBUG_TRACE
3670     AFSDbgPrint( L"NPFormatNetworkName remote name %s as %s\n",
3671                  lpRemoteName,
3672                  lpFormattedName);
3673 #endif
3674
3675     return WN_SUCCESS;
3676 }
3677
3678 /************************************************************
3679 /       Unsupported entry points
3680 /************************************************************/
3681
3682 //
3683 // AuthGroup processing is implemented in src/WINNT/afsd/afslogon.c
3684 //
3685 DWORD APIENTRY
3686 NPLogonNotify(
3687     PLUID   lpLogonId,
3688     LPCWSTR lpAuthentInfoType,
3689     LPVOID  lpAuthentInfo,
3690     LPCWSTR lpPreviousAuthentInfoType,
3691     LPVOID  lpPreviousAuthentInfo,
3692     LPWSTR  lpStationName,
3693     LPVOID  StationHandle,
3694     LPWSTR  *lpLogonScript)
3695 {
3696
3697 #ifdef AFS_DEBUG_TRACE
3698     AFSDbgPrint( L"NPLogonNotify, returning WN_NOT_SUPPORTED\n");
3699 #endif
3700
3701     return WN_NOT_SUPPORTED;
3702 }
3703
3704 DWORD APIENTRY
3705 NPPasswordChangeNotify (
3706     LPCWSTR    lpAuthentInfoType,
3707     LPVOID    lpAuthentInfo,
3708     LPCWSTR    lpPreviousAuthentInfoType,
3709     LPVOID    lpPreviousAuthentInfo,
3710     LPWSTR    lpStationName,
3711     LPVOID    StationHandle,
3712     DWORD    dwChangeInfo )
3713 {
3714
3715 #ifdef AFS_DEBUG_TRACE
3716     AFSDbgPrint( L"NPPasswordChangeNotify, returning WN_NOT_SUPPORTED\n");
3717 #endif
3718
3719     SetLastError( WN_NOT_SUPPORTED );
3720
3721     return WN_NOT_SUPPORTED;
3722 }
3723
3724 DWORD APIENTRY
3725 NPGetUser( LPTSTR lpName,
3726            LPTSTR lpUserName,
3727            LPDWORD lpBufferSize)
3728 {
3729
3730     DWORD rc = WN_NOT_SUPPORTED;
3731
3732     AFSDbgPrint( L"NPGetUser Entry Name %s\n", lpName);
3733
3734     return rc;
3735 }
3736
3737
3738 DWORD
3739 APIENTRY
3740 NPGetReconnectFlags( LPWSTR  lpRemoteName,
3741                      unsigned char *Parameter2)
3742 {
3743
3744     DWORD    dwStatus = WN_NOT_SUPPORTED;
3745
3746     AFSDbgPrint( L"NPGetReconnectFlags RemoteName %s\n",
3747                  lpRemoteName);
3748
3749     return dwStatus;
3750 }
3751
3752
3753 DWORD
3754 APIENTRY
3755 I_SystemFocusDialog( VOID)
3756 {
3757
3758     DWORD    dwStatus = WN_NOT_SUPPORTED;
3759
3760     AFSDbgPrint( L"I_SystemFocusDialog\n");
3761
3762     return dwStatus;
3763 }
3764
3765 /************************************************************
3766 /       END Unsupported entry points
3767 /************************************************************/
3768
3769
3770 HANDLE
3771 OpenRedirector()
3772 {
3773
3774     HANDLE hControlDevice = NULL;
3775     WCHAR wchError[ 256];
3776
3777     hControlDevice = CreateFile( AFS_SYMLINK_W,
3778                                  GENERIC_READ | GENERIC_WRITE,
3779                                  FILE_SHARE_READ | FILE_SHARE_WRITE,
3780                                  NULL,
3781                                  OPEN_EXISTING,
3782                                  0,
3783                                  NULL );
3784
3785     if( hControlDevice == INVALID_HANDLE_VALUE)
3786     {
3787
3788         hControlDevice = NULL;
3789 #ifdef AFS_DEBUG_TRACE
3790         AFSDbgPrint( L"Failed to open control device error: %d\n",
3791                      GetLastError());
3792 #endif
3793     }
3794 #if 0
3795     //
3796     // only do this if you want network shares to fail to mount
3797     // when the file system is not yet ready
3798     //
3799     else {
3800
3801         AFSDriverStatusRespCB   respCB;
3802         DWORD                   dwBytes;
3803
3804         memset( &respCB, '\0', sizeof( AFSDriverStatusRespCB));
3805
3806         if ( !DeviceIoControl( hControlDevice,
3807                                IOCTL_AFS_STATUS_REQUEST,
3808                                NULL,
3809                                0,
3810                                (void *)&respCB,
3811                                sizeof( AFSDriverStatusRespCB),
3812                                &dwBytes,
3813                                NULL) ||
3814              dwBytes != sizeof(AFSDriverStatusRespCB) ||
3815              respCB.Status != AFS_DRIVER_STATUS_READY )
3816         {
3817
3818             CloseHandle( hControlDevice);
3819
3820             hControlDevice = NULL;
3821         }
3822     }
3823 #endif
3824
3825     return hControlDevice;
3826 }
3827
3828 LARGE_INTEGER
3829 AFSRetrieveAuthId()
3830 {
3831
3832     LARGE_INTEGER liAuthId = {0,0};
3833     HANDLE hToken = NULL;
3834     TOKEN_STATISTICS stTokenInfo;
3835     DWORD dwCopyBytes = 0;
3836
3837     if ( !OpenThreadToken( GetCurrentThread(),
3838                            TOKEN_QUERY,
3839                            FALSE,       // Impersonation
3840                            &hToken))
3841     {
3842         if( !OpenProcessToken( GetCurrentProcess(),
3843                                TOKEN_QUERY,
3844                                &hToken))
3845         {
3846
3847 #ifdef AFS_DEBUG_TRACE
3848             AFSDbgPrint( L"AFSRetrieveAuthId Failed to retrieve Thread and Process tokens 0x%X\n",
3849                          GetLastError());
3850 #endif
3851         }
3852         else
3853         {
3854
3855 #ifdef AFS_DEBUG_TRACE
3856             AFSDbgPrint( L"AFSRetrieveAuthId Retrieved Process Token\n");
3857 #endif
3858         }
3859     }
3860     else
3861     {
3862
3863 #ifdef AFS_DEBUG_TRACE
3864         AFSDbgPrint( L"AFSRetrieveAuthId Retrieved Thread Token\n");
3865 #endif
3866     }
3867
3868     if ( hToken != NULL)
3869     {
3870
3871         if( !GetTokenInformation( hToken,
3872                                   TokenStatistics,
3873                                   &stTokenInfo,
3874                                   sizeof( TOKEN_STATISTICS),
3875                                   &dwCopyBytes))
3876         {
3877
3878 #ifdef AFS_DEBUG_TRACE
3879             AFSDbgPrint( L"AFSRetrieveAuthId Failed to retrieve token information 0x%X\n",
3880                          GetLastError());
3881 #endif
3882         }
3883         else
3884         {
3885
3886             liAuthId.HighPart = stTokenInfo.AuthenticationId.HighPart;
3887             liAuthId.LowPart = stTokenInfo.AuthenticationId.LowPart;
3888         }
3889
3890         CloseHandle( hToken);
3891     }
3892
3893     return liAuthId;
3894 }
3895
3896 static BOOL
3897 Debug(void)
3898 {
3899     static int init = 0;
3900     static BOOL debug = 0;
3901
3902     if ( !init ) {
3903         HKEY hk;
3904
3905         if (RegOpenKey (HKEY_LOCAL_MACHINE,
3906                          TEXT("SYSTEM\\CurrentControlSet\\Services\\AFSRedirector\\NetworkProvider"), &hk) == 0)
3907         {
3908             DWORD dwSize = sizeof(BOOL);
3909             DWORD dwType = REG_DWORD;
3910             RegQueryValueEx (hk, TEXT("Debug"), NULL, &dwType, (PBYTE)&debug, &dwSize);
3911             RegCloseKey (hk);
3912         }
3913         init = 1;
3914     }
3915
3916     return debug;
3917 }
3918
3919 ULONG
3920 _cdecl
3921 AFSDbgPrint(
3922     PWCHAR Format,
3923     ...
3924     )
3925 {
3926     HRESULT rc = S_OK;
3927     WCHAR wszbuffer[512];
3928     va_list marker;
3929
3930     if ( !Debug() )
3931         return 0;
3932
3933     va_start( marker, Format );
3934     {
3935         StringCbPrintf( wszbuffer, sizeof(wszbuffer), L"[%d-%08X] ",
3936 #ifdef AMD64
3937                            64,
3938 #else
3939                            32,
3940 #endif
3941                            GetCurrentThreadId());
3942
3943         rc = StringCbVPrintfW( &wszbuffer[ 14], sizeof(wszbuffer) - 14, Format, marker);
3944
3945         if (SUCCEEDED(rc))
3946             OutputDebugString( wszbuffer );
3947         else
3948             OutputDebugString(L"AFSDbgPrint Failed to create string\n");
3949     }
3950     return SUCCEEDED(rc) ? 1 : 0;
3951 }