You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1269 lines
35 KiB
1269 lines
35 KiB
/*++
|
|
|
|
Copyright (c) 1989-1993 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
to32.c
|
|
|
|
Abstract:
|
|
|
|
Provides entry points for the Functions from WFW3.1
|
|
Network provider design which are niw thunked to some
|
|
32 bit equivalent.
|
|
|
|
Author:
|
|
|
|
Chuck Y Chan (ChuckC) 25-Mar-1993
|
|
|
|
Revision History:
|
|
|
|
|
|
--*/
|
|
#include <windows.h>
|
|
#include <locals.h>
|
|
|
|
//
|
|
// addresses to 32 bit entry points. note these cannot be
|
|
// called directly. CallProc32W must be used,
|
|
//
|
|
LPVOID lpfnWNetAddConnection = NULL ;
|
|
LPVOID lpfnWNetCancelConnection = NULL ;
|
|
LPVOID lpfnWNetGetConnection = NULL ;
|
|
LPVOID lpfnWNetRestoreConnection = NULL ;
|
|
LPVOID lpfnWNetGetUser = NULL ;
|
|
LPVOID lpfnWNetBrowseDialog = NULL ;
|
|
LPVOID lpfnWNetConnectDialog = NULL ;
|
|
LPVOID lpfnWNetDisconnectDialog = NULL ;
|
|
LPVOID lpfnWNetConnectionDialog = NULL ;
|
|
LPVOID lpfnWNetPropertyDialog = NULL ;
|
|
LPVOID lpfnWNetGetPropertyText = NULL ;
|
|
LPVOID lpfnWNetShareAsDialog = NULL ;
|
|
LPVOID lpfnWNetStopShareDialog = NULL ;
|
|
LPVOID lpfnWNetServerBrowseDialog = NULL ;
|
|
LPVOID lpfnWNetGetDirectoryType = NULL ;
|
|
LPVOID lpfnWNetDirectoryNotify = NULL ;
|
|
LPVOID lpfnGetLastError32 = NULL ;
|
|
LPVOID lpfnClosePrinter = NULL ;
|
|
LPVOID lpfnConnectToPrinter = NULL ;
|
|
|
|
//
|
|
// forward declare
|
|
//
|
|
WORD Get32BitEntryPoints( LPVOID *lplpfn, DWORD dwDll, LPSTR lpProcName ) ;
|
|
WORD API PrintConnectDialog(HWND p1) ;
|
|
WORD GetAlignedMemory(LPVOID FAR *pAligned, HANDLE FAR *pHandle, WORD wSize) ;
|
|
void FreeAlignedMemory(HANDLE handle) ;
|
|
|
|
//
|
|
// WNetAddConnection thunk to Win32
|
|
//
|
|
UINT API WNetAddConnection(LPSTR p1,LPSTR p2,LPSTR p3)
|
|
{
|
|
WORD err ;
|
|
LPSTR aligned_p1 = NULL, aligned_p2 = NULL, aligned_p3 = NULL ;
|
|
HANDLE handle_p1 = NULL, handle_p2 = NULL, handle_p3 = NULL;
|
|
|
|
if (p1 == NULL || p3 == NULL)
|
|
return WN_BAD_POINTER ;
|
|
|
|
if (p2 && (*p2 == '\0'))
|
|
p2 = NULL ;
|
|
|
|
if (!lpfnWNetAddConnection)
|
|
{
|
|
//
|
|
// start off as a our code until we get the entry point
|
|
//
|
|
vLastCall = LAST_CALL_IS_LOCAL ;
|
|
|
|
//
|
|
// get the entry point from 32 bit side
|
|
//
|
|
err = Get32BitEntryPoints( &lpfnWNetAddConnection,
|
|
USE_MPR_DLL,
|
|
"WNetAddConnectionA" ) ;
|
|
if (err)
|
|
{
|
|
SetLastError(err) ;
|
|
return err ;
|
|
}
|
|
}
|
|
|
|
//
|
|
// make copy of parameters so that we are aligned (p1 & p3 wont be NULL)
|
|
//
|
|
if (err = GetAlignedMemory(&aligned_p1, &handle_p1, lstrlen(p1)+1))
|
|
goto ExitPoint ;
|
|
lstrcpy(aligned_p1, p1) ;
|
|
|
|
if (err = GetAlignedMemory(&aligned_p3, &handle_p3, lstrlen(p3)+1))
|
|
goto ExitPoint ;
|
|
lstrcpy(aligned_p3, p3) ;
|
|
|
|
if (p2)
|
|
{
|
|
if (err = GetAlignedMemory(&aligned_p2, &handle_p2, lstrlen(p2)+1))
|
|
goto ExitPoint ;
|
|
lstrcpy(aligned_p2, p2) ;
|
|
}
|
|
|
|
//
|
|
// note it is no longer an error in our code. and call the API
|
|
//
|
|
vLastCall = LAST_CALL_IS_WIN32 ;
|
|
err = MapWin32ErrorToWN16( CallProc32W(aligned_p1,
|
|
(DWORD)aligned_p2,
|
|
(DWORD)aligned_p3,
|
|
lpfnWNetAddConnection,
|
|
(DWORD)7,
|
|
(DWORD)3) ) ;
|
|
ExitPoint:
|
|
|
|
FreeAlignedMemory(handle_p1) ;
|
|
FreeAlignedMemory(handle_p2) ;
|
|
FreeAlignedMemory(handle_p3) ;
|
|
return err ;
|
|
}
|
|
|
|
|
|
//
|
|
// WNetCancelConnection thunk to Win32
|
|
//
|
|
UINT API WNetCancelConnection(LPSTR p1,BOOL p2)
|
|
{
|
|
WORD err ;
|
|
LPSTR aligned_p1 = NULL ;
|
|
HANDLE handle_p1 = NULL ;
|
|
|
|
if (p1 == NULL)
|
|
return WN_BAD_POINTER ;
|
|
|
|
if (!lpfnWNetCancelConnection)
|
|
{
|
|
//
|
|
// start off as a our code until we get the entry point
|
|
//
|
|
vLastCall = LAST_CALL_IS_LOCAL ;
|
|
|
|
//
|
|
// get the entry point from 32 bit side
|
|
//
|
|
err = Get32BitEntryPoints( &lpfnWNetCancelConnection,
|
|
USE_MPR_DLL,
|
|
"WNetCancelConnectionA" ) ;
|
|
if (err)
|
|
{
|
|
SetLastError(err) ;
|
|
return err ;
|
|
}
|
|
}
|
|
|
|
//
|
|
// make copy of parameters so that we are aligned
|
|
//
|
|
if (err = GetAlignedMemory(&aligned_p1, &handle_p1, lstrlen(p1)+1))
|
|
goto ExitPoint ;
|
|
lstrcpy(aligned_p1, p1) ;
|
|
|
|
//
|
|
// note it is no longer an error in our code. and call the API
|
|
//
|
|
vLastCall = LAST_CALL_IS_WIN32 ;
|
|
err = MapWin32ErrorToWN16( CallProc32W(aligned_p1,
|
|
(DWORD)p2,
|
|
(DWORD)lpfnWNetCancelConnection,
|
|
(DWORD)2,
|
|
(DWORD)2) ) ;
|
|
ExitPoint:
|
|
|
|
FreeAlignedMemory(handle_p1) ;
|
|
return err ;
|
|
}
|
|
|
|
//
|
|
// WNetGetConnection thunk to Win32
|
|
//
|
|
UINT API WNetGetConnection(LPSTR p1,LPSTR p2, UINT FAR *p3)
|
|
{
|
|
WORD err ;
|
|
LPSTR aligned_p1 = NULL, aligned_p2 = NULL ;
|
|
LPDWORD aligned_p3 = NULL ;
|
|
HANDLE handle_p1 = NULL, handle_p2 = NULL, handle_p3 = NULL;
|
|
|
|
if (p1 == NULL || p2 == NULL || p3 == NULL)
|
|
return WN_BAD_POINTER ;
|
|
|
|
if (!lpfnWNetGetConnection)
|
|
{
|
|
//
|
|
// start off as a our code until we get the entry point
|
|
//
|
|
vLastCall = LAST_CALL_IS_LOCAL ;
|
|
|
|
//
|
|
// get the entry point from 32 bit side
|
|
//
|
|
err = Get32BitEntryPoints( &lpfnWNetGetConnection,
|
|
USE_MPR_DLL,
|
|
"WNetGetConnectionA" ) ;
|
|
if (err)
|
|
{
|
|
SetLastError(err) ;
|
|
return err ;
|
|
}
|
|
}
|
|
|
|
//
|
|
// make copy of parameters so that we are aligned
|
|
//
|
|
if (err = GetAlignedMemory(&aligned_p1, &handle_p1, lstrlen(p1)+1))
|
|
goto ExitPoint ;
|
|
lstrcpy(aligned_p1, p1) ;
|
|
|
|
if (err = GetAlignedMemory(&aligned_p2, &handle_p2, *p3 ? *p3 : 1))
|
|
goto ExitPoint ;
|
|
|
|
if (err = GetAlignedMemory(&aligned_p3, &handle_p3, sizeof(DWORD)))
|
|
goto ExitPoint ;
|
|
*aligned_p3 = *p3 ;
|
|
|
|
//
|
|
// note it is no longer an error in our code. and call the API
|
|
//
|
|
vLastCall = LAST_CALL_IS_WIN32 ;
|
|
err = MapWin32ErrorToWN16( CallProc32W(aligned_p1,
|
|
(DWORD)aligned_p2,
|
|
(DWORD)aligned_p3,
|
|
lpfnWNetGetConnection,
|
|
(DWORD)7,
|
|
(DWORD)3) ) ;
|
|
lstrcpy(p2, aligned_p2) ;
|
|
|
|
if (err == WN_SUCCESS)
|
|
*p3 = lstrlen(p2) + 1;
|
|
else
|
|
*p3 = (UINT)*aligned_p3 ;
|
|
|
|
ExitPoint:
|
|
|
|
FreeAlignedMemory(handle_p1) ;
|
|
FreeAlignedMemory(handle_p2) ;
|
|
FreeAlignedMemory(handle_p3) ;
|
|
return err ;
|
|
}
|
|
|
|
UINT API WNetRestoreConnection(HWND p1,LPSTR p2)
|
|
{
|
|
WORD err ;
|
|
LPSTR aligned_p2 = NULL ;
|
|
HANDLE handle_p2 = NULL ;
|
|
|
|
if (p2 == NULL)
|
|
return WN_BAD_POINTER ;
|
|
|
|
if (!lpfnWNetRestoreConnection)
|
|
{
|
|
//
|
|
// start off as a our code until we get the entry point
|
|
//
|
|
vLastCall = LAST_CALL_IS_LOCAL ;
|
|
|
|
//
|
|
// get the entry point from 32 bit side
|
|
//
|
|
err = Get32BitEntryPoints( &lpfnWNetRestoreConnection,
|
|
USE_MPRUI_DLL,
|
|
"WNetRestoreConnectionA" ) ;
|
|
if (err)
|
|
{
|
|
SetLastError(err) ;
|
|
return err ;
|
|
}
|
|
}
|
|
|
|
//
|
|
// guard against this weird case from Win3.0 days where -1
|
|
// means something special. NULL is close approximation -> ie all.
|
|
//
|
|
if (p2 == (LPSTR)-1)
|
|
p2 = NULL ;
|
|
|
|
if (p2)
|
|
{
|
|
if (err = GetAlignedMemory(&aligned_p2, &handle_p2, lstrlen(p2)+1))
|
|
goto ExitPoint ;
|
|
lstrcpy(aligned_p2, p2) ;
|
|
}
|
|
|
|
//
|
|
// note it is no longer an error in our code. and call the API
|
|
//
|
|
vLastCall = LAST_CALL_IS_WIN32 ;
|
|
err = MapWin32ErrorToWN16( CallProc32W((LPVOID)TO_HWND32(p1),
|
|
(DWORD)aligned_p2,
|
|
(DWORD)lpfnWNetRestoreConnection,
|
|
(DWORD)1,
|
|
(DWORD)2) ) ;
|
|
|
|
ExitPoint:
|
|
|
|
FreeAlignedMemory(handle_p2) ;
|
|
return err ;
|
|
}
|
|
|
|
WORD API WNetGetUser(LPSTR p1,LPINT p2)
|
|
{
|
|
WORD err ;
|
|
LONG lTmp = *p2 ;
|
|
LPSTR aligned_p1 = NULL ;
|
|
LPINT aligned_p2 = NULL ;
|
|
HANDLE handle_p1 = NULL, handle_p2 = NULL ;
|
|
|
|
if (p1 == NULL || p2 == NULL)
|
|
return WN_BAD_POINTER ;
|
|
|
|
if (!lpfnWNetGetUser)
|
|
{
|
|
//
|
|
// start off as a our code until we get the entry point
|
|
//
|
|
vLastCall = LAST_CALL_IS_LOCAL ;
|
|
|
|
//
|
|
// get the entry point from 32 bit side
|
|
//
|
|
err = Get32BitEntryPoints( &lpfnWNetGetUser,
|
|
USE_MPR_DLL,
|
|
"WNetGetUserA" ) ;
|
|
if (err)
|
|
{
|
|
SetLastError(err) ;
|
|
return err ;
|
|
}
|
|
}
|
|
|
|
if (err = GetAlignedMemory(&aligned_p1, &handle_p1, *p2))
|
|
goto ExitPoint ;
|
|
|
|
if (err = GetAlignedMemory(&aligned_p2, &handle_p2, sizeof(DWORD)))
|
|
goto ExitPoint ;
|
|
*aligned_p2 = *p2 ;
|
|
|
|
//
|
|
// note it is no longer an error in our code. and call the API
|
|
//
|
|
vLastCall = LAST_CALL_IS_WIN32 ;
|
|
err = MapWin32ErrorToWN16( CallProc32W(NULL,
|
|
(DWORD)aligned_p1,
|
|
(DWORD)aligned_p2,
|
|
lpfnWNetGetUser,
|
|
(DWORD)7,
|
|
(DWORD)3) );
|
|
*p2 = (int) *aligned_p2 ;
|
|
lstrcpy(p1, aligned_p1) ;
|
|
|
|
ExitPoint:
|
|
|
|
FreeAlignedMemory(handle_p1) ;
|
|
FreeAlignedMemory(handle_p2) ;
|
|
return err ;
|
|
}
|
|
|
|
WORD API WNetBrowseDialog(HWND p1,WORD p2,LPSTR p3)
|
|
{
|
|
WORD err ;
|
|
DWORD dwErr ;
|
|
LPSTR aligned_p3 = NULL ;
|
|
HANDLE handle_p3 = NULL ;
|
|
|
|
if (p3 == NULL)
|
|
return WN_BAD_POINTER ;
|
|
|
|
if (!lpfnWNetBrowseDialog)
|
|
{
|
|
//
|
|
// start off as a our code until we get the entry point
|
|
//
|
|
vLastCall = LAST_CALL_IS_LOCAL ;
|
|
|
|
//
|
|
// get the entry point from 32 bit side
|
|
//
|
|
err = Get32BitEntryPoints( &lpfnWNetBrowseDialog,
|
|
USE_MPRUI_DLL,
|
|
"BrowseDialogA0" ) ;
|
|
if (err)
|
|
{
|
|
SetLastError(err) ;
|
|
return err ;
|
|
}
|
|
}
|
|
|
|
//
|
|
// note that the WFW API does not let user specify buffer size.
|
|
// we have a tmp buffer, and then copy over. this takes care
|
|
// data alignment, also make sure we dont fault on 32 bit side.
|
|
//
|
|
// the 128 is consistent with what their docs specs the buffer
|
|
// size should be.
|
|
//
|
|
if (err = GetAlignedMemory(&aligned_p3, &handle_p3, 128))
|
|
goto ExitPoint ;
|
|
|
|
//
|
|
// note it is no longer an error in our code. and call the API
|
|
//
|
|
vLastCall = LAST_CALL_IS_WIN32 ;
|
|
dwErr = CallProc32W((LPVOID)TO_HWND32(p1),
|
|
(DWORD)MapWNType16To32(p2),
|
|
(DWORD)aligned_p3,
|
|
(DWORD)128,
|
|
lpfnWNetBrowseDialog,
|
|
(DWORD)2,
|
|
(DWORD)4) ;
|
|
if (dwErr == 0xFFFFFFFF)
|
|
err = WN_CANCEL ;
|
|
else
|
|
err = MapWin32ErrorToWN16( dwErr ) ;
|
|
|
|
if (!err)
|
|
lstrcpy(p3,aligned_p3) ;
|
|
|
|
ExitPoint:
|
|
|
|
FreeAlignedMemory(handle_p3) ;
|
|
return err ;
|
|
}
|
|
|
|
WORD API WNetConnectDialog(HWND p1,WORD p2)
|
|
{
|
|
WORD err ;
|
|
DWORD dwErr ;
|
|
|
|
if (p2 == WNTYPE_PRINTER)
|
|
{
|
|
err = PrintConnectDialog(p1) ;
|
|
return err ;
|
|
}
|
|
|
|
if (!lpfnWNetConnectDialog)
|
|
{
|
|
//
|
|
// start off as a our code until we get the entry point
|
|
//
|
|
vLastCall = LAST_CALL_IS_LOCAL ;
|
|
|
|
//
|
|
// get the entry point from 32 bit side
|
|
//
|
|
err = Get32BitEntryPoints( &lpfnWNetConnectDialog,
|
|
USE_MPR_DLL,
|
|
"WNetConnectionDialog" ) ;
|
|
if (err)
|
|
{
|
|
SetLastError(err) ;
|
|
return err ;
|
|
}
|
|
}
|
|
|
|
//
|
|
// note it is no longer an error in our code. and call the API
|
|
//
|
|
vLastCall = LAST_CALL_IS_WIN32 ;
|
|
dwErr = CallProc32W( (LPVOID)TO_HWND32(p1),
|
|
(DWORD)MapWNType16To32(p2),
|
|
(DWORD)lpfnWNetConnectDialog,
|
|
(DWORD) 0,
|
|
(DWORD) 2 ) ;
|
|
if (dwErr == 0xFFFFFFFF)
|
|
err = WN_CANCEL ;
|
|
else
|
|
err = MapWin32ErrorToWN16( dwErr ) ;
|
|
return err ;
|
|
}
|
|
|
|
|
|
WORD API WNetDisconnectDialog(HWND p1,WORD p2)
|
|
{
|
|
WORD err ;
|
|
DWORD dwErr ;
|
|
|
|
if (!lpfnWNetDisconnectDialog)
|
|
{
|
|
//
|
|
// start off as a our code until we get the entry point
|
|
//
|
|
vLastCall = LAST_CALL_IS_LOCAL ;
|
|
|
|
//
|
|
// get the entry point from 32 bit side
|
|
//
|
|
err = Get32BitEntryPoints( &lpfnWNetDisconnectDialog,
|
|
USE_MPR_DLL,
|
|
"WNetDisconnectDialog" ) ;
|
|
if (err)
|
|
{
|
|
SetLastError(err) ;
|
|
return err ;
|
|
}
|
|
}
|
|
|
|
//
|
|
// note it is no longer an error in our code. and call the API
|
|
//
|
|
vLastCall = LAST_CALL_IS_WIN32 ;
|
|
dwErr = CallProc32W( (LPVOID)TO_HWND32(p1),
|
|
(DWORD)MapWNType16To32(p2),
|
|
(DWORD)lpfnWNetDisconnectDialog,
|
|
(DWORD) 0,
|
|
(DWORD) 2 ) ;
|
|
if (dwErr == 0xFFFFFFFF)
|
|
err = WN_CANCEL ;
|
|
else
|
|
err = MapWin32ErrorToWN16( dwErr ) ;
|
|
return err ;
|
|
}
|
|
|
|
WORD API WNetConnectionDialog(HWND p1,WORD p2)
|
|
{
|
|
return (WNetConnectDialog(p1,p2)) ;
|
|
}
|
|
|
|
WORD API PrintConnectDialog(HWND p1)
|
|
{
|
|
WORD err ;
|
|
DWORD dwErr ;
|
|
DWORD handle ;
|
|
|
|
if (!lpfnClosePrinter)
|
|
{
|
|
//
|
|
// start off as a our code until we get the entry point
|
|
//
|
|
vLastCall = LAST_CALL_IS_LOCAL ;
|
|
|
|
//
|
|
// get the entry point from 32 bit side
|
|
//
|
|
err = Get32BitEntryPoints( &lpfnClosePrinter,
|
|
USE_WINSPOOL_DRV,
|
|
"ClosePrinter" ) ;
|
|
if (err)
|
|
{
|
|
SetLastError(err) ;
|
|
return err ;
|
|
}
|
|
}
|
|
|
|
if (!lpfnConnectToPrinter)
|
|
{
|
|
//
|
|
// start off as a our code until we get the entry point
|
|
//
|
|
vLastCall = LAST_CALL_IS_LOCAL ;
|
|
|
|
//
|
|
// get the entry point from 32 bit side
|
|
//
|
|
err = Get32BitEntryPoints( &lpfnConnectToPrinter,
|
|
USE_WINSPOOL_DRV,
|
|
"ConnectToPrinterDlg" ) ;
|
|
if (err)
|
|
{
|
|
SetLastError(err) ;
|
|
return err ;
|
|
}
|
|
}
|
|
|
|
//
|
|
// note it is no longer an error in our code. and call the API
|
|
//
|
|
err = WN_SUCCESS ;
|
|
vLastCall = LAST_CALL_IS_WIN32 ;
|
|
handle = CallProc32W( (LPVOID)TO_HWND32(p1),
|
|
(DWORD) 0,
|
|
(DWORD)lpfnConnectToPrinter,
|
|
(DWORD) 0,
|
|
(DWORD) 2 ) ;
|
|
if (handle == 0)
|
|
err = WN_CANCEL ; // most likely reason
|
|
else
|
|
{
|
|
dwErr = MapWin32ErrorToWN16( CallProc32W((LPVOID)handle,
|
|
(DWORD)lpfnClosePrinter,
|
|
(DWORD)0,
|
|
(DWORD)1) );
|
|
// but ignore the error
|
|
}
|
|
return err ;
|
|
}
|
|
|
|
WORD API WNetPropertyDialog(HWND hwndParent,
|
|
WORD iButton,
|
|
WORD nPropSel,
|
|
LPSTR lpszName,
|
|
WORD nType)
|
|
{
|
|
WORD err ;
|
|
LPSTR aligned_name = NULL ;
|
|
HANDLE handle_name = NULL ;
|
|
|
|
if (!lpfnWNetPropertyDialog)
|
|
{
|
|
//
|
|
// start off as a our code until we get the entry point
|
|
//
|
|
vLastCall = LAST_CALL_IS_LOCAL ;
|
|
|
|
//
|
|
// get the entry point from 32 bit side
|
|
//
|
|
err = Get32BitEntryPoints( &lpfnWNetPropertyDialog,
|
|
USE_MPR_DLL,
|
|
"WNetPropertyDialogA" ) ;
|
|
if (err)
|
|
{
|
|
SetLastError(err) ;
|
|
return err ;
|
|
}
|
|
}
|
|
|
|
if (lpszName)
|
|
{
|
|
if (err = GetAlignedMemory(&aligned_name,
|
|
&handle_name,
|
|
lstrlen(lpszName)+1))
|
|
goto ExitPoint ;
|
|
lstrcpy(aligned_name, lpszName) ;
|
|
}
|
|
|
|
//
|
|
// note it is no longer an error in our code. and call the API
|
|
//
|
|
vLastCall = LAST_CALL_IS_WIN32 ;
|
|
err = MapWin32ErrorToWN16( CallProc32W( (LPVOID)TO_HWND32(hwndParent),
|
|
(DWORD) iButton,
|
|
(DWORD) nPropSel,
|
|
(DWORD) aligned_name,
|
|
(DWORD) nType,
|
|
lpfnWNetPropertyDialog,
|
|
(DWORD)2,
|
|
(DWORD)5) ) ;
|
|
ExitPoint:
|
|
|
|
FreeAlignedMemory(handle_name) ;
|
|
return err ;
|
|
}
|
|
|
|
WORD API WNetGetPropertyText(WORD iButton,
|
|
WORD nPropSel,
|
|
LPSTR lpszName,
|
|
LPSTR lpszButtonName,
|
|
WORD cbButtonName,
|
|
WORD nType)
|
|
{
|
|
WORD err ;
|
|
LPSTR aligned_name = NULL, aligned_button_name = NULL ;
|
|
HANDLE handle_name = NULL, handle_button_name = NULL ;
|
|
|
|
if (lpszButtonName == NULL)
|
|
return WN_BAD_POINTER ;
|
|
|
|
if (!lpfnWNetGetPropertyText)
|
|
{
|
|
//
|
|
// start off as a our code until we get the entry point
|
|
//
|
|
vLastCall = LAST_CALL_IS_LOCAL ;
|
|
|
|
//
|
|
// get the entry point from 32 bit side
|
|
//
|
|
err = Get32BitEntryPoints( &lpfnWNetGetPropertyText,
|
|
USE_MPR_DLL,
|
|
"WNetGetPropertyTextA" ) ;
|
|
if (err)
|
|
{
|
|
SetLastError(err) ;
|
|
return err ;
|
|
}
|
|
}
|
|
|
|
if (lpszName)
|
|
{
|
|
if (err = GetAlignedMemory(&aligned_name,
|
|
&handle_name,
|
|
lstrlen(lpszName)+1))
|
|
goto ExitPoint ;
|
|
lstrcpy(aligned_name, lpszName) ;
|
|
}
|
|
|
|
if (err = GetAlignedMemory(&aligned_button_name,
|
|
&handle_button_name,
|
|
cbButtonName))
|
|
goto ExitPoint ;
|
|
|
|
//
|
|
// note it is no longer an error in our code. and call the API
|
|
//
|
|
vLastCall = LAST_CALL_IS_WIN32 ;
|
|
err = MapWin32ErrorToWN16( CallProc32W( (LPVOID)iButton,
|
|
(DWORD) nPropSel,
|
|
(DWORD) aligned_name,
|
|
(DWORD) aligned_button_name,
|
|
(DWORD) cbButtonName,
|
|
(DWORD) nType,
|
|
lpfnWNetGetPropertyText,
|
|
(DWORD)12,
|
|
(DWORD)6) ) ;
|
|
if (err == WN_SUCCESS)
|
|
lstrcpy(lpszButtonName, aligned_button_name) ;
|
|
|
|
ExitPoint:
|
|
|
|
FreeAlignedMemory(handle_name) ;
|
|
FreeAlignedMemory(handle_button_name) ;
|
|
return err ;
|
|
}
|
|
|
|
WORD API WNetShareAsDialog(HWND hwndParent,
|
|
WORD iType,
|
|
LPSTR lpszPath)
|
|
{
|
|
WORD err ;
|
|
LPSTR aligned_path = NULL ;
|
|
HANDLE handle_path = NULL ;
|
|
|
|
if (!lpfnWNetShareAsDialog)
|
|
{
|
|
//
|
|
// start off as a our code until we get the entry point
|
|
//
|
|
vLastCall = LAST_CALL_IS_LOCAL ;
|
|
|
|
//
|
|
// get the entry point from 32 bit side
|
|
//
|
|
err = Get32BitEntryPoints( &lpfnWNetShareAsDialog,
|
|
USE_NTLANMAN_DLL,
|
|
"ShareAsDialogA0" ) ;
|
|
if (err)
|
|
{
|
|
SetLastError(err) ;
|
|
return err ;
|
|
}
|
|
}
|
|
|
|
if (lpszPath)
|
|
{
|
|
if (err = GetAlignedMemory(&aligned_path,
|
|
&handle_path,
|
|
lstrlen(lpszPath)+1))
|
|
goto ExitPoint ;
|
|
lstrcpy(aligned_path, lpszPath) ;
|
|
}
|
|
|
|
//
|
|
// note it is no longer an error in our code. and call the API
|
|
//
|
|
vLastCall = LAST_CALL_IS_WIN32 ;
|
|
err = MapWin32ErrorToWN16( CallProc32W( (LPVOID)TO_HWND32(hwndParent),
|
|
(DWORD) MapWNType16To32(iType),
|
|
(DWORD) aligned_path,
|
|
lpfnWNetShareAsDialog,
|
|
(DWORD)1,
|
|
(DWORD)3) ) ;
|
|
ExitPoint:
|
|
|
|
FreeAlignedMemory(handle_path) ;
|
|
return err ;
|
|
}
|
|
|
|
WORD API WNetStopShareDialog(HWND hwndParent,
|
|
WORD iType,
|
|
LPSTR lpszPath)
|
|
{
|
|
WORD err ;
|
|
LPSTR aligned_path = NULL ;
|
|
HANDLE handle_path = NULL ;
|
|
|
|
if (!lpfnWNetStopShareDialog)
|
|
{
|
|
//
|
|
// start off as a our code until we get the entry point
|
|
//
|
|
vLastCall = LAST_CALL_IS_LOCAL ;
|
|
|
|
//
|
|
// get the entry point from 32 bit side
|
|
//
|
|
err = Get32BitEntryPoints( &lpfnWNetStopShareDialog,
|
|
USE_NTLANMAN_DLL,
|
|
"StopShareDialogA0" ) ;
|
|
if (err)
|
|
{
|
|
SetLastError(err) ;
|
|
return err ;
|
|
}
|
|
}
|
|
|
|
if (lpszPath)
|
|
{
|
|
if (err = GetAlignedMemory(&aligned_path,
|
|
&handle_path,
|
|
lstrlen(lpszPath)+1))
|
|
goto ExitPoint ;
|
|
lstrcpy(aligned_path, lpszPath) ;
|
|
}
|
|
|
|
//
|
|
// note it is no longer an error in our code. and call the API
|
|
//
|
|
vLastCall = LAST_CALL_IS_WIN32 ;
|
|
err = MapWin32ErrorToWN16( CallProc32W( (LPVOID)TO_HWND32(hwndParent),
|
|
(DWORD) MapWNType16To32(iType),
|
|
(DWORD) aligned_path,
|
|
lpfnWNetStopShareDialog,
|
|
(DWORD)1,
|
|
(DWORD)3) ) ;
|
|
ExitPoint:
|
|
|
|
FreeAlignedMemory(handle_path) ;
|
|
return err ;
|
|
}
|
|
|
|
WORD API WNetServerBrowseDialog(HWND hwndParent,
|
|
LPSTR lpszSectionName,
|
|
LPSTR lpszBuffer,
|
|
WORD cbBuffer,
|
|
DWORD flFlags)
|
|
{
|
|
WORD err ;
|
|
LPSTR aligned_buffer = NULL ;
|
|
HANDLE handle_buffer = NULL ;
|
|
|
|
UNREFERENCED(lpszSectionName) ;
|
|
UNREFERENCED(flFlags) ;
|
|
|
|
if (!lpfnWNetServerBrowseDialog)
|
|
{
|
|
//
|
|
// start off as a our code until we get the entry point
|
|
//
|
|
vLastCall = LAST_CALL_IS_LOCAL ;
|
|
|
|
//
|
|
// get the entry point from 32 bit side
|
|
//
|
|
err = Get32BitEntryPoints( &lpfnWNetServerBrowseDialog,
|
|
USE_NTLANMAN_DLL,
|
|
"ServerBrowseDialogA0" ) ;
|
|
if (err)
|
|
{
|
|
SetLastError(err) ;
|
|
return err ;
|
|
}
|
|
}
|
|
|
|
if (lpszBuffer)
|
|
{
|
|
if (err = GetAlignedMemory(&aligned_buffer, &handle_buffer, cbBuffer))
|
|
goto ExitPoint ;
|
|
}
|
|
|
|
//
|
|
// note it is no longer an error in our code. and call the API
|
|
//
|
|
vLastCall = LAST_CALL_IS_WIN32 ;
|
|
err = MapWin32ErrorToWN16( CallProc32W( (LPVOID)TO_HWND32(hwndParent),
|
|
(DWORD) aligned_buffer,
|
|
(DWORD) cbBuffer,
|
|
lpfnWNetServerBrowseDialog,
|
|
(DWORD)2,
|
|
(DWORD)3) ) ;
|
|
if (err == WN_SUCCESS)
|
|
lstrcpy(lpszBuffer, aligned_buffer) ;
|
|
|
|
ExitPoint:
|
|
|
|
FreeAlignedMemory(handle_buffer) ;
|
|
return err ;
|
|
}
|
|
|
|
WORD API WNetGetDirectoryType(LPSTR p1,LPINT p2)
|
|
{
|
|
WORD err ;
|
|
LPSTR aligned_p1 = NULL ;
|
|
LPDWORD aligned_p2 = NULL ;
|
|
HANDLE handle_p1 = NULL, handle_p2 = NULL ;
|
|
|
|
if (p1 == NULL || p2 == NULL)
|
|
return WN_BAD_POINTER ;
|
|
|
|
if (!lpfnWNetGetDirectoryType)
|
|
{
|
|
//
|
|
// start off as a our code until we get the entry point
|
|
//
|
|
vLastCall = LAST_CALL_IS_LOCAL ;
|
|
|
|
//
|
|
// get the entry point from 32 bit side
|
|
//
|
|
err = Get32BitEntryPoints( &lpfnWNetGetDirectoryType,
|
|
USE_MPR_DLL,
|
|
"WNetGetDirectoryTypeA" ) ;
|
|
if (err)
|
|
{
|
|
SetLastError(err) ;
|
|
return err ;
|
|
}
|
|
}
|
|
|
|
if (err = GetAlignedMemory(&aligned_p1, &handle_p1, lstrlen(p1)+1))
|
|
goto ExitPoint ;
|
|
lstrcpy(aligned_p1, p1) ;
|
|
|
|
if (err = GetAlignedMemory(&aligned_p2, &handle_p2, sizeof(DWORD)))
|
|
goto ExitPoint ;
|
|
|
|
//
|
|
// note it is no longer an error in our code. and call the API
|
|
//
|
|
vLastCall = LAST_CALL_IS_WIN32 ;
|
|
err = MapWin32ErrorToWN16( CallProc32W(aligned_p1,
|
|
(DWORD)aligned_p2,
|
|
(DWORD)TRUE,
|
|
lpfnWNetGetDirectoryType,
|
|
(DWORD)6,
|
|
(DWORD)3) ) ;
|
|
*p2 = (int) *aligned_p2 ;
|
|
|
|
ExitPoint:
|
|
|
|
FreeAlignedMemory(handle_p1) ;
|
|
FreeAlignedMemory(handle_p2) ;
|
|
return err ;
|
|
}
|
|
|
|
WORD API WNetDirectoryNotify(HWND p1,LPSTR p2,WORD p3)
|
|
{
|
|
UNREFERENCED(p1) ;
|
|
UNREFERENCED(p2) ;
|
|
UNREFERENCED(p3) ;
|
|
return WN_SUCCESS ;
|
|
}
|
|
|
|
DWORD API GetLastError32(VOID)
|
|
{
|
|
WORD err ;
|
|
DWORD dwErr ;
|
|
|
|
if (!lpfnGetLastError32)
|
|
{
|
|
//
|
|
// start off as a our code until we get the entry point
|
|
//
|
|
vLastCall = LAST_CALL_IS_LOCAL ;
|
|
|
|
//
|
|
// get the entry point from 32 bit side
|
|
//
|
|
err = Get32BitEntryPoints( &lpfnGetLastError32,
|
|
USE_KERNEL32_DLL,
|
|
"GetLastError" ) ;
|
|
if (err)
|
|
{
|
|
SetLastError(err) ;
|
|
return err ;
|
|
}
|
|
}
|
|
|
|
//
|
|
// note it is no longer an error in our code. and call the API
|
|
//
|
|
vLastCall = LAST_CALL_IS_WIN32 ;
|
|
dwErr = (UINT) CallProc32W((LPVOID)lpfnGetLastError32,
|
|
(DWORD)0,
|
|
(DWORD)0) ;
|
|
return (MapWin32ErrorToWN16(dwErr)) ;
|
|
}
|
|
|
|
/*
|
|
* Misc support routines
|
|
*/
|
|
|
|
/*******************************************************************
|
|
|
|
NAME: Get32BitEntryPoints
|
|
|
|
SYNOPSIS: Get the address of a 32 bit entry point that can
|
|
then be passed to CallProv32W. Will load the library
|
|
if it has not already been loaded.
|
|
|
|
ENTRY: lplpfn - used to return the address
|
|
dwDll - which dll to use (see locals.h defintions)
|
|
lpProcName - proc to load
|
|
|
|
EXIT:
|
|
|
|
RETURNS: error code
|
|
|
|
NOTES:
|
|
|
|
HISTORY:
|
|
ChuckC 25-Mar-93 Created
|
|
|
|
********************************************************************/
|
|
WORD Get32BitEntryPoints( LPVOID *lplpfn, DWORD dwDll, LPSTR lpProcName )
|
|
{
|
|
static DWORD hmodKernel32 = NULL ;
|
|
static DWORD hmodNTLanman = NULL ;
|
|
static DWORD hmodMpr = NULL ;
|
|
static DWORD hmodMprUI = NULL ;
|
|
static DWORD hmodWinSpool = NULL ;
|
|
DWORD hmod = NULL ;
|
|
|
|
//
|
|
// if we havent loaded it appropriate DLL, load it now
|
|
//
|
|
switch (dwDll)
|
|
{
|
|
case USE_MPR_DLL:
|
|
if (hmodMpr == NULL)
|
|
{
|
|
hmodMpr = LoadLibraryEx32W(MPR_DLL, NULL, 0) ;
|
|
if (hmodMpr == NULL)
|
|
return WN_NOT_SUPPORTED ;
|
|
}
|
|
hmod = hmodMpr ;
|
|
break ;
|
|
|
|
case USE_MPRUI_DLL:
|
|
if (hmodMprUI == NULL)
|
|
{
|
|
hmodMprUI = LoadLibraryEx32W(MPRUI_DLL, NULL, 0) ;
|
|
if (hmodMprUI == NULL)
|
|
return WN_NOT_SUPPORTED ;
|
|
}
|
|
hmod = hmodMprUI ;
|
|
break ;
|
|
|
|
case USE_NTLANMAN_DLL:
|
|
if (hmodNTLanman == NULL)
|
|
{
|
|
hmodNTLanman = LoadLibraryEx32W(NTLANMAN_DLL, NULL, 0) ;
|
|
if (hmodNTLanman == NULL)
|
|
return WN_NOT_SUPPORTED ;
|
|
}
|
|
hmod = hmodNTLanman ;
|
|
break ;
|
|
|
|
case USE_KERNEL32_DLL:
|
|
if (hmodKernel32 == NULL)
|
|
{
|
|
hmodKernel32 = LoadLibraryEx32W(KERNEL32_DLL, NULL, 0) ;
|
|
if (hmodKernel32 == NULL)
|
|
return WN_NOT_SUPPORTED ;
|
|
}
|
|
hmod = hmodKernel32 ;
|
|
break ;
|
|
|
|
case USE_WINSPOOL_DRV:
|
|
if (hmodWinSpool == NULL)
|
|
{
|
|
hmodWinSpool = LoadLibraryEx32W(WINSPOOL_DRV, NULL, 0) ;
|
|
if (hmodWinSpool == NULL)
|
|
return WN_NOT_SUPPORTED ;
|
|
}
|
|
hmod = hmodWinSpool ;
|
|
break ;
|
|
|
|
default:
|
|
return ERROR_GEN_FAILURE ;
|
|
}
|
|
|
|
//
|
|
// get the procedure
|
|
//
|
|
*lplpfn = (LPVOID) GetProcAddress32W(hmod, lpProcName) ;
|
|
if (! *lplpfn )
|
|
return WN_NOT_SUPPORTED ;
|
|
|
|
return WN_SUCCESS ;
|
|
}
|
|
|
|
/*******************************************************************
|
|
|
|
NAME: MapWNType16To32
|
|
|
|
SYNOPSIS: map the 16 WNet types for DISK/PRINT, etc
|
|
to their 32 bit equivalents
|
|
|
|
ENTRY: nType - 16 bit type
|
|
|
|
EXIT:
|
|
|
|
RETURNS: the 32 bit type
|
|
|
|
NOTES:
|
|
|
|
HISTORY:
|
|
ChuckC 25-Mar-93 Created
|
|
|
|
********************************************************************/
|
|
DWORD MapWNType16To32(WORD nType)
|
|
{
|
|
switch (nType)
|
|
{
|
|
case WNTYPE_DRIVE :
|
|
case WNTYPE_FILE :
|
|
return RESOURCETYPE_DISK ;
|
|
case WNTYPE_PRINTER :
|
|
return RESOURCETYPE_PRINT ;
|
|
case WNTYPE_COMM :
|
|
default :
|
|
return RESOURCETYPE_ERROR ;
|
|
}
|
|
}
|
|
|
|
/*******************************************************************
|
|
|
|
NAME: MapWin32ErrorToWN16
|
|
|
|
SYNOPSIS: maps a Win 32 error the old style WN_ 16 bit error.
|
|
|
|
ENTRY: err - Win32 error
|
|
|
|
EXIT:
|
|
|
|
RETURNS: Win 16 error
|
|
|
|
NOTES:
|
|
|
|
HISTORY:
|
|
ChuckC 25-Mar-93 Created
|
|
|
|
********************************************************************/
|
|
WORD MapWin32ErrorToWN16(DWORD err)
|
|
{
|
|
switch (err)
|
|
{
|
|
case ERROR_NOT_SUPPORTED:
|
|
return WN_NOT_SUPPORTED ;
|
|
|
|
case WIN32_WN_CANCEL:
|
|
return WN_CANCEL ;
|
|
|
|
case WIN32_EXTENDED_ERROR :
|
|
case ERROR_UNEXP_NET_ERR:
|
|
return WN_NET_ERROR ;
|
|
|
|
case ERROR_MORE_DATA:
|
|
return WN_MORE_DATA ;
|
|
|
|
case ERROR_INVALID_PARAMETER:
|
|
return WN_BAD_VALUE ;
|
|
|
|
case ERROR_INVALID_PASSWORD:
|
|
return WN_BAD_PASSWORD ;
|
|
|
|
case ERROR_ACCESS_DENIED:
|
|
return WN_ACCESS_DENIED ;
|
|
|
|
case ERROR_NETWORK_BUSY:
|
|
return WN_FUNCTION_BUSY ;
|
|
|
|
case ERROR_NOT_ENOUGH_MEMORY:
|
|
return WN_OUT_OF_MEMORY ;
|
|
|
|
case ERROR_BAD_NET_NAME:
|
|
case ERROR_BAD_NETPATH:
|
|
return WN_BAD_NETNAME ;
|
|
|
|
case ERROR_INVALID_DRIVE:
|
|
return WN_BAD_LOCALNAME ;
|
|
|
|
case ERROR_ALREADY_ASSIGNED:
|
|
return WN_ALREADY_CONNECTED ;
|
|
|
|
case ERROR_GEN_FAILURE:
|
|
return WN_DEVICE_ERROR ;
|
|
|
|
case NERR_UseNotFound:
|
|
return WN_NOT_CONNECTED ;
|
|
|
|
default:
|
|
return ( (WORD) err ) ;
|
|
}
|
|
}
|
|
|
|
/*******************************************************************
|
|
|
|
NAME: GetAlignedMemory
|
|
|
|
SYNOPSIS: global alloc some mem to make sure we have DWORD
|
|
aligned data. non x86 platforms may need this.
|
|
|
|
ENTRY: pAligned : used to return pointer to aligned memory allocated
|
|
pHandle : used to return handle of aligned memory allocated
|
|
wSize : bytes required
|
|
|
|
EXIT:
|
|
|
|
RETURNS: WN_SUCCESS or WN_OUT_OF_MEMORY
|
|
|
|
NOTES:
|
|
|
|
HISTORY:
|
|
ChuckC 27-Feb-94 Created
|
|
|
|
********************************************************************/
|
|
WORD GetAlignedMemory(LPVOID FAR *pAligned, HANDLE FAR *pHandle, WORD wSize)
|
|
{
|
|
*pAligned = NULL ;
|
|
*pHandle = NULL ;
|
|
|
|
if (!(*pHandle = GlobalAlloc(GMEM_ZEROINIT|GMEM_FIXED,wSize)))
|
|
{
|
|
return WN_OUT_OF_MEMORY ;
|
|
}
|
|
|
|
if (!(*pAligned = (LPVOID)GlobalLock(*pHandle)))
|
|
{
|
|
(void) GlobalFree(*pHandle) ;
|
|
*pHandle = NULL ;
|
|
return WN_OUT_OF_MEMORY ;
|
|
}
|
|
|
|
return WN_SUCCESS ;
|
|
}
|
|
|
|
/*******************************************************************
|
|
|
|
NAME: FreeAlignedMemory
|
|
|
|
SYNOPSIS: free global memory allocated by GetAlignedMemory.
|
|
|
|
ENTRY: Handle : handle of aligned memory to be freed
|
|
|
|
EXIT:
|
|
|
|
RETURNS: none
|
|
|
|
NOTES:
|
|
|
|
HISTORY:
|
|
ChuckC 27-Feb-94 Created
|
|
|
|
********************************************************************/
|
|
void FreeAlignedMemory(HANDLE handle)
|
|
{
|
|
if (handle)
|
|
{
|
|
(void) GlobalUnlock(handle) ;
|
|
(void) GlobalFree(handle) ;
|
|
}
|
|
}
|
|
|