nfs41_np.c File Reference

#include <windows.h>
#include <npapi.h>
#include <devioctl.h>
#include <strsafe.h>
#include "nfs41_driver.h"
#include "nfs41_np.h"
#include "options.h"
#include <pseh/pseh2.h>

Include dependency graph for nfs41_np.c:

Go to the source code of this file.

Macros
#define	DbgP(_x_)
#define	TRACE_TAG   L"[NFS41_NP]"
#define	WNNC_DRIVER(major, minor)   ( major * 0x00010000 + minor )

Functions
ULONG _cdecl	NFS41DbgPrint (__in LPTSTR Format,...)
int	filter (unsigned int code)
DWORD	OpenSharedMemory (PHANDLE phMutex, PHANDLE phMemory, PVOID *pMemory)
VOID	CloseSharedMemory (PHANDLE hMutex, PHANDLE hMemory, PVOID *pMemory)
static DWORD	StoreConnectionInfo (IN LPCWSTR LocalName, IN LPCWSTR ConnectionName, IN USHORT ConnectionNameLength, IN LPNETRESOURCE lpNetResource)
ULONG	SendTo_NFS41Driver (IN ULONG IoctlCode, IN PVOID InputDataBuf, IN ULONG InputDataLen, IN PVOID OutputDataBuf, IN PULONG pOutputDataLen)
DWORD APIENTRY	NPGetCaps (DWORD nIndex)
DWORD APIENTRY	NPLogonNotify (__in PLUID lpLogonId, __in PCWSTR lpAuthentInfoType, __in PVOID lpAuthentInfo, __in PCWSTR lpPreviousAuthentInfoType, __in PVOID lpPreviousAuthentInfo, __in PWSTR lpStationName, __in PVOID StationHandle, __out PWSTR *lpLogonScript)
DWORD APIENTRY	NPPasswordChangeNotify (__in LPCWSTR lpAuthentInfoType, __in LPVOID lpAuthentInfo, __in LPCWSTR lpPreviousAuthentInfoType, __in LPVOID lpPreviousAuthentInfo, __in LPWSTR lpStationName, LPVOID StationHandle, DWORD dwChangeInfo)
DWORD APIENTRY	NPAddConnection (__in LPNETRESOURCE lpNetResource, __in_opt LPWSTR lpPassword, __in_opt LPWSTR lpUserName)
DWORD APIENTRY	NPAddConnection3 (__in HWND hwndOwner, __in LPNETRESOURCE lpNetResource, __in_opt LPWSTR lpPassword, __in_opt LPWSTR lpUserName, __in DWORD dwFlags)
DWORD APIENTRY	NPCancelConnection (__in LPWSTR lpName, __in BOOL fForce)
DWORD APIENTRY	NPGetConnection (__in LPWSTR lpLocalName, __out_bcount(*lpBufferSize) LPWSTR lpRemoteName, __inout LPDWORD lpBufferSize)
DWORD APIENTRY	NPOpenEnum (DWORD dwScope, DWORD dwType, DWORD dwUsage, LPNETRESOURCE lpNetResource, LPHANDLE lphEnum)
DWORD APIENTRY	NPEnumResource (HANDLE hEnum, LPDWORD lpcCount, LPVOID lpBuffer, LPDWORD lpBufferSize)
DWORD APIENTRY	NPCloseEnum (HANDLE hEnum)
DWORD APIENTRY	NPGetResourceParent (LPNETRESOURCE lpNetResource, LPVOID lpBuffer, LPDWORD lpBufferSize)
DWORD APIENTRY	NPGetResourceInformation (__in LPNETRESOURCE lpNetResource, __out_bcount(*lpBufferSize) LPVOID lpBuffer, __inout LPDWORD lpBufferSize, __deref_out LPWSTR *lplpSystem)
DWORD APIENTRY	NPGetUniversalName (LPCWSTR lpLocalPath, DWORD dwInfoLevel, LPVOID lpBuffer, LPDWORD lpBufferSize)

Macro Definition Documentation

DbgP

#define DbgP

(

_x_

)

Definition at line 36 of file nfs41_np.c.

TRACE_TAG

#define TRACE_TAG   L"[NFS41_NP]"

Definition at line 38 of file nfs41_np.c.

WNNC_DRIVER

#define WNNC_DRIVER	(		major,
			minor
	)		( major * 0x00010000 + minor )

Definition at line 39 of file nfs41_np.c.

Function Documentation

CloseSharedMemory()

VOID CloseSharedMemory	(	PHANDLE	hMutex,
		PHANDLE	hMemory,
		PVOID *	pMemory
	)

Definition at line 143 of file nfs41_np.c.

{
    if (*pMemory)
    {
        UnmapViewOfFile(*pMemory);
        *pMemory = NULL;
    }
    if (*hMemory)
    {
        CloseHandle(*hMemory);
        *hMemory = 0;
    }
    if (*hMutex)
    {
        if (ReleaseMutex(*hMutex) == FALSE)
        {
            DbgP((TEXT("CloseSharedMemory: ReleaseMutex error: %d\n"), GetLastError()));
        }
        CloseHandle(*hMutex);
        *hMutex = 0;
    }
}

Referenced by NPCancelConnection(), NPEnumResource(), NPGetConnection(), and StoreConnectionInfo().

filter()

int filter

(

unsigned int

code

)

Definition at line 61 of file nfs41_np.c.

{
    DbgP((L"####Got exception %u\n", code));
    return EXCEPTION_CONTINUE_SEARCH;
}

NFS41DbgPrint()

ULONG _cdecl NFS41DbgPrint	(	__in LPTSTR	Format,
			...
	)

Definition at line 42 of file nfs41_np.c.

{
    ULONG rc = 0;
    TCHAR szbuffer[256];
 
    va_list marker;
    va_start( marker, Format );
    {
 
        //StringCchVPrintfW( szbuffer, 127, Format, marker );
        StringCchVPrintfW( szbuffer, 256, Format, marker );
        szbuffer[255] = (TCHAR)0;
        OutputDebugString( TRACE_TAG );
        OutputDebugString( szbuffer );
    }
 
    return rc;
}

NPAddConnection()

DWORD APIENTRY NPAddConnection	(	__in LPNETRESOURCE	lpNetResource,
		__in_opt LPWSTR	lpPassword,
		__in_opt LPWSTR	lpUserName
	)

Definition at line 419 of file nfs41_np.c.

{
    return NPAddConnection3( NULL, lpNetResource, lpPassword, lpUserName, 0 );
}

Referenced by _tryLoadProvider().

NPAddConnection3()

DWORD APIENTRY NPAddConnection3	(	__in HWND	hwndOwner,
		__in LPNETRESOURCE	lpNetResource,
		__in_opt LPWSTR	lpPassword,
		__in_opt LPWSTR	lpUserName,
		__in DWORD	dwFlags
	)

Definition at line 428 of file nfs41_np.c.

{
    DWORD   Status;
    WCHAR   wszScratch[128];
    WCHAR   LocalName[3];
    DWORD   CopyBytes = 0;
    CONNECTION_INFO Connection;
    LPWSTR  ConnectionName;
    WCHAR ServerName[MAX_PATH];
    PWCHAR p;
    DWORD i;
 
    DbgP(( L"[aglo] NPAddConnection3('%s', '%s')\n",
        lpNetResource->lpLocalName, lpNetResource->lpRemoteName ));
    DbgP(( L"[aglo] username = '%s', passwd = '%s'\n", lpUserName, lpPassword));
 
    Status = InitializeConnectionInfo(&Connection,
        (PMOUNT_OPTION_BUFFER)lpNetResource->lpComment,
        &ConnectionName);
    if (Status)  {
        DbgP(( L"InitializeConnectionInfo failed with %d\n", Status ));
        goto out;
    }
 
    //  \device\miniredirector\;<DriveLetter>:\Server\Share
 
    // local name, must start with "X:"
    if (lstrlen(lpNetResource->lpLocalName) < 2 ||
        lpNetResource->lpLocalName[1] != L':') {
        Status = WN_BAD_LOCALNAME;
        goto out;
    }
 
    LocalName[0] = (WCHAR) toupper(lpNetResource->lpLocalName[0]);
    LocalName[1] = L':';
    LocalName[2] = L'\0';
    StringCchCopyW( ConnectionName, MAX_PATH, NFS41_DEVICE_NAME );
    StringCchCatW( ConnectionName, MAX_PATH, L"\\;" );
    StringCchCatW( ConnectionName, MAX_PATH, LocalName );
 
    // remote name, must start with "\\"
    if (lpNetResource->lpRemoteName[0] == L'\0' ||
        lpNetResource->lpRemoteName[0] != L'\\' ||
        lpNetResource->lpRemoteName[1] != L'\\') {
        Status = WN_BAD_NETNAME;
        goto out;
    }
 
    /* note: remotename comes as \\server but we need to add \server thus +1 pointer */
    p = lpNetResource->lpRemoteName + 1;
    ServerName[0] = L'\\';
    i = 1;
    for(;;) {
        /* convert servername ending unix slash to windows slash */
        if (p[i] == L'/')
            p[i] = L'\\';
        /* deal with servername ending with any slash */
        if (p[i] == L'\0')
            p[i] = L'\\';
        ServerName[i] = p[i];
        if (p[i] == L'\\') break;
        i++;
    }
    ServerName[i] = L'\0';
    StringCchCatW( ConnectionName, MAX_PATH, ServerName);
    /* insert the "nfs4" in between the server name and the path,
     * just to make sure all calls to our driver come thru this */
    StringCchCatW( ConnectionName, MAX_PATH, L"\\nfs4" );
 
#ifdef CONVERT_2_UNIX_SLASHES
    /* convert all windows slashes to unix slashes */
    {
        PWCHAR q = p;
        DWORD j = 0;
        for(;;) {
            if(q[j] == L'\0') break;
            if (q[j] == L'\\') q[j] = L'/';
            j++;
        }
    }
#else
    /* convert all unix slashes to windows slashes */
    {
        PWCHAR q = p;
        DWORD j = 0;
        for(;;) {
            if(q[j] == L'\0') break;
            if (q[j] == L'/') q[j] = L'\\';
            j++;
        }
    }
#endif
    StringCchCatW( ConnectionName, MAX_PATH, &p[i]);
    DbgP(( L"[aglo] Full Connect Name: %s\n", ConnectionName ));
    DbgP(( L"[aglo] Full Connect Name Length: %d %d\n",
        (wcslen(ConnectionName) + 1) * sizeof(WCHAR),
        (lstrlen(ConnectionName) + 1) * sizeof(WCHAR)));
 
    if ( QueryDosDevice( LocalName, wszScratch, 128 )
        || GetLastError() != ERROR_FILE_NOT_FOUND) {
        Status = WN_ALREADY_CONNECTED;
        goto out;
    }
 
    MarshalConnectionInfo(&Connection);
 
    Status = SendTo_NFS41Driver( IOCTL_NFS41_ADDCONN,
        Connection.Buffer, Connection.BufferSize,
        NULL, &CopyBytes );
    if (Status) {
        DbgP(( L"[aglo] SendTo_NFS41Driver failed with %d\n", Status));
        goto out;
    }
 
    DbgP(( L"[aglo] calling DefineDosDevice\n"));
    if ( !DefineDosDevice( DDD_RAW_TARGET_PATH |
                           DDD_NO_BROADCAST_SYSTEM,
                           lpNetResource->lpLocalName,
                           ConnectionName ) ) {
        Status = GetLastError();
        DbgP(( L"[aglo] DefineDosDevice failed with %d\n", Status));
        goto out_delconn;
    }
 
    // The connection was established and the local device mapping
    // added. Include this in the list of mapped devices.
    Status = StoreConnectionInfo(LocalName, ConnectionName,
        Connection.Buffer->NameLength, lpNetResource);
    if (Status) {
        DbgP(( L"[aglo] StoreConnectionInfo failed with %d\n", Status));
        goto out_undefine;
    }
 
out:
    FreeConnectionInfo(&Connection);
    DbgP(( L"[aglo] NPAddConnection3: status %08X\n", Status));
    return Status;
out_undefine:
    DefineDosDevice(DDD_REMOVE_DEFINITION | DDD_RAW_TARGET_PATH |
        DDD_EXACT_MATCH_ON_REMOVE, LocalName, ConnectionName);
out_delconn:
    SendTo_NFS41Driver(IOCTL_NFS41_DELCONN, ConnectionName,
        Connection.Buffer->NameLength, NULL, &CopyBytes);
    goto out;
}

Referenced by _tryLoadProvider(), and NPAddConnection().

NPCancelConnection()

DWORD APIENTRY NPCancelConnection	(	__in LPWSTR	lpName,
		__in BOOL	fForce
	)

Definition at line 580 of file nfs41_np.c.

{
    DWORD   Status = 0;
 
    HANDLE  hMutex, hMemory;
    PNFS41NP_SHARED_MEMORY  pSharedMemory;
 
    DbgP((TEXT("NPCancelConnection\n")));
    DbgP((TEXT("NPCancelConnection: ConnectionName: %S\n"), lpName));
 
    Status = OpenSharedMemory( &hMutex,
                               &hMemory,
                               (PVOID)&pSharedMemory);
 
    if (Status == WN_SUCCESS)
    {
        INT  Index;
        PNFS41NP_NETRESOURCE pNetResource;
        Status = WN_NOT_CONNECTED;
 
        DbgP((TEXT("NPCancelConnection: NextIndex %d, NumResources %d\n"),
                    pSharedMemory->NextAvailableIndex,
                    pSharedMemory->NumberOfResourcesInUse));
 
        for (Index = 0; Index < pSharedMemory->NextAvailableIndex; Index++)
        {
            pNetResource = &pSharedMemory->NetResources[Index];
 
            if (pNetResource->InUse)
            {
                if ( ( (wcslen(lpName) + 1) * sizeof(WCHAR) ==
                        pNetResource->LocalNameLength)
                        && ( !wcscmp(lpName, pNetResource->LocalName) ))
                {
                    ULONG CopyBytes;
 
                    DbgP((TEXT("NPCancelConnection: Connection Found:\n")));
 
                    CopyBytes = 0;
 
                    Status = SendTo_NFS41Driver( IOCTL_NFS41_DELCONN,
                                pNetResource->ConnectionName,
                                pNetResource->ConnectionNameLength,
                                NULL,
                                &CopyBytes );
 
                    if (Status != WN_SUCCESS)
                    {
                        DbgP((TEXT("NPCancelConnection: SendToMiniRdr returned Status %lx\n"),Status));
                        break;
                    }
 
                    if (DefineDosDevice(DDD_REMOVE_DEFINITION | DDD_RAW_TARGET_PATH | DDD_EXACT_MATCH_ON_REMOVE,
                            lpName,
                            pNetResource->ConnectionName) == FALSE)
                    {
                        DbgP((TEXT("RemoveDosDevice:  DefineDosDevice error: %d\n"), GetLastError()));
                        Status = GetLastError();
                    }
                    else
                    {
                        pNetResource->InUse = FALSE;
                        pSharedMemory->NumberOfResourcesInUse--;
 
                        if (Index+1 == pSharedMemory->NextAvailableIndex)
                            pSharedMemory->NextAvailableIndex--;
                    }
                    break;
                }
 
                DbgP((TEXT("NPCancelConnection: Name %S EntryName %S\n"),
                            lpName,pNetResource->LocalName));
#ifndef __REACTOS__
                DbgP((TEXT("NPCancelConnection: Name Length %d Entry Name Length %d\n"),
                           pNetResource->LocalNameLength,pNetResource->LocalName));
#else
                DbgP((TEXT("NPCancelConnection: Name Length %d Entry Name Length %d\n"),
                           (wcslen(lpName) + 1) * sizeof(WCHAR), pNetResource->LocalNameLength));
#endif
 
            }
        }
 
        CloseSharedMemory( &hMutex,
                           &hMemory,
                          (PVOID)&pSharedMemory);
    }
 
    return Status;
}

Referenced by _tryLoadProvider().

NPCloseEnum()

DWORD APIENTRY NPCloseEnum

(

HANDLE

hEnum

)

Definition at line 881 of file nfs41_np.c.

{
    DbgP((L"[aglo] NPCloseEnum\n"));
    HeapFree( GetProcessHeap( ), 0, (PVOID) hEnum );
    return WN_SUCCESS;
}

Referenced by _tryLoadProvider().

NPEnumResource()

DWORD APIENTRY NPEnumResource	(	HANDLE	hEnum,
		LPDWORD	lpcCount,
		LPVOID	lpBuffer,
		LPDWORD	lpBufferSize
	)

Definition at line 773 of file nfs41_np.c.

{
    DWORD           Status = WN_SUCCESS;
    ULONG           EntriesCopied;
    LPNETRESOURCE   pNetResource;
    ULONG           SpaceNeeded = 0;
    ULONG           SpaceAvailable;
    PWCHAR          StringZone;
    HANDLE  hMutex, hMemory;
    PNFS41NP_SHARED_MEMORY  pSharedMemory;
    PNFS41NP_NETRESOURCE pNfsNetResource;
    INT  Index = *(PULONG)hEnum;
 
 
    DbgP((L"[aglo] NPEnumResource\n"));
 
    DbgP((L"[aglo] NPEnumResource Count Requested %d\n", *lpcCount));
 
    pNetResource = (LPNETRESOURCE) lpBuffer;
    SpaceAvailable = *lpBufferSize;
    EntriesCopied = 0;
    StringZone = (PWCHAR) ((PBYTE)lpBuffer + *lpBufferSize);
 
    Status = OpenSharedMemory( &hMutex,
                               &hMemory,
                               (PVOID)&pSharedMemory);
 
    if ( Status == WN_SUCCESS)
    {
        Status = WN_NO_MORE_ENTRIES;
        for (Index = *(PULONG)hEnum; EntriesCopied < *lpcCount &&
                Index < pSharedMemory->NextAvailableIndex; Index++)
        {
            pNfsNetResource = &pSharedMemory->NetResources[Index];
 
            if (pNfsNetResource->InUse)
            {
                SpaceNeeded  = sizeof( NETRESOURCE );
                SpaceNeeded += pNfsNetResource->LocalNameLength;
                SpaceNeeded += pNfsNetResource->RemoteNameLength;
                SpaceNeeded += 5 * sizeof(WCHAR);               // comment
                SpaceNeeded += sizeof(NFS41_PROVIDER_NAME_U);  // provider name
                if ( SpaceNeeded > SpaceAvailable )
                {
                    Status = WN_MORE_DATA;
                    DbgP((L"[aglo] NPEnumResource More Data Needed - %d\n", SpaceNeeded));
                    *lpBufferSize = SpaceNeeded;
                    break;
                }
                else
                {
                    SpaceAvailable -= SpaceNeeded;
 
                    pNetResource->dwScope       = pNfsNetResource->dwScope;
                    pNetResource->dwType        = pNfsNetResource->dwType;
                    pNetResource->dwDisplayType = pNfsNetResource->dwDisplayType;
                    pNetResource->dwUsage       = pNfsNetResource->dwUsage;
 
                    // setup string area at opposite end of buffer
                    SpaceNeeded -= sizeof( NETRESOURCE );
                    StringZone = (PWCHAR)( (PBYTE) StringZone - SpaceNeeded );
                    // copy local name
                    StringCchCopy( StringZone,
                        pNfsNetResource->LocalNameLength,
                        pNfsNetResource->LocalName );
                    pNetResource->lpLocalName = StringZone;
                    StringZone += pNfsNetResource->LocalNameLength/sizeof(WCHAR);
                    // copy remote name
                    StringCchCopy( StringZone,
                        pNfsNetResource->RemoteNameLength,
                        pNfsNetResource->RemoteName );
                    pNetResource->lpRemoteName = StringZone;
                    StringZone += pNfsNetResource->RemoteNameLength/sizeof(WCHAR);
                    // copy comment
                    pNetResource->lpComment = StringZone;
                    *StringZone++ = L'A';
                    *StringZone++ = L'_';
                    *StringZone++ = L'O';
                    *StringZone++ = L'K';
                    *StringZone++ = L'\0';
                    // copy provider name
                    pNetResource->lpProvider = StringZone;
                    StringCbCopyW( StringZone, sizeof(NFS41_PROVIDER_NAME_U), NFS41_PROVIDER_NAME_U );
                    StringZone += sizeof(NFS41_PROVIDER_NAME_U)/sizeof(WCHAR);
                    EntriesCopied++;
                    // set new bottom of string zone
                    StringZone = (PWCHAR)( (PBYTE) StringZone - SpaceNeeded );
                    Status = WN_SUCCESS;
                }
                pNetResource++;
            }
        }
        CloseSharedMemory( &hMutex, &hMemory, (PVOID*)&pSharedMemory);
    }
 
    *lpcCount = EntriesCopied;
    *(PULONG) hEnum = Index;
 
    DbgP((L"[aglo] NPEnumResource entries returned: %d\n", EntriesCopied));
 
    return Status;
}

Referenced by _tryLoadProvider().

NPGetCaps()

DWORD APIENTRY NPGetCaps

(

DWORD

nIndex

)

Definition at line 329 of file nfs41_np.c.

{
   DWORD rc = 0;
 
#ifndef __REACTOS__
    DbgP(( L"[aglo] GetNetCaps %d\n", nIndex ));
#endif
    switch ( nIndex )
    {
        case WNNC_SPEC_VERSION:
            rc = WNNC_SPEC_VERSION51;
            break;
 
        case WNNC_NET_TYPE:
            rc = WNNC_NET_RDR2SAMPLE;
            break;
 
        case WNNC_DRIVER_VERSION:
            rc = WNNC_DRIVER(1, 0);
            break;
 
        case WNNC_CONNECTION:
            rc = WNNC_CON_GETCONNECTIONS |
                 WNNC_CON_CANCELCONNECTION |
                 WNNC_CON_ADDCONNECTION |
                 WNNC_CON_ADDCONNECTION3;
            break;
 
        case WNNC_ENUMERATION:
            rc = WNNC_ENUM_LOCAL;
            break;
 
        case WNNC_START:
            rc = 1;
            break;
 
        case WNNC_USER:
        case WNNC_DIALOG:
        case WNNC_ADMIN:
        default:
            rc = 0;
            break;
    }
 
    return rc;
}

Referenced by _tryLoadProvider().

NPGetConnection()

DWORD APIENTRY NPGetConnection	(	__in LPWSTR	lpLocalName,
		__out_bcount *lpBufferSize LPWSTR	lpRemoteName,
		__inout LPDWORD	lpBufferSize
	)

Definition at line 674 of file nfs41_np.c.

{
    DWORD   Status = 0;
 
    HANDLE  hMutex, hMemory;
    PNFS41NP_SHARED_MEMORY  pSharedMemory;
 
    Status = OpenSharedMemory( &hMutex,
                               &hMemory,
                               (PVOID)&pSharedMemory);
 
    if (Status == WN_SUCCESS)
    {
        INT  Index;
        PNFS41NP_NETRESOURCE pNetResource;
        Status = WN_NOT_CONNECTED;
 
        for (Index = 0; Index < pSharedMemory->NextAvailableIndex; Index++)
        {
            pNetResource = &pSharedMemory->NetResources[Index];
 
            if (pNetResource->InUse)
            {
                if ( ( (wcslen(lpLocalName) + 1) * sizeof(WCHAR) ==
                        pNetResource->LocalNameLength)
                        && ( !wcscmp(lpLocalName, pNetResource->LocalName) ))
                {
                    if (*lpBufferSize < pNetResource->RemoteNameLength)
                    {
                        *lpBufferSize = pNetResource->RemoteNameLength;
                        Status = WN_MORE_DATA;
                    }
                    else
                    {
                        *lpBufferSize = pNetResource->RemoteNameLength;
                        CopyMemory( lpRemoteName,
                                    pNetResource->RemoteName,
                                    pNetResource->RemoteNameLength);
                        Status = WN_SUCCESS;
                    }
                    break;
                }
            }
        }
 
        CloseSharedMemory( &hMutex, &hMemory, (PVOID)&pSharedMemory);
    }
 
    return Status;
}

Referenced by _tryLoadProvider().

NPGetResourceInformation()

DWORD APIENTRY NPGetResourceInformation	(	__in LPNETRESOURCE	lpNetResource,
		__out_bcount *lpBufferSize LPVOID	lpBuffer,
		__inout LPDWORD	lpBufferSize,
		__deref_out LPWSTR *	lplpSystem
	)

Definition at line 900 of file nfs41_np.c.

{
    DbgP(( L"[aglo] NPGetResourceInformation: WN_NOT_SUPPORTED\n" ));
    return WN_NOT_SUPPORTED;
}

Referenced by _tryLoadProvider().

NPGetResourceParent()

DWORD APIENTRY NPGetResourceParent	(	LPNETRESOURCE	lpNetResource,
		LPVOID	lpBuffer,
		LPDWORD	lpBufferSize
	)

Definition at line 890 of file nfs41_np.c.

{
    DbgP(( L"[aglo] NPGetResourceParent: WN_NOT_SUPPORTED\n" ));
    return WN_NOT_SUPPORTED;
}

NPGetUniversalName()

DWORD APIENTRY NPGetUniversalName	(	LPCWSTR	lpLocalPath,
		DWORD	dwInfoLevel,
		LPVOID	lpBuffer,
		LPDWORD	lpBufferSize
	)

Definition at line 911 of file nfs41_np.c.

{
    DbgP(( L"[aglo] NPGetUniversalName: WN_NOT_SUPPORTED\n" ));
    return WN_NOT_SUPPORTED;
}

NPLogonNotify()

DWORD APIENTRY NPLogonNotify	(	__in PLUID	lpLogonId,
		__in PCWSTR	lpAuthentInfoType,
		__in PVOID	lpAuthentInfo,
		__in PCWSTR	lpPreviousAuthentInfoType,
		__in PVOID	lpPreviousAuthentInfo,
		__in PWSTR	lpStationName,
		__in PVOID	StationHandle,
		__out PWSTR *	lpLogonScript
	)

Definition at line 378 of file nfs41_np.c.

{
    *lpLogonScript = NULL;
    DbgP(( L"[aglo] NPLogonNotify: returning WN_SUCCESS\n" ));
    return WN_SUCCESS;
}

NPOpenEnum()

DWORD APIENTRY NPOpenEnum	(	DWORD	dwScope,
		DWORD	dwType,
		DWORD	dwUsage,
		LPNETRESOURCE	lpNetResource,
		LPHANDLE	lphEnum
	)

Definition at line 729 of file nfs41_np.c.

{
    DWORD   Status;
 
    DbgP((L"[aglo] NPOpenEnum\n"));
 
    *lphEnum = NULL;
 
    switch ( dwScope )
    {
        case RESOURCE_CONNECTED:
        {
            *lphEnum = HeapAlloc( GetProcessHeap( ), HEAP_ZERO_MEMORY, sizeof( ULONG ) );
 
            if (*lphEnum )
            {
                Status = WN_SUCCESS;
            }
            else
            {
                Status = WN_OUT_OF_MEMORY;
            }
            break;
        }
        break;
 
        case RESOURCE_CONTEXT:
        default:
            Status  = WN_NOT_SUPPORTED;
            break;
    }
 
 
    DbgP((L"[aglo] NPOpenEnum returning Status %lx\n",Status));
 
    return(Status);
}

Referenced by _tryLoadProvider().

NPPasswordChangeNotify()

DWORD APIENTRY NPPasswordChangeNotify	(	__in LPCWSTR	lpAuthentInfoType,
		__in LPVOID	lpAuthentInfo,
		__in LPCWSTR	lpPreviousAuthentInfoType,
		__in LPVOID	lpPreviousAuthentInfo,
		__in LPWSTR	lpStationName,
		LPVOID	StationHandle,
		DWORD	dwChangeInfo
	)

Definition at line 394 of file nfs41_np.c.

{
    DbgP(( L"[aglo] NPPasswordChangeNotify: WN_NOT_SUPPORTED\n" ));
    SetLastError( WN_NOT_SUPPORTED );
    return WN_NOT_SUPPORTED;
}

OpenSharedMemory()

DWORD OpenSharedMemory	(	PHANDLE	phMutex,
		PHANDLE	phMemory,
		PVOID *	pMemory
	)

Definition at line 68 of file nfs41_np.c.

{
    DWORD dwStatus;
 
    *phMutex = 0;
    *phMemory = 0;
    *pMemory = NULL;
 
    *phMutex = CreateMutex(NULL, FALSE, TEXT(NFS41NP_MUTEX_NAME));
    if (*phMutex == NULL)
    {
        dwStatus = GetLastError();
        DbgP((TEXT("OpenSharedMemory:  OpenMutex failed\n")));
        goto OpenSharedMemoryAbort1;
    }
 
    WaitForSingleObject(*phMutex, INFINITE);
 
    *phMemory = OpenFileMapping(FILE_MAP_WRITE,
                                FALSE,
                                TEXT(NFS41_USER_SHARED_MEMORY_NAME));
    if (*phMemory == NULL)
    {
        dwStatus = GetLastError();
        DbgP((TEXT("OpenSharedMemory:  OpenFileMapping failed\n")));
        goto OpenSharedMemoryAbort2;
    }
 
    *pMemory = MapViewOfFile(*phMemory, FILE_MAP_WRITE, 0, 0, 0);
    if (*pMemory == NULL)
    {
        dwStatus = GetLastError();
        DbgP((TEXT("OpenSharedMemory:  MapViewOfFile failed\n")));
        goto OpenSharedMemoryAbort3;
    }
 
    return ERROR_SUCCESS;
 
OpenSharedMemoryAbort3:
    CloseHandle(*phMemory);
 
OpenSharedMemoryAbort2:
    ReleaseMutex(*phMutex);
    CloseHandle(*phMutex);
    *phMutex = NULL;
 
OpenSharedMemoryAbort1:
    DbgP((TEXT("OpenSharedMemory: return dwStatus: %d\n"), dwStatus));
 
    return dwStatus;
}

Referenced by NPCancelConnection(), NPEnumResource(), NPGetConnection(), and StoreConnectionInfo().

SendTo_NFS41Driver()

ULONG SendTo_NFS41Driver	(	IN ULONG	IoctlCode,
		IN PVOID	InputDataBuf,
		IN ULONG	InputDataLen,
		IN PVOID	OutputDataBuf,
		IN PULONG	pOutputDataLen
	)

Definition at line 268 of file nfs41_np.c.

{
    HANDLE  DeviceHandle;       // The mini rdr device handle
    BOOL    rc = FALSE;
    ULONG   Status;
 
    Status = WN_SUCCESS;
    DbgP((L"[aglo] calling CreateFile\n"));
    DeviceHandle = CreateFile(
        NFS41_USER_DEVICE_NAME,
        GENERIC_READ | GENERIC_WRITE,
        FILE_SHARE_READ | FILE_SHARE_WRITE,
        (LPSECURITY_ATTRIBUTES)NULL,
        OPEN_EXISTING,
        0,
        (HANDLE) NULL );
 
    DbgP((L"[aglo] after CreateFile Device Handle\n"));
    if ( INVALID_HANDLE_VALUE != DeviceHandle )
    {
        _SEH2_TRY {
        DbgP((L"[aglo] calling DeviceIoControl\n"));
        rc = DeviceIoControl(
            DeviceHandle,
            IoctlCode,
            InputDataBuf,
            InputDataLen,
            OutputDataBuf,
            *pOutputDataLen,
            pOutputDataLen,
            NULL );
        } _SEH2_EXCEPT(_SEH2_GetExceptionCode()) {
            DbgP((L"#### In except\n"));
        } _SEH2_END;
        DbgP((L"[aglo] returned from DeviceIoControl %08lx\n", rc));
            if ( !rc )
            {
                DbgP((L"[aglo] SendTo_NFS41Driver: returning error from DeviceIoctl\n"));
                Status = GetLastError( );
            }
            else
            {
                DbgP((L"[aglo] SendTo_NFS41Driver: The DeviceIoctl call succeded\n"));
            }
            CloseHandle(DeviceHandle);
    }
    else
    {
        Status = GetLastError( );
        DbgP((L"[aglo] SendTo_NFS41Driver: error %08lx opening device \n", Status));
    }
    DbgP((L"[aglo] returned from SendTo_NFS41Driver %08lx\n", Status));
    return Status;
}

Referenced by NPAddConnection3(), and NPCancelConnection().

StoreConnectionInfo()

static DWORD StoreConnectionInfo ( IN LPCWSTR  LocalName, IN LPCWSTR  ConnectionName, IN USHORT  ConnectionNameLength, IN LPNETRESOURCE  lpNetResource  )

static

Definition at line 187 of file nfs41_np.c.

{
    DWORD status;
    HANDLE hMutex, hMemory;
    PNFS41NP_SHARED_MEMORY pSharedMemory;
    PNFS41NP_NETRESOURCE pNfs41NetResource;
    INT Index;
    BOOLEAN FreeEntryFound = FALSE;
 
#ifdef __REACTOS__
    status = OpenSharedMemory(&hMutex, &hMemory, (PVOID *)&pSharedMemory);
#else
    status = OpenSharedMemory(&hMutex, &hMemory, &(PVOID)pSharedMemory);
#endif
    if (status)
        goto out;
 
    DbgP((TEXT("StoreConnectionInfo: NextIndex %d, NumResources %d\n"),
        pSharedMemory->NextAvailableIndex,
        pSharedMemory->NumberOfResourcesInUse));
 
    for (Index = 0; Index < pSharedMemory->NextAvailableIndex; Index++)
    {
        if (!pSharedMemory->NetResources[Index].InUse)
        {
            FreeEntryFound = TRUE;
            DbgP((TEXT("Reusing existing index %d\n"), Index));
            break;
        }
    }
 
    if (!FreeEntryFound)
    {
        if (pSharedMemory->NextAvailableIndex >= NFS41NP_MAX_DEVICES) {
            status = WN_NO_MORE_DEVICES;
            goto out_close;
        }
        Index = pSharedMemory->NextAvailableIndex++;
        DbgP((TEXT("Using new index %d\n"), Index));
    }
 
    pSharedMemory->NumberOfResourcesInUse += 1;
 
    pNfs41NetResource = &pSharedMemory->NetResources[Index];
 
    pNfs41NetResource->InUse                = TRUE;
    pNfs41NetResource->dwScope              = lpNetResource->dwScope;
    pNfs41NetResource->dwType               = lpNetResource->dwType;
    pNfs41NetResource->dwDisplayType        = lpNetResource->dwDisplayType;
    pNfs41NetResource->dwUsage              = RESOURCEUSAGE_CONNECTABLE;
    pNfs41NetResource->LocalNameLength      = (USHORT)(wcslen(LocalName) + 1) * sizeof(WCHAR);
    pNfs41NetResource->RemoteNameLength     = (USHORT)(wcslen(lpNetResource->lpRemoteName) + 1) * sizeof(WCHAR);
    pNfs41NetResource->ConnectionNameLength = ConnectionNameLength;
 
    StringCchCopy(pNfs41NetResource->LocalName,
        pNfs41NetResource->LocalNameLength,
        LocalName);
    StringCchCopy(pNfs41NetResource->RemoteName,
        pNfs41NetResource->RemoteNameLength,
        lpNetResource->lpRemoteName);
    StringCchCopy(pNfs41NetResource->ConnectionName,
        pNfs41NetResource->ConnectionNameLength,
        ConnectionName);
 
    // TODO: copy mount options -cbodley
 
out_close:
#ifdef __REACTOS__
    CloseSharedMemory(&hMutex, &hMemory, (PVOID *)&pSharedMemory);
#else
    CloseSharedMemory(&hMutex, &hMemory, &(PVOID)pSharedMemory);
#endif
out:
    return status;
}

Referenced by NPAddConnection3().