Headers diff for mpr.dll between 6.0.6002.18005-Windows 6.0 and 6.1.7600.16385-Windows 7.0 versions

npapi.h (6.0.6002.18005-Windows 6.0)		npapi.h (6.1.7600.16385-Windows 7.0)

/*---------------------------------------------------------------		/*++
THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED
TO THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
PARTICULAR PURPOSE.


Copyright (C) 1991 - 2000. Microsoft Corporation. All rights reserved.		Copyright (c) Microsoft Corporation. All rights reserved.


npapi.h		Module Name:

		npapi.h

Abstract:		Abstract:

Network Provider API prototypes and manifests. A network provider		Network Provider API prototypes and manifests. A network provider

is a client of the Win32 Winnet driver. See the "NT/Win32 Network		is a client of the Win32 WNet APIs. See the "NT/Win32 Network
Provider API Specification" document for further details.		Provider API Specification" document for further details.

Environment:		Environment:

User Mode -Win32		User Mode -Win32


Notes:		--*/

This file currently contains the function typedefs that will be needed
by the winnet driver to support multiple providers using LoadLibrary.


#ifndef _NPAPI_INCLUDED		#ifndef _NPAPI_INCLUDED
#define _NPAPI_INCLUDED		#define _NPAPI_INCLUDED


		#if _MSC_VER > 1000
		#pragma once
		#endif

		#ifdef __cplusplus
		extern "C" {
		#endif

//		//
// CONNECTIONS		// CONNECTIONS
//		//

DWORD APIENTRY		DWORD APIENTRY
NPAddConnection (		NPAddConnection (

LPNETRESOURCEW lpNetResource,		__in LPNETRESOURCEW lpNetResource,
LPWSTR lpPassword,		__in_opt LPWSTR lpPassword,
LPWSTR lpUserName		__in_opt LPWSTR lpUserName
);		);


typedef DWORD (*PF_NPAddConnection) (		typedef DWORD (APIENTRY *PF_NPAddConnection) (
LPNETRESOURCEW lpNetResource,		__in LPNETRESOURCEW lpNetResource,
LPWSTR lpPassword,		__in_opt LPWSTR lpPassword,
LPWSTR lpUserName		__in_opt LPWSTR lpUserName
);		);

DWORD APIENTRY		DWORD APIENTRY
NPAddConnection3 (		NPAddConnection3 (

HWND hwndOwner,		__in_opt HWND hwndOwner,
LPNETRESOURCEW lpNetResource,		__in LPNETRESOURCEW lpNetResource,
LPTSTR lpPassword,		__in_opt LPWSTR lpPassword,
LPTSTR lpUserName,		__in_opt LPWSTR lpUserName,
DWORD dwFlags		__in DWORD dwFlags
);		);


typedef DWORD (*PF_NPAddConnection3) (		typedef DWORD (APIENTRY *PF_NPAddConnection3) (
HWND hwndOwner,		__in_opt HWND hwndOwner,
LPNETRESOURCEW lpNetResource,		__in LPNETRESOURCEW lpNetResource,
LPWSTR lpPassword,		__in_opt LPWSTR lpPassword,
LPWSTR lpUserName,		__in_opt LPWSTR lpUserName,
DWORD dwFlags		__in DWORD dwFlags
);		);

DWORD APIENTRY		DWORD APIENTRY
NPCancelConnection (		NPCancelConnection (

LPWSTR lpName,		__in LPWSTR lpName,
BOOL fForce		__in BOOL fForce
);		);
typedef DWORD (*PF_NPCancelConnection) (
LPWSTR lpName,		typedef DWORD (APIENTRY *PF_NPCancelConnection) (
BOOL fForce		__in LPWSTR lpName,
);		__in BOOL fForce
		);

DWORD APIENTRY		DWORD APIENTRY
NPGetConnection (		NPGetConnection (

LPWSTR lpLocalName,		__in LPWSTR lpLocalName,
LPWSTR lpRemoteName,		__out_ecount_opt(*lpnBufferLen) LPWSTR lpRemoteName,
LPDWORD lpnBufferLen		__inout LPDWORD lpnBufferLen
);		);
typedef DWORD (*PF_NPGetConnection) (
LPWSTR lpLocalName,		typedef DWORD (APIENTRY *PF_NPGetConnection) (
LPWSTR lpRemoteName,		__in LPWSTR lpLocalName,
LPDWORD lpnBufferLen		__out_ecount_opt(*lpnBufferLen) LPWSTR lpRemoteName,
);		__inout LPDWORD lpnBufferLen
		);

		#define WNGETCON_CONNECTED 0x00000000
		#define WNGETCON_DISCONNECTED 0x00000001

		DWORD APIENTRY
		NPGetConnection3 (
		__in LPCWSTR lpLocalName,
		__in DWORD dwLevel,
		__out_bcount(*lpBufferSize) LPVOID lpBuffer,
		__inout LPDWORD lpBufferSize
		);

		typedef DWORD (APIENTRY *PF_NPGetConnection3) (
		__in LPCWSTR lpLocalName,
		__in DWORD dwLevel,
		__out_bcount(*lpBufferSize) LPVOID lpBuffer,
		__inout LPDWORD lpBufferSize
		);

DWORD APIENTRY		DWORD APIENTRY
NPGetUniversalName (		NPGetUniversalName (

LPWSTR lpLocalPath,		__in LPCWSTR lpLocalPath,
DWORD dwInfoLevel,		__in DWORD dwInfoLevel,
LPVOID lpBuffer,		__out_bcount(*lpBufferSize) LPVOID lpBuffer,
LPDWORD lpBufferSize		__inout LPDWORD lpBufferSize
);		);
typedef DWORD (*PF_NPGetUniversalName) (
LPWSTR lpLocalPath,		typedef DWORD (APIENTRY *PF_NPGetUniversalName) (
DWORD dwInfoLevel,		__in LPCWSTR lpLocalPath,
LPVOID lpBuffer,		__in DWORD dwInfoLevel,
LPDWORD lpnBufferSize		__out_bcount(*lpnBufferSize) LPVOID lpBuffer,
);		__inout LPDWORD lpnBufferSize
		);

		DWORD APIENTRY
		NPGetConnectionPerformance (
		__in LPCWSTR lpRemoteName,
		__out LPNETCONNECTINFOSTRUCT lpNetConnectInfo
		);

		typedef DWORD (APIENTRY *PF_NPGetConnectionPerformance) (
		__in LPCWSTR lpRemoteName,
		__out LPNETCONNECTINFOSTRUCT lpNetConnectInfo
		);

DWORD APIENTRY		DWORD APIENTRY
NPOpenEnum (		NPOpenEnum (

DWORD dwScope,		__in DWORD dwScope,
DWORD dwType,		__in DWORD dwType,
DWORD dwUsage,		__in DWORD dwUsage,
LPNETRESOURCEW lpNetResource,		__in_opt LPNETRESOURCEW lpNetResource,
LPHANDLE lphEnum		__out LPHANDLE lphEnum
);		);
typedef DWORD (*PF_NPOpenEnum) (
DWORD dwScope,		typedef DWORD (APIENTRY *PF_NPOpenEnum) (
DWORD dwType,		__in DWORD dwScope,
DWORD dwUsage,		__in DWORD dwType,
LPNETRESOURCEW lpNetResource,		__in DWORD dwUsage,
LPHANDLE lphEnum		__in_opt LPNETRESOURCEW lpNetResource,
);		__out LPHANDLE lphEnum
		);

DWORD APIENTRY		DWORD APIENTRY
NPEnumResource (		NPEnumResource (

HANDLE hEnum,		__in HANDLE hEnum,
LPDWORD lpcCount,		__inout LPDWORD lpcCount,
LPVOID lpBuffer,		__out_bcount(*lpBufferSize) LPVOID lpBuffer,
LPDWORD lpBufferSize		__inout LPDWORD lpBufferSize
);		);
typedef DWORD (*PF_NPEnumResource) (
HANDLE hEnum,		typedef DWORD (APIENTRY *PF_NPEnumResource) (
LPDWORD lpcCount,		__in HANDLE hEnum,
LPVOID lpBuffer,		__inout LPDWORD lpcCount,
LPDWORD lpBufferSize		__out_bcount(*lpbufferSize) LPVOID lpBuffer,
);		__inout LPDWORD lpBufferSize
		);

DWORD APIENTRY		DWORD APIENTRY
NPCloseEnum (		NPCloseEnum (

HANDLE hEnum		__in HANDLE hEnum
);		);
typedef DWORD (*PF_NPCloseEnum) (
HANDLE hEnum		typedef DWORD (APIENTRY *PF_NPCloseEnum) (
);		__in HANDLE hEnum
		);

//		//
// CAPABILITIES		// CAPABILITIES
//		//


#define WNNC_SPEC_VERSION 0x00000001		#define WNNC_SPEC_VERSION 0x00000001
#define WNNC_SPEC_VERSION51 0x00050001		#define WNNC_SPEC_VERSION51 0x00050001
#define WNNC_NET_TYPE 0x00000002
#define WNNC_NET_NONE 0x00000000
/*
removed because of macro definition warnings
#define WNNC_NET_MSNET 0x00000100
#define WNNC_NET_LANMAN 0x00000200
#define WNNC_NET_NETWARE 0x00000300
#define WNNC_NET_VINES 0x00000400
*/


#define WNNC_DRIVER_VERSION 0x00000003		#define WNNC_NET_TYPE 0x00000002
		#define WNNC_NET_NONE 0x00000000


#define WNNC_USER 0x00000004		#define WNNC_DRIVER_VERSION 0x00000003
#define WNNC_USR_GETUSER 0x00000001


#define WNNC_CONNECTION 0x00000006		#define WNNC_USER 0x00000004
#define WNNC_CON_ADDCONNECTION 0x00000001		#define WNNC_USR_GETUSER 0x00000001
#define WNNC_CON_CANCELCONNECTION 0x00000002
#define WNNC_CON_GETCONNECTIONS 0x00000004
#define WNNC_CON_ADDCONNECTION3 0x00000008


#define WNNC_DIALOG 0x00000008		#define WNNC_CONNECTION 0x00000006
#define WNNC_DLG_DEVICEMODE 0x00000001		#define WNNC_CON_ADDCONNECTION 0x00000001
#define WNNC_DLG_PROPERTYDIALOG 0x00000020		#define WNNC_CON_CANCELCONNECTION 0x00000002
#define WNNC_DLG_SEARCHDIALOG 0x00000040		#define WNNC_CON_GETCONNECTIONS 0x00000004
#define WNNC_DLG_FORMATNETWORKNAME 0x00000080		#define WNNC_CON_ADDCONNECTION3 0x00000008
#define WNNC_DLG_PERMISSIONEDITOR 0x00000100		#define WNNC_CON_GETPERFORMANCE 0x00000040
		#define WNNC_CON_DEFER 0x00000080


#define WNNC_ADMIN 0x00000009		#define WNNC_DIALOG 0x00000008
#define WNNC_ADM_GETDIRECTORYTYPE 0x00000001		#define WNNC_DLG_DEVICEMODE 0x00000001
#define WNNC_ADM_DIRECTORYNOTIFY 0x00000002		#define WNNC_DLG_PROPERTYDIALOG 0x00000020
		#define WNNC_DLG_SEARCHDIALOG 0x00000040
		#define WNNC_DLG_FORMATNETWORKNAME 0x00000080
		#define WNNC_DLG_PERMISSIONEDITOR 0x00000100
		#define WNNC_DLG_GETRESOURCEPARENT 0x00000200
		#define WNNC_DLG_GETRESOURCEINFORMATION 0x00000800


#define WNNC_ENUMERATION 0x0000000B		#define WNNC_ADMIN 0x00000009
#define WNNC_ENUM_GLOBAL 0x00000001		#define WNNC_ADM_GETDIRECTORYTYPE 0x00000001
#define WNNC_ENUM_LOCAL 0x00000002		#define WNNC_ADM_DIRECTORYNOTIFY 0x00000002


#define WNNC_START 0x0000000C		#define WNNC_ENUMERATION 0x0000000B
#define WNNC_WAIT_FOR_START 0x00000001		#define WNNC_ENUM_GLOBAL 0x00000001
		#define WNNC_ENUM_LOCAL 0x00000002
		#define WNNC_ENUM_CONTEXT 0x00000004
		#define WNNC_ENUM_SHAREABLE 0x00000008

		#define WNNC_START 0x0000000C
		#define WNNC_WAIT_FOR_START 0x00000001

		#define WNNC_CONNECTION_FLAGS 0x0000000D
		#define WNNC_CF_DEFAULT ( CONNECT_TEMPORARY \| CONNECT_INTERACTIVE \| CONNECT_PROM
		PT )
		#define WNNC_CF_MAXIMUM (WNNC_CF_DEFAULT \| CONNECT_DEFERRED \| CONNECT_COMMANDLIN
		E \| CONNECT_CMD_SAVECRED \| CONNECT_CRED_RESET)

DWORD APIENTRY		DWORD APIENTRY
NPGetCaps (		NPGetCaps (

DWORD ndex		__in DWORD ndex
);		);
typedef DWORD (*PF_NPGetCaps) (
DWORD ndex		typedef DWORD (APIENTRY *PF_NPGetCaps) (
);		__in DWORD ndex
		);

//		//
// OTHER		// OTHER
//		//

DWORD APIENTRY		DWORD APIENTRY
NPGetUser (		NPGetUser (

LPWSTR lpName,		__in LPWSTR lpName,
LPWSTR lpUserName,		__out_ecount(*lpnBufferLen) LPWSTR lpUserName,
LPDWORD lpnBufferLen		__inout LPDWORD lpnBufferLen
);		);
typedef DWORD (*PF_NPGetUser) (
LPWSTR lpName,		typedef DWORD (APIENTRY *PF_NPGetUser) (
LPWSTR lpUserName,		__in LPWSTR lpName,
LPDWORD lpnBufferLen		__out_ecount(*lpnBufferLen) LPWSTR lpUserName,
);		__inout LPDWORD lpnBufferLen
		);

#define WNTYPE_DRIVE 1		#define WNTYPE_DRIVE 1
#define WNTYPE_FILE 2		#define WNTYPE_FILE 2
#define WNTYPE_PRINTER 3		#define WNTYPE_PRINTER 3
#define WNTYPE_COMM 4		#define WNTYPE_COMM 4

#define WNPS_FILE 0		#define WNPS_FILE 0
#define WNPS_DIR 1		#define WNPS_DIR 1
#define WNPS_MULT 2		#define WNPS_MULT 2

DWORD APIENTRY		DWORD APIENTRY
NPDeviceMode(		NPDeviceMode(

HWND hParent		__in HWND hParent
);		);
typedef DWORD (*PF_NPDeviceMode) (
HWND hParent		typedef DWORD (APIENTRY *PF_NPDeviceMode) (
);		__in HWND hParent
		);

// flag for search dialog		// flag for search dialog
#define WNSRCH_REFRESH_FIRST_LEVEL 0x00000001		#define WNSRCH_REFRESH_FIRST_LEVEL 0x00000001

DWORD APIENTRY		DWORD APIENTRY
NPSearchDialog(		NPSearchDialog(

HWND hwndParent,		__in HWND hwndParent,
LPNETRESOURCEW lpNetResource,		__in_opt LPNETRESOURCEW lpNetResource,
LPVOID lpBuffer,		__out_ecount(cbBuffer) LPVOID lpBuffer,
DWORD cbBuffer,		__in DWORD cbBuffer,
LPDWORD lpnFlags		__out LPDWORD lpnFlags
);		);
typedef DWORD (*PF_NPSearchDialog) (
HWND hwndParent,		typedef DWORD (APIENTRY *PF_NPSearchDialog) (
LPNETRESOURCEW lpNetResource,		__in HWND hwndParent,
LPVOID lpBuffer,		__in_opt LPNETRESOURCEW lpNetResource,
DWORD cbBuffer,		__out_ecount(cbBuffer) LPVOID lpBuffer,
LPDWORD lpnFlags		__in DWORD cbBuffer,
);		__out LPDWORD lpnFlags
		);

		DWORD APIENTRY
		NPGetResourceParent(
		__in LPNETRESOURCEW lpNetResource,
		__out_bcount(*lpBufferSize) LPVOID lpBuffer,
		__inout LPDWORD lpBufferSize
		);

		typedef DWORD (APIENTRY *PF_NPGetResourceParent) (
		__in LPNETRESOURCEW lpNetResource,
		__out_bcount(*lpBufferSize) LPVOID lpBuffer,
		__inout LPDWORD lpBufferSize
		);

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

		typedef DWORD (APIENTRY *PF_NPGetResourceInformation) (
		__in LPNETRESOURCEW lpNetResource,
		__out_bcount(*lpBufferSize) LPVOID lpBuffer,
		__inout LPDWORD lpBufferSize,
		__deref_out LPWSTR *lplpSystem
		);


/*
removed because of macro definition warnings
// flags for format network name
#define WNFMT_MULTILINE 0x00000001
#define WNFMT_ABBREVIATED 0x00000002
#define WNFMT_INENUM 0x00000010
*/
DWORD APIENTRY		DWORD APIENTRY
NPFormatNetworkName(		NPFormatNetworkName(

LPWSTR lpRemoteName,		__in LPWSTR lpRemoteName,
LPWSTR lpFormattedName,		__out_ecount(*lpnLength) LPWSTR lpFormattedName,
LPDWORD lpnLength,		__inout LPDWORD lpnLength,
DWORD dwFlags,		__in DWORD dwFlags,
DWORD dwAveCharPerLine		__in DWORD dwAveCharPerLine
);		);
typedef DWORD (*PF_NPFormatNetworkName) (
LPWSTR lpRemoteName,		typedef DWORD (APIENTRY *PF_NPFormatNetworkName) (
LPWSTR lpFormattedName,		__in LPWSTR lpRemoteName,
LPDWORD lpnLength,		__out_ecount(*lpnLength) LPWSTR lpFormattedName,
DWORD dwFlags,		__inout LPDWORD lpnLength,
DWORD dwAveCharPerLine		__in DWORD dwFlags,
);		__in DWORD dwAveCharPerLine
		);

DWORD APIENTRY		DWORD APIENTRY
NPGetPropertyText(		NPGetPropertyText(

DWORD iButton,		__in DWORD iButton,
DWORD nPropSel,		__in DWORD nPropSel,
LPWSTR lpName,		__in LPWSTR lpName,
LPWSTR lpButtonName,		__out_ecount(nButtonNameLen) LPWSTR lpButtonName,
DWORD nButtonNameLen,		__in DWORD nButtonNameLen,
DWORD nType		__in DWORD nType
);		);
typedef DWORD (*PF_NPGetPropertyText) (
DWORD iButton,		typedef DWORD (APIENTRY *PF_NPGetPropertyText) (
DWORD nPropSel,		__in DWORD iButton,
LPWSTR lpName,		__in DWORD nPropSel,
LPWSTR lpButtonName,		__in LPWSTR lpName,
DWORD nButtonNameLen,		__out_ecount(nButtonNameLen) LPWSTR lpButtonName,
DWORD nType		__in DWORD nButtonNameLen,
);		__in DWORD nType
		);

DWORD APIENTRY		DWORD APIENTRY
NPPropertyDialog(		NPPropertyDialog(

HWND hwndParent,		__in HWND hwndParent,
DWORD iButtonDlg,		__in DWORD iButtonDlg,
DWORD nPropSel,		__in DWORD nPropSel,
LPWSTR lpFileName,		__in LPWSTR lpFileName,
DWORD nType		__in DWORD nType
);		);
typedef DWORD (*PF_NPPropertyDialog) (
HWND hwndParent,		typedef DWORD (APIENTRY *PF_NPPropertyDialog) (
DWORD iButtonDlg,		__in HWND hwndParent,
DWORD nPropSel,		__in DWORD iButtonDlg,
LPWSTR lpFileName,		__in DWORD nPropSel,
DWORD nType		__in LPWSTR lpFileName,
);		__in DWORD nType
		);

//		//
// ADMIN		// ADMIN
//		//

#define WNDT_NORMAL 0		#define WNDT_NORMAL 0
#define WNDT_NETWORK 1		#define WNDT_NETWORK 1

#define WNDN_MKDIR 1		#define WNDN_MKDIR 1
#define WNDN_RMDIR 2		#define WNDN_RMDIR 2
#define WNDN_MVDIR 3		#define WNDN_MVDIR 3

DWORD APIENTRY		DWORD APIENTRY
NPGetDirectoryType (		NPGetDirectoryType (

LPWSTR lpName,		__in LPWSTR lpName,
LPINT lpType,		__in LPINT lpType,
BOOL bFlushCache		__in BOOL bFlushCache
);		);
typedef DWORD (*PF_NPGetDirectoryType) (
LPWSTR lpName,		typedef DWORD (APIENTRY *PF_NPGetDirectoryType) (
LPINT lpType,		__in LPWSTR lpName,
BOOL bFlushCache		__in LPINT lpType,
);		__in BOOL bFlushCache
		);

DWORD APIENTRY		DWORD APIENTRY
NPDirectoryNotify (		NPDirectoryNotify (

HWND hwnd,		__in HWND hwnd,
LPWSTR lpDir,		__in LPWSTR lpDir,
DWORD dwOper		__in DWORD dwOper
);		);
typedef DWORD (*PF_NPDirectoryNotify) (
HWND hwnd,		typedef DWORD (APIENTRY *PF_NPDirectoryNotify) (
LPWSTR lpDir,		__in HWND hwnd,
DWORD dwOper		__in LPWSTR lpDir,
);		__in DWORD dwOper
		);

VOID		VOID
WNetSetLastErrorA(		WNetSetLastErrorA(

DWORD err,		__in DWORD err,
LPSTR lpError,		__in LPSTR lpError,
LPSTR lpProviders		__in LPSTR lpProviders
);		);

VOID		VOID
WNetSetLastErrorW(		WNetSetLastErrorW(

DWORD err,		__in DWORD err,
LPWSTR lpError,		__in LPWSTR lpError,
LPWSTR lpProviders		__in LPWSTR lpProviders
);		);

#ifdef UNICODE		#ifdef UNICODE

#define WNetSetLastError WNetSetLastErrorW		#define WNetSetLastError WNetSetLastErrorW
#else		#else

#define WNetSetLastError WNetSetLastErrorA		#define WNetSetLastError WNetSetLastErrorA
#endif // UNICODE		#endif // UNICODE

//		//
// CREDENTIAL MANAGEMENT and other classes of providers		// CREDENTIAL MANAGEMENT and other classes of providers
//		//

// Define the Net/Authentication and othr Provider Classes		// Define the Net/Authentication and othr Provider Classes
#define WN_NETWORK_CLASS 0x00000001		#define WN_NETWORK_CLASS 0x00000001
#define WN_CREDENTIAL_CLASS 0x00000002		#define WN_CREDENTIAL_CLASS 0x00000002
#define WN_PRIMARY_AUTHENT_CLASS 0x00000004		#define WN_PRIMARY_AUTHENT_CLASS 0x00000004
#define WN_SERVICE_CLASS 0x00000008		#define WN_SERVICE_CLASS 0x00000008

#define WN_VALID_LOGON_ACCOUNT 0x00000001		#define WN_VALID_LOGON_ACCOUNT 0x00000001
#define WN_NT_PASSWORD_CHANGED 0x00000002		#define WN_NT_PASSWORD_CHANGED 0x00000002

DWORD APIENTRY		DWORD APIENTRY
NPLogonNotify (		NPLogonNotify (

PLUID lpLogonId,		__in PLUID lpLogonId,
LPCWSTR lpAuthentInfoType,		__in LPCWSTR lpAuthentInfoType,
LPVOID lpAuthentInfo,		__in LPVOID lpAuthentInfo,
LPCWSTR lpPreviousAuthentInfoType,		__in_opt LPCWSTR lpPreviousAuthentInfoType,
LPVOID lpPreviousAuthentInfo,		__in_opt LPVOID lpPreviousAuthentInfo,
LPWSTR lpStationName,		__in LPWSTR lpStationName,
LPVOID StationHandle,		__in_opt LPVOID StationHandle,
LPWSTR *lpLogonScript		__out LPWSTR *lpLogonScript
);		);
typedef DWORD (*PF_NPLogonNotify) (
PLUID lpLogonId,		typedef DWORD (APIENTRY *PF_NPLogonNotify) (
LPCWSTR lpAuthentInfoType,		__in PLUID lpLogonId,
LPVOID lpAuthentInfo,		__in LPCWSTR lpAuthentInfoType,
LPCWSTR lpPreviousAuthentInfoType,		__in LPVOID lpAuthentInfo,
LPVOID lpPreviousAuthentInfo,		__in_opt LPCWSTR lpPreviousAuthentInfoType,
LPWSTR lpStationName,		__in_opt LPVOID lpPreviousAuthentInfo,
LPVOID StationHandle,		__in LPWSTR lpStationName,
LPWSTR *lpLogonScript		__in_opt LPVOID StationHandle,
);		__out LPWSTR *lpLogonScript
		);

DWORD APIENTRY		DWORD APIENTRY
NPPasswordChangeNotify (		NPPasswordChangeNotify (

LPCWSTR lpAuthentInfoType,		__in LPCWSTR lpAuthentInfoType,
LPVOID lpAuthentInfo,		__in LPVOID lpAuthentInfo,
LPCWSTR lpPreviousAuthentInfoType,		__in LPCWSTR lpPreviousAuthentInfoType,
LPVOID lpPreviousAuthentInfo,		__in LPVOID lpPreviousAuthentInfo,
LPWSTR lpStationName,		__in LPWSTR lpStationName,
LPVOID StationHandle,		__in_opt LPVOID StationHandle,
DWORD dwChangeInfo		__in DWORD dwChangeInfo
);		);


typedef DWORD (*PF_NPPasswordChangeNotify) (		typedef DWORD (APIENTRY *PF_NPPasswordChangeNotify) (
LPCWSTR lpAuthentInfoType		__in LPCWSTR lpAuthentInfoType,
,		__in LPVOID lpAuthentInfo,
LPVOID lpAuthentInfo,		__in LPCWSTR lpPreviousAuthentInfoType,
LPCWSTR lpPreviousAuthent		__in LPVOID lpPreviousAuthentInfo,
InfoType,		__in LPWSTR lpStationName,
LPVOID lpPreviousAuthent		__in_opt LPVOID StationHandle,
Info,		__in DWORD dwChangeInfo
LPWSTR lpStationName,		);
LPVOID StationHandle,
DWORD dwChangeInfo
);

//		//
// CONNECTION NOTIFICATION		// CONNECTION NOTIFICATION
//		//

//		//
// NotifyStatus		// NotifyStatus
//		//
#define NOTIFY_PRE 0x00000001		#define NOTIFY_PRE 0x00000001
#define NOTIFY_POST 0x00000002		#define NOTIFY_POST 0x00000002


typedef struct _NOTIFYINFO		typedef struct _NOTIFYINFO {
{		DWORD dwNotifyStatus;
DWORD dwNotifyStatus;		DWORD dwOperationStatus;
DWORD dwOperationStatus;		LPVOID lpContext;
LPVOID lpContext;
} NOTIFYINFO, *LPNOTIFYINFO;		} NOTIFYINFO, *LPNOTIFYINFO;


typedef struct _NOTIFYADD		typedef struct _NOTIFYADD {
{		HWND hwndOwner;
HWND hwndOwner;		NETRESOURCE NetResource;
NETRESOURCE NetResource;		DWORD dwAddFlags;
DWORD dwAddFlags;
} NOTIFYADD, *LPNOTIFYADD;		} NOTIFYADD, *LPNOTIFYADD;


typedef struct _NOTIFYCANCEL		typedef struct _NOTIFYCANCEL {
{		LPWSTR lpName;
LPTSTR lpName;		LPWSTR lpProvider;
LPTSTR lpProvider;		DWORD dwFlags;
DWORD dwFlags;		BOOL fForce;
BOOL fForce;
} NOTIFYCANCEL, *LPNOTIFYCANCEL;		} NOTIFYCANCEL, *LPNOTIFYCANCEL;

DWORD APIENTRY		DWORD APIENTRY
AddConnectNotify (		AddConnectNotify (

LPNOTIFYINFO lpNotifyInfo,		__inout LPNOTIFYINFO lpNotifyInfo,
LPNOTIFYADD lpAddInfo		__in LPNOTIFYADD lpAddInfo
);		);


typedef DWORD (*PF_AddConnectNotify) (		typedef DWORD (APIENTRY *PF_AddConnectNotify) (
LPNOTIFYINFO lpNotifyInfo,		__inout LPNOTIFYINFO lpNotifyInfo,
LPNOTIFYADD lpAddInfo		__in LPNOTIFYADD lpAddInfo
);		);

DWORD APIENTRY		DWORD APIENTRY
CancelConnectNotify (		CancelConnectNotify (

LPNOTIFYINFO lpNotifyInfo,		__inout LPNOTIFYINFO lpNotifyInfo,
LPNOTIFYCANCEL lpCancelInfo		__in LPNOTIFYCANCEL lpCancelInfo
);		);


typedef DWORD (*PF_CancelConnectNotify) (		typedef DWORD (APIENTRY *PF_CancelConnectNotify) (
LPNOTIFYINFO lpNotifyInfo,		__inout LPNOTIFYINFO lpNotifyInfo,
LPNOTIFYCANCEL lpCancelInfo		__in LPNOTIFYCANCEL lpCancelInfo
);		);

//		//
// Permission editor dialogs		// Permission editor dialogs
//		//

//		//
// Capabilities bits of permission editor dialogs		// Capabilities bits of permission editor dialogs
//		//
#define WNPERMC_PERM 0x00000001		#define WNPERMC_PERM 0x00000001
#define WNPERMC_AUDIT 0x00000002		#define WNPERMC_AUDIT 0x00000002
#define WNPERMC_OWNER 0x00000004		#define WNPERMC_OWNER 0x00000004

DWORD APIENTRY		DWORD APIENTRY
NPFMXGetPermCaps (		NPFMXGetPermCaps (

LPWSTR lpDriveName		__in LPWSTR lpDriveName
);		);


typedef DWORD (*PF_NPFMXGetPermCaps) (		typedef DWORD (APIENTRY *PF_NPFMXGetPermCaps) (
LPWSTR lpDriveName		__in LPWSTR lpDriveName
);		);

//		//
// Type of security dialog		// Type of security dialog
//		//
#define WNPERM_DLG_PERM 0		#define WNPERM_DLG_PERM 0
#define WNPERM_DLG_AUDIT 1		#define WNPERM_DLG_AUDIT 1
#define WNPERM_DLG_OWNER 2		#define WNPERM_DLG_OWNER 2

DWORD APIENTRY		DWORD APIENTRY
NPFMXEditPerm (		NPFMXEditPerm (

LPWSTR lpDriveName,		__in LPWSTR lpDriveName,
HWND hwndFMX,		__in HWND hwndFMX,
DWORD nDialogType		__in DWORD nDialogType
);		);


typedef DWORD (*PF_NPFMXEditPerm) (		typedef DWORD (APIENTRY *PF_NPFMXEditPerm) (
LPWSTR lpDriveName,		__in LPWSTR lpDriveName,
HWND hwndFMX,		__in HWND hwndFMX,
DWORD nDialogType		__in DWORD nDialogType
);		);

DWORD APIENTRY		DWORD APIENTRY
NPFMXGetPermHelp (		NPFMXGetPermHelp (

LPWSTR lpDriveName,		__in LPWSTR lpDriveName,
DWORD nDialogType,		__in DWORD nDialogType,
BOOL fDirectory,		__in BOOL fDirectory,
LPVOID lpFileNameBuffer,		__out_ecount(*lpBufferSize) LPVOID lpFileNameBuffer,
LPDWORD lpBufferSize,		__inout LPDWORD lpBufferSize,
LPDWORD lpnHelpContext		__out LPDWORD lpnHelpContext
);		);


typedef DWORD (*PF_NPFMXGetPermHelp) (		typedef DWORD (APIENTRY *PF_NPFMXGetPermHelp) (
LPWSTR lpDriveName,		__in LPWSTR lpDriveName,
DWORD nDialogType,		__in DWORD nDialogType,
BOOL fDirectory,		__in BOOL fDirectory,
LPVOID lpFileNameBuffer,		__out_ecount(*lpBufferSize) LPVOID lpFileNameBuffer,
LPDWORD lpBufferSize,		__inout LPDWORD lpBufferSize,
LPDWORD lpnHelpContext		__out LPDWORD lpnHelpContext
);		);

		#ifdef __cplusplus
		}
		#endif

#endif // _NPAPI_INCLUDED		#endif // _NPAPI_INCLUDED

End of changes. 54 change blocks.
330 lines changed or deleted		401 lines changed or added

winnetwk.h (6.0.6002.18005-Windows 6.0)		winnetwk.h (6.1.7600.16385-Windows 7.0)

skipping to change at line 36		skipping to change at line 36
#pragma once		#pragma once

#ifdef __cplusplus		#ifdef __cplusplus
extern "C" {		extern "C" {
#endif		#endif

//		//
// Network types		// Network types
//		//


#define WNNC_NET_MSNET 0x00010000		#include <wnnc.h>
#define WNNC_NET_LANMAN 0x00020000
#define WNNC_NET_NETWARE 0x00030000
#define WNNC_NET_VINES 0x00040000
#define WNNC_NET_10NET 0x00050000
#define WNNC_NET_LOCUS 0x00060000
#define WNNC_NET_SUN_PC_NFS 0x00070000
#define WNNC_NET_LANSTEP 0x00080000
#define WNNC_NET_9TILES 0x00090000
#define WNNC_NET_LANTASTIC 0x000A0000
#define WNNC_NET_AS400 0x000B0000
#define WNNC_NET_FTP_NFS 0x000C0000
#define WNNC_NET_PATHWORKS 0x000D0000
#define WNNC_NET_LIFENET 0x000E0000
#define WNNC_NET_POWERLAN 0x000F0000
#define WNNC_NET_BWNFS 0x00100000
#define WNNC_NET_COGENT 0x00110000
#define WNNC_NET_FARALLON 0x00120000
#define WNNC_NET_APPLETALK 0x00130000
#define WNNC_NET_INTERGRAPH 0x00140000
#define WNNC_NET_SYMFONET 0x00150000
#define WNNC_NET_CLEARCASE 0x00160000
#define WNNC_NET_FRONTIER 0x00170000
#define WNNC_NET_BMC 0x00180000
#define WNNC_NET_DCE 0x00190000
#define WNNC_NET_AVID 0x001A0000
#define WNNC_NET_DOCUSPACE 0x001B0000
#define WNNC_NET_MANGOSOFT 0x001C0000
#define WNNC_NET_SERNET 0x001D0000
#define WNNC_NET_RIVERFRONT1 0X001E0000
#define WNNC_NET_RIVERFRONT2 0x001F0000
#define WNNC_NET_DECORB 0x00200000
#define WNNC_NET_PROTSTOR 0x00210000
#define WNNC_NET_FJ_REDIR 0x00220000
#define WNNC_NET_DISTINCT 0x00230000
#define WNNC_NET_TWINS 0x00240000
#define WNNC_NET_RDR2SAMPLE 0x00250000
#define WNNC_NET_CSC 0x00260000
#define WNNC_NET_3IN1 0x00270000
#define WNNC_NET_EXTENDNET 0x00290000
#define WNNC_NET_STAC 0x002A0000
#define WNNC_NET_FOXBAT 0x002B0000
#define WNNC_NET_YAHOO 0x002C0000
#define WNNC_NET_EXIFS 0x002D0000
#define WNNC_NET_DAV 0x002E0000
#define WNNC_NET_KNOWARE 0x002F0000
#define WNNC_NET_OBJECT_DIRE 0x00300000
#define WNNC_NET_MASFAX 0x00310000
#define WNNC_NET_HOB_NFS 0x00320000
#define WNNC_NET_SHIVA 0x00330000
#define WNNC_NET_IBMAL 0x00340000
#define WNNC_NET_LOCK 0x00350000
#define WNNC_NET_TERMSRV 0x00360000
#define WNNC_NET_SRT 0x00370000
#define WNNC_NET_QUINCY 0x00380000
#define WNNC_NET_OPENAFS 0x00390000
#define WNNC_NET_AVID1 0X003A0000
#define WNNC_NET_DFS 0x003B0000
#define WNNC_NET_KWNP 0x003C0000
#define WNNC_NET_ZENWORKS 0x003D0000
#define WNNC_NET_DRIVEONWEB 0x003E0000
#define WNNC_NET_VMWARE 0x003F0000
#define WNNC_NET_RSFX 0x00400000
#define WNNC_NET_MFILES 0x00410000
#define WNNC_NET_MS_NFS 0x00420000
#define WNNC_NET_GOOGLE 0x00430000

#define WNNC_CRED_MANAGER 0xFFFF0000

//		//
// Network Resources.		// Network Resources.
//		//

#define RESOURCE_CONNECTED 0x00000001		#define RESOURCE_CONNECTED 0x00000001
#define RESOURCE_GLOBALNET 0x00000002		#define RESOURCE_GLOBALNET 0x00000002
#define RESOURCE_REMEMBERED 0x00000003		#define RESOURCE_REMEMBERED 0x00000003
#if(WINVER >= 0x0400)		#if(WINVER >= 0x0400)
#define RESOURCE_RECENT 0x00000004		#define RESOURCE_RECENT 0x00000004

skipping to change at line 205		skipping to change at line 138
#define CONNECT_LOCALDRIVE 0x00000100		#define CONNECT_LOCALDRIVE 0x00000100
#define CONNECT_CURRENT_MEDIA 0x00000200		#define CONNECT_CURRENT_MEDIA 0x00000200
#define CONNECT_DEFERRED 0x00000400		#define CONNECT_DEFERRED 0x00000400
#define CONNECT_RESERVED 0xFF000000		#define CONNECT_RESERVED 0xFF000000
#endif /* WINVER >= 0x0400 */		#endif /* WINVER >= 0x0400 */
#if(WINVER >= 0x0500)		#if(WINVER >= 0x0500)
#define CONNECT_COMMANDLINE 0x00000800		#define CONNECT_COMMANDLINE 0x00000800
#define CONNECT_CMD_SAVECRED 0x00001000		#define CONNECT_CMD_SAVECRED 0x00001000
#endif /* WINVER >= 0x0500 */		#endif /* WINVER >= 0x0500 */
#if(WINVER >= 0x0600)		#if(WINVER >= 0x0600)

#define CONNECT_CRED_RESET 0x00002000		#define CONNECT_CRED_RESET 0x00002000
#endif /* WINVER >= 0x0600 */		#endif /* WINVER >= 0x0600 */


		__checkReturn
DWORD APIENTRY		DWORD APIENTRY
WNetAddConnectionA(		WNetAddConnectionA(
__in LPCSTR lpRemoteName,		__in LPCSTR lpRemoteName,
__in_opt LPCSTR lpPassword,		__in_opt LPCSTR lpPassword,
__in_opt LPCSTR lpLocalName		__in_opt LPCSTR lpLocalName
);		);

		__checkReturn
DWORD APIENTRY		DWORD APIENTRY
WNetAddConnectionW(		WNetAddConnectionW(
__in LPCWSTR lpRemoteName,		__in LPCWSTR lpRemoteName,
__in_opt LPCWSTR lpPassword,		__in_opt LPCWSTR lpPassword,
__in_opt LPCWSTR lpLocalName		__in_opt LPCWSTR lpLocalName
);		);
#ifdef UNICODE		#ifdef UNICODE
#define WNetAddConnection WNetAddConnectionW		#define WNetAddConnection WNetAddConnectionW
#else		#else
#define WNetAddConnection WNetAddConnectionA		#define WNetAddConnection WNetAddConnectionA
#endif // !UNICODE		#endif // !UNICODE


		__checkReturn
DWORD APIENTRY		DWORD APIENTRY
WNetAddConnection2A(		WNetAddConnection2A(
__in LPNETRESOURCEA lpNetResource,		__in LPNETRESOURCEA lpNetResource,
__in_opt LPCSTR lpPassword,		__in_opt LPCSTR lpPassword,
__in_opt LPCSTR lpUserName,		__in_opt LPCSTR lpUserName,
__in DWORD dwFlags		__in DWORD dwFlags
);		);

		__checkReturn
DWORD APIENTRY		DWORD APIENTRY
WNetAddConnection2W(		WNetAddConnection2W(
__in LPNETRESOURCEW lpNetResource,		__in LPNETRESOURCEW lpNetResource,
__in_opt LPCWSTR lpPassword,		__in_opt LPCWSTR lpPassword,
__in_opt LPCWSTR lpUserName,		__in_opt LPCWSTR lpUserName,
__in DWORD dwFlags		__in DWORD dwFlags
);		);
#ifdef UNICODE		#ifdef UNICODE
#define WNetAddConnection2 WNetAddConnection2W		#define WNetAddConnection2 WNetAddConnection2W
#else		#else
#define WNetAddConnection2 WNetAddConnection2A		#define WNetAddConnection2 WNetAddConnection2A
#endif // !UNICODE		#endif // !UNICODE


		__checkReturn
DWORD APIENTRY		DWORD APIENTRY
WNetAddConnection3A(		WNetAddConnection3A(
__in_opt HWND hwndOwner,		__in_opt HWND hwndOwner,
__in LPNETRESOURCEA lpNetResource,		__in LPNETRESOURCEA lpNetResource,
__in_opt LPCSTR lpPassword,		__in_opt LPCSTR lpPassword,
__in_opt LPCSTR lpUserName,		__in_opt LPCSTR lpUserName,
__in DWORD dwFlags		__in DWORD dwFlags
);		);

		__checkReturn
DWORD APIENTRY		DWORD APIENTRY
WNetAddConnection3W(		WNetAddConnection3W(
__in_opt HWND hwndOwner,		__in_opt HWND hwndOwner,
__in LPNETRESOURCEW lpNetResource,		__in LPNETRESOURCEW lpNetResource,
__in_opt LPCWSTR lpPassword,		__in_opt LPCWSTR lpPassword,
__in_opt LPCWSTR lpUserName,		__in_opt LPCWSTR lpUserName,
__in DWORD dwFlags		__in DWORD dwFlags
);		);
#ifdef UNICODE		#ifdef UNICODE
#define WNetAddConnection3 WNetAddConnection3W		#define WNetAddConnection3 WNetAddConnection3W
#else		#else
#define WNetAddConnection3 WNetAddConnection3A		#define WNetAddConnection3 WNetAddConnection3A
#endif // !UNICODE		#endif // !UNICODE


		__checkReturn
DWORD APIENTRY		DWORD APIENTRY
WNetCancelConnectionA(		WNetCancelConnectionA(
__in LPCSTR lpName,		__in LPCSTR lpName,
__in BOOL fForce		__in BOOL fForce
);		);

		__checkReturn
DWORD APIENTRY		DWORD APIENTRY
WNetCancelConnectionW(		WNetCancelConnectionW(
__in LPCWSTR lpName,		__in LPCWSTR lpName,
__in BOOL fForce		__in BOOL fForce
);		);
#ifdef UNICODE		#ifdef UNICODE
#define WNetCancelConnection WNetCancelConnectionW		#define WNetCancelConnection WNetCancelConnectionW
#else		#else
#define WNetCancelConnection WNetCancelConnectionA		#define WNetCancelConnection WNetCancelConnectionA
#endif // !UNICODE		#endif // !UNICODE


		__checkReturn
DWORD APIENTRY		DWORD APIENTRY
WNetCancelConnection2A(		WNetCancelConnection2A(
__in LPCSTR lpName,		__in LPCSTR lpName,
__in DWORD dwFlags,		__in DWORD dwFlags,
__in BOOL fForce		__in BOOL fForce
);		);

		__checkReturn
DWORD APIENTRY		DWORD APIENTRY
WNetCancelConnection2W(		WNetCancelConnection2W(
__in LPCWSTR lpName,		__in LPCWSTR lpName,
__in DWORD dwFlags,		__in DWORD dwFlags,
__in BOOL fForce		__in BOOL fForce
);		);
#ifdef UNICODE		#ifdef UNICODE
#define WNetCancelConnection2 WNetCancelConnection2W		#define WNetCancelConnection2 WNetCancelConnection2W
#else		#else
#define WNetCancelConnection2 WNetCancelConnection2A		#define WNetCancelConnection2 WNetCancelConnection2A
#endif // !UNICODE		#endif // !UNICODE


		__checkReturn
DWORD APIENTRY		DWORD APIENTRY
WNetGetConnectionA(		WNetGetConnectionA(
__in LPCSTR lpLocalName,		__in LPCSTR lpLocalName,
__out_ecount_opt(*lpnLength) LPSTR lpRemoteName,		__out_ecount_opt(*lpnLength) LPSTR lpRemoteName,
__inout LPDWORD lpnLength		__inout LPDWORD lpnLength
);		);

		__checkReturn
DWORD APIENTRY		DWORD APIENTRY
WNetGetConnectionW(		WNetGetConnectionW(
__in LPCWSTR lpLocalName,		__in LPCWSTR lpLocalName,
__out_ecount_opt(*lpnLength) LPWSTR lpRemoteName,		__out_ecount_opt(*lpnLength) LPWSTR lpRemoteName,
__inout LPDWORD lpnLength		__inout LPDWORD lpnLength
);		);
#ifdef UNICODE		#ifdef UNICODE
#define WNetGetConnection WNetGetConnectionW		#define WNetGetConnection WNetGetConnectionW
#else		#else
#define WNetGetConnection WNetGetConnectionA		#define WNetGetConnection WNetGetConnectionA
#endif // !UNICODE		#endif // !UNICODE

#if (_WIN32_WINNT >= _WIN32_WINNT_LONGHORN)		#if (_WIN32_WINNT >= _WIN32_WINNT_LONGHORN)

		__checkReturn
DWORD APIENTRY		DWORD APIENTRY
WNetRestoreSingleConnectionW(		WNetRestoreSingleConnectionW(
__in_opt HWND hwndParent,		__in_opt HWND hwndParent,
__in LPCWSTR lpDevice,		__in LPCWSTR lpDevice,
__in BOOL fUseUI		__in BOOL fUseUI
);		);

#else		#else

		__checkReturn
DWORD APIENTRY		DWORD APIENTRY
WNetRestoreConnectionW(		WNetRestoreConnectionW(
__in_opt HWND hWnd,		__in_opt HWND hWnd,
__in LPCWSTR lpDevice		__in LPCWSTR lpDevice
);		);

#endif		#endif

#if(WINVER >= 0x0400)		#if(WINVER >= 0x0400)

		__checkReturn
DWORD APIENTRY		DWORD APIENTRY
WNetUseConnectionA(		WNetUseConnectionA(
__in_opt HWND hwndOwner,		__in_opt HWND hwndOwner,
__in LPNETRESOURCEA lpNetResource,		__in LPNETRESOURCEA lpNetResource,
__in_opt LPCSTR lpPassword,		__in_opt LPCSTR lpPassword,
__in_opt LPCSTR lpUserId,		__in_opt LPCSTR lpUserId,
__in DWORD dwFlags,		__in DWORD dwFlags,
__out_ecount_opt(*lpBufferSize) LPSTR lpAccessName,		__out_ecount_opt(*lpBufferSize) LPSTR lpAccessName,
__inout_opt LPDWORD lpBufferSize,		__inout_opt LPDWORD lpBufferSize,
__out_opt LPDWORD lpResult		__out_opt LPDWORD lpResult
);		);

		__checkReturn
DWORD APIENTRY		DWORD APIENTRY
WNetUseConnectionW(		WNetUseConnectionW(
__in_opt HWND hwndOwner,		__in_opt HWND hwndOwner,
__in LPNETRESOURCEW lpNetResource,		__in LPNETRESOURCEW lpNetResource,
__in_opt LPCWSTR lpPassword,		__in_opt LPCWSTR lpPassword,
__in_opt LPCWSTR lpUserId,		__in_opt LPCWSTR lpUserId,
__in DWORD dwFlags,		__in DWORD dwFlags,
__out_ecount_opt(*lpBufferSize) LPWSTR lpAccessName,		__out_ecount_opt(*lpBufferSize) LPWSTR lpAccessName,
__inout_opt LPDWORD lpBufferSize,		__inout_opt LPDWORD lpBufferSize,
__out_opt LPDWORD lpResult		__out_opt LPDWORD lpResult

skipping to change at line 372		skipping to change at line 319
#ifdef UNICODE		#ifdef UNICODE
#define WNetUseConnection WNetUseConnectionW		#define WNetUseConnection WNetUseConnectionW
#else		#else
#define WNetUseConnection WNetUseConnectionA		#define WNetUseConnection WNetUseConnectionA
#endif // !UNICODE		#endif // !UNICODE
#endif /* WINVER >= 0x0400 */		#endif /* WINVER >= 0x0400 */

//		//
// Network Connection Dialogs.		// Network Connection Dialogs.
//		//

		__checkReturn
DWORD APIENTRY		DWORD APIENTRY
WNetConnectionDialog(		WNetConnectionDialog(
__in HWND hwnd,		__in HWND hwnd,
__in DWORD dwType		__in DWORD dwType
);		);


		__checkReturn
DWORD APIENTRY		DWORD APIENTRY
WNetDisconnectDialog(		WNetDisconnectDialog(

__in HWND hwnd,		__in_opt HWND hwnd,
__in DWORD dwType		__in DWORD dwType
);		);

#if(WINVER >= 0x0400)		#if(WINVER >= 0x0400)
typedef struct _CONNECTDLGSTRUCTA{		typedef struct _CONNECTDLGSTRUCTA{
DWORD cbStructure; /* size of this structure in bytes */		DWORD cbStructure; /* size of this structure in bytes */
HWND hwndOwner; /* owner window for the dialog */		HWND hwndOwner; /* owner window for the dialog */
LPNETRESOURCEA lpConnRes;/* Requested Resource info */		LPNETRESOURCEA lpConnRes;/* Requested Resource info */
DWORD dwFlags; /* flags (see below) */		DWORD dwFlags; /* flags (see below) */
DWORD dwDevNum; /* number of devices connected to */		DWORD dwDevNum; /* number of devices connected to */

skipping to change at line 421		skipping to change at line 369
#define CONNDLG_HIDE_BOX 0x00000008 /* Hide persistent connect checkbox */		#define CONNDLG_HIDE_BOX 0x00000008 /* Hide persistent connect checkbox */

/*		/*
* NOTE: Set at most ONE of the below flags. If neither flag is set,		* NOTE: Set at most ONE of the below flags. If neither flag is set,
* then the persistence is set to whatever the user chose during		* then the persistence is set to whatever the user chose during
* a previous connection		* a previous connection
*/		*/
#define CONNDLG_PERSIST 0x00000010 /* Force persistent connection */		#define CONNDLG_PERSIST 0x00000010 /* Force persistent connection */
#define CONNDLG_NOT_PERSIST 0x00000020 /* Force connection NOT persistent */		#define CONNDLG_NOT_PERSIST 0x00000020 /* Force connection NOT persistent */


		__checkReturn
DWORD APIENTRY		DWORD APIENTRY
WNetConnectionDialog1A(		WNetConnectionDialog1A(
__inout LPCONNECTDLGSTRUCTA lpConnDlgStruct		__inout LPCONNECTDLGSTRUCTA lpConnDlgStruct
);		);

		__checkReturn
DWORD APIENTRY		DWORD APIENTRY
WNetConnectionDialog1W(		WNetConnectionDialog1W(
__inout LPCONNECTDLGSTRUCTW lpConnDlgStruct		__inout LPCONNECTDLGSTRUCTW lpConnDlgStruct
);		);
#ifdef UNICODE		#ifdef UNICODE
#define WNetConnectionDialog1 WNetConnectionDialog1W		#define WNetConnectionDialog1 WNetConnectionDialog1W
#else		#else
#define WNetConnectionDialog1 WNetConnectionDialog1A		#define WNetConnectionDialog1 WNetConnectionDialog1A
#endif // !UNICODE		#endif // !UNICODE


skipping to change at line 460		skipping to change at line 410
typedef DISCDLGSTRUCTW DISCDLGSTRUCT;		typedef DISCDLGSTRUCTW DISCDLGSTRUCT;
typedef LPDISCDLGSTRUCTW LPDISCDLGSTRUCT;		typedef LPDISCDLGSTRUCTW LPDISCDLGSTRUCT;
#else		#else
typedef DISCDLGSTRUCTA DISCDLGSTRUCT;		typedef DISCDLGSTRUCTA DISCDLGSTRUCT;
typedef LPDISCDLGSTRUCTA LPDISCDLGSTRUCT;		typedef LPDISCDLGSTRUCTA LPDISCDLGSTRUCT;
#endif // UNICODE		#endif // UNICODE

#define DISC_UPDATE_PROFILE 0x00000001		#define DISC_UPDATE_PROFILE 0x00000001
#define DISC_NO_FORCE 0x00000040		#define DISC_NO_FORCE 0x00000040


		__checkReturn
DWORD APIENTRY		DWORD APIENTRY
WNetDisconnectDialog1A(		WNetDisconnectDialog1A(
__in LPDISCDLGSTRUCTA lpConnDlgStruct		__in LPDISCDLGSTRUCTA lpConnDlgStruct
);		);

		__checkReturn
DWORD APIENTRY		DWORD APIENTRY
WNetDisconnectDialog1W(		WNetDisconnectDialog1W(
__in LPDISCDLGSTRUCTW lpConnDlgStruct		__in LPDISCDLGSTRUCTW lpConnDlgStruct
);		);
#ifdef UNICODE		#ifdef UNICODE
#define WNetDisconnectDialog1 WNetDisconnectDialog1W		#define WNetDisconnectDialog1 WNetDisconnectDialog1W
#else		#else
#define WNetDisconnectDialog1 WNetDisconnectDialog1A		#define WNetDisconnectDialog1 WNetDisconnectDialog1A
#endif // !UNICODE		#endif // !UNICODE
#endif /* WINVER >= 0x0400 */		#endif /* WINVER >= 0x0400 */

//		//
// Network Browsing.		// Network Browsing.
//		//


		__checkReturn
DWORD APIENTRY		DWORD APIENTRY
WNetOpenEnumA(		WNetOpenEnumA(
__in DWORD dwScope,		__in DWORD dwScope,
__in DWORD dwType,		__in DWORD dwType,
__in DWORD dwUsage,		__in DWORD dwUsage,
__in_opt LPNETRESOURCEA lpNetResource,		__in_opt LPNETRESOURCEA lpNetResource,
__out LPHANDLE lphEnum		__out LPHANDLE lphEnum
);		);

		__checkReturn
DWORD APIENTRY		DWORD APIENTRY
WNetOpenEnumW(		WNetOpenEnumW(
__in DWORD dwScope,		__in DWORD dwScope,
__in DWORD dwType,		__in DWORD dwType,
__in DWORD dwUsage,		__in DWORD dwUsage,
__in_opt LPNETRESOURCEW lpNetResource,		__in_opt LPNETRESOURCEW lpNetResource,
__out LPHANDLE lphEnum		__out LPHANDLE lphEnum
);		);
#ifdef UNICODE		#ifdef UNICODE
#define WNetOpenEnum WNetOpenEnumW		#define WNetOpenEnum WNetOpenEnumW
#else		#else
#define WNetOpenEnum WNetOpenEnumA		#define WNetOpenEnum WNetOpenEnumA
#endif // !UNICODE		#endif // !UNICODE


		__checkReturn
DWORD APIENTRY		DWORD APIENTRY
WNetEnumResourceA(		WNetEnumResourceA(
__in HANDLE hEnum,		__in HANDLE hEnum,
__inout LPDWORD lpcCount,		__inout LPDWORD lpcCount,
__out_bcount(*lpBufferSize) LPVOID lpBuffer,		__out_bcount(*lpBufferSize) LPVOID lpBuffer,
__inout LPDWORD lpBufferSize		__inout LPDWORD lpBufferSize
);		);

		__checkReturn
DWORD APIENTRY		DWORD APIENTRY
WNetEnumResourceW(		WNetEnumResourceW(
__in HANDLE hEnum,		__in HANDLE hEnum,
__inout LPDWORD lpcCount,		__inout LPDWORD lpcCount,
__out_bcount(*lpBufferSize) LPVOID lpBuffer,		__out_bcount(*lpBufferSize) LPVOID lpBuffer,
__inout LPDWORD lpBufferSize		__inout LPDWORD lpBufferSize
);		);
#ifdef UNICODE		#ifdef UNICODE
#define WNetEnumResource WNetEnumResourceW		#define WNetEnumResource WNetEnumResourceW
#else		#else
#define WNetEnumResource WNetEnumResourceA		#define WNetEnumResource WNetEnumResourceA
#endif // !UNICODE		#endif // !UNICODE


		__checkReturn
DWORD APIENTRY		DWORD APIENTRY
WNetCloseEnum(		WNetCloseEnum(
__in HANDLE hEnum		__in HANDLE hEnum
);		);

#if(WINVER >= 0x0400)		#if(WINVER >= 0x0400)

		__checkReturn
DWORD APIENTRY		DWORD APIENTRY
WNetGetResourceParentA(		WNetGetResourceParentA(
__in LPNETRESOURCEA lpNetResource,		__in LPNETRESOURCEA lpNetResource,
__out_bcount(*lpcbBuffer) LPVOID lpBuffer,		__out_bcount(*lpcbBuffer) LPVOID lpBuffer,
__inout LPDWORD lpcbBuffer		__inout LPDWORD lpcbBuffer
);		);

		__checkReturn
DWORD APIENTRY		DWORD APIENTRY
WNetGetResourceParentW(		WNetGetResourceParentW(
__in LPNETRESOURCEW lpNetResource,		__in LPNETRESOURCEW lpNetResource,
__out_bcount(*lpcbBuffer) LPVOID lpBuffer,		__out_bcount(*lpcbBuffer) LPVOID lpBuffer,
__inout LPDWORD lpcbBuffer		__inout LPDWORD lpcbBuffer
);		);
#ifdef UNICODE		#ifdef UNICODE
#define WNetGetResourceParent WNetGetResourceParentW		#define WNetGetResourceParent WNetGetResourceParentW
#else		#else
#define WNetGetResourceParent WNetGetResourceParentA		#define WNetGetResourceParent WNetGetResourceParentA
#endif // !UNICODE		#endif // !UNICODE


		__checkReturn
DWORD APIENTRY		DWORD APIENTRY
WNetGetResourceInformationA(		WNetGetResourceInformationA(
__in LPNETRESOURCEA lpNetResource,		__in LPNETRESOURCEA lpNetResource,
__out_bcount(*lpcbBuffer) LPVOID lpBuffer,		__out_bcount(*lpcbBuffer) LPVOID lpBuffer,
__inout LPDWORD lpcbBuffer,		__inout LPDWORD lpcbBuffer,
__deref_out LPSTR *lplpSystem		__deref_out LPSTR *lplpSystem
);		);

		__checkReturn
DWORD APIENTRY		DWORD APIENTRY
WNetGetResourceInformationW(		WNetGetResourceInformationW(
__in LPNETRESOURCEW lpNetResource,		__in LPNETRESOURCEW lpNetResource,
__out_bcount(*lpcbBuffer) LPVOID lpBuffer,		__out_bcount(*lpcbBuffer) LPVOID lpBuffer,
__inout LPDWORD lpcbBuffer,		__inout LPDWORD lpcbBuffer,
__deref_out LPWSTR *lplpSystem		__deref_out LPWSTR *lplpSystem
);		);
#ifdef UNICODE		#ifdef UNICODE
#define WNetGetResourceInformation WNetGetResourceInformationW		#define WNetGetResourceInformation WNetGetResourceInformationW
#else		#else

skipping to change at line 605		skipping to change at line 566
LPWSTR lpRemainingPath;		LPWSTR lpRemainingPath;
}REMOTE_NAME_INFOW, *LPREMOTE_NAME_INFOW;		}REMOTE_NAME_INFOW, *LPREMOTE_NAME_INFOW;
#ifdef UNICODE		#ifdef UNICODE
typedef REMOTE_NAME_INFOW REMOTE_NAME_INFO;		typedef REMOTE_NAME_INFOW REMOTE_NAME_INFO;
typedef LPREMOTE_NAME_INFOW LPREMOTE_NAME_INFO;		typedef LPREMOTE_NAME_INFOW LPREMOTE_NAME_INFO;
#else		#else
typedef REMOTE_NAME_INFOA REMOTE_NAME_INFO;		typedef REMOTE_NAME_INFOA REMOTE_NAME_INFO;
typedef LPREMOTE_NAME_INFOA LPREMOTE_NAME_INFO;		typedef LPREMOTE_NAME_INFOA LPREMOTE_NAME_INFO;
#endif // UNICODE		#endif // UNICODE


		__checkReturn
DWORD APIENTRY		DWORD APIENTRY
WNetGetUniversalNameA(		WNetGetUniversalNameA(
__in LPCSTR lpLocalPath,		__in LPCSTR lpLocalPath,
__in DWORD dwInfoLevel,		__in DWORD dwInfoLevel,
__out_bcount(*lpBufferSize) LPVOID lpBuffer,		__out_bcount(*lpBufferSize) LPVOID lpBuffer,
__inout LPDWORD lpBufferSize		__inout LPDWORD lpBufferSize
);		);

		__checkReturn
DWORD APIENTRY		DWORD APIENTRY
WNetGetUniversalNameW(		WNetGetUniversalNameW(
__in LPCWSTR lpLocalPath,		__in LPCWSTR lpLocalPath,
__in DWORD dwInfoLevel,		__in DWORD dwInfoLevel,
__out_bcount(*lpBufferSize) LPVOID lpBuffer,		__out_bcount(*lpBufferSize) LPVOID lpBuffer,
__inout LPDWORD lpBufferSize		__inout LPDWORD lpBufferSize
);		);
#ifdef UNICODE		#ifdef UNICODE
#define WNetGetUniversalName WNetGetUniversalNameW		#define WNetGetUniversalName WNetGetUniversalNameW
#else		#else
#define WNetGetUniversalName WNetGetUniversalNameA		#define WNetGetUniversalName WNetGetUniversalNameA
#endif // !UNICODE		#endif // !UNICODE

//		//
// Authentication and Logon/Logoff.		// Authentication and Logon/Logoff.
//		//

		__checkReturn
DWORD APIENTRY		DWORD APIENTRY
WNetGetUserA(		WNetGetUserA(
__in_opt LPCSTR lpName,		__in_opt LPCSTR lpName,
__out_ecount(*lpnLength) LPSTR lpUserName,		__out_ecount(*lpnLength) LPSTR lpUserName,
__inout LPDWORD lpnLength		__inout LPDWORD lpnLength
);		);

		//
		// Authentication and Logon/Logoff.
		//
		__checkReturn
DWORD APIENTRY		DWORD APIENTRY
WNetGetUserW(		WNetGetUserW(
__in_opt LPCWSTR lpName,		__in_opt LPCWSTR lpName,
__out_ecount(*lpnLength) LPWSTR lpUserName,		__out_ecount(*lpnLength) LPWSTR lpUserName,
__inout LPDWORD lpnLength		__inout LPDWORD lpnLength
);		);
#ifdef UNICODE		#ifdef UNICODE
#define WNetGetUser WNetGetUserW		#define WNetGetUser WNetGetUserW
#else		#else
#define WNetGetUser WNetGetUserA		#define WNetGetUser WNetGetUserA

skipping to change at line 659		skipping to change at line 626
//		//

#if(WINVER >= 0x0400)		#if(WINVER >= 0x0400)
#define WNFMT_MULTILINE 0x01		#define WNFMT_MULTILINE 0x01
#define WNFMT_ABBREVIATED 0x02		#define WNFMT_ABBREVIATED 0x02
#define WNFMT_INENUM 0x10		#define WNFMT_INENUM 0x10
#define WNFMT_CONNECTION 0x20		#define WNFMT_CONNECTION 0x20
#endif /* WINVER >= 0x0400 */		#endif /* WINVER >= 0x0400 */

#if(WINVER >= 0x0400)		#if(WINVER >= 0x0400)

		__checkReturn
DWORD APIENTRY		DWORD APIENTRY
WNetGetProviderNameA(		WNetGetProviderNameA(
__in DWORD dwNetType,		__in DWORD dwNetType,
__out_ecount(*lpBufferSize) LPSTR lpProviderName,		__out_ecount(*lpBufferSize) LPSTR lpProviderName,
__inout LPDWORD lpBufferSize		__inout LPDWORD lpBufferSize
);		);

		__checkReturn
DWORD APIENTRY		DWORD APIENTRY
WNetGetProviderNameW(		WNetGetProviderNameW(
__in DWORD dwNetType,		__in DWORD dwNetType,
__out_ecount(*lpBufferSize) LPWSTR lpProviderName,		__out_ecount(*lpBufferSize) LPWSTR lpProviderName,
__inout LPDWORD lpBufferSize		__inout LPDWORD lpBufferSize
);		);
#ifdef UNICODE		#ifdef UNICODE
#define WNetGetProviderName WNetGetProviderNameW		#define WNetGetProviderName WNetGetProviderNameW
#else		#else
#define WNetGetProviderName WNetGetProviderNameA		#define WNetGetProviderName WNetGetProviderNameA

skipping to change at line 692		skipping to change at line 661
ULONG_PTR dwHandle;		ULONG_PTR dwHandle;
WORD wNetType;		WORD wNetType;
DWORD dwPrinters;		DWORD dwPrinters;
DWORD dwDrives;		DWORD dwDrives;
} NETINFOSTRUCT, FAR *LPNETINFOSTRUCT;		} NETINFOSTRUCT, FAR *LPNETINFOSTRUCT;

#define NETINFO_DLL16 0x00000001 /* Provider running as 16 bit Winnet Dri ver */		#define NETINFO_DLL16 0x00000001 /* Provider running as 16 bit Winnet Dri ver */
#define NETINFO_DISKRED 0x00000004 /* Provider requires disk redirections t o connect */		#define NETINFO_DISKRED 0x00000004 /* Provider requires disk redirections t o connect */
#define NETINFO_PRINTERRED 0x00000008 /* Provider requires printer redirection s to connect */		#define NETINFO_PRINTERRED 0x00000008 /* Provider requires printer redirection s to connect */


		__checkReturn
DWORD APIENTRY		DWORD APIENTRY
WNetGetNetworkInformationA(		WNetGetNetworkInformationA(
__in LPCSTR lpProvider,		__in LPCSTR lpProvider,
__out LPNETINFOSTRUCT lpNetInfoStruct		__out LPNETINFOSTRUCT lpNetInfoStruct
);		);

		__checkReturn
DWORD APIENTRY		DWORD APIENTRY
WNetGetNetworkInformationW(		WNetGetNetworkInformationW(
__in LPCWSTR lpProvider,		__in LPCWSTR lpProvider,
__out LPNETINFOSTRUCT lpNetInfoStruct		__out LPNETINFOSTRUCT lpNetInfoStruct
);		);
#ifdef UNICODE		#ifdef UNICODE
#define WNetGetNetworkInformation WNetGetNetworkInformationW		#define WNetGetNetworkInformation WNetGetNetworkInformationW
#else		#else
#define WNetGetNetworkInformation WNetGetNetworkInformationA		#define WNetGetNetworkInformation WNetGetNetworkInformationA
#endif // !UNICODE		#endif // !UNICODE

#endif /* WINVER >= 0x0400 */		#endif /* WINVER >= 0x0400 */

//		//
// Error handling.		// Error handling.
//		//


		__checkReturn
DWORD APIENTRY		DWORD APIENTRY
WNetGetLastErrorA(		WNetGetLastErrorA(
__out LPDWORD lpError,		__out LPDWORD lpError,
__out_ecount(nErrorBufSize) LPSTR lpErrorBuf,		__out_ecount(nErrorBufSize) LPSTR lpErrorBuf,
__in DWORD nErrorBufSize,		__in DWORD nErrorBufSize,
__out_ecount(nNameBufSize) LPSTR lpNameBuf,		__out_ecount(nNameBufSize) LPSTR lpNameBuf,
__in DWORD nNameBufSize		__in DWORD nNameBufSize
);		);

		__checkReturn
DWORD APIENTRY		DWORD APIENTRY
WNetGetLastErrorW(		WNetGetLastErrorW(
__out LPDWORD lpError,		__out LPDWORD lpError,
__out_ecount(nErrorBufSize) LPWSTR lpErrorBuf,		__out_ecount(nErrorBufSize) LPWSTR lpErrorBuf,
__in DWORD nErrorBufSize,		__in DWORD nErrorBufSize,
__out_ecount(nNameBufSize) LPWSTR lpNameBuf,		__out_ecount(nNameBufSize) LPWSTR lpNameBuf,
__in DWORD nNameBufSize		__in DWORD nNameBufSize
);		);
#ifdef UNICODE		#ifdef UNICODE
#define WNetGetLastError WNetGetLastErrorW		#define WNetGetLastError WNetGetLastErrorW

skipping to change at line 818		skipping to change at line 791
DWORD dwSpeed;		DWORD dwSpeed;
DWORD dwDelay;		DWORD dwDelay;
DWORD dwOptDataSize;		DWORD dwOptDataSize;
} NETCONNECTINFOSTRUCT, *LPNETCONNECTINFOSTRUCT;		} NETCONNECTINFOSTRUCT, *LPNETCONNECTINFOSTRUCT;

#define WNCON_FORNETCARD 0x00000001		#define WNCON_FORNETCARD 0x00000001
#define WNCON_NOTROUTED 0x00000002		#define WNCON_NOTROUTED 0x00000002
#define WNCON_SLOWLINK 0x00000004		#define WNCON_SLOWLINK 0x00000004
#define WNCON_DYNAMIC 0x00000008		#define WNCON_DYNAMIC 0x00000008


		__checkReturn
DWORD APIENTRY		DWORD APIENTRY
MultinetGetConnectionPerformanceA(		MultinetGetConnectionPerformanceA(
__in LPNETRESOURCEA lpNetResource,		__in LPNETRESOURCEA lpNetResource,
__out LPNETCONNECTINFOSTRUCT lpNetConnectInfoStruct		__out LPNETCONNECTINFOSTRUCT lpNetConnectInfoStruct
);		);

		__checkReturn
DWORD APIENTRY		DWORD APIENTRY
MultinetGetConnectionPerformanceW(		MultinetGetConnectionPerformanceW(
__in LPNETRESOURCEW lpNetResource,		__in LPNETRESOURCEW lpNetResource,
__out LPNETCONNECTINFOSTRUCT lpNetConnectInfoStruct		__out LPNETCONNECTINFOSTRUCT lpNetConnectInfoStruct
);		);
#ifdef UNICODE		#ifdef UNICODE
#define MultinetGetConnectionPerformance MultinetGetConnectionPerformanceW		#define MultinetGetConnectionPerformance MultinetGetConnectionPerformanceW
#else		#else
#define MultinetGetConnectionPerformance MultinetGetConnectionPerformanceA		#define MultinetGetConnectionPerformance MultinetGetConnectionPerformanceA
#endif // !UNICODE		#endif // !UNICODE

End of changes. 46 change blocks.
74 lines changed or deleted		49 lines changed or added

This html diff was produced by rfcdiff 1.41.