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.
769 lines
21 KiB
769 lines
21 KiB
/*++
|
|
|
|
|
|
Intel Corporation Proprietary Information
|
|
Copyright (c) 1995 Intel Corporation
|
|
|
|
This listing is supplied under the terms of a license agreement with
|
|
Intel Corporation and may not be used, copied, nor disclosed except in
|
|
accordance with the terms of that agreeement.
|
|
|
|
|
|
Module Name:
|
|
|
|
nsprovid.h
|
|
|
|
Abstract:
|
|
|
|
This module defines the WinSock2 class NSPROVIDER along with its
|
|
methods.
|
|
|
|
Author:
|
|
|
|
Dirk Brandewie ([email protected]) 05-Dec-1995
|
|
|
|
Revision History:
|
|
|
|
09-Nov-1995 [email protected]
|
|
Initial Revision
|
|
--*/
|
|
#ifndef _NSPROVIDER_
|
|
#define _NSPROVIDER_
|
|
|
|
#include <winsock2.h>
|
|
#include <ws2spi.h>
|
|
#include "classfwd.h"
|
|
#include "dthook.h"
|
|
#include "wsautil.h"
|
|
#include "dprocess.h"
|
|
#include "dthread.h"
|
|
|
|
|
|
class NSPROVIDER {
|
|
|
|
public:
|
|
|
|
NSPROVIDER();
|
|
|
|
INT
|
|
Initialize(
|
|
IN LPWSTR lpszLibFile,
|
|
IN LPGUID lpProviderId
|
|
);
|
|
|
|
|
|
INT WSAAPI
|
|
NSPUnInstallNameSpace (
|
|
);
|
|
|
|
//
|
|
// Client Query APIs
|
|
//
|
|
|
|
INT WSAAPI
|
|
NSPLookupServiceBegin(
|
|
IN LPWSAQUERYSETW lpqsRestrictions,
|
|
IN LPWSASERVICECLASSINFOW lpServiceClassInfo,
|
|
IN DWORD dwControlFlags,
|
|
OUT LPHANDLE lphLookup
|
|
);
|
|
|
|
INT WINAPI
|
|
SupportsIoctl(
|
|
);
|
|
|
|
INT WSAAPI
|
|
NSPIoctl(
|
|
IN HANDLE hLookup,
|
|
IN DWORD dwControlCode,
|
|
IN LPVOID lpvInBuffer,
|
|
IN DWORD cbInBuffer,
|
|
OUT LPVOID lpvOutBuffer,
|
|
IN DWORD cbOutBuffer,
|
|
OUT LPDWORD lpcbBytesReturned,
|
|
IN LPWSACOMPLETION lpCompletion,
|
|
IN LPWSATHREADID lpThreadId
|
|
);
|
|
|
|
INT WSAAPI
|
|
NSPLookupServiceNext(
|
|
IN HANDLE hLookup,
|
|
IN DWORD dwcontrolFlags,
|
|
IN OUT LPDWORD lpdwBufferLength,
|
|
OUT LPWSAQUERYSETW lpqsResults
|
|
);
|
|
|
|
INT WSAAPI
|
|
NSPLookupServiceEnd(
|
|
IN HANDLE hLookup
|
|
);
|
|
|
|
//
|
|
// Service Address Registration and Deregistration APIs and Data Types.
|
|
//
|
|
|
|
INT WSAAPI
|
|
NSPSetService(
|
|
IN LPWSASERVICECLASSINFOW lpServiceClassInfo,
|
|
IN LPWSAQUERYSETW lpqsRegInfo,
|
|
IN WSAESETSERVICEOP essOperation,
|
|
IN DWORD dwControlFlags
|
|
);
|
|
|
|
|
|
//
|
|
// Service Installation/Removal APIs and Data Types.
|
|
//
|
|
|
|
INT WSAAPI
|
|
NSPInstallServiceClass(
|
|
IN LPWSASERVICECLASSINFOW lpServiceClassInfo
|
|
);
|
|
|
|
INT WSAAPI
|
|
NSPRemoveServiceClass(
|
|
IN LPGUID lpServiceClassId
|
|
);
|
|
|
|
INT WSAAPI
|
|
NSPGetServiceClassInfo(
|
|
IN OUT LPDWORD lpdwBufSize,
|
|
IN OUT LPWSASERVICECLASSINFOW lpServiceClassInfo
|
|
);
|
|
|
|
|
|
// Provider cleanup
|
|
INT WSAAPI
|
|
NSPCleanup (
|
|
);
|
|
|
|
VOID
|
|
Reference (
|
|
);
|
|
|
|
VOID
|
|
Dereference (
|
|
);
|
|
|
|
private:
|
|
|
|
// Should never be called directly, but through dereferencing.
|
|
~NSPROVIDER();
|
|
|
|
LONG m_reference_count;
|
|
// How many time this structure was referenced
|
|
|
|
DWORD m_namespace_id;
|
|
// The identifier of the namespace supported by the service provider.
|
|
|
|
HINSTANCE m_library_handle;
|
|
// The handle to the service provider DLL.
|
|
|
|
NSP_ROUTINE m_proctable;
|
|
// Structure containing the fuction pointers to the entry points of the
|
|
// service provider DLL.
|
|
|
|
GUID m_provider_id;
|
|
// The GUID associated with an interface in the service provider DLL.
|
|
|
|
#ifdef DEBUG_TRACING
|
|
LPSTR m_library_name;
|
|
// The name of the service provider DLL.
|
|
#endif
|
|
|
|
};
|
|
|
|
inline
|
|
VOID
|
|
NSPROVIDER::Reference () {
|
|
//
|
|
// Object is created with reference count of 1
|
|
// and is destroyed whenever it gets back to 0.
|
|
//
|
|
assert (m_reference_count>0);
|
|
InterlockedIncrement (&m_reference_count);
|
|
}
|
|
|
|
inline
|
|
VOID
|
|
NSPROVIDER::Dereference () {
|
|
assert (m_reference_count>0);
|
|
if (InterlockedDecrement (&m_reference_count)==0)
|
|
delete this;
|
|
}
|
|
|
|
//
|
|
// Client Query APIs
|
|
//
|
|
|
|
|
|
inline INT WSAAPI
|
|
NSPROVIDER::NSPLookupServiceBegin(
|
|
IN LPWSAQUERYSETW lpqsRestrictions,
|
|
IN LPWSASERVICECLASSINFOW lpServiceClassInfo,
|
|
IN DWORD dwControlFlags,
|
|
OUT LPHANDLE lphLookup
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
NSPLookupServiceBegin() is used to initiate a client query that is
|
|
constrained by the information contained within a WSAQUERYSET
|
|
structure. WSALookupServiceBegin() only returns a handle, which should be
|
|
used by subsequent calls to NSPLookupServiceNext() to get the actual
|
|
results.
|
|
|
|
|
|
|
|
Arguments:
|
|
|
|
lpProviderId - Contains the specific provider ID that should be used for
|
|
the query.
|
|
|
|
lpqsRestrictions - contains the search criteria.
|
|
|
|
lpServiceClassInfo - A WSASERVICECLASSINFOW structure which contains all of
|
|
the schema information for the service.
|
|
|
|
dwControlFlags - controls the depth of the search:
|
|
|
|
lphLookup - Handle to be used in subsequent calls to NSPLookupServiceNext
|
|
in order to retrieve the results set.
|
|
|
|
Return Value:
|
|
|
|
The function should return NO_ERROR (0) if the routine succeeds. It should
|
|
return SOCKET_ERROR (-1) if the routine fails
|
|
--*/
|
|
{
|
|
INT ReturnValue=SOCKET_ERROR;
|
|
|
|
assert (m_reference_count>0);
|
|
if (PREAPINOTIFY(( DTCODE_NSPLookupServiceBegin,
|
|
&ReturnValue,
|
|
(LPSTR) m_library_name,
|
|
&m_provider_id,
|
|
&lpqsRestrictions,
|
|
&lpServiceClassInfo,
|
|
&dwControlFlags,
|
|
&lphLookup )) ) {
|
|
return(ReturnValue);
|
|
}
|
|
|
|
ReturnValue = ReturnValue = m_proctable.NSPLookupServiceBegin(
|
|
&m_provider_id,
|
|
lpqsRestrictions,
|
|
lpServiceClassInfo,
|
|
dwControlFlags,
|
|
lphLookup
|
|
);
|
|
|
|
POSTAPINOTIFY((DTCODE_NSPLookupServiceBegin,
|
|
&ReturnValue,
|
|
m_library_name,
|
|
&m_provider_id,
|
|
&lpqsRestrictions,
|
|
&lpServiceClassInfo,
|
|
&dwControlFlags,
|
|
&lphLookup ));
|
|
|
|
assert (m_reference_count>0);
|
|
return(ReturnValue);
|
|
|
|
|
|
}
|
|
|
|
inline INT WSAAPI
|
|
NSPROVIDER::NSPLookupServiceNext(
|
|
IN HANDLE hLookup,
|
|
IN DWORD dwControlFlags,
|
|
IN OUT LPDWORD lpdwBufferLength,
|
|
OUT LPWSAQUERYSETW lpqsResults
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
NSPLookupServiceNext() is called after obtaining a Handle from a previous
|
|
call to NSPLookupServiceBegin() in order to retrieve the requested service
|
|
information. The provider will pass back a WSAQUERYSET structure in the
|
|
lpqsResults buffer. The client should continue to call this API until it
|
|
returns WSA_E_NOMORE, indicating that all of the WSAQUERYSET have been
|
|
returned.
|
|
|
|
Arguments:
|
|
|
|
hLookup - Handle returned from the previous call to
|
|
NSPLookupServiceBegin().
|
|
|
|
dwControlFlags - Flags to control the next operation. This is currently
|
|
used to indicate to the provider what to do if the result
|
|
set is too big for the buffer. If on the previous call to
|
|
NSPLookupServiceNext() the result set was too large for
|
|
the buffer, the client can choose to do one of two things
|
|
on this call. First, it can choose to pass a bigger
|
|
buffer and try again. Second, if it cannot or is
|
|
unwilling to allocate a larger buffer, it can pass
|
|
LUP_FLUSHPREVIOUS to tell the provider to throw away the
|
|
last result set - which was too large - and move on to the
|
|
next set for this call.
|
|
|
|
lpdwBufferLength - on input, the number of bytes contained in the buffer
|
|
pointed to by lpresResults. On output - if the API
|
|
fails, and the error is WSAEFAULT, then it contains the
|
|
minimum number of bytes to pass for the lpqsResults to
|
|
retrieve the record.
|
|
|
|
lpqsResults - a pointer to a block of memory, which will contain one result
|
|
set in a WSAQUERYSET structure on return.
|
|
|
|
Return Value:
|
|
|
|
The function should return NO_ERROR (0) if the routine succeeds. It should
|
|
return SOCKET_ERROR (-1) if the routine fails.
|
|
--*/
|
|
{
|
|
INT ReturnValue=SOCKET_ERROR;
|
|
|
|
assert (m_reference_count>0);
|
|
if (PREAPINOTIFY(( DTCODE_NSPLookupServiceNext,
|
|
&ReturnValue,
|
|
m_library_name,
|
|
&hLookup,
|
|
&dwControlFlags,
|
|
&lpdwBufferLength,
|
|
&lpqsResults )) ) {
|
|
return(ReturnValue);
|
|
}
|
|
|
|
ReturnValue = m_proctable.NSPLookupServiceNext(
|
|
hLookup,
|
|
dwControlFlags,
|
|
lpdwBufferLength,
|
|
lpqsResults
|
|
);
|
|
|
|
POSTAPINOTIFY((DTCODE_NSPLookupServiceNext,
|
|
&ReturnValue,
|
|
m_library_name,
|
|
&hLookup,
|
|
&dwControlFlags,
|
|
&lpdwBufferLength,
|
|
&lpqsResults ));
|
|
|
|
assert (m_reference_count>0);
|
|
return(ReturnValue);
|
|
}
|
|
|
|
|
|
inline INT WINAPI
|
|
NSPROVIDER::SupportsIoctl(
|
|
)
|
|
{
|
|
if (m_proctable.NSPIoctl != NULL)
|
|
return (TRUE);
|
|
else
|
|
return (FALSE);
|
|
}
|
|
|
|
|
|
inline INT WSAAPI
|
|
NSPROVIDER::NSPIoctl(
|
|
IN HANDLE hLookup,
|
|
IN DWORD dwControlCode,
|
|
IN LPVOID lpvInBuffer,
|
|
IN DWORD cbInBuffer,
|
|
OUT LPVOID lpvOutBuffer,
|
|
IN DWORD cbOutBuffer,
|
|
OUT LPDWORD lpcbBytesReturned,
|
|
IN LPWSACOMPLETION lpCompletion,
|
|
IN LPWSATHREADID lpThreadId
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
The NSPIoctl function is used to set or retrieve operating parameters
|
|
associated with a namespace query handle.
|
|
|
|
Any IOCTL may block indefinitely, depending upon the relevant namespace's
|
|
implementation. If an application cannot tolerate blocking in a
|
|
NSPIoctl call, overlapped I/O would be advised. For these operations,
|
|
which cannot be completed immediately, completion is indicated later
|
|
through the mechanism specified in the pCompletion parameter.
|
|
If pCompletion is NULL, this is a blocking call. To make this call
|
|
non-blocking and return immediately, set WSACOMPLETION::Type to
|
|
LUP_NOTIFY_IMMEDIATELY.
|
|
|
|
Arguments:
|
|
|
|
hLookup - Lookup handle returned from a call to WSALookupServiceBegin.
|
|
|
|
dwControlCode - The control code of the operation to perform.
|
|
|
|
pvInBuffer - A pointer to the input buffer for the operation.
|
|
|
|
cbInBuffer - The size of the input buffer for the operation.
|
|
|
|
pvOutBuffer - A pointer to the output buffer for the operation.
|
|
|
|
pcbOutBuffer - A pointer to an integral value for the size of the output
|
|
buffer.
|
|
|
|
pCompletion - A pointer to a WSACOMPLETION structure.
|
|
|
|
Return Value:
|
|
|
|
Upon successful completion, WSANSIoctl returns NO_ERROR (0). Otherwise,
|
|
a value of SOCKET_ERROR (-1) is returned, and a specific error code can
|
|
be retrieved by calling WSAGetLastError.
|
|
--*/
|
|
{
|
|
INT ReturnValue=SOCKET_ERROR;
|
|
|
|
assert(m_reference_count > 0);
|
|
if (PREAPINOTIFY((DTCODE_NSPIoctl,
|
|
&ReturnValue,
|
|
m_library_name,
|
|
&hLookup,
|
|
&dwControlCode,
|
|
&lpvInBuffer,
|
|
&cbInBuffer,
|
|
&lpvOutBuffer,
|
|
&lpcbBytesReturned,
|
|
&cbOutBuffer,
|
|
&lpCompletion,
|
|
&lpThreadId)) ) {
|
|
return (ReturnValue);
|
|
}
|
|
|
|
ReturnValue = m_proctable.NSPIoctl(
|
|
hLookup,
|
|
dwControlCode,
|
|
lpvInBuffer,
|
|
cbInBuffer,
|
|
lpvOutBuffer,
|
|
cbOutBuffer,
|
|
lpcbBytesReturned,
|
|
lpCompletion,
|
|
lpThreadId
|
|
);
|
|
|
|
POSTAPINOTIFY((DTCODE_NSPIoctl,
|
|
&ReturnValue,
|
|
m_library_name,
|
|
&hLookup,
|
|
&dwControlCode,
|
|
&lpvInBuffer,
|
|
&cbInBuffer,
|
|
&lpvOutBuffer,
|
|
&lpcbBytesReturned,
|
|
&cbOutBuffer,
|
|
&lpCompletion,
|
|
&lpThreadId));
|
|
|
|
assert(m_reference_count > 0);
|
|
return (ReturnValue);
|
|
}
|
|
|
|
|
|
inline INT WSAAPI
|
|
NSPROVIDER::NSPLookupServiceEnd(
|
|
IN HANDLE hLookup
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
NSPLookupServiceEnd() is called to free the handle after previous calls to
|
|
NSPLookupServiceBegin() and NSPLookupServiceNext(). It is possible to
|
|
receive a NSPLookupServiceEnd() call on another thread while processing a
|
|
NSPLookupServiceNext(). This indicates that the client has cancelled the
|
|
request, and the provider should close the handle and return from the
|
|
NSPLookupServiceNext() call as well, setting the last error to
|
|
WSA_E_CANCELLED.
|
|
|
|
|
|
Arguments:
|
|
|
|
hLookup - Handle previously obtained by calling NSPLookupServiceBegin().
|
|
|
|
|
|
Return Value:
|
|
|
|
The function should return NO_ERROR (0) if the routine succeeds. It should
|
|
return SOCKET_ERROR (-1) if the routine fails.
|
|
--*/
|
|
{
|
|
INT ReturnValue=SOCKET_ERROR;
|
|
|
|
assert (m_reference_count>0);
|
|
if (PREAPINOTIFY(( DTCODE_NSPLookupServiceEnd,
|
|
&ReturnValue,
|
|
m_library_name,
|
|
&hLookup )) ) {
|
|
return(ReturnValue);
|
|
}
|
|
|
|
ReturnValue =m_proctable.NSPLookupServiceEnd(
|
|
hLookup );
|
|
|
|
POSTAPINOTIFY((DTCODE_NSPLookupServiceEnd,
|
|
&ReturnValue,
|
|
m_library_name,
|
|
&hLookup ));
|
|
|
|
assert (m_reference_count>0);
|
|
return(ReturnValue);
|
|
}
|
|
|
|
|
|
//
|
|
// Service Address Registration and Deregistration APIs and Data Types.
|
|
//
|
|
|
|
inline INT WSAAPI
|
|
NSPROVIDER::NSPSetService(
|
|
IN LPWSASERVICECLASSINFOW lpServiceClassInfo,
|
|
IN LPWSAQUERYSETW lpqsRegInfo,
|
|
IN WSAESETSERVICEOP essOperation,
|
|
IN DWORD dwControlFlags
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
NSPSetService() is used to register or deregister a service instance within
|
|
a name space.
|
|
|
|
Arguments:
|
|
|
|
lpProviderId - Pointer to the GUID of the specific name space provider that
|
|
this service is being registered in.
|
|
|
|
lpServiceClasslnfo - contains service class schema information.
|
|
|
|
lpqsRegInfo - specifies property information to be updated upon
|
|
registration.
|
|
|
|
essOperation - an enumeration.
|
|
|
|
dwControlFlags - ControlFlags.
|
|
|
|
Return Value:
|
|
|
|
The function should return NO_ERROR (0) if the routine succeeds. It should
|
|
return SOCKET_ERROR (-1) if the routine fails.
|
|
--*/
|
|
{
|
|
INT ReturnValue=SOCKET_ERROR;
|
|
|
|
assert (m_reference_count>0);
|
|
if (PREAPINOTIFY(( DTCODE_NSPSetService
|
|
&ReturnValue,
|
|
m_library_name,
|
|
(PCHAR) &m_provider_id,
|
|
&lpServiceClassInfo,
|
|
&lpqsRegInfo,
|
|
&essOperation,
|
|
&dwControlFlags )) ) {
|
|
return(ReturnValue);
|
|
}
|
|
|
|
ReturnValue = m_proctable.NSPSetService(
|
|
&m_provider_id,
|
|
lpServiceClassInfo,
|
|
lpqsRegInfo,
|
|
essOperation,
|
|
dwControlFlags);
|
|
|
|
POSTAPINOTIFY((DTCODE_NSPSetService,
|
|
&ReturnValue,
|
|
m_library_name,
|
|
&m_provider_id,
|
|
&lpServiceClassInfo,
|
|
&lpqsRegInfo,
|
|
&essOperation,
|
|
&dwControlFlags ));
|
|
|
|
assert (m_reference_count>0);
|
|
return(ReturnValue);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// Service Installation/Removal APIs and Data Types.
|
|
//
|
|
|
|
inline INT WSAAPI
|
|
NSPROVIDER::NSPInstallServiceClass(
|
|
IN LPWSASERVICECLASSINFOW lpServiceClassInfo
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
NSPInstallServiceClass() is used to register service class schema within
|
|
the name space providers. The schema includes the class name, class id,
|
|
and any name space specific type information that is common to all
|
|
instances of the service, such as SAP ID or object ID. A name space
|
|
provider is expected to store any class info associated with that
|
|
namespace.
|
|
|
|
Arguments:
|
|
|
|
lpProviderId - Pointer to the GUID of the specific name space provider that
|
|
this service class schema is being registered in.
|
|
|
|
lpServiceClasslnfo - contains service class schema information.
|
|
|
|
Return Value:
|
|
|
|
The function should return NO_ERROR (0) if the routine succeeds. It should
|
|
return SOCKET_ERROR (-1) if the routine fails.
|
|
--*/
|
|
{
|
|
INT ReturnValue=SOCKET_ERROR;
|
|
|
|
assert (m_reference_count>0);
|
|
if (PREAPINOTIFY(( DTCODE_NSPInstallServiceClass,
|
|
&ReturnValue,
|
|
m_library_name,
|
|
&m_provider_id,
|
|
&lpServiceClassInfo )) ) {
|
|
return(ReturnValue);
|
|
}
|
|
|
|
ReturnValue = m_proctable.NSPInstallServiceClass(
|
|
&m_provider_id,
|
|
lpServiceClassInfo);
|
|
|
|
POSTAPINOTIFY(( DTCODE_NSPInstallServiceClass,
|
|
&ReturnValue,
|
|
m_library_name,
|
|
&m_provider_id,
|
|
&lpServiceClassInfo ));
|
|
|
|
assert (m_reference_count>0);
|
|
return(ReturnValue);
|
|
}
|
|
|
|
|
|
inline INT WSAAPI
|
|
NSPROVIDER::NSPRemoveServiceClass(
|
|
IN LPGUID lpServiceClassId
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
NSPRemoveServiceClass() is used to permanently remove a specified service
|
|
class from the name space.
|
|
|
|
Arguments:
|
|
|
|
lpServiceClassId Pointer to the service class ID that is to be removed.
|
|
|
|
Return Value:
|
|
|
|
The function should return NO_ERROR (0) if the routine succeeds. It should
|
|
return SOCKET_ERROR (-1) if the routine fails.
|
|
--*/
|
|
{
|
|
INT ReturnValue=SOCKET_ERROR;
|
|
|
|
assert (m_reference_count>0);
|
|
if (PREAPINOTIFY(( DTCODE_NSPRemoveServiceClass,
|
|
&ReturnValue,
|
|
m_library_name,
|
|
&m_provider_id,
|
|
&lpServiceClassId )) ) {
|
|
return(ReturnValue);
|
|
}
|
|
|
|
ReturnValue = m_proctable.NSPRemoveServiceClass(
|
|
&m_provider_id,
|
|
lpServiceClassId);
|
|
|
|
POSTAPINOTIFY((DTCODE_NSPRemoveServiceClass,
|
|
&ReturnValue,
|
|
m_library_name,
|
|
&m_provider_id,
|
|
&lpServiceClassId ));
|
|
|
|
assert (m_reference_count>0);
|
|
return(ReturnValue);
|
|
}
|
|
|
|
|
|
inline INT WSAAPI
|
|
NSPROVIDER::NSPGetServiceClassInfo(
|
|
IN OUT LPDWORD lpdwBufSize,
|
|
IN OUT LPWSASERVICECLASSINFOW lpServiceClassInfo
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
NSPGetServiceClassInfo() is used to retrieve all of the class information
|
|
(schema) pertaining to the service from the name space providers. This
|
|
call retrieves any name space specific information that is common to all
|
|
instances of the service, including connection information for SAP, or port
|
|
information for SAP or TCP.
|
|
|
|
Arguments:
|
|
|
|
lpdwBufferLength - on input, the number of bytes contained in the buffer
|
|
pointed to by lpServiceClassInfos. On output - if the
|
|
API fails, and the error is WSAEFAULT, then it contains
|
|
the minimum number of bytes to pass for the
|
|
lpServiceClassInfo to retrieve the record.
|
|
|
|
lpServiceClasslnfo - returns service class to name space specific mapping
|
|
information. The lpServiceClassId field must be
|
|
filled in to indicate which SERVICECLASSINFOW record
|
|
should be returned.
|
|
|
|
Return Value:
|
|
|
|
The function should return NO_ERROR (0) if the routine succeeds. It should
|
|
return SOCKET_ERROR (-1) if the routine fails.
|
|
--*/
|
|
{
|
|
INT ReturnValue=SOCKET_ERROR;
|
|
|
|
assert (m_reference_count>0);
|
|
if (PREAPINOTIFY(( DTCODE_NSPGetServiceClassInfo,
|
|
&ReturnValue,
|
|
m_library_name,
|
|
&m_provider_id,
|
|
&lpdwBufSize,
|
|
&lpServiceClassInfo )) ) {
|
|
return(ReturnValue);
|
|
}
|
|
|
|
ReturnValue = m_proctable.NSPGetServiceClassInfo(
|
|
&m_provider_id,
|
|
lpdwBufSize,
|
|
lpServiceClassInfo);
|
|
|
|
POSTAPINOTIFY((DTCODE_NSPGetServiceClassInfo,
|
|
&ReturnValue,
|
|
m_library_name,
|
|
&m_provider_id,
|
|
&lpdwBufSize,
|
|
&lpServiceClassInfo ));
|
|
|
|
assert (m_reference_count>0);
|
|
return(ReturnValue);
|
|
}
|
|
|
|
#endif // _NSPROVIDER_
|
|
|
|
|
|
|
|
|
|
|
|
|