able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/mvdm/wow16/wfwnet/to32.c

1269 lines
34 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
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) ;
}
}

Reference in a new issue Copy permalink