able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/ds/nw/fpnw/client/ncpstub.c

1436 lines
33 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1993 Microsoft Corporation
Module Name:
ncpstub.c
Abstract:
Contains NCP Server APIs.
Author:
Yi-Hsin Sung (yihsins) 11-Sept-1993
Andy Herron (andyhe)
Revision History:
--*/
#include <nt.h>
#include <ntrtl.h>
#include <rpc.h>
#include <ncpsvc.h>
#include <nwstruct.h>
DWORD NwpMapRpcError(
IN DWORD RpcError
);
DWORD
FpnwApiBufferFree(
IN LPVOID pBuffer
)
/*++
Routine Description:
This API frees the memory allocated by all enumeration and getinfo APIs.
Arguments:
pBuffer - A pointer to an API information buffer previously returned
on an API call.
Return Value:
Error.
--*/
{
if ( pBuffer == NULL )
return NO_ERROR;
MIDL_user_free( pBuffer );
return NO_ERROR;
}
DWORD
NwApiBufferFree(
IN LPVOID pBuffer
)
{ return(FpnwApiBufferFree( pBuffer ));
}
DWORD
FpnwServerGetInfo(
IN LPWSTR pServerName OPTIONAL,
IN DWORD dwLevel,
OUT LPBYTE *ppServerInfo
)
/*++
Routine Description:
This API returns the information about the given server.
Arguments:
pServerName - A pointer to a UNICODE string containing the name of the
remote server on which the function is to execute. A NULL pointer
or string specifies the local machine.
dwLevel - Reserved for the level of the server structure requested, use
1 for now.
ppServerInfo - Place to store a pointer pointing to the returned
NWSERVERINFO structure.
Return Value:
Error.
--*/
{
DWORD err;
if ( dwLevel != 1 )
return ERROR_INVALID_LEVEL;
if ( ppServerInfo == NULL )
return ERROR_INVALID_PARAMETER;
RpcTryExcept
{
err = NwrServerGetInfo( pServerName,
dwLevel,
(PFPNWSERVERINFO *) ppServerInfo );
}
RpcExcept(1)
{
err = NwpMapRpcError( RpcExceptionCode() );
}
RpcEndExcept
return err;
}
DWORD
NwServerGetInfo(
IN LPWSTR pServerName OPTIONAL,
IN DWORD dwLevel,
OUT PNWSERVERINFO *ppServerInfo
)
{ return(FpnwServerGetInfo( pServerName,
dwLevel,
(LPBYTE *) ppServerInfo));
}
DWORD
FpnwServerSetInfo(
IN LPWSTR pServerName OPTIONAL,
IN DWORD dwLevel,
IN LPBYTE pServerInfo
)
/*++
Routine Description:
This API sets the information about the given server.
Arguments:
pServerName - A pointer to a UNICODE string containing the name of the
remote server on which the function is to execute. A NULL pointer
or string specifies the local machine.
dwLevel - Reserved for the level of the server structure contained in
pServerInfo, use 1 for now.
pServerInfo - Points to a NWSERVERINFO structure which contains the server
properties to set to.
Return Value:
Error.
--*/
{
DWORD err;
if ( dwLevel != 1 )
return ERROR_INVALID_LEVEL;
if ( pServerInfo == NULL )
return ERROR_INVALID_PARAMETER;
RpcTryExcept
{
err = NwrServerSetInfo( pServerName,
dwLevel,
(PNWSERVERINFO) pServerInfo );
}
RpcExcept(1)
{
err = NwpMapRpcError( RpcExceptionCode() );
}
RpcEndExcept
return err;
}
DWORD
NwServerSetInfo(
IN LPWSTR pServerName OPTIONAL,
IN DWORD dwLevel,
IN PNWSERVERINFO pServerInfo
)
{ return( FpnwServerSetInfo( pServerName,
dwLevel,
(LPBYTE) pServerInfo ));
}
DWORD
FpnwVolumeAdd(
IN LPWSTR pServerName OPTIONAL,
IN DWORD dwLevel,
IN LPBYTE pVolumeInfo
)
/*++
Routine Description:
This API adds a volume to the given server.
Arguments:
pServerName - A pointer to a UNICODE string containing the name of the
remote server on which the function is to execute. A NULL pointer
or string specifies the local machine.
dwLevel - Reserved for the level of the volume structure contained in
pVolumeInfo, use 1 & 2 for now.
pVolumeInfo - Points to a NWVOLUMEINFO structure which contains the
information about the volume to be added, i.e. the volume name, path,
type, user limit and description. dwCurrentUses will be ignored.
Return Value:
Error.
--*/
{
DWORD err;
ULONG SDLength = 0;
ULONG oldSDLength;
PSECURITY_DESCRIPTOR fileSecurityDescriptor = NULL;
PSECURITY_DESCRIPTOR oldFileSecurityDescriptor = NULL;
PFPNWVOLUMEINFO_2 volInfo = (PFPNWVOLUMEINFO_2) pVolumeInfo;
if ( dwLevel != 1 && dwLevel != 2 )
return ERROR_INVALID_LEVEL;
if ( pVolumeInfo == NULL )
return ERROR_INVALID_PARAMETER;
RpcTryExcept
{
if ( dwLevel == 2 ) {
//
// Save this. We need to restore this later.
//
oldFileSecurityDescriptor = volInfo->FileSecurityDescriptor;
oldSDLength = volInfo->dwFileSecurityDescriptorLength;
if ( oldFileSecurityDescriptor != NULL ) {
if ( !RtlValidSecurityDescriptor( oldFileSecurityDescriptor ) ) {
return ERROR_INVALID_PARAMETER;
}
//
// Make a self relative security descriptor for use in the
// RPC call..
//
err = RtlMakeSelfRelativeSD(
oldFileSecurityDescriptor,
NULL,
&SDLength
);
if (err != STATUS_BUFFER_TOO_SMALL) {
return(ERROR_INVALID_PARAMETER);
} else {
fileSecurityDescriptor = MIDL_user_allocate( SDLength );
if ( fileSecurityDescriptor == NULL) {
return ERROR_NOT_ENOUGH_MEMORY;
} else {
//
// make an appropriate self-relative security descriptor
//
err = RtlMakeSelfRelativeSD(
oldFileSecurityDescriptor,
(PSECURITY_DESCRIPTOR) fileSecurityDescriptor,
&SDLength
);
if ( !NT_SUCCESS(err) ) {
MIDL_user_free( fileSecurityDescriptor );
return(ERROR_INVALID_PARAMETER);
}
volInfo->FileSecurityDescriptor = fileSecurityDescriptor;
volInfo->dwFileSecurityDescriptorLength = SDLength;
}
}
} else {
volInfo->dwFileSecurityDescriptorLength = 0;
}
}
err = NwrVolumeAdd( pServerName,
dwLevel,
(LPVOLUME_INFO) pVolumeInfo );
if ( fileSecurityDescriptor != NULL ) {
//
// restore old values
//
volInfo->dwFileSecurityDescriptorLength = oldSDLength;
volInfo->FileSecurityDescriptor = oldFileSecurityDescriptor;
MIDL_user_free( fileSecurityDescriptor );
}
}
RpcExcept(1)
{
err = NwpMapRpcError( RpcExceptionCode() );
}
RpcEndExcept
return err;
}
DWORD
NwVolumeAdd(
IN LPWSTR pServerName OPTIONAL,
IN DWORD dwLevel,
IN PNWVOLUMEINFO pVolumeInfo
)
{ return( FpnwVolumeAdd( pServerName, dwLevel, (LPBYTE) pVolumeInfo ));
}
DWORD
FpnwVolumeDel(
IN LPWSTR pServerName OPTIONAL,
IN LPWSTR pVolumeName
)
/*++
Routine Description:
This API deletes a volume from the given server.
Arguments:
pServerName - A pointer to a UNICODE string containing the name of the
remote server on which the function is to execute. A NULL pointer
or string specifies the local machine.
pVolumeName - Specifies teh volume name that is to be deleted.
Return Value:
Error.
--*/
{
DWORD err;
if ( (pVolumeName == NULL) || (pVolumeName[0] == 0 ))
return ERROR_INVALID_PARAMETER;
RpcTryExcept
{
err = NwrVolumeDel( pServerName,
pVolumeName );
}
RpcExcept(1)
{
err = NwpMapRpcError( RpcExceptionCode() );
}
RpcEndExcept
return err;
}
DWORD
NwVolumeDel(
IN LPWSTR pServerName OPTIONAL,
IN LPWSTR pVolumeName
)
{ return( FpnwVolumeDel( pServerName, pVolumeName ));
}
DWORD
FpnwVolumeEnum(
IN LPWSTR pServerName OPTIONAL,
IN DWORD dwLevel,
OUT LPBYTE *ppVolumeInfo,
OUT PDWORD pEntriesRead,
IN OUT PDWORD resumeHandle OPTIONAL
)
/*++
Routine Description:
This enumerates all volumes on the given server.
Arguments:
pServerName - A pointer to a UNICODE string containing the name of the
remote server on which the function is to execute. A NULL pointer
or string specifies the local machine.
dwLevel - Reserved for the level of the volume structure contained in
*ppVolumeInfo, use 1 for now.
ppVolumeInfo - On return, this will point to an array of NWVOLUMEINFO
structures, one for each volume on the server.
pEntriesRead - On return, this will specify the number of volumes returned
resumeHandle - On return, a resume handle is stored in the DWORD pointed
to by resumeHandle, and is used to continue an existing server search.
The handle should be zero on the first call and left unchanged for
subsequent calls. If the resumeHandle is NULL, then no resume
handle is stored.
Return Value:
Error.
--*/
{
DWORD err;
FPNWVOLUMEINFO_CONTAINER NwVolumeInfoContainer;
if ( dwLevel != 1 )
return ERROR_INVALID_LEVEL;
if ( ppVolumeInfo == NULL || pEntriesRead == NULL )
return ERROR_INVALID_PARAMETER;
NwVolumeInfoContainer.Buffer = NULL;
RpcTryExcept
{
err = NwrVolumeEnum( pServerName,
dwLevel,
&NwVolumeInfoContainer,
resumeHandle );
*ppVolumeInfo = (LPBYTE) NwVolumeInfoContainer.Buffer;
if ( NwVolumeInfoContainer.Buffer != NULL ) {
*pEntriesRead = NwVolumeInfoContainer.EntriesRead;
} else {
*pEntriesRead = 0;
}
}
RpcExcept(1)
{
err = NwpMapRpcError( RpcExceptionCode() );
}
RpcEndExcept
return err;
}
DWORD
NwVolumeEnum(
IN LPWSTR pServerName OPTIONAL,
IN DWORD dwLevel,
OUT PNWVOLUMEINFO *ppVolumeInfo,
OUT PDWORD pEntriesRead,
IN OUT PDWORD resumeHandle OPTIONAL
)
{ return(FpnwVolumeEnum( pServerName,
dwLevel,
(LPBYTE *)ppVolumeInfo,
pEntriesRead,
resumeHandle ));
}
DWORD
FpnwVolumeGetInfo(
IN LPWSTR pServerName OPTIONAL,
IN LPWSTR pVolumeName,
IN DWORD dwLevel,
OUT LPBYTE *ppVolumeInfo
)
/*++
Routine Description:
This querys the information about the given volume on the given server.
Arguments:
pServerName - A pointer to a UNICODE string containing the name of the
remote server on which the function is to execute. A NULL pointer
or string specifies the local machine.
pVolumeName - A pointer to a UNICODE string containing the name of the
volume we want to get information on.
dwLevel - Reserved for the level of the volume structure contained in
*ppVolumeInfo, use 1 for now.
ppVolumeInfo - On return, this will point to a NWVOLUMEINFO structure
which contains information on the given volume on the given server.
Return Value:
Error.
--*/
{
DWORD err;
if ( dwLevel != 1 && dwLevel != 2 ) {
return ERROR_INVALID_LEVEL;
}
if ((pVolumeName == NULL) ||
(pVolumeName[0] == 0 ) ||
(ppVolumeInfo == NULL) ) {
return ERROR_INVALID_PARAMETER;
}
*ppVolumeInfo = NULL ;
RpcTryExcept
{
err = NwrVolumeGetInfo( pServerName,
pVolumeName,
dwLevel,
(LPVOLUME_INFO *) ppVolumeInfo );
}
RpcExcept(1)
{
err = NwpMapRpcError( RpcExceptionCode() );
}
RpcEndExcept
return err;
}
DWORD
NwVolumeGetInfo(
IN LPWSTR pServerName OPTIONAL,
IN LPWSTR pVolumeName,
IN DWORD dwLevel,
OUT PNWVOLUMEINFO *ppVolumeInfo
)
{ return(FpnwVolumeGetInfo( pServerName,
pVolumeName,
dwLevel,
(LPBYTE *)ppVolumeInfo ));
}
DWORD
FpnwVolumeSetInfo(
IN LPWSTR pServerName OPTIONAL,
IN LPWSTR pVolumeName,
IN DWORD dwLevel,
IN LPBYTE pVolumeInfo
)
/*++
Routine Description:
This sets the information about the given volume on the given server.
Arguments:
pServerName - A pointer to a UNICODE string containing the name of the
remote server on which the function is to execute. A NULL pointer
or string specifies the local machine.
pVolumeName - A pointer to a UNICODE string containing the name of the
volume we want to set information on.
dwLevel - Reserved for the level of the volume structure contained in
pVolumeInfo, use 1 for now.
pVolumeInfo - Points to a NWVOLUMEINFO structure which contains
information on the given volume to set to. Only dwMaxUses can be
set. All the other fields in this structure will be ignored.
Return Value:
Error.
--*/
{
DWORD err;
ULONG SDLength = 0;
ULONG oldSDLength;
PFPNWVOLUMEINFO_2 volInfo = (PFPNWVOLUMEINFO_2) pVolumeInfo;
PSECURITY_DESCRIPTOR fileSecurityDescriptor = NULL;
PSECURITY_DESCRIPTOR oldFileSecurityDescriptor = NULL;
if ( dwLevel != 1 && dwLevel != 2 )
return ERROR_INVALID_LEVEL;
if ( ((pVolumeName == NULL) ||
( pVolumeName[0] == 0 )) ||
( pVolumeInfo == NULL )
) {
return ERROR_INVALID_PARAMETER;
}
RpcTryExcept
{
if ( dwLevel == 2 ) {
//
// Save this. We need to restore this later.
//
oldFileSecurityDescriptor = volInfo->FileSecurityDescriptor;
oldSDLength = volInfo->dwFileSecurityDescriptorLength;
if ( oldFileSecurityDescriptor != NULL ) {
if ( !RtlValidSecurityDescriptor( oldFileSecurityDescriptor ) ) {
return ERROR_INVALID_PARAMETER;
}
//
// Make a self relative security descriptor for use in the
// RPC call..
//
err = RtlMakeSelfRelativeSD(
oldFileSecurityDescriptor,
NULL,
&SDLength
);
if (err != STATUS_BUFFER_TOO_SMALL) {
return(ERROR_INVALID_PARAMETER);
} else {
fileSecurityDescriptor = MIDL_user_allocate( SDLength );
if ( fileSecurityDescriptor == NULL) {
return ERROR_NOT_ENOUGH_MEMORY;
} else {
//
// make an appropriate self-relative security descriptor
//
err = RtlMakeSelfRelativeSD(
oldFileSecurityDescriptor,
(PSECURITY_DESCRIPTOR) fileSecurityDescriptor,
&SDLength
);
if ( !NT_SUCCESS(err) ) {
MIDL_user_free( fileSecurityDescriptor );
return(ERROR_INVALID_PARAMETER);
}
volInfo->FileSecurityDescriptor = fileSecurityDescriptor;
volInfo->dwFileSecurityDescriptorLength = SDLength;
}
}
} else {
volInfo->dwFileSecurityDescriptorLength = 0;
}
}
err = NwrVolumeSetInfo( pServerName,
pVolumeName,
dwLevel,
(LPVOLUME_INFO) pVolumeInfo );
if ( fileSecurityDescriptor != NULL ) {
//
// restore old values
//
volInfo->dwFileSecurityDescriptorLength = oldSDLength;
volInfo->FileSecurityDescriptor = oldFileSecurityDescriptor;
MIDL_user_free( fileSecurityDescriptor );
}
}
RpcExcept(1)
{
err = NwpMapRpcError( RpcExceptionCode() );
}
RpcEndExcept
return err;
}
DWORD
NwVolumeSetInfo(
IN LPWSTR pServerName OPTIONAL,
IN LPWSTR pVolumeName,
IN DWORD dwLevel,
IN PNWVOLUMEINFO pVolumeInfo
)
{ return( FpnwVolumeSetInfo( pServerName,
pVolumeName,
dwLevel,
(LPBYTE) pVolumeInfo ));
}
DWORD
FpnwConnectionEnum(
IN LPWSTR pServerName OPTIONAL,
IN DWORD dwLevel,
OUT LPBYTE *ppConnectionInfo,
OUT PDWORD pEntriesRead,
IN OUT PDWORD resumeHandle OPTIONAL
)
/*++
Routine Description:
This enumerates all connections on the given server.
Arguments:
pServerName - A pointer to a UNICODE string containing the name of the
remote server on which the function is to execute. A NULL pointer
or string specifies the local machine.
dwLevel - Reserved for the level of the volume structure contained in
*ppConnectionInfo, use 1 for now.
ppConnectionInfo - On return, this will point to an array of
NWCONNECTIONINFO structures, one for each volume on the server.
pEntriesRead - On return, this will specify the number of current
connecitons.
resumeHandle - On return, a resume handle is stored in the DWORD pointed
to by resumeHandle, and is used to continue an existing server search.
The handle should be zero on the first call and left unchanged for
subsequent calls. If the resumeHandle is NULL, then no resume
handle is stored.
Return Value:
Error.
--*/
{
DWORD err;
FPNWCONNECTIONINFO_CONTAINER NwConnectionInfoContainer;
if ( dwLevel != 1 )
return ERROR_INVALID_LEVEL;
if (( ppConnectionInfo == NULL ) || ( pEntriesRead == NULL ))
return ERROR_INVALID_PARAMETER;
NwConnectionInfoContainer.Buffer = NULL;
RpcTryExcept
{
err = NwrConnectionEnum( pServerName,
dwLevel,
&NwConnectionInfoContainer,
resumeHandle );
*ppConnectionInfo = (LPBYTE) NwConnectionInfoContainer.Buffer;
if ( NwConnectionInfoContainer.Buffer != NULL ) {
*pEntriesRead = NwConnectionInfoContainer.EntriesRead;
} else {
*pEntriesRead = 0;
}
}
RpcExcept(1)
{
err = NwpMapRpcError( RpcExceptionCode() );
}
RpcEndExcept
return err;
}
DWORD
NwConnectionEnum(
IN LPWSTR pServerName OPTIONAL,
IN DWORD dwLevel,
OUT PNWCONNECTIONINFO *ppConnectionInfo,
OUT PDWORD pEntriesRead,
IN OUT PDWORD resumeHandle OPTIONAL
)
{ return(FpnwConnectionEnum( pServerName,
dwLevel,
(LPBYTE *) ppConnectionInfo,
pEntriesRead,
resumeHandle ));
}
DWORD
FpnwConnectionDel(
IN LPWSTR pServerName OPTIONAL,
IN DWORD dwConnectionId
)
/*++
Routine Description:
This delete the connection with the given connection id on the given server.
Arguments:
pServerName - A pointer to a UNICODE string containing the name of the
remote server on which the function is to execute. A NULL pointer
or string specifies the local machine.
dwConnectionId - The identification number of the connection to tear down.
Return Value:
Error.
--*/
{
DWORD err;
RpcTryExcept
{
err = NwrConnectionDel( pServerName,
dwConnectionId );
}
RpcExcept(1)
{
err = NwpMapRpcError( RpcExceptionCode() );
}
RpcEndExcept
return err;
}
DWORD
NwConnectionDel(
IN LPWSTR pServerName OPTIONAL,
IN DWORD dwConnectionId
)
{ return( FpnwConnectionDel( pServerName, dwConnectionId ));
}
DWORD
FpnwVolumeConnEnum(
IN LPWSTR pServerName OPTIONAL,
IN DWORD dwLevel,
IN LPWSTR pVolumeName OPTIONAL,
IN DWORD dwConnectionId,
OUT LPBYTE *ppVolumeConnInfo,
OUT PDWORD pEntriesRead,
IN OUT PDWORD resumeHandle OPTIONAL
)
/*++
Routine Description:
This enumerates all connections to a volume or list all volumes used by
a particular connection on the given server.
Arguments:
pServerName - A pointer to a UNICODE string containing the name of the
remote server on which the function is to execute. A NULL pointer
or string specifies the local machine.
dwLevel - Reserved for the level of the volume structure contained in
*ppVolumeConnInfo, use 1 for now.
pVolumeName - Specifies the volume name which we want to get all opened
resources. This must be NULL if dwConnectionId is not 0.
dwConnectionId - Specifies the connection id on which we want to get all
opened resources. This must be 0 if pVolumeName is not NULL.
ppVolumeConnInfo - On return, this will point to an array of
NWVOLUMECONNINFO structures.
pEntriesRead - On return, this will specify the number of NWVOLUMECONNINFO
returned.
resumeHandle - On return, a resume handle is stored in the DWORD pointed
to by resumeHandle, and is used to continue an existing server search.
The handle should be zero on the first call and left unchanged for
subsequent calls. If the resumeHandle is NULL, then no resume
handle is stored.
Return Value:
Error.
--*/
{
DWORD err;
FPNWVOLUMECONNINFO_CONTAINER NwVolumeConnInfoContainer;
if ( dwLevel != 1 )
return ERROR_INVALID_LEVEL;
if ( ( dwConnectionId == 0 )
&& (( pVolumeName == NULL ) || ( *pVolumeName == 0 ))
)
{
return ERROR_INVALID_PARAMETER;
}
if ( ( dwConnectionId != 0 )
&& (( pVolumeName != NULL) && ( *pVolumeName != 0 ))
)
{
return ERROR_INVALID_PARAMETER;
}
if (( ppVolumeConnInfo == NULL ) || ( pEntriesRead == NULL ))
return ERROR_INVALID_PARAMETER;
NwVolumeConnInfoContainer.Buffer = NULL;
RpcTryExcept
{
err = NwrVolumeConnEnum( pServerName,
dwLevel,
pVolumeName,
dwConnectionId,
&NwVolumeConnInfoContainer,
resumeHandle );
*ppVolumeConnInfo = (LPBYTE) NwVolumeConnInfoContainer.Buffer;
if ( NwVolumeConnInfoContainer.Buffer != NULL ) {
*pEntriesRead = NwVolumeConnInfoContainer.EntriesRead;
} else {
*pEntriesRead = 0;
}
}
RpcExcept(1)
{
err = NwpMapRpcError( RpcExceptionCode() );
}
RpcEndExcept
return err;
}
DWORD
NwVolumeConnEnum(
IN LPWSTR pServerName OPTIONAL,
IN DWORD dwLevel,
IN LPWSTR pVolumeName OPTIONAL,
IN DWORD dwConnectionId,
OUT PNWVOLUMECONNINFO *ppVolumeConnInfo,
OUT PDWORD pEntriesRead,
IN OUT PDWORD resumeHandle OPTIONAL
)
{ return( FpnwVolumeConnEnum( pServerName,
dwLevel,
pVolumeName,
dwConnectionId,
(LPBYTE *) ppVolumeConnInfo,
pEntriesRead,
resumeHandle ));
}
DWORD
FpnwFileEnum(
IN LPWSTR pServerName OPTIONAL,
IN DWORD dwLevel,
IN LPWSTR pPathName OPTIONAL,
OUT LPBYTE *ppFileInfo,
OUT PDWORD pEntriesRead,
IN OUT PDWORD resumeHandle OPTIONAL
)
/*++
Routine Description:
This enumerates files opened on the server.
Arguments:
pServerName - A pointer to a UNICODE string containing the name of the
remote server on which the function is to execute. A NULL pointer
or string specifies the local machine.
dwLevel - Reserved for the level of the volume structure contained in
*ppFileInfo, use 1 for now.
pPathName - If this is not NULL, this means that we want to filter
on the path. We only want entries with this path, i.e., all users that
currently opened the file. If this is NULL, then all files that are
opened are returned along with the user information.
ppFileInfo - On return, this will point to an array of NWFILEINFO structures
pEntriesRead - On return, this will specify the number of NWFILEINFO
returned.
resumeHandle - On return, a resume handle is stored in the DWORD pointed
to by resumeHandle, and is used to continue an existing server search.
The handle should be zero on the first call and left unchanged for
subsequent calls. If the resumeHandle is NULL, then no resume
handle is stored.
Return Value:
Error.
--*/
{
DWORD err;
FPNWFILEINFO_CONTAINER NwFileInfoContainer;
if ( dwLevel != 1 )
return ERROR_INVALID_LEVEL;
if (( ppFileInfo == NULL ) || ( pEntriesRead == NULL ))
return ERROR_INVALID_PARAMETER;
NwFileInfoContainer.Buffer = NULL;
RpcTryExcept
{
err = NwrFileEnum( pServerName,
dwLevel,
pPathName,
&NwFileInfoContainer,
resumeHandle );
*ppFileInfo = (LPBYTE) NwFileInfoContainer.Buffer;
if ( NwFileInfoContainer.Buffer != NULL ) {
*pEntriesRead = NwFileInfoContainer.EntriesRead;
} else {
*pEntriesRead = 0;
}
}
RpcExcept(1)
{
err = NwpMapRpcError( RpcExceptionCode() );
}
RpcEndExcept
return err;
}
DWORD
NwFileEnum(
IN LPWSTR pServerName OPTIONAL,
IN DWORD dwLevel,
IN LPWSTR pPathName OPTIONAL,
OUT PNWFILEINFO *ppFileInfo,
OUT PDWORD pEntriesRead,
IN OUT PDWORD resumeHandle OPTIONAL
)
{ return(FpnwFileEnum( pServerName,
dwLevel,
pPathName,
(LPBYTE *) ppFileInfo,
pEntriesRead,
resumeHandle ));
}
DWORD
FpnwFileClose(
IN LPWSTR pServerName OPTIONAL,
IN DWORD dwFileId
)
/*++
Routine Description:
This closes the file with the given identification number.
Arguments:
pServerName - A pointer to a UNICODE string containing the name of the
remote server on which the function is to execute. A NULL pointer
or string specifies the local machine.
dwFileId - The identification number of the file to close.
Return Value:
Error.
--*/
{
DWORD err;
RpcTryExcept
{
err = NwrFileClose( pServerName,
dwFileId );
}
RpcExcept(1)
{
err = NwpMapRpcError( RpcExceptionCode() );
}
RpcEndExcept
return err;
}
DWORD
NwFileClose(
IN LPWSTR pServerName OPTIONAL,
IN DWORD dwFileId
)
{ return(FpnwFileClose( pServerName, dwFileId ));
}
DWORD
FpnwMessageBufferSend(
IN LPWSTR pServerName OPTIONAL,
IN DWORD dwConnectionId,
IN DWORD fConsoleBroadcast,
IN LPBYTE pbBuffer,
IN DWORD cbBuffer
)
/*++
Routine Description:
This sends the message to the given connection id.
Arguments:
pServerName - A pointer to a UNICODE string containing the name of the
remote server on which the function is to execute. A NULL pointer
or string specifies the local machine.
dwConnectionId - The id of the connection to send message to.
fConsoleBroadcast - If this is TRUE, that means use console broadcast. If
FALSE, use user broadcast.
pbBuffer - Points to the message buffer to be sent.
cbBuffer - The size of the pbBuffer in bytes.
Return Value:
Error.
--*/
{
DWORD err;
if (( pbBuffer == NULL ) || ( cbBuffer == 0 ))
return ERROR_INVALID_PARAMETER;
RpcTryExcept
{
err = NwrMessageBufferSend( pServerName,
dwConnectionId,
fConsoleBroadcast,
pbBuffer,
cbBuffer );
}
RpcExcept(1)
{
err = NwpMapRpcError( RpcExceptionCode() );
}
RpcEndExcept
return err;
}
DWORD
NwMessageBufferSend(
IN LPWSTR pServerName OPTIONAL,
IN DWORD dwConnectionId,
IN DWORD fConsoleBroadcast,
IN LPBYTE pbBuffer,
IN DWORD cbBuffer
)
{ return( FpnwMessageBufferSend( pServerName,
dwConnectionId,
fConsoleBroadcast,
pbBuffer,
cbBuffer ));
}
DWORD
FpnwSetDefaultQueue(
IN LPWSTR pServerName OPTIONAL,
IN LPWSTR pQueueName
)
/*++
Routine Description:
This sets the default queue on the server.
Arguments:
pServerName - A pointer to a UNICODE string containing the name of the
remote server on which the function is to execute. A NULL pointer
or string specifies the local machine.
pQueueName - The name of the queue that will become the default
Return Value:
Error.
--*/
{
DWORD err;
if (( pQueueName == NULL ) || ( *pQueueName == 0 ))
return ERROR_INVALID_PARAMETER;
RpcTryExcept
{
err = NwrSetDefaultQueue( pServerName,
pQueueName );
}
RpcExcept(1)
{
err = NwpMapRpcError( RpcExceptionCode() );
}
RpcEndExcept
return err;
}
DWORD
NwSetDefaultQueue(
IN LPWSTR pServerName OPTIONAL,
IN LPWSTR pQueueName
)
{ return(FpnwSetDefaultQueue( pServerName, pQueueName ));
}
DWORD
FpnwAddPServer(
IN LPWSTR pServerName OPTIONAL,
IN LPWSTR pPServerName
)
/*++
Routine Description:
This adds a pserver.
Arguments:
pServerName - A pointer to a UNICODE string containing the name of the
remote server on which the function is to execute. A NULL pointer
or string specifies the local machine.
pPServerName - The name of the PServer.
Return Value:
Error.
--*/
{
DWORD err;
if (( pPServerName == NULL ) || ( *pPServerName == 0 ))
return ERROR_INVALID_PARAMETER;
RpcTryExcept
{
err = NwrAddPServer( pServerName,
pPServerName );
}
RpcExcept(1)
{
err = NwpMapRpcError( RpcExceptionCode() );
}
RpcEndExcept
return err;
}
DWORD
NwAddPServer(
IN LPWSTR pServerName OPTIONAL,
IN LPWSTR pPServerName
)
{ return( FpnwAddPServer( pServerName, pPServerName ));
}
DWORD
FpnwRemovePServer(
IN LPWSTR pServerName OPTIONAL,
IN LPWSTR pPServerName
)
/*++
Routine Description:
This removes a pserver.
Arguments:
pServerName - A pointer to a UNICODE string containing the name of the
remote server on which the function is to execute. A NULL pointer
or string specifies the local machine.
pPServerName - The name of the PServer.
Return Value:
Error.
--*/
{
DWORD err;
if (( pPServerName == NULL ) || ( *pPServerName == 0 ))
return ERROR_INVALID_PARAMETER;
RpcTryExcept
{
err = NwrRemovePServer( pServerName,
pPServerName );
}
RpcExcept(1)
{
err = NwpMapRpcError( RpcExceptionCode() );
}
RpcEndExcept
return err;
}
DWORD
NwRemovePServer(
IN LPWSTR pServerName OPTIONAL,
IN LPWSTR pPServerName
)
{ return( FpnwRemovePServer( pServerName, pPServerName ));
}
DWORD NwpMapRpcError(
IN DWORD RpcError
)
/*++
Routine Description:
This routine maps the RPC error into a more meaningful windows
error for the caller.
Arguments:
RpcError - Supplies the exception error raised by RPC
Return Value:
Returns the mapped error.
--*/
{
switch (RpcError)
{
case RPC_S_INVALID_BINDING:
case RPC_X_SS_IN_NULL_CONTEXT:
case RPC_X_SS_CONTEXT_DAMAGED:
case RPC_X_SS_HANDLES_MISMATCH:
case ERROR_INVALID_HANDLE:
return ERROR_INVALID_HANDLE;
case RPC_X_NULL_REF_POINTER:
return ERROR_INVALID_PARAMETER;
case STATUS_ACCESS_VIOLATION:
return ERROR_INVALID_ADDRESS;
default:
return RpcError;
}
}
// ncpstub.c eof.
Reference in a new issue Copy permalink