wnet.c File Reference

#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "winnls.h"
#include "winioctl.h"
#include "winnetwk.h"
#include "npapi.h"
#include "winreg.h"
#include "winuser.h"
#include "ddk/mountmgr.h"
#include "wine/debug.h"
#include "mprres.h"
#include "wnetpriv.h"

Include dependency graph for wnet.c:

Go to the source code of this file.

Classes
struct	_WNetProvider
struct	_WNetProviderTable
struct	_WNetEnumerator
struct	use_connection_context

Macros
#define	WINE_MOUNTMGR_EXTENSIONS
#define	WNET_ENUMERATOR_TYPE_GLOBAL   0
#define	WNET_ENUMERATOR_TYPE_PROVIDER   1
#define	WNET_ENUMERATOR_TYPE_CONTEXT   2
#define	WNET_ENUMERATOR_TYPE_CONNECTED   3
#define	WNET_ENUMERATOR_TYPE_REMEMBERED   4
#define	BAD_PROVIDER_INDEX   (DWORD)0xffffffff
#define	MPR_GETPROC(proc)   ((PF_##proc)GetProcAddress(hLib, #proc))

Typedefs
typedef struct _WNetProvider	WNetProvider
typedef struct _WNetProvider *	PWNetProvider
typedef struct _WNetProviderTable	WNetProviderTable
typedef struct _WNetProviderTable *	PWNetProviderTable
typedef struct _WNetEnumerator	WNetEnumerator
typedef struct _WNetEnumerator *	PWNetEnumerator

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (mpr)
static DWORD	_findProviderIndexW (LPCWSTR lpProvider)
static void	_tryLoadProvider (PCWSTR provider)
void	wnetInit (HINSTANCE hInstDll)
void	wnetFree (void)
static LPNETRESOURCEW	_copyNetResourceForEnumW (LPNETRESOURCEW lpNet)
static void	_freeEnumNetResource (LPNETRESOURCEW lpNet)
static PWNetEnumerator	_createGlobalEnumeratorW (DWORD dwScope, DWORD dwType, DWORD dwUsage, LPNETRESOURCEW lpNet)
static PWNetEnumerator	_createProviderEnumerator (DWORD dwScope, DWORD dwType, DWORD dwUsage, DWORD index, HANDLE handle)
static PWNetEnumerator	_createContextEnumerator (DWORD dwScope, DWORD dwType, DWORD dwUsage)
static PWNetEnumerator	_createConnectedEnumerator (DWORD dwScope, DWORD dwType, DWORD dwUsage)
static PWNetEnumerator	_createRememberedEnumerator (DWORD dwScope, DWORD dwType, HKEY remembered)
static DWORD	_thunkNetResourceArrayWToA (const NETRESOURCEW *lpNetArrayIn, const DWORD *lpcCount, LPVOID lpBuffer, const DWORD *lpBufferSize)
static DWORD	_thunkNetResourceArrayAToW (const NETRESOURCEA *lpNetArrayIn, const DWORD *lpcCount, LPVOID lpBuffer, const DWORD *lpBufferSize)
DWORD WINAPI	WNetOpenEnumA (DWORD dwScope, DWORD dwType, DWORD dwUsage, LPNETRESOURCEA lpNet, LPHANDLE lphEnum)
DWORD WINAPI	WNetOpenEnumW (DWORD dwScope, DWORD dwType, DWORD dwUsage, LPNETRESOURCEW lpNet, LPHANDLE lphEnum)
DWORD WINAPI	WNetEnumResourceA (HANDLE hEnum, LPDWORD lpcCount, LPVOID lpBuffer, LPDWORD lpBufferSize)
static DWORD	_countProviderBytesW (PWNetProvider provider)
static DWORD	_enumerateProvidersW (PWNetEnumerator enumerator, LPDWORD lpcCount, LPVOID lpBuffer, const DWORD *lpBufferSize)
static DWORD	_globalEnumeratorAdvance (PWNetEnumerator enumerator)
static DWORD	_enumerateGlobalPassthroughW (PWNetEnumerator enumerator, LPDWORD lpcCount, LPVOID lpBuffer, LPDWORD lpBufferSize)
static DWORD	_enumerateGlobalW (PWNetEnumerator enumerator, LPDWORD lpcCount, LPVOID lpBuffer, LPDWORD lpBufferSize)
static DWORD	_enumerateProviderW (PWNetEnumerator enumerator, LPDWORD lpcCount, LPVOID lpBuffer, LPDWORD lpBufferSize)
static DWORD	_enumerateContextW (PWNetEnumerator enumerator, LPDWORD lpcCount, LPVOID lpBuffer, LPDWORD lpBufferSize)
static DWORD	_copyStringToEnumW (const WCHAR *source, DWORD *left, void **end)
static DWORD	_enumerateConnectedW (PWNetEnumerator enumerator, DWORD *user_count, void *user_buffer, DWORD *user_size)
static WCHAR *	get_reg_str (HKEY hkey, const WCHAR *value, DWORD *len)
static DWORD	_enumeratorRememberedW (PWNetEnumerator enumerator, DWORD *user_count, void *user_buffer, DWORD *user_size)
DWORD WINAPI	WNetEnumResourceW (HANDLE hEnum, LPDWORD lpcCount, LPVOID lpBuffer, LPDWORD lpBufferSize)
DWORD WINAPI	WNetCloseEnum (HANDLE hEnum)
DWORD WINAPI	WNetGetResourceInformationA (LPNETRESOURCEA lpNetResource, LPVOID lpBuffer, LPDWORD cbBuffer, LPSTR *lplpSystem)
DWORD WINAPI	WNetGetResourceInformationW (LPNETRESOURCEW lpNetResource, LPVOID lpBuffer, LPDWORD cbBuffer, LPWSTR *lplpSystem)
DWORD WINAPI	WNetGetResourceParentA (LPNETRESOURCEA lpNetResource, LPVOID lpBuffer, LPDWORD lpBufferSize)
DWORD WINAPI	WNetGetResourceParentW (LPNETRESOURCEW lpNetResource, LPVOID lpBuffer, LPDWORD lpBufferSize)
DWORD WINAPI	WNetAddConnectionA (LPCSTR lpRemoteName, LPCSTR lpPassword, LPCSTR lpLocalName)
DWORD WINAPI	WNetAddConnectionW (LPCWSTR lpRemoteName, LPCWSTR lpPassword, LPCWSTR lpLocalName)
DWORD WINAPI	WNetAddConnection2A (LPNETRESOURCEA lpNetResource, LPCSTR lpPassword, LPCSTR lpUserID, DWORD dwFlags)
DWORD WINAPI	WNetAddConnection2W (LPNETRESOURCEW lpNetResource, LPCWSTR lpPassword, LPCWSTR lpUserID, DWORD dwFlags)
DWORD WINAPI	WNetAddConnection3A (HWND hwndOwner, LPNETRESOURCEA lpNetResource, LPCSTR lpPassword, LPCSTR lpUserID, DWORD dwFlags)
DWORD WINAPI	WNetAddConnection3W (HWND hwndOwner, LPNETRESOURCEW lpNetResource, LPCWSTR lpPassword, LPCWSTR lpUserID, DWORD dwFlags)
static DWORD	use_connection_pre_set_accessnameW (struct use_connection_context *ctxt, WCHAR *local_name)
static void	use_connection_set_accessnameW (struct use_connection_context *ctxt, WCHAR *local_name)
static DWORD	wnet_use_provider (struct use_connection_context *ctxt, NETRESOURCEW *netres, WNetProvider *provider, BOOLEAN redirect)
static DWORD	wnet_use_connection (struct use_connection_context *ctxt)
DWORD WINAPI	WNetUseConnectionW (HWND hwndOwner, NETRESOURCEW *resource, LPCWSTR password, LPCWSTR userid, DWORD flags, LPWSTR accessname, DWORD *buffer_size, DWORD *result)
static DWORD	use_connection_pre_set_accessnameA (struct use_connection_context *ctxt, WCHAR *local_name)
static void	use_connection_set_accessnameA (struct use_connection_context *ctxt, WCHAR *local_name)
static LPWSTR	strdupAtoW (LPCSTR str)
static void	netresource_a_to_w (NETRESOURCEA *resourceA, NETRESOURCEW *resourceW)
static void	free_netresourceW (NETRESOURCEW *resource)
DWORD WINAPI	WNetUseConnectionA (HWND hwndOwner, NETRESOURCEA *resource, LPCSTR password, LPCSTR userid, DWORD flags, LPSTR accessname, DWORD *buffer_size, DWORD *result)
DWORD WINAPI	WNetCancelConnectionA (LPCSTR lpName, BOOL fForce)
DWORD WINAPI	WNetCancelConnectionW (LPCWSTR lpName, BOOL fForce)
DWORD WINAPI	WNetCancelConnection2A (LPCSTR lpName, DWORD dwFlags, BOOL fForce)
DWORD WINAPI	WNetCancelConnection2W (LPCWSTR lpName, DWORD dwFlags, BOOL fForce)
DWORD WINAPI	WNetRestoreConnectionA (HWND hwndOwner, LPCSTR lpszDevice)
DWORD WINAPI	WNetRestoreConnectionW (HWND hwndOwner, LPCWSTR lpszDevice)
DWORD WINAPI	WNetGetConnectionA (LPCSTR lpLocalName, LPSTR lpRemoteName, LPDWORD lpBufferSize)
static DWORD	get_drive_connection (WCHAR letter, LPWSTR remote, LPDWORD size)
DWORD WINAPI	WNetGetConnectionW (LPCWSTR lpLocalName, LPWSTR lpRemoteName, LPDWORD lpBufferSize)
DWORD WINAPI	WNetSetConnectionA (LPCSTR lpName, DWORD dwProperty, LPVOID pvValue)
DWORD WINAPI	WNetSetConnectionW (LPCWSTR lpName, DWORD dwProperty, LPVOID pvValue)
DWORD WINAPI	WNetGetUniversalNameA (LPCSTR lpLocalPath, DWORD dwInfoLevel, LPVOID lpBuffer, LPDWORD lpBufferSize)
DWORD WINAPI	WNetGetUniversalNameW (LPCWSTR lpLocalPath, DWORD dwInfoLevel, LPVOID lpBuffer, LPDWORD lpBufferSize)
DWORD WINAPI	WNetClearConnections (HWND owner)
DWORD WINAPI	WNetGetUserA (LPCSTR lpName, LPSTR lpUserID, LPDWORD lpBufferSize)
DWORD WINAPI	WNetGetUserW (LPCWSTR lpName, LPWSTR lpUserID, LPDWORD lpBufferSize)
DWORD WINAPI	WNetConnectionDialog (HWND hwnd, DWORD dwType)
DWORD WINAPI	WNetConnectionDialog1A (LPCONNECTDLGSTRUCTA lpConnDlgStruct)
DWORD WINAPI	WNetConnectionDialog1W (LPCONNECTDLGSTRUCTW lpConnDlgStruct)
DWORD WINAPI	WNetDisconnectDialog (HWND hwnd, DWORD dwType)
DWORD WINAPI	WNetDisconnectDialog1A (LPDISCDLGSTRUCTA lpConnDlgStruct)
DWORD WINAPI	WNetDisconnectDialog1W (LPDISCDLGSTRUCTW lpConnDlgStruct)
DWORD WINAPI	WNetGetLastErrorA (LPDWORD lpError, LPSTR lpErrorBuf, DWORD nErrorBufSize, LPSTR lpNameBuf, DWORD nNameBufSize)
DWORD WINAPI	WNetGetLastErrorW (LPDWORD lpError, LPWSTR lpErrorBuf, DWORD nErrorBufSize, LPWSTR lpNameBuf, DWORD nNameBufSize)
DWORD WINAPI	WNetGetNetworkInformationA (LPCSTR lpProvider, LPNETINFOSTRUCT lpNetInfoStruct)
DWORD WINAPI	WNetGetNetworkInformationW (LPCWSTR lpProvider, LPNETINFOSTRUCT lpNetInfoStruct)
DWORD WINAPI	WNetGetProviderNameA (DWORD dwNetType, LPSTR lpProvider, LPDWORD lpBufferSize)
DWORD WINAPI	WNetGetProviderNameW (DWORD dwNetType, LPWSTR lpProvider, LPDWORD lpBufferSize)

Variables
static PWNetProviderTable	providerTable
static const WCHAR	connectionType [] = { 'C','o','n','n','e','c','t','i','o','n','T','y','p','e',0 }
static const WCHAR	providerName [] = { 'P','r','o','v','i','d','e','r','N','a','m','e',0 }
static const WCHAR	remotePath [] = { 'R','e','m','o','t','e','P','a','t','h',0 }
static const WCHAR	providerType [] = { 'P','r','o','v','i','d','e','r','T','y','p','e',0 }
static const WCHAR	userName [] = { 'U','s','e','r','N','a','m','e',0 }

Macro Definition Documentation

BAD_PROVIDER_INDEX

#define BAD_PROVIDER_INDEX   (DWORD)0xffffffff

Definition at line 120 of file wnet.c.

MPR_GETPROC

#define MPR_GETPROC

(

proc

)

((PF_##proc)GetProcAddress(hLib, #proc))

WINE_MOUNTMGR_EXTENSIONS

#define WINE_MOUNTMGR_EXTENSIONS

Definition at line 33 of file wnet.c.

WNET_ENUMERATOR_TYPE_CONNECTED

#define WNET_ENUMERATOR_TYPE_CONNECTED   3

Definition at line 81 of file wnet.c.

WNET_ENUMERATOR_TYPE_CONTEXT

#define WNET_ENUMERATOR_TYPE_CONTEXT   2

Definition at line 80 of file wnet.c.

WNET_ENUMERATOR_TYPE_GLOBAL

#define WNET_ENUMERATOR_TYPE_GLOBAL   0

Definition at line 78 of file wnet.c.

WNET_ENUMERATOR_TYPE_PROVIDER

#define WNET_ENUMERATOR_TYPE_PROVIDER   1

Definition at line 79 of file wnet.c.

WNET_ENUMERATOR_TYPE_REMEMBERED

#define WNET_ENUMERATOR_TYPE_REMEMBERED   4

Definition at line 82 of file wnet.c.

Typedef Documentation

PWNetEnumerator

typedef struct _WNetEnumerator * PWNetEnumerator

PWNetProvider

typedef struct _WNetProvider * PWNetProvider

PWNetProviderTable

typedef struct _WNetProviderTable * PWNetProviderTable

WNetEnumerator

typedef struct _WNetEnumerator WNetEnumerator

WNetProvider

typedef struct _WNetProvider WNetProvider

WNetProviderTable

typedef struct _WNetProviderTable WNetProviderTable

Function Documentation

_copyNetResourceForEnumW()

static LPNETRESOURCEW _copyNetResourceForEnumW ( LPNETRESOURCEW  lpNet )

static

Definition at line 527 of file wnet.c.

{
    LPNETRESOURCEW ret;

    if (lpNet)
    {
        ret = HeapAlloc(GetProcessHeap(), 0, sizeof(NETRESOURCEW));
        if (ret)
        {
            size_t len;

            *ret = *lpNet;
            ret->lpLocalName = ret->lpComment = ret->lpProvider = NULL;
            if (lpNet->lpRemoteName)
            {
                len = lstrlenW(lpNet->lpRemoteName) + 1;
                ret->lpRemoteName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
                if (ret->lpRemoteName)
                    lstrcpyW(ret->lpRemoteName, lpNet->lpRemoteName);
            }
        }
    }
    else
        ret = NULL;
    return ret;
}

Referenced by _createGlobalEnumeratorW().

_copyStringToEnumW()

static DWORD _copyStringToEnumW ( const WCHAR *  source, DWORD *  left, void **  end  )

static

Definition at line 1418 of file wnet.c.

{
    DWORD len;
    WCHAR* local = *end;

    len = lstrlenW(source) + 1;
    len *= sizeof(WCHAR);
    if (*left < len)
        return WN_MORE_DATA;

    local -= (len / sizeof(WCHAR));
    memcpy(local, source, len);
    *left -= len;
    *end = local;

    return WN_SUCCESS;
}

Referenced by _enumerateConnectedW().

_countProviderBytesW()

static DWORD _countProviderBytesW ( PWNetProvider  provider )

static

Definition at line 1102 of file wnet.c.

{
    DWORD ret;

    if (provider)
    {
        ret = sizeof(NETRESOURCEW);
        ret += 2 * (lstrlenW(provider->name) + 1) * sizeof(WCHAR);
    }
    else
        ret = 0;
    return ret;
}

Referenced by _enumerateProvidersW().

_createConnectedEnumerator()

static PWNetEnumerator _createConnectedEnumerator ( DWORD  dwScope, DWORD  dwType, DWORD  dwUsage  )

static

Definition at line 619 of file wnet.c.

{
    PWNetEnumerator ret = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WNetEnumerator));
    if (ret)
    {
        ret->enumType = WNET_ENUMERATOR_TYPE_CONNECTED;
        ret->dwScope = dwScope;
        ret->dwType  = dwType;
        ret->dwUsage = dwUsage;
        ret->specific.handles = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(HANDLE) * providerTable->numProviders);
        if (!ret->specific.handles)
        {
            HeapFree(GetProcessHeap(), 0, ret);
            ret = NULL;
        }
    }
    return ret;
}

Referenced by WNetOpenEnumW().

_createContextEnumerator()

static PWNetEnumerator _createContextEnumerator ( DWORD  dwScope, DWORD  dwType, DWORD  dwUsage  )

static

Definition at line 603 of file wnet.c.

{
    PWNetEnumerator ret = HeapAlloc(GetProcessHeap(),
     HEAP_ZERO_MEMORY, sizeof(WNetEnumerator));

    if (ret)
    {
        ret->enumType = WNET_ENUMERATOR_TYPE_CONTEXT;
        ret->dwScope = dwScope;
        ret->dwType  = dwType;
        ret->dwUsage = dwUsage;
    }
    return ret;
}

Referenced by WNetOpenEnumW().

_createGlobalEnumeratorW()

static PWNetEnumerator _createGlobalEnumeratorW ( DWORD  dwScope, DWORD  dwType, DWORD  dwUsage, LPNETRESOURCEW  lpNet  )

static

Definition at line 563 of file wnet.c.

{
    PWNetEnumerator ret = HeapAlloc(GetProcessHeap(),
     HEAP_ZERO_MEMORY, sizeof(WNetEnumerator));

    if (ret)
    {
        ret->enumType = WNET_ENUMERATOR_TYPE_GLOBAL;
        ret->dwScope = dwScope;
        ret->dwType  = dwType;
        ret->dwUsage = dwUsage;
        ret->specific.net = _copyNetResourceForEnumW(lpNet);
    }
    return ret;
}

Referenced by WNetOpenEnumW().

_createProviderEnumerator()

static PWNetEnumerator _createProviderEnumerator ( DWORD  dwScope, DWORD  dwType, DWORD  dwUsage, DWORD  index, HANDLE  handle  )

static

Definition at line 580 of file wnet.c.

{
    PWNetEnumerator ret;

    if (!providerTable || index >= providerTable->numProviders)
        ret = NULL;
    else
    {
        ret = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WNetEnumerator));
        if (ret)
        {
            ret->enumType      = WNET_ENUMERATOR_TYPE_PROVIDER;
            ret->providerIndex = index;
            ret->dwScope       = dwScope;
            ret->dwType        = dwType;
            ret->dwUsage       = dwUsage;
            ret->handle        = handle;
        }
    }
    return ret;
}

Referenced by WNetOpenEnumW().

_createRememberedEnumerator()

static PWNetEnumerator _createRememberedEnumerator ( DWORD  dwScope, DWORD  dwType, HKEY  remembered  )

static

Definition at line 639 of file wnet.c.

{
    PWNetEnumerator ret = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WNetEnumerator));
    if (ret)
    {
        ret->enumType = WNET_ENUMERATOR_TYPE_REMEMBERED;
        ret->dwScope = dwScope;
        ret->dwType = dwType;
        ret->specific.remembered.registry = remembered;
    }
    return ret;
}

Referenced by WNetOpenEnumW().

_enumerateConnectedW()

static DWORD _enumerateConnectedW ( PWNetEnumerator  enumerator, DWORD *  user_count, void *  user_buffer, DWORD *  user_size  )

static

Definition at line 1436 of file wnet.c.

{
    DWORD ret, index, count, total_count, size, i, left;
    void* end;
    NETRESOURCEW* curr, * buffer;
    HANDLE* handles;

    if (!enumerator)
        return WN_BAD_POINTER;
    if (enumerator->enumType != WNET_ENUMERATOR_TYPE_CONNECTED)
        return WN_BAD_VALUE;
    if (!user_count || !user_buffer || !user_size)
        return WN_BAD_POINTER;
    if (!providerTable)
        return WN_NO_NETWORK;

    handles = enumerator->specific.handles;
    left = *user_size;
    size = *user_size;
    buffer = HeapAlloc(GetProcessHeap(), 0, *user_size);
    if (!buffer)
        return WN_NO_NETWORK;

    curr = user_buffer;
    end = (char *)user_buffer + size;
    count = *user_count;
    total_count = 0;

    ret = WN_NO_MORE_ENTRIES;
    for (index = 0; index < providerTable->numProviders; index++)
    {
        if (providerTable->table[index].dwEnumScopes)
        {
            if (handles[index] == 0)
            {
                ret = providerTable->table[index].openEnum(enumerator->dwScope,
                                                           enumerator->dwType,
                                                           enumerator->dwUsage,
                                                           NULL, &handles[index]);
                if (ret != WN_SUCCESS)
                    continue;
            }

            ret = providerTable->table[index].enumResource(handles[index],
                                                           &count, buffer,
                                                           &size);
            total_count += count;
            if (ret == WN_MORE_DATA)
                break;

            if (ret == WN_SUCCESS)
            {
                for (i = 0; i < count; ++i)
                {
                    if (left < sizeof(NETRESOURCEW))
                    {
                        ret = WN_MORE_DATA;
                        break;
                    }

                    memcpy(curr, &buffer[i], sizeof(NETRESOURCEW));
                    left -= sizeof(NETRESOURCEW);

                    ret = _copyStringToEnumW(buffer[i].lpLocalName, &left, &end);
                    if (ret == WN_MORE_DATA)
                        break;
                    curr->lpLocalName = end;

                    ret = _copyStringToEnumW(buffer[i].lpRemoteName, &left, &end);
                    if (ret == WN_MORE_DATA)
                        break;
                    curr->lpRemoteName = end;

                    ret = _copyStringToEnumW(buffer[i].lpProvider, &left, &end);
                    if (ret == WN_MORE_DATA)
                        break;
                    curr->lpProvider = end;

                    ++curr;
                }

                size = left;
            }

            if (*user_count != -1)
                count = *user_count - total_count;
            else
                count = *user_count;
        }
    }

    if (total_count == 0)
        ret = WN_NO_MORE_ENTRIES;

    *user_count = total_count;
    if (ret != WN_MORE_DATA && ret != WN_NO_MORE_ENTRIES)
        ret = WN_SUCCESS;

    HeapFree(GetProcessHeap(), 0, buffer);

    TRACE("Returning %d\n", ret);
    return ret;
}

Referenced by WNetEnumResourceW().

_enumerateContextW()

static DWORD _enumerateContextW ( PWNetEnumerator  enumerator, LPDWORD  lpcCount, LPVOID  lpBuffer, LPDWORD  lpBufferSize  )

static

Definition at line 1341 of file wnet.c.

{
    DWORD ret;
    size_t cchEntireNetworkLen, bytesNeeded;

    if (!enumerator)
        return WN_BAD_POINTER;
    if (enumerator->enumType != WNET_ENUMERATOR_TYPE_CONTEXT)
        return WN_BAD_VALUE;
    if (!lpcCount)
        return WN_BAD_POINTER;
    if (!lpBuffer)
        return WN_BAD_POINTER;
    if (!lpBufferSize)
        return WN_BAD_POINTER;
    if (!providerTable)
        return WN_NO_NETWORK;

    cchEntireNetworkLen = lstrlenW(providerTable->entireNetwork) + 1;
    bytesNeeded = sizeof(NETRESOURCEW) + cchEntireNetworkLen * sizeof(WCHAR);
    if (*lpBufferSize < bytesNeeded)
    {
        *lpBufferSize = bytesNeeded;
        ret = WN_MORE_DATA;
    }
    else
    {
        LPNETRESOURCEW lpNet = lpBuffer;

        lpNet->dwScope = RESOURCE_GLOBALNET;
        lpNet->dwType = enumerator->dwType;
        lpNet->dwDisplayType = RESOURCEDISPLAYTYPE_ROOT;
        lpNet->dwUsage = RESOURCEUSAGE_CONTAINER;
        lpNet->lpLocalName = NULL;
        lpNet->lpRemoteName = NULL;
        lpNet->lpProvider = NULL;
        /* odd, but correct: put comment at end of buffer, so it won't get
         * overwritten by subsequent calls to a provider's enumResource
         */
        lpNet->lpComment = (LPWSTR)((LPBYTE)lpBuffer + *lpBufferSize -
         (cchEntireNetworkLen * sizeof(WCHAR)));
        lstrcpyW(lpNet->lpComment, providerTable->entireNetwork);
        ret = WN_SUCCESS;
    }
    if (ret == WN_SUCCESS)
    {
        DWORD bufferSize = *lpBufferSize - bytesNeeded;

        /* "Entire Network" entry enumerated--morph this into a global
         * enumerator.  enumerator->lpNet continues to be NULL, since it has
         * no meaning when the scope isn't RESOURCE_GLOBALNET.
         */
        enumerator->enumType = WNET_ENUMERATOR_TYPE_GLOBAL;
        ret = _enumerateGlobalW(enumerator, lpcCount,
         (LPBYTE)lpBuffer + bytesNeeded, &bufferSize);
        if (ret == WN_SUCCESS)
        {
            /* reflect the fact that we already enumerated "Entire Network" */
            (*lpcCount)++;
            *lpBufferSize = bufferSize + bytesNeeded;
        }
        else
        {
            /* the provider enumeration failed, but we already succeeded in
             * enumerating "Entire Network"--leave type as global to allow a
             * retry, but indicate success with a count of one.
             */
            ret = WN_SUCCESS;
            *lpcCount = 1;
            *lpBufferSize = bytesNeeded;
        }
    }
    TRACE("Returning %d\n", ret);
    return ret;
}

Referenced by WNetEnumResourceW().

_enumerateGlobalPassthroughW()

static DWORD _enumerateGlobalPassthroughW ( PWNetEnumerator  enumerator, LPDWORD  lpcCount, LPVOID  lpBuffer, LPDWORD  lpBufferSize  )

static

Definition at line 1236 of file wnet.c.

{
    DWORD ret;

    if (!enumerator)
        return WN_BAD_POINTER;
    if (enumerator->enumType != WNET_ENUMERATOR_TYPE_GLOBAL)
        return WN_BAD_VALUE;
    if (!lpcCount)
        return WN_BAD_POINTER;
    if (!lpBuffer)
        return WN_BAD_POINTER;
    if (!lpBufferSize)
        return WN_BAD_POINTER;
    if (*lpBufferSize < sizeof(NETRESOURCEW))
        return WN_MORE_DATA;

    ret = _globalEnumeratorAdvance(enumerator);
    if (ret == WN_SUCCESS)
    {
        ret = providerTable->table[enumerator->providerIndex].
         openEnum(enumerator->dwScope, enumerator->dwType,
         enumerator->dwUsage, enumerator->specific.net,
         &enumerator->handle);
        if (ret == WN_SUCCESS)
        {
            ret = providerTable->table[enumerator->providerIndex].
             enumResource(enumerator->handle, lpcCount, lpBuffer,
             lpBufferSize);
            if (ret != WN_MORE_DATA)
                enumerator->providerDone = TRUE;
        }
    }
    TRACE("Returning %d\n", ret);
    return ret;
}

Referenced by _enumerateGlobalW().

_enumerateGlobalW()

static DWORD _enumerateGlobalW ( PWNetEnumerator  enumerator, LPDWORD  lpcCount, LPVOID  lpBuffer, LPDWORD  lpBufferSize  )

static

Definition at line 1274 of file wnet.c.

{
    DWORD ret;

    if (!enumerator)
        return WN_BAD_POINTER;
    if (enumerator->enumType != WNET_ENUMERATOR_TYPE_GLOBAL)
        return WN_BAD_VALUE;
    if (!lpcCount)
        return WN_BAD_POINTER;
    if (!lpBuffer)
        return WN_BAD_POINTER;
    if (!lpBufferSize)
        return WN_BAD_POINTER;
    if (*lpBufferSize < sizeof(NETRESOURCEW))
        return WN_MORE_DATA;
    if (!providerTable)
        return WN_NO_NETWORK;

    switch (enumerator->dwScope)
    {
        case RESOURCE_GLOBALNET:
            if (enumerator->specific.net)
                ret = _enumerateGlobalPassthroughW(enumerator, lpcCount,
                 lpBuffer, lpBufferSize);
            else
                ret = _enumerateProvidersW(enumerator, lpcCount, lpBuffer,
                 lpBufferSize);
            break;
        case RESOURCE_CONTEXT:
            ret = _enumerateGlobalPassthroughW(enumerator, lpcCount, lpBuffer,
             lpBufferSize);
            break;
        default:
            WARN("unexpected scope 0x%08x\n", enumerator->dwScope);
            ret = WN_NO_MORE_ENTRIES;
    }
    TRACE("Returning %d\n", ret);
    return ret;
}

Referenced by _enumerateContextW(), and WNetEnumResourceW().

_enumerateProvidersW()

static DWORD _enumerateProvidersW ( PWNetEnumerator  enumerator, LPDWORD  lpcCount, LPVOID  lpBuffer, const DWORD *  lpBufferSize  )

static

Definition at line 1116 of file wnet.c.

{
    DWORD ret;

    if (!enumerator)
        return WN_BAD_POINTER;
    if (enumerator->enumType != WNET_ENUMERATOR_TYPE_GLOBAL)
        return WN_BAD_VALUE;
    if (!lpcCount)
        return WN_BAD_POINTER;
    if (!lpBuffer)
        return WN_BAD_POINTER;
    if (!lpBufferSize)
        return WN_BAD_POINTER;
    if (*lpBufferSize < sizeof(NETRESOURCEA))
        return WN_MORE_DATA;

    if (!providerTable || enumerator->providerIndex >= 
     providerTable->numProviders)
        ret = WN_NO_MORE_ENTRIES;
    else
    {
        DWORD bytes = 0, count = 0, countLimit, i;
        LPNETRESOURCEW resource;
        LPWSTR strNext;

        countLimit = *lpcCount == -1 ?
         providerTable->numProviders - enumerator->providerIndex : *lpcCount;
        while (count < countLimit && bytes < *lpBufferSize)
        {
            DWORD bytesNext = _countProviderBytesW(
             &providerTable->table[count + enumerator->providerIndex]);

            if (bytes + bytesNext < *lpBufferSize)
            {
                bytes += bytesNext;
                count++;
            }
        }
        strNext = (LPWSTR)((LPBYTE)lpBuffer + count * sizeof(NETRESOURCEW));
        for (i = 0, resource = lpBuffer; i < count; i++, resource++)
        {
            resource->dwScope = RESOURCE_GLOBALNET;
            resource->dwType = RESOURCETYPE_ANY;
            resource->dwDisplayType = RESOURCEDISPLAYTYPE_NETWORK;
            resource->dwUsage = RESOURCEUSAGE_CONTAINER |
             RESOURCEUSAGE_RESERVED;
            resource->lpLocalName = NULL;
            resource->lpRemoteName = strNext;
            lstrcpyW(resource->lpRemoteName,
             providerTable->table[i + enumerator->providerIndex].name);
            strNext += lstrlenW(resource->lpRemoteName) + 1;
            resource->lpComment = NULL;
            resource->lpProvider = strNext;
            lstrcpyW(resource->lpProvider,
             providerTable->table[i + enumerator->providerIndex].name);
            strNext += lstrlenW(resource->lpProvider) + 1;
        }
        enumerator->providerIndex += count;
        *lpcCount = count;
        ret = count > 0 ? WN_SUCCESS : WN_MORE_DATA;
    }
    TRACE("Returning %d\n", ret);
    return ret;
}

Referenced by _enumerateGlobalW().

_enumerateProviderW()

static DWORD _enumerateProviderW ( PWNetEnumerator  enumerator, LPDWORD  lpcCount, LPVOID  lpBuffer, LPDWORD  lpBufferSize  )

static

Definition at line 1316 of file wnet.c.

{
    if (!enumerator)
        return WN_BAD_POINTER;
    if (enumerator->enumType != WNET_ENUMERATOR_TYPE_PROVIDER)
        return WN_BAD_VALUE;
    if (!enumerator->handle)
        return WN_BAD_VALUE;
    if (!lpcCount)
        return WN_BAD_POINTER;
    if (!lpBuffer)
        return WN_BAD_POINTER;
    if (!lpBufferSize)
        return WN_BAD_POINTER;
    if (!providerTable)
        return WN_NO_NETWORK;
    if (enumerator->providerIndex >= providerTable->numProviders)
        return WN_NO_MORE_ENTRIES;
    if (!providerTable->table[enumerator->providerIndex].enumResource)
        return WN_BAD_VALUE;
    return providerTable->table[enumerator->providerIndex].enumResource(
     enumerator->handle, lpcCount, lpBuffer, lpBufferSize);
}

Referenced by WNetEnumResourceW().

_enumeratorRememberedW()

static DWORD _enumeratorRememberedW ( PWNetEnumerator  enumerator, DWORD *  user_count, void *  user_buffer, DWORD *  user_size  )

static

Definition at line 1559 of file wnet.c.

{
    HKEY registry, connection;
    WCHAR buffer[255];
    LONG size_left;
    DWORD index, ret, type, len, size, registry_size, full_size = 0, total_count;
    NETRESOURCEW * net_buffer = user_buffer;
    WCHAR * str, * registry_string;

    /* we will do the work in a single loop, so here is some things:
     * we write netresource at the begin of the user buffer
     * we write strings at the end of the user buffer
     */
    size_left = *user_size;
    total_count = 0;
    type = enumerator->dwType;
    registry = enumerator->specific.remembered.registry;
    str = (WCHAR *)((ULONG_PTR)user_buffer + *user_size - sizeof(WCHAR));
    for (index = enumerator->specific.remembered.index; ; ++index)
    {
        enumerator->specific.remembered.index = index;

        if (*user_count != -1 && total_count == *user_count)
        {
            ret = WN_SUCCESS;
            break;
        }

        len = ARRAY_SIZE(buffer);
        ret = RegEnumKeyExW(registry, index, buffer, &len, NULL, NULL, NULL, NULL);
        if (ret != ERROR_SUCCESS)
        {
            if (ret == ERROR_NO_MORE_ITEMS) ret = WN_SUCCESS;
            break;
        }

        if (RegOpenKeyExW(registry, buffer, 0, KEY_READ, &connection) != ERROR_SUCCESS)
        {
            continue;
        }

        full_size = sizeof(NETRESOURCEW);
        size_left -= sizeof(NETRESOURCEW);

        if (size_left > 0)
        {
            size = sizeof(DWORD);
            RegQueryValueExW(connection, connectionType, NULL, NULL, (BYTE *)&net_buffer->dwType, &size);
            if (type != RESOURCETYPE_ANY && net_buffer->dwType != type)
            {
                size_left += sizeof(NETRESOURCEW);
                RegCloseKey(connection);
                continue;
            }

            net_buffer->dwScope = RESOURCE_REMEMBERED;
            net_buffer->dwDisplayType = RESOURCEDISPLAYTYPE_GENERIC;
            net_buffer->dwUsage = RESOURCEUSAGE_CONNECTABLE;
        }
        else
            ret = WN_MORE_DATA;

        /* FIXME: this only supports drive letters */
        full_size += 3 * sizeof(WCHAR);
        size_left -= 3 * sizeof(WCHAR);
        if (size_left > 0)
        {
            str -= 3;
            str[0] = buffer[0];
            str[1] = ':';
            str[2] = 0;
            net_buffer->lpLocalName = str;
        }

        registry_size = 0;
        registry_string = get_reg_str(connection, providerName, &registry_size);
        if (registry_string)
        {
            full_size += registry_size;
            size_left -= registry_size;

            if (size_left > 0)
            {
                str -= (registry_size / sizeof(WCHAR));
                lstrcpyW(str, registry_string);
                net_buffer->lpProvider = str;
            }
            else
                ret = WN_MORE_DATA;

            HeapFree(GetProcessHeap(), 0, registry_string);
        }

        registry_size = 0;
        registry_string = get_reg_str(connection, remotePath, &registry_size);
        if (registry_string)
        {
            full_size += registry_size;
            size_left -= registry_size;

            if (size_left > 0)
            {
                str -= (registry_size / sizeof(WCHAR));
                lstrcpyW(str, registry_string);
                net_buffer->lpRemoteName = str;
            }
            else
                ret = WN_MORE_DATA;

            HeapFree(GetProcessHeap(), 0, registry_string);
        }

        RegCloseKey(connection);

        net_buffer->lpComment = NULL;

        if (size_left < 0)
            break;

        ++total_count;
        ++net_buffer;
    }

    if (total_count == 0)
        ret = WN_NO_MORE_ENTRIES;

    *user_count = total_count;

    if (ret != WN_MORE_DATA && ret != WN_NO_MORE_ENTRIES)
        ret = WN_SUCCESS;

    if (ret == WN_MORE_DATA)
        *user_size = *user_size + full_size;

    return ret;
}

Referenced by WNetEnumResourceW().

_findProviderIndexW()

static DWORD _findProviderIndexW ( LPCWSTR  lpProvider )

static

Definition at line 507 of file wnet.c.

{
    DWORD ret = BAD_PROVIDER_INDEX;

    if (providerTable && providerTable->numProviders)
    {
        DWORD i;

        for (i = 0; i < providerTable->numProviders &&
         ret == BAD_PROVIDER_INDEX; i++)
            if (!lstrcmpW(lpProvider, providerTable->table[i].name))
                ret = i;
    }
    return ret;
}

Referenced by wnet_use_connection(), WNetGetNetworkInformationW(), and WNetOpenEnumW().

_freeEnumNetResource()

static void _freeEnumNetResource ( LPNETRESOURCEW  lpNet )

static

Definition at line 554 of file wnet.c.

{
    if (lpNet)
    {
        HeapFree(GetProcessHeap(), 0, lpNet->lpRemoteName);
        HeapFree(GetProcessHeap(), 0, lpNet);
    }
}

Referenced by WNetCloseEnum().

_globalEnumeratorAdvance()

static DWORD _globalEnumeratorAdvance ( PWNetEnumerator  enumerator )

static

Definition at line 1192 of file wnet.c.

{
    if (!enumerator)
        return WN_BAD_POINTER;
    if (enumerator->enumType != WNET_ENUMERATOR_TYPE_GLOBAL)
        return WN_BAD_VALUE;
    if (!providerTable || enumerator->providerIndex >=
     providerTable->numProviders)
        return WN_NO_MORE_ENTRIES;

    if (enumerator->providerDone)
    {
        DWORD dwEnum = 0;
        enumerator->providerDone = FALSE;
        if (enumerator->handle)
        {
            providerTable->table[enumerator->providerIndex].closeEnum(
             enumerator->handle);
            enumerator->handle = NULL;
            enumerator->providerIndex++;
        }
        if (enumerator->dwScope == RESOURCE_CONNECTED)
            dwEnum = WNNC_ENUM_LOCAL;
        else if (enumerator->dwScope == RESOURCE_GLOBALNET)
            dwEnum = WNNC_ENUM_GLOBAL;
        else if (enumerator->dwScope == RESOURCE_CONTEXT)
            dwEnum = WNNC_ENUM_CONTEXT;
        for (; enumerator->providerIndex < providerTable->numProviders &&
         !(providerTable->table[enumerator->providerIndex].dwEnumScopes
         & dwEnum); enumerator->providerIndex++)
            ;
    }
    return enumerator->providerIndex < providerTable->numProviders ?
     WN_SUCCESS : WN_NO_MORE_ENTRIES;
}

Referenced by _enumerateGlobalPassthroughW().

_thunkNetResourceArrayAToW()

static DWORD _thunkNetResourceArrayAToW ( const NETRESOURCEA *  lpNetArrayIn, const DWORD *  lpcCount, LPVOID  lpBuffer, const DWORD *  lpBufferSize  )

static

Definition at line 745 of file wnet.c.

{
    DWORD i, numToThunk, totalBytes, ret;
    LPWSTR strNext;

    if (!lpNetArrayIn)
        return WN_BAD_POINTER;
    if (!lpcCount)
        return WN_BAD_POINTER;
    if (*lpcCount == -1)
        return WN_BAD_VALUE;
    if (!lpBuffer)
        return WN_BAD_POINTER;
    if (!lpBufferSize)
        return WN_BAD_POINTER;

    for (i = 0, numToThunk = 0, totalBytes = 0; i < *lpcCount; i++)
    {
        const NETRESOURCEA *lpNet = lpNetArrayIn + i;

        totalBytes += sizeof(NETRESOURCEW);
        if (lpNet->lpLocalName)
            totalBytes += MultiByteToWideChar(CP_ACP, 0, lpNet->lpLocalName,
             -1, NULL, 0) * sizeof(WCHAR);
        if (lpNet->lpRemoteName)
            totalBytes += MultiByteToWideChar(CP_ACP, 0, lpNet->lpRemoteName,
             -1, NULL, 0) * sizeof(WCHAR);
        if (lpNet->lpComment)
            totalBytes += MultiByteToWideChar(CP_ACP, 0, lpNet->lpComment,
             -1, NULL, 0) * sizeof(WCHAR);
        if (lpNet->lpProvider)
            totalBytes += MultiByteToWideChar(CP_ACP, 0, lpNet->lpProvider,
             -1, NULL, 0) * sizeof(WCHAR);
        if (totalBytes < *lpBufferSize)
            numToThunk = i + 1;
    }
    strNext = (LPWSTR)((LPBYTE)lpBuffer + numToThunk * sizeof(NETRESOURCEW));
    for (i = 0; i < numToThunk; i++)
    {
        LPNETRESOURCEW lpNetOut = (LPNETRESOURCEW)lpBuffer + i;
        const NETRESOURCEA *lpNetIn = lpNetArrayIn + i;

        memcpy(lpNetOut, lpNetIn, sizeof(NETRESOURCEW));
        /* lie about string lengths, we already verified how many
         * we have space for above
         */
        if (lpNetIn->lpLocalName)
        {
            lpNetOut->lpLocalName = strNext;
            strNext += MultiByteToWideChar(CP_ACP, 0, lpNetIn->lpLocalName,
             -1, lpNetOut->lpLocalName, *lpBufferSize);
        }
        if (lpNetIn->lpRemoteName)
        {
            lpNetOut->lpRemoteName = strNext;
            strNext += MultiByteToWideChar(CP_ACP, 0, lpNetIn->lpRemoteName,
             -1, lpNetOut->lpRemoteName, *lpBufferSize);
        }
        if (lpNetIn->lpComment)
        {
            lpNetOut->lpComment = strNext;
            strNext += MultiByteToWideChar(CP_ACP, 0, lpNetIn->lpComment,
             -1, lpNetOut->lpComment, *lpBufferSize);
        }
        if (lpNetIn->lpProvider)
        {
            lpNetOut->lpProvider = strNext;
            strNext += MultiByteToWideChar(CP_ACP, 0, lpNetIn->lpProvider,
             -1, lpNetOut->lpProvider, *lpBufferSize);
        }
    }
    ret = numToThunk < *lpcCount ? WN_MORE_DATA : WN_SUCCESS;
    TRACE("numToThunk is %d, *lpcCount is %d, returning %d\n", numToThunk,
     *lpcCount, ret);
    return ret;
}

Referenced by WNetGetResourceInformationA(), and WNetOpenEnumA().

_thunkNetResourceArrayWToA()

static DWORD _thunkNetResourceArrayWToA ( const NETRESOURCEW *  lpNetArrayIn, const DWORD *  lpcCount, LPVOID  lpBuffer, const DWORD *  lpBufferSize  )

static

Definition at line 660 of file wnet.c.

{
    DWORD i, numToThunk, totalBytes, ret;
    LPSTR strNext;

    if (!lpNetArrayIn)
        return WN_BAD_POINTER;
    if (!lpcCount)
        return WN_BAD_POINTER;
    if (*lpcCount == -1)
        return WN_BAD_VALUE;
    if (!lpBuffer)
        return WN_BAD_POINTER;
    if (!lpBufferSize)
        return WN_BAD_POINTER;

    for (i = 0, numToThunk = 0, totalBytes = 0; i < *lpcCount; i++)
    {
        const NETRESOURCEW *lpNet = lpNetArrayIn + i;

        totalBytes += sizeof(NETRESOURCEA);
        if (lpNet->lpLocalName)
            totalBytes += WideCharToMultiByte(CP_ACP, 0, lpNet->lpLocalName,
             -1, NULL, 0, NULL, NULL);
        if (lpNet->lpRemoteName)
            totalBytes += WideCharToMultiByte(CP_ACP, 0, lpNet->lpRemoteName,
             -1, NULL, 0, NULL, NULL);
        if (lpNet->lpComment)
            totalBytes += WideCharToMultiByte(CP_ACP, 0, lpNet->lpComment,
             -1, NULL, 0, NULL, NULL);
        if (lpNet->lpProvider)
            totalBytes += WideCharToMultiByte(CP_ACP, 0, lpNet->lpProvider,
             -1, NULL, 0, NULL, NULL);
        if (totalBytes < *lpBufferSize)
            numToThunk = i + 1;
    }
    strNext = (LPSTR)((LPBYTE)lpBuffer + numToThunk * sizeof(NETRESOURCEA));
    for (i = 0; i < numToThunk; i++)
    {
        LPNETRESOURCEA lpNetOut = (LPNETRESOURCEA)lpBuffer + i;
        const NETRESOURCEW *lpNetIn = lpNetArrayIn + i;

        memcpy(lpNetOut, lpNetIn, sizeof(NETRESOURCEA));
        /* lie about string lengths, we already verified how many
         * we have space for above
         */
        if (lpNetIn->lpLocalName)
        {
            lpNetOut->lpLocalName = strNext;
            strNext += WideCharToMultiByte(CP_ACP, 0, lpNetIn->lpLocalName, -1,
             lpNetOut->lpLocalName, *lpBufferSize, NULL, NULL);
        }
        if (lpNetIn->lpRemoteName)
        {
            lpNetOut->lpRemoteName = strNext;
            strNext += WideCharToMultiByte(CP_ACP, 0, lpNetIn->lpRemoteName, -1,
             lpNetOut->lpRemoteName, *lpBufferSize, NULL, NULL);
        }
        if (lpNetIn->lpComment)
        {
            lpNetOut->lpComment = strNext;
            strNext += WideCharToMultiByte(CP_ACP, 0, lpNetIn->lpComment, -1,
             lpNetOut->lpComment, *lpBufferSize, NULL, NULL);
        }
        if (lpNetIn->lpProvider)
        {
            lpNetOut->lpProvider = strNext;
            strNext += WideCharToMultiByte(CP_ACP, 0, lpNetIn->lpProvider, -1,
             lpNetOut->lpProvider, *lpBufferSize, NULL, NULL);
        }
    }
    ret = numToThunk < *lpcCount ? WN_MORE_DATA : WN_SUCCESS;
    TRACE("numToThunk is %d, *lpcCount is %d, returning %d\n", numToThunk,
     *lpcCount, ret);
    return ret;
}

Referenced by WNetEnumResourceA(), and WNetGetResourceInformationA().

_tryLoadProvider()

static void _tryLoadProvider ( PCWSTR  provider )

static

Definition at line 133 of file wnet.c.

{
    static const WCHAR servicePrefix[] = { 'S','y','s','t','e','m','\\',
     'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
     'S','e','r','v','i','c','e','s','\\',0 };
    static const WCHAR serviceFmt[] = { '%','s','%','s','\\',
     'N','e','t','w','o','r','k','P','r','o','v','i','d','e','r',0 };
    WCHAR serviceName[MAX_PATH];
    HKEY hKey;

    TRACE("%s\n", debugstr_w(provider));
    swprintf(serviceName, serviceFmt, servicePrefix, provider);
    serviceName[ARRAY_SIZE(serviceName) - 1] = '\0';
    if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, serviceName, 0, KEY_READ, &hKey) ==
     ERROR_SUCCESS)
    {
        static const WCHAR szProviderPath[] = { 'P','r','o','v','i','d','e','r',
         'P','a','t','h',0 };
        WCHAR providerPath[MAX_PATH];
        DWORD type, size = sizeof(providerPath);

        if (RegQueryValueExW(hKey, szProviderPath, NULL, &type,
         (LPBYTE)providerPath, &size) == ERROR_SUCCESS && (type == REG_SZ || type == REG_EXPAND_SZ))
        {
            static const WCHAR szProviderName[] = { 'N','a','m','e',0 };
            PWSTR name = NULL;

            if (type == REG_EXPAND_SZ)
            {
                WCHAR path[MAX_PATH];
                if (ExpandEnvironmentStringsW(providerPath, path, MAX_PATH)) lstrcpyW( providerPath, path );
            }

            size = 0;
            RegQueryValueExW(hKey, szProviderName, NULL, NULL, NULL, &size);
            if (size)
            {
                name = HeapAlloc(GetProcessHeap(), 0, size);
                if (RegQueryValueExW(hKey, szProviderName, NULL, &type,
                 (LPBYTE)name, &size) != ERROR_SUCCESS || type != REG_SZ)
                {
                    HeapFree(GetProcessHeap(), 0, name);
                    name = NULL;
                }
            }
            if (name)
            {
                HMODULE hLib = LoadLibraryW(providerPath);

                if (hLib)
                {
#define MPR_GETPROC(proc) ((PF_##proc)GetProcAddress(hLib, #proc))

                    PF_NPGetCaps getCaps = MPR_GETPROC(NPGetCaps);

                    TRACE("loaded lib %p\n", hLib);
                    if (getCaps)
                    {
                        DWORD connectCap;
                        PWNetProvider provider =
                         &providerTable->table[providerTable->numProviders];

                        provider->hLib = hLib;
                        provider->name = name;
                        TRACE("name is %s\n", debugstr_w(name));
                        provider->getCaps = getCaps;
                        provider->dwSpecVersion = getCaps(WNNC_SPEC_VERSION);
                        provider->dwNetType = getCaps(WNNC_NET_TYPE);
                        TRACE("net type is 0x%08x\n", provider->dwNetType);
                        provider->dwEnumScopes = getCaps(WNNC_ENUMERATION);
                        if (provider->dwEnumScopes)
                        {
                            TRACE("supports enumeration\n");
                            provider->openEnum = MPR_GETPROC(NPOpenEnum);
                            TRACE("NPOpenEnum %p\n", provider->openEnum);
                            provider->enumResource = MPR_GETPROC(NPEnumResource);
                            TRACE("NPEnumResource %p\n", provider->enumResource);
                            provider->closeEnum = MPR_GETPROC(NPCloseEnum);
                            TRACE("NPCloseEnum %p\n", provider->closeEnum);
                            provider->getResourceInformation = MPR_GETPROC(NPGetResourceInformation);
                            TRACE("NPGetResourceInformation %p\n", provider->getResourceInformation);
                            if (!provider->openEnum ||
                                !provider->enumResource ||
                                !provider->closeEnum)
                            {
                                provider->openEnum = NULL;
                                provider->enumResource = NULL;
                                provider->closeEnum = NULL;
                                provider->dwEnumScopes = 0;
                                WARN("Couldn't load enumeration functions\n");
                            }
                        }
                        connectCap = getCaps(WNNC_CONNECTION);
                        if (connectCap & WNNC_CON_ADDCONNECTION)
                            provider->addConnection = MPR_GETPROC(NPAddConnection);
                        if (connectCap & WNNC_CON_ADDCONNECTION3)
                            provider->addConnection3 = MPR_GETPROC(NPAddConnection3);
                        if (connectCap & WNNC_CON_CANCELCONNECTION)
                            provider->cancelConnection = MPR_GETPROC(NPCancelConnection);
#ifdef __REACTOS__
                        if (connectCap & WNNC_CON_GETCONNECTIONS)
                            provider->getConnection = MPR_GETPROC(NPGetConnection);
#endif
                        TRACE("NPAddConnection %p\n", provider->addConnection);
                        TRACE("NPAddConnection3 %p\n", provider->addConnection3);
                        TRACE("NPCancelConnection %p\n", provider->cancelConnection);
                        providerTable->numProviders++;
                    }
                    else
                    {
                        WARN("Provider %s didn't export NPGetCaps\n",
                         debugstr_w(provider));
                        HeapFree(GetProcessHeap(), 0, name);
                        FreeLibrary(hLib);
                    }

#undef MPR_GETPROC
                }
                else
                {
                    WARN("Couldn't load library %s for provider %s\n",
                     debugstr_w(providerPath), debugstr_w(provider));
                    HeapFree(GetProcessHeap(), 0, name);
                }
            }
            else
            {
                WARN("Couldn't get provider name for provider %s\n",
                 debugstr_w(provider));
            }
        }
        else
            WARN("Couldn't open value %s\n", debugstr_w(szProviderPath));
        RegCloseKey(hKey);
    }
    else
        WARN("Couldn't open service key for provider %s\n",
         debugstr_w(provider));
}

Referenced by wnetInit().

free_netresourceW()

static void free_netresourceW ( NETRESOURCEW *  resource )

static

Definition at line 2338 of file wnet.c.

{
    HeapFree(GetProcessHeap(), 0, resource->lpLocalName);
    HeapFree(GetProcessHeap(), 0, resource->lpRemoteName);
    HeapFree(GetProcessHeap(), 0, resource->lpComment);
    HeapFree(GetProcessHeap(), 0, resource->lpProvider);
}

Referenced by WNetUseConnectionA().

get_drive_connection()

static DWORD get_drive_connection ( WCHAR  letter, LPWSTR  remote, LPDWORD  size  )

static

Definition at line 2581 of file wnet.c.

{
#ifndef __REACTOS__
    char buffer[1024];
    struct mountmgr_unix_drive *data = (struct mountmgr_unix_drive *)buffer;
    HANDLE mgr;
    DWORD ret = WN_NOT_CONNECTED;
    DWORD bytes_returned;

    if ((mgr = CreateFileW( MOUNTMGR_DOS_DEVICE_NAME, GENERIC_READ|GENERIC_WRITE,
                            FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING,
                            0, 0 )) == INVALID_HANDLE_VALUE)
    {
        ERR( "failed to open mount manager err %u\n", GetLastError() );
        return ret;
    }
    memset( data, 0, sizeof(*data) );
    data->letter = letter;
    if (DeviceIoControl( mgr, IOCTL_MOUNTMGR_QUERY_UNIX_DRIVE, data, sizeof(*data),
                         data, sizeof(buffer), &bytes_returned, NULL ))
    {
        char *p, *mount_point = buffer + data->mount_point_offset;
        DWORD len;

        if (data->mount_point_offset && !strncmp( mount_point, "unc/", 4 ))
        {
            mount_point += 2;
            mount_point[0] = '\\';
            for (p = mount_point; *p; p++) if (*p == '/') *p = '\\';

            len = MultiByteToWideChar( CP_UNIXCP, 0, mount_point, -1, NULL, 0 );
            if (len > *size)
            {
                *size = len;
                ret = WN_MORE_DATA;
            }
            else
            {
                *size = MultiByteToWideChar( CP_UNIXCP, 0, mount_point, -1, remote, *size);
                ret = WN_SUCCESS;
            }
        }
    }
    CloseHandle( mgr );
    return ret;
#else
    DWORD ret = WN_NO_NETWORK;
    DWORD index;
    WCHAR local[3] = {letter, ':', 0};

    if (providerTable != NULL)
    {
        for (index = 0; index < providerTable->numProviders; index++)
        {
            if(providerTable->table[index].getCaps(WNNC_CONNECTION) &
                WNNC_CON_GETCONNECTIONS)
            {
                if (providerTable->table[index].getConnection)
                    ret = providerTable->table[index].getConnection(
                        local, remote, size);
                else
                    ret = WN_NO_NETWORK;
                if (ret == WN_SUCCESS || ret == WN_MORE_DATA)
                    break;
            }
        }
    }
    if (ret)
        SetLastError(ret);
    return ret;
#endif
}

Referenced by WNetGetConnectionW().

get_reg_str()

static WCHAR* get_reg_str ( HKEY  hkey, const WCHAR *  value, DWORD *  len  )

static

Definition at line 1545 of file wnet.c.

{
    DWORD type;
    WCHAR *ret = NULL;

    if (!RegQueryValueExW(hkey, value, NULL, &type, NULL, len) && type == REG_SZ)
    {
        if (!(ret = HeapAlloc(GetProcessHeap(), 0, *len))) return NULL;
        RegQueryValueExW(hkey, value, 0, 0, (BYTE *)ret, len);
    }

    return ret;
}

Referenced by _enumeratorRememberedW().

netresource_a_to_w()

static void netresource_a_to_w ( NETRESOURCEA *  resourceA, NETRESOURCEW *  resourceW  )

static

Definition at line 2326 of file wnet.c.

{
    resourceW->dwScope = resourceA->dwScope;
    resourceW->dwType = resourceA->dwType;
    resourceW->dwDisplayType = resourceA->dwDisplayType;
    resourceW->dwUsage = resourceA->dwUsage;
    resourceW->lpLocalName = strdupAtoW(resourceA->lpLocalName);
    resourceW->lpRemoteName = strdupAtoW(resourceA->lpRemoteName);
    resourceW->lpComment = strdupAtoW(resourceA->lpComment);
    resourceW->lpProvider = strdupAtoW(resourceA->lpProvider);
}

Referenced by WNetUseConnectionA().

strdupAtoW()

static LPWSTR strdupAtoW ( LPCSTR  str )

static

Definition at line 2314 of file wnet.c.

{
    LPWSTR ret;
    INT len;

    if (!str) return NULL;
    len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
    ret = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
    if (ret) MultiByteToWideChar( CP_ACP, 0, str, -1, ret, len );
    return ret;
}

Referenced by netresource_a_to_w(), WNetCancelConnection2A(), and WNetUseConnectionA().

use_connection_pre_set_accessnameA()

static DWORD use_connection_pre_set_accessnameA ( struct use_connection_context *  ctxt, WCHAR *  local_name  )

static

Definition at line 2278 of file wnet.c.

{
    if (ctxt->accessname && ctxt->buffer_size && *ctxt->buffer_size)
    {
        DWORD len;

        if (local_name)
            len = WideCharToMultiByte(CP_ACP, 0, local_name, -1, NULL, 0, NULL, NULL) - 1;
        else
            len = strlen(ctxt->resourceA->lpRemoteName);

        if (++len > *ctxt->buffer_size)
        {
            *ctxt->buffer_size = len;
            return ERROR_MORE_DATA;
        }
    }
    else
        ctxt->accessname = NULL;

    return ERROR_SUCCESS;
}

Referenced by WNetUseConnectionA().

use_connection_pre_set_accessnameW()

static DWORD use_connection_pre_set_accessnameW ( struct use_connection_context *  ctxt, WCHAR *  local_name  )

static

Definition at line 2091 of file wnet.c.

{
    if (ctxt->accessname && ctxt->buffer_size && *ctxt->buffer_size)
    {
        DWORD len;

        if (local_name)
            len = lstrlenW(local_name);
        else
            len = lstrlenW(ctxt->resource->lpRemoteName);

        if (++len > *ctxt->buffer_size)
        {
            *ctxt->buffer_size = len;
            return ERROR_MORE_DATA;
        }
    }
    else
        ctxt->accessname = NULL;

    return ERROR_SUCCESS;
}

Referenced by WNetUseConnectionW().

use_connection_set_accessnameA()

static void use_connection_set_accessnameA ( struct use_connection_context *  ctxt, WCHAR *  local_name  )

static

Definition at line 2301 of file wnet.c.

{
    char *accessname = ctxt->accessname;
    if (local_name)
    {
        WideCharToMultiByte(CP_ACP, 0, local_name, -1, accessname, *ctxt->buffer_size, NULL, NULL);
        if (ctxt->result)
            *ctxt->result = CONNECT_LOCALDRIVE;
    }
    else
        strcpy(accessname, ctxt->resourceA->lpRemoteName);
}

Referenced by WNetUseConnectionA().

use_connection_set_accessnameW()

static void use_connection_set_accessnameW ( struct use_connection_context *  ctxt, WCHAR *  local_name  )

static

Definition at line 2114 of file wnet.c.

{
    WCHAR *accessname = ctxt->accessname;
    if (local_name)
    {
        lstrcpyW(accessname, local_name);
        if (ctxt->result)
            *ctxt->result = CONNECT_LOCALDRIVE;
    }
    else
        lstrcpyW(accessname, ctxt->resource->lpRemoteName);
}

Referenced by WNetUseConnectionW().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

mpr

)

wnet_use_connection()

static DWORD wnet_use_connection ( struct use_connection_context *  ctxt )

static

Definition at line 2156 of file wnet.c.

{
    WNetProvider *provider = NULL;
    DWORD index, ret = WN_NO_NETWORK;
    BOOL redirect = FALSE;
    WCHAR letter[3] = {'Z', ':', 0};
    NETRESOURCEW netres;

    if (!providerTable || providerTable->numProviders == 0)
        return WN_NO_NETWORK;

    if (!ctxt->resource)
        return ERROR_INVALID_PARAMETER;
    netres = *ctxt->resource;

    if (!netres.lpLocalName && (ctxt->flags & CONNECT_REDIRECT))
    {
        if (netres.dwType != RESOURCETYPE_DISK && netres.dwType != RESOURCETYPE_PRINT)
            return ERROR_BAD_DEV_TYPE;

        if (netres.dwType == RESOURCETYPE_PRINT)
        {
            FIXME("Local device selection is not implemented for printers.\n");
            return WN_NO_NETWORK;
        }

        redirect = TRUE;
        netres.lpLocalName = letter;
    }

    if (ctxt->flags & CONNECT_INTERACTIVE)
        return ERROR_BAD_NET_NAME;

    if ((ret = ctxt->pre_set_accessname(ctxt, netres.lpLocalName)))
        return ret;

    if (netres.lpProvider)
    {
        index = _findProviderIndexW(netres.lpProvider);
        if (index == BAD_PROVIDER_INDEX)
            return ERROR_BAD_PROVIDER;

        provider = &providerTable->table[index];
        ret = wnet_use_provider(ctxt, &netres, provider, redirect);
    }
    else
    {
        for (index = 0; index < providerTable->numProviders; index++)
        {
            provider = &providerTable->table[index];
            ret = wnet_use_provider(ctxt, &netres, provider, redirect);
            if (ret == WN_SUCCESS || ret == WN_ALREADY_CONNECTED)
                break;
        }
    }

    if (ret == WN_SUCCESS && ctxt->flags & CONNECT_UPDATE_PROFILE)
    {
        HKEY user_profile;

        if (netres.dwType == RESOURCETYPE_PRINT)
        {
            FIXME("Persistent connection are not supported for printers\n");
            return ret;
        }

        if (RegOpenCurrentUser(KEY_ALL_ACCESS, &user_profile) == ERROR_SUCCESS)
        {
            HKEY network;
            WCHAR subkey[10] = {'N', 'e', 't', 'w', 'o', 'r', 'k', '\\', netres.lpLocalName[0], 0};

            if (RegCreateKeyExW(user_profile, subkey, 0, NULL, REG_OPTION_NON_VOLATILE,
                                KEY_ALL_ACCESS, NULL, &network, NULL) == ERROR_SUCCESS)
            {
                DWORD dword_arg = RESOURCETYPE_DISK;
                DWORD len = (lstrlenW(provider->name) + 1) * sizeof(WCHAR);
                static const WCHAR empty[1] = {0};

                RegSetValueExW(network, connectionType, 0, REG_DWORD, (const BYTE *)&dword_arg, sizeof(DWORD));
                RegSetValueExW(network, providerName, 0, REG_SZ, (const BYTE *)provider->name, len);
                RegSetValueExW(network, providerType, 0, REG_DWORD, (const BYTE *)&provider->dwNetType, sizeof(DWORD));
                len = (lstrlenW(netres.lpRemoteName) + 1) * sizeof(WCHAR);
                RegSetValueExW(network, remotePath, 0, REG_SZ, (const BYTE *)netres.lpRemoteName, len);
                len = sizeof(empty);
                RegSetValueExW(network, userName, 0, REG_SZ, (const BYTE *)empty, len);
                RegCloseKey(network);
            }

            RegCloseKey(user_profile);
        }
    }

    return ret;
}

Referenced by WNetUseConnectionA(), and WNetUseConnectionW().

wnet_use_provider()

static DWORD wnet_use_provider ( struct use_connection_context *  ctxt, NETRESOURCEW *  netres, WNetProvider *  provider, BOOLEAN  redirect  )

static

Definition at line 2127 of file wnet.c.

{
    DWORD caps, ret;

    caps = provider->getCaps(WNNC_CONNECTION);
    if (!(caps & (WNNC_CON_ADDCONNECTION | WNNC_CON_ADDCONNECTION3)))
        return ERROR_BAD_PROVIDER;

    ret = WN_ACCESS_DENIED;
    do
    {
        if ((caps & WNNC_CON_ADDCONNECTION3) && provider->addConnection3)
            ret = provider->addConnection3(ctxt->hwndOwner, netres, ctxt->password, ctxt->userid, ctxt->flags);
        else if ((caps & WNNC_CON_ADDCONNECTION) && provider->addConnection)
            ret = provider->addConnection(netres, ctxt->password, ctxt->userid);

        if (ret == WN_ALREADY_CONNECTED && redirect)
            netres->lpLocalName[0] -= 1;
    } while (redirect && ret == WN_ALREADY_CONNECTED && netres->lpLocalName[0] >= 'C');

    if (ret == WN_SUCCESS && ctxt->accessname)
        ctxt->set_accessname(ctxt, netres->lpLocalName);

    return ret;
}

Referenced by wnet_use_connection().

WNetAddConnection2A()

DWORD WINAPI WNetAddConnection2A	(	LPNETRESOURCEA	lpNetResource,
		LPCSTR	lpPassword,
		LPCSTR	lpUserID,
		DWORD	dwFlags
	)

Definition at line 2035 of file wnet.c.

{
    return WNetUseConnectionA(NULL, lpNetResource, lpPassword, lpUserID, dwFlags,
                              NULL, 0, NULL);
}

WNetAddConnection2W()

DWORD WINAPI WNetAddConnection2W	(	LPNETRESOURCEW	lpNetResource,
		LPCWSTR	lpPassword,
		LPCWSTR	lpUserID,
		DWORD	dwFlags
	)

Definition at line 2046 of file wnet.c.

{
    return WNetUseConnectionW(NULL, lpNetResource, lpPassword, lpUserID, dwFlags,
                              NULL, 0, NULL);
}

WNetAddConnection3A()

DWORD WINAPI WNetAddConnection3A	(	HWND	hwndOwner,
		LPNETRESOURCEA	lpNetResource,
		LPCSTR	lpPassword,
		LPCSTR	lpUserID,
		DWORD	dwFlags
	)

Definition at line 2057 of file wnet.c.

{
    return WNetUseConnectionA(hwndOwner, lpNetResource, lpPassword, lpUserID,
                              dwFlags, NULL, 0, NULL);
}

WNetAddConnection3W()

DWORD WINAPI WNetAddConnection3W	(	HWND	hwndOwner,
		LPNETRESOURCEW	lpNetResource,
		LPCWSTR	lpPassword,
		LPCWSTR	lpUserID,
		DWORD	dwFlags
	)

Definition at line 2068 of file wnet.c.

{
    return WNetUseConnectionW(hwndOwner, lpNetResource, lpPassword, lpUserID,
                              dwFlags, NULL, 0, NULL);
}

WNetAddConnectionA()

DWORD WINAPI WNetAddConnectionA	(	LPCSTR	lpRemoteName,
		LPCSTR	lpPassword,
		LPCSTR	lpLocalName
	)

Definition at line 2007 of file wnet.c.

{
    NETRESOURCEA resourcesA;

    memset(&resourcesA, 0, sizeof(resourcesA));
    resourcesA.lpRemoteName = (LPSTR)lpRemoteName;
    resourcesA.lpLocalName = (LPSTR)lpLocalName;
    return WNetUseConnectionA(NULL, &resourcesA, lpPassword, NULL, 0, NULL, 0, NULL);
}

WNetAddConnectionW()

DWORD WINAPI WNetAddConnectionW	(	LPCWSTR	lpRemoteName,
		LPCWSTR	lpPassword,
		LPCWSTR	lpLocalName
	)

Definition at line 2021 of file wnet.c.

{
    NETRESOURCEW resourcesW;

    memset(&resourcesW, 0, sizeof(resourcesW));
    resourcesW.lpRemoteName = (LPWSTR)lpRemoteName;
    resourcesW.lpLocalName = (LPWSTR)lpLocalName;
    return WNetUseConnectionW(NULL, &resourcesW, lpPassword, NULL, 0, NULL, 0, NULL);
}

WNetCancelConnection2A()

DWORD WINAPI WNetCancelConnection2A	(	LPCSTR	lpName,
		DWORD	dwFlags,
		BOOL	fForce
	)

Definition at line 2402 of file wnet.c.

{
    DWORD ret;
    WCHAR * name = strdupAtoW(lpName);
    if (!name)
        return ERROR_NOT_CONNECTED;

    ret = WNetCancelConnection2W(name, dwFlags, fForce);
    HeapFree(GetProcessHeap(), 0, name);

    return ret;
}

Referenced by WNetCancelConnectionA().

WNetCancelConnection2W()

DWORD WINAPI WNetCancelConnection2W	(	LPCWSTR	lpName,
		DWORD	dwFlags,
		BOOL	fForce
	)

Definition at line 2418 of file wnet.c.

{
    DWORD ret = WN_NO_NETWORK;
    DWORD index;

    if (providerTable != NULL)
    {
        for (index = 0; index < providerTable->numProviders; index++)
        {
            if(providerTable->table[index].getCaps(WNNC_CONNECTION) &
                WNNC_CON_CANCELCONNECTION)
            {
                if (providerTable->table[index].cancelConnection)
                    ret = providerTable->table[index].cancelConnection((LPWSTR)lpName, fForce);
                else
                    ret = WN_NO_NETWORK;
                if (ret == WN_SUCCESS || ret == WN_OPEN_FILES)
                    break;
            }
        }
    }

    if (ret == WN_SUCCESS && dwFlags & CONNECT_UPDATE_PROFILE)
    {
        HKEY user_profile;

        /* FIXME: Only remove it if that's a drive letter */
        if (iswalpha(lpName[0]) && lpName[1] == ':' &&
            RegOpenCurrentUser(KEY_ALL_ACCESS, &user_profile) == ERROR_SUCCESS)
        {
            WCHAR subkey[10] = {'N', 'e', 't', 'w', 'o', 'r', 'k', '\\', lpName[0], 0};

            RegDeleteKeyW(user_profile, subkey);

            RegCloseKey(user_profile);
        }
    }

    return ret;
}

Referenced by DrivesContextMenuCallback(), WNetCancelConnection2A(), WNetCancelConnectionW(), and WNetClearConnections().

WNetCancelConnectionA()

DWORD WINAPI WNetCancelConnectionA	(	LPCSTR	lpName,
		BOOL	fForce
	)

Definition at line 2386 of file wnet.c.

{
    return WNetCancelConnection2A(lpName, 0, fForce);
}

Referenced by test_WNetUseConnection().

WNetCancelConnectionW()

DWORD WINAPI WNetCancelConnectionW	(	LPCWSTR	lpName,
		BOOL	fForce
	)

Definition at line 2394 of file wnet.c.

{
    return WNetCancelConnection2W(lpName, 0, fForce);
}

WNetClearConnections()

DWORD WINAPI WNetClearConnections

(

HWND

owner

)

Definition at line 2825 of file wnet.c.

{
    HANDLE connected;
    PWSTR connection;
    DWORD ret, size, count;
    NETRESOURCEW * resources, * iter;

    ret = WNetOpenEnumW(RESOURCE_CONNECTED, RESOURCETYPE_ANY, 0, NULL, &connected);
    if (ret != WN_SUCCESS)
    {
        if (ret != WN_NO_NETWORK)
        {
            return ret;
        }

        /* Means no provider, then, clearing is OK */
        return WN_SUCCESS;
    }

    size = 0x1000;
    resources = HeapAlloc(GetProcessHeap(), 0, size);
    if (!resources)
    {
        WNetCloseEnum(connected);
        return WN_OUT_OF_MEMORY;
    }

    for (;;)
    {
        size = 0x1000;
        count = -1;

        memset(resources, 0, size);
        ret = WNetEnumResourceW(connected, &count, resources, &size);
        if (ret == WN_SUCCESS || ret == WN_MORE_DATA)
        {
            for (iter = resources; count; count--, iter++)
            {
                if (iter->lpLocalName && iter->lpLocalName[0])
                    connection = iter->lpLocalName;
                else
                    connection = iter->lpRemoteName;

                WNetCancelConnection2W(connection, 0, TRUE);
            }
        }
        else
            break;
    }

    HeapFree(GetProcessHeap(), 0, resources);
    WNetCloseEnum(connected);

    return ret;
}

Referenced by LogoffShutdownThread().

WNetCloseEnum()

DWORD WINAPI WNetCloseEnum

(

HANDLE

hEnum

)

Definition at line 1760 of file wnet.c.

{
    DWORD ret, index;
    HANDLE *handles;

    TRACE( "(%p)\n", hEnum );

    if (hEnum)
    {
        PWNetEnumerator enumerator = (PWNetEnumerator)hEnum;

        switch (enumerator->enumType)
        {
            case WNET_ENUMERATOR_TYPE_GLOBAL:
                if (enumerator->specific.net)
                    _freeEnumNetResource(enumerator->specific.net);
                if (enumerator->handle)
                    providerTable->table[enumerator->providerIndex].
                     closeEnum(enumerator->handle);
                ret = WN_SUCCESS;
                break;
            case WNET_ENUMERATOR_TYPE_PROVIDER:
                if (enumerator->handle)
                    providerTable->table[enumerator->providerIndex].
                     closeEnum(enumerator->handle);
                ret = WN_SUCCESS;
                break;
            case WNET_ENUMERATOR_TYPE_CONNECTED:
                handles = enumerator->specific.handles;
                for (index = 0; index < providerTable->numProviders; index++)
                {
                    if (providerTable->table[index].dwEnumScopes && handles[index])
                        providerTable->table[index].closeEnum(handles[index]);
                }
                HeapFree(GetProcessHeap(), 0, handles);
                ret = WN_SUCCESS;
                break;
            case WNET_ENUMERATOR_TYPE_REMEMBERED:
                RegCloseKey(enumerator->specific.remembered.registry);
                ret = WN_SUCCESS;
                break;
            default:
                WARN("bogus enumerator type!\n");
                ret = WN_BAD_HANDLE;
        }
        HeapFree(GetProcessHeap(), 0, hEnum);
    }
    else
        ret = WN_BAD_HANDLE;
    if (ret)
        SetLastError(ret);
    TRACE("Returning %d\n", ret);
    return ret;
}

Referenced by EnumerateConnectedDrives(), EnumerateConnections(), CNetFolderEnum::EnumerateRec(), np_enum(), RestoreAllConnections(), and WNetClearConnections().

WNetConnectionDialog()

DWORD WINAPI WNetConnectionDialog	(	HWND	hwnd,
		DWORD	dwType
	)

Definition at line 2911 of file wnet.c.

{
    CONNECTDLGSTRUCTW conn_dlg;
    NETRESOURCEW net_res;

    ZeroMemory(&conn_dlg, sizeof(conn_dlg));
    ZeroMemory(&net_res, sizeof(net_res));

    conn_dlg.cbStructure = sizeof(conn_dlg);
    conn_dlg.lpConnRes = &net_res;
    conn_dlg.hwndOwner = hwnd;
    net_res.dwType = dwType;

    return WNetConnectionDialog1W(&conn_dlg);
}

Referenced by FrameWndProc(), and CShellBrowser::OnMapNetworkDrive().

WNetConnectionDialog1A()

DWORD WINAPI WNetConnectionDialog1A

(

LPCONNECTDLGSTRUCTA

lpConnDlgStruct

)

Definition at line 2930 of file wnet.c.

{
    FIXME( "(%p): stub\n", lpConnDlgStruct );

    SetLastError(WN_NO_NETWORK);
    return WN_NO_NETWORK;
}

WNetConnectionDialog1W()

DWORD WINAPI WNetConnectionDialog1W

(

LPCONNECTDLGSTRUCTW

lpConnDlgStruct

)

Definition at line 2941 of file wnet.c.

{
    FIXME( "(%p): stub\n", lpConnDlgStruct );

    SetLastError(WN_NO_NETWORK);
    return WN_NO_NETWORK;
}

Referenced by WNetConnectionDialog().

WNetDisconnectDialog()

DWORD WINAPI WNetDisconnectDialog	(	HWND	hwnd,
		DWORD	dwType
	)

Definition at line 2952 of file wnet.c.

{
#ifdef __REACTOS__
    DWORD dwRet;
    HMODULE hDll = LoadLibraryW(L"netplwiz.dll");
    static BOOL (WINAPI *pSHDisconnectNetDrives)(PVOID);
    pSHDisconnectNetDrives = (VOID *) GetProcAddress(hDll, "SHDisconnectNetDrives");
    
    dwRet = pSHDisconnectNetDrives(NULL);
    
    FreeLibrary(hDll);
    return dwRet;
#else
    FIXME( "(%p, %08X): stub\n", hwnd, dwType );

    SetLastError(WN_NO_NETWORK);
    return WN_NO_NETWORK;
#endif
}

Referenced by FrameWndProc(), and CShellBrowser::OnDisconnectNetworkDrive().

WNetDisconnectDialog1A()

DWORD WINAPI WNetDisconnectDialog1A

(

LPDISCDLGSTRUCTA

lpConnDlgStruct

)

Definition at line 2975 of file wnet.c.

{
    FIXME( "(%p): stub\n", lpConnDlgStruct );

    SetLastError(WN_NO_NETWORK);
    return WN_NO_NETWORK;
}

WNetDisconnectDialog1W()

DWORD WINAPI WNetDisconnectDialog1W

(

LPDISCDLGSTRUCTW

lpConnDlgStruct

)

Definition at line 2986 of file wnet.c.

{
    FIXME( "(%p): stub\n", lpConnDlgStruct );

    SetLastError(WN_NO_NETWORK);
    return WN_NO_NETWORK;
}

WNetEnumResourceA()

DWORD WINAPI WNetEnumResourceA	(	HANDLE	hEnum,
		LPDWORD	lpcCount,
		LPVOID	lpBuffer,
		LPDWORD	lpBufferSize
	)

Definition at line 1050 of file wnet.c.

{
    DWORD ret;

    TRACE( "(%p, %p, %p, %p)\n", hEnum, lpcCount, lpBuffer, lpBufferSize );

    if (!hEnum)
        ret = WN_BAD_POINTER;
    else if (!lpcCount)
        ret = WN_BAD_POINTER;
    else if (!lpBuffer)
        ret = WN_BAD_POINTER;
    else if (!lpBufferSize)
        ret = WN_BAD_POINTER;
    else if (*lpBufferSize < sizeof(NETRESOURCEA))
    {
        *lpBufferSize = sizeof(NETRESOURCEA);
        ret = WN_MORE_DATA;
    }
    else
    {
        DWORD localCount = *lpcCount, localSize = *lpBufferSize;
        LPVOID localBuffer = HeapAlloc(GetProcessHeap(), 0, localSize);

        if (localBuffer)
        {
            ret = WNetEnumResourceW(hEnum, &localCount, localBuffer,
             &localSize);
            if (ret == WN_SUCCESS || (ret == WN_MORE_DATA && localCount != -1))
            {
                /* FIXME: this isn't necessarily going to work in the case of
                 * WN_MORE_DATA, because our enumerator may have moved on to
                 * the next provider.  MSDN states that a large (16KB) buffer
                 * size is the appropriate usage of this function, so
                 * hopefully it won't be an issue.
                 */
                ret = _thunkNetResourceArrayWToA(localBuffer, &localCount,
                 lpBuffer, lpBufferSize);
                *lpcCount = localCount;
            }
            HeapFree(GetProcessHeap(), 0, localBuffer);
        }
        else
            ret = WN_OUT_OF_MEMORY;
    }
    if (ret)
        SetLastError(ret);
    TRACE("Returning %d\n", ret);
    return ret;
}

WNetEnumResourceW()

DWORD WINAPI WNetEnumResourceW	(	HANDLE	hEnum,
		LPDWORD	lpcCount,
		LPVOID	lpBuffer,
		LPDWORD	lpBufferSize
	)

Definition at line 1700 of file wnet.c.

{
    DWORD ret;

    TRACE( "(%p, %p, %p, %p)\n", hEnum, lpcCount, lpBuffer, lpBufferSize );

    if (!hEnum)
        ret = WN_BAD_POINTER;
    else if (!lpcCount)
        ret = WN_BAD_POINTER;
    else if (!lpBuffer)
        ret = WN_BAD_POINTER;
    else if (!lpBufferSize)
        ret = WN_BAD_POINTER;
    else if (*lpBufferSize < sizeof(NETRESOURCEW))
    {
        *lpBufferSize = sizeof(NETRESOURCEW);
        ret = WN_MORE_DATA;
    }
    else
    {
        PWNetEnumerator enumerator = (PWNetEnumerator)hEnum;

        switch (enumerator->enumType)
        {
            case WNET_ENUMERATOR_TYPE_GLOBAL:
                ret = _enumerateGlobalW(enumerator, lpcCount, lpBuffer,
                 lpBufferSize);
                break;
            case WNET_ENUMERATOR_TYPE_PROVIDER:
                ret = _enumerateProviderW(enumerator, lpcCount, lpBuffer,
                 lpBufferSize);
                break;
            case WNET_ENUMERATOR_TYPE_CONTEXT:
                ret = _enumerateContextW(enumerator, lpcCount, lpBuffer,
                 lpBufferSize);
                break;
            case WNET_ENUMERATOR_TYPE_CONNECTED:
                ret = _enumerateConnectedW(enumerator, lpcCount, lpBuffer,
                 lpBufferSize);
                break;
            case WNET_ENUMERATOR_TYPE_REMEMBERED:
                ret = _enumeratorRememberedW(enumerator, lpcCount, lpBuffer,
                 lpBufferSize);
                break;
            default:
                WARN("bogus enumerator type!\n");
                ret = WN_NO_NETWORK;
        }
    }
    if (ret)
        SetLastError(ret);
    TRACE("Returning %d\n", ret);
    return ret;
}

Referenced by WNetClearConnections(), and WNetEnumResourceA().

wnetFree()

void wnetFree

(

void

)

Definition at line 490 of file wnet.c.

{
    if (providerTable)
    {
        DWORD i;

        for (i = 0; i < providerTable->numProviders; i++)
        {
            HeapFree(GetProcessHeap(), 0, providerTable->table[i].name);
            FreeModule(providerTable->table[i].hLib);
        }
        HeapFree(GetProcessHeap(), 0, providerTable->entireNetwork);
        HeapFree(GetProcessHeap(), 0, providerTable);
        providerTable = NULL;
    }
}

Referenced by DllMain().

WNetGetConnectionA()

DWORD WINAPI WNetGetConnectionA	(	LPCSTR	lpLocalName,
		LPSTR	lpRemoteName,
		LPDWORD	lpBufferSize
	)

Definition at line 2492 of file wnet.c.

{
    DWORD ret;

    if (!lpLocalName)
        ret = WN_BAD_POINTER;
    else if (!lpBufferSize)
        ret = WN_BAD_POINTER;
    else if (!lpRemoteName && *lpBufferSize)
        ret = WN_BAD_POINTER;
    else
    {
        int len = MultiByteToWideChar(CP_ACP, 0, lpLocalName, -1, NULL, 0);

        if (len)
        {
            PWSTR wideLocalName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));

            if (wideLocalName)
            {
                WCHAR wideRemoteStatic[MAX_PATH];
                DWORD wideRemoteSize = ARRAY_SIZE(wideRemoteStatic);

                MultiByteToWideChar(CP_ACP, 0, lpLocalName, -1, wideLocalName, len);

                /* try once without memory allocation */
                ret = WNetGetConnectionW(wideLocalName, wideRemoteStatic,
                 &wideRemoteSize);
                if (ret == WN_SUCCESS)
                {
                    int len = WideCharToMultiByte(CP_ACP, 0, wideRemoteStatic,
                     -1, NULL, 0, NULL, NULL);

                    if (len <= *lpBufferSize)
                    {
                        WideCharToMultiByte(CP_ACP, 0, wideRemoteStatic, -1,
                         lpRemoteName, *lpBufferSize, NULL, NULL);
                        ret = WN_SUCCESS;
                    }
                    else
                    {
                        *lpBufferSize = len;
                        ret = WN_MORE_DATA;
                    }
                }
                else if (ret == WN_MORE_DATA)
                {
                    PWSTR wideRemote = HeapAlloc(GetProcessHeap(), 0,
                     wideRemoteSize * sizeof(WCHAR));

                    if (wideRemote)
                    {
                        ret = WNetGetConnectionW(wideLocalName, wideRemote,
                         &wideRemoteSize);
                        if (ret == WN_SUCCESS)
                        {
                            if (len <= *lpBufferSize)
                            {
                                WideCharToMultiByte(CP_ACP, 0, wideRemoteStatic,
                                 -1, lpRemoteName, *lpBufferSize, NULL, NULL);
                                ret = WN_SUCCESS;
                            }
                            else
                            {
                                *lpBufferSize = len;
                                ret = WN_MORE_DATA;
                            }
                        }
                        HeapFree(GetProcessHeap(), 0, wideRemote);
                    }
                    else
                        ret = WN_OUT_OF_MEMORY;
                }
                HeapFree(GetProcessHeap(), 0, wideLocalName);
            }
            else
                ret = WN_OUT_OF_MEMORY;
        }
        else
            ret = WN_BAD_LOCALNAME;
    }
    if (ret)
        SetLastError(ret);
    TRACE("Returning %d\n", ret);
    return ret;
}

WNetGetConnectionW()

DWORD WINAPI WNetGetConnectionW	(	LPCWSTR	lpLocalName,
		LPWSTR	lpRemoteName,
		LPDWORD	lpBufferSize
	)

Definition at line 2659 of file wnet.c.

{
    DWORD ret;

    TRACE("(%s, %p, %p)\n", debugstr_w(lpLocalName), lpRemoteName,
     lpBufferSize);

    if (!lpLocalName)
        ret = WN_BAD_POINTER;
    else if (!lpBufferSize)
        ret = WN_BAD_POINTER;
    else if (!lpRemoteName && *lpBufferSize)
        ret = WN_BAD_POINTER;
    else if (!lpLocalName[0])
        ret = WN_BAD_LOCALNAME;
    else
    {
        if (lpLocalName[1] == ':')
        {
            switch(GetDriveTypeW(lpLocalName))
            {
            case DRIVE_REMOTE:
                ret = get_drive_connection( lpLocalName[0], lpRemoteName, lpBufferSize );
                break;
            case DRIVE_REMOVABLE:
            case DRIVE_FIXED:
            case DRIVE_CDROM:
                TRACE("file is local\n");
                ret = WN_NOT_CONNECTED;
                break;
            default:
                ret = WN_BAD_LOCALNAME;
            }
        }
        else
            ret = WN_BAD_LOCALNAME;
    }
    if (ret)
        SetLastError(ret);
    TRACE("Returning %d\n", ret);
    return ret;
}

Referenced by WNetGetConnectionA().

WNetGetLastErrorA()

DWORD WINAPI WNetGetLastErrorA	(	LPDWORD	lpError,
		LPSTR	lpErrorBuf,
		DWORD	nErrorBufSize,
		LPSTR	lpNameBuf,
		DWORD	nNameBufSize
	)

Definition at line 2997 of file wnet.c.

{
    FIXME( "(%p, %p, %d, %p, %d): stub\n",
           lpError, lpErrorBuf, nErrorBufSize, lpNameBuf, nNameBufSize );

    SetLastError(WN_NO_NETWORK);
    return WN_NO_NETWORK;
}

WNetGetLastErrorW()

DWORD WINAPI WNetGetLastErrorW	(	LPDWORD	lpError,
		LPWSTR	lpErrorBuf,
		DWORD	nErrorBufSize,
		LPWSTR	lpNameBuf,
		DWORD	nNameBufSize
	)

Definition at line 3011 of file wnet.c.

{
    FIXME( "(%p, %p, %d, %p, %d): stub\n",
           lpError, lpErrorBuf, nErrorBufSize, lpNameBuf, nNameBufSize );

    SetLastError(WN_NO_NETWORK);
    return WN_NO_NETWORK;
}

Referenced by display_network_error(), and WNetGetLastErrorWrapW().

WNetGetNetworkInformationA()

DWORD WINAPI WNetGetNetworkInformationA	(	LPCSTR	lpProvider,
		LPNETINFOSTRUCT	lpNetInfoStruct
	)

Definition at line 3025 of file wnet.c.

{
    DWORD ret;

    TRACE( "(%s, %p)\n", debugstr_a(lpProvider), lpNetInfoStruct );

    if (!lpProvider)
        ret = WN_BAD_POINTER;
    else
    {
        int len;

        len = MultiByteToWideChar(CP_ACP, 0, lpProvider, -1, NULL, 0);
        if (len)
        {
            LPWSTR wideProvider = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));

            if (wideProvider)
            {
                MultiByteToWideChar(CP_ACP, 0, lpProvider, -1, wideProvider,
                 len);
                ret = WNetGetNetworkInformationW(wideProvider, lpNetInfoStruct);
                HeapFree(GetProcessHeap(), 0, wideProvider);
            }
            else
                ret = WN_OUT_OF_MEMORY;
        }
        else
            ret = GetLastError();
    }
    if (ret)
        SetLastError(ret);
    TRACE("Returning %d\n", ret);
    return ret;
}

WNetGetNetworkInformationW()

DWORD WINAPI WNetGetNetworkInformationW	(	LPCWSTR	lpProvider,
		LPNETINFOSTRUCT	lpNetInfoStruct
	)

Definition at line 3065 of file wnet.c.

{
    DWORD ret;

    TRACE( "(%s, %p)\n", debugstr_w(lpProvider), lpNetInfoStruct );

    if (!lpProvider)
        ret = WN_BAD_POINTER;
    else if (!lpNetInfoStruct)
        ret = WN_BAD_POINTER;
    else if (lpNetInfoStruct->cbStructure < sizeof(NETINFOSTRUCT))
        ret = WN_BAD_VALUE;
    else
    {
        if (providerTable && providerTable->numProviders)
        {
            DWORD providerIndex = _findProviderIndexW(lpProvider);

            if (providerIndex != BAD_PROVIDER_INDEX)
            {
                lpNetInfoStruct->cbStructure = sizeof(NETINFOSTRUCT);
                lpNetInfoStruct->dwProviderVersion =
                 providerTable->table[providerIndex].dwSpecVersion;
                lpNetInfoStruct->dwStatus = NO_ERROR;
                lpNetInfoStruct->dwCharacteristics = 0;
                lpNetInfoStruct->dwHandle = 0;
                lpNetInfoStruct->wNetType =
                 HIWORD(providerTable->table[providerIndex].dwNetType);
                lpNetInfoStruct->dwPrinters = -1;
                lpNetInfoStruct->dwDrives = -1;
                ret = WN_SUCCESS;
            }
            else
                ret = WN_BAD_PROVIDER;
        }
        else
            ret = WN_NO_NETWORK;
    }
    if (ret)
        SetLastError(ret);
    TRACE("Returning %d\n", ret);
    return ret;
}

Referenced by WNetGetNetworkInformationA().

WNetGetProviderNameA()

DWORD WINAPI WNetGetProviderNameA	(	DWORD	dwNetType,
		LPSTR	lpProvider,
		LPDWORD	lpBufferSize
	)

Definition at line 3113 of file wnet.c.

{
    DWORD ret;

    TRACE("(0x%08x, %s, %p)\n", dwNetType, debugstr_a(lpProvider),
     lpBufferSize);

    if (!lpProvider)
        ret = WN_BAD_POINTER;
    else if (!lpBufferSize)
        ret = WN_BAD_POINTER;
    else
    {
        if (providerTable)
        {
            DWORD i;

            ret = WN_NO_NETWORK;
            for (i = 0; i < providerTable->numProviders &&
             HIWORD(providerTable->table[i].dwNetType) != HIWORD(dwNetType);
             i++)
                ;
            if (i < providerTable->numProviders)
            {
                DWORD sizeNeeded = WideCharToMultiByte(CP_ACP, 0,
                 providerTable->table[i].name, -1, NULL, 0, NULL, NULL);

                if (*lpBufferSize < sizeNeeded)
                {
                    *lpBufferSize = sizeNeeded;
                    ret = WN_MORE_DATA;
                }
                else
                {
                    WideCharToMultiByte(CP_ACP, 0, providerTable->table[i].name,
                     -1, lpProvider, *lpBufferSize, NULL, NULL);
                    ret = WN_SUCCESS;
                    /* FIXME: is *lpBufferSize set to the number of characters
                     * copied? */
                }
            }
        }
        else
            ret = WN_NO_NETWORK;
    }
    if (ret)
        SetLastError(