mirror of https://github.com/lianthony/NT4.0
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.
921 lines
26 KiB
921 lines
26 KiB
/*++
|
|
|
|
Copyright (c) 1994 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
gssrvce.c
|
|
|
|
Abstract:
|
|
|
|
Service Registration and Resolution APIs tests
|
|
|
|
SetService() API
|
|
GetService() API
|
|
|
|
Author:
|
|
|
|
Hui-Li Chen (hui-lich) Microsoft, June 14, 1994
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include "wsnsp.h"
|
|
#include "gssrvce.h"
|
|
#include "conio.h"
|
|
|
|
// This results in a NBP service name of "NSP AT Test:TypeATNSP@*"
|
|
#define SERVICE_NAME __TEXT("NSP AT Test")
|
|
#define SERVICE_TYPE_NAME __TEXT("TypeATNSP")
|
|
|
|
TEST_PROTO gTest = TEST_AT;
|
|
|
|
WORD svcType = 0x1313 ;
|
|
|
|
// {EC8EB190-6A31-11ce-BA5208002B313ED2}
|
|
GUID ServiceTypeGuid =
|
|
{ 0xec8eb190, 0x6a31, 0x11ce, { 0xba, 0x52, 0x8, 0x0, 0x2b, 0x31, 0x3e, 0xd2 } };
|
|
|
|
|
|
int var = 0, failed = 0, passed = 0;
|
|
|
|
BYTE blob_buffer[10];
|
|
BYTE ServiceTypeInfoBuffer[sizeof(SERVICE_TYPE_INFO_ABS) + 400] ;
|
|
LPSERVICE_TYPE_INFO_ABS lpServiceNsTypeInfo ;
|
|
LPSERVICE_TYPE_VALUE_ABS lpSvcTypeValues ;
|
|
|
|
static DWORD dwSapValue = 59 ;
|
|
static DWORD dwValue1 = 61 ;
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
//
|
|
// main funcion
|
|
//
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
VOID _CRTAPI1 main( int argc, char *argv[] )
|
|
{
|
|
WSADATA wsaData;
|
|
WORD wVersion;
|
|
|
|
|
|
if ( !ParseOptions( argc, argv ) )
|
|
Usage();
|
|
|
|
CreateLogFile(gsLogName);
|
|
|
|
wVersion = MAKEWORD( 1, 1);
|
|
if ( WSAStartup( wVersion, &wsaData ) != 0 )
|
|
{
|
|
Print("Error calling WSAStartup. Error=%d\n", GetLastError());
|
|
ExitProcess( 0 );
|
|
}
|
|
|
|
Print("API tests for SetService & GetService\n");
|
|
switch( gTest )
|
|
{
|
|
case TEST_TCP:
|
|
Test_TCP();
|
|
break;
|
|
|
|
case TEST_NW:
|
|
Test_NW();
|
|
break;
|
|
|
|
case TEST_AT:
|
|
Test_AT();
|
|
break;
|
|
|
|
default:
|
|
Print("In SetService & GetService tests, the test must be either TCP/IP, SPX/IPX or AppleTalk!\n");
|
|
break;
|
|
}
|
|
|
|
End_Of_Tests( var, passed, failed );
|
|
|
|
WSACleanup();
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Test_TCP
|
|
//
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
void Test_TCP ( void )
|
|
{
|
|
|
|
GUID guid = SVCID_TCP( 9999 );
|
|
|
|
Print("\n============= Name Space \'NS_DEFAUL' ===============\n");
|
|
Test_SetService_GetService( NS_DEFAULT, &guid );
|
|
|
|
Print("\n============= Name Space \'NS_TCPIP_LOCAL'===========\n");
|
|
Test_SetService_GetService( NS_TCPIP_LOCAL, &guid );
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Test_NW
|
|
//
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
void Test_NW ( void )
|
|
{
|
|
|
|
GUID guid = SVCID_NETWARE( 0x1313 );
|
|
|
|
Print("\n============= Name Space \'NS_DEFAULT' ===============\n");
|
|
Test_SetService_GetService( NS_DEFAULT, &guid );
|
|
|
|
Print("\n============= Name Space \'NS_SAP' ==================\n");
|
|
Test_SetService_GetService( NS_SAP, &guid );
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Test_AT
|
|
//
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
void Test_AT ( void )
|
|
{
|
|
#if 0
|
|
|
|
DWORD statusFlags;
|
|
SERVICE_INFO serviceInfo;
|
|
|
|
//
|
|
// Set up information to pass to SetService() to add or delete this
|
|
// service. Most of the SERVICE_INFO fields are not needed for
|
|
// an add or delete operation. The main things of interest are the
|
|
// GUID and the ServiceSpecificInfo structure.
|
|
//
|
|
|
|
serviceInfo.lpServiceType = &ServiceTypeGuid;
|
|
serviceInfo.lpServiceName = NULL ; // not used
|
|
serviceInfo.lpComment = NULL ; // not used
|
|
serviceInfo.lpLocale = NULL; // not used
|
|
serviceInfo.dwDisplayHint = 0; // not used
|
|
serviceInfo.dwVersion = 0; // not used
|
|
serviceInfo.dwTime = 0; // not used
|
|
serviceInfo.lpMachineName = NULL ; // not used
|
|
serviceInfo.lpServiceAddress = NULL ; // not used
|
|
|
|
serviceInfo.ServiceSpecificInfo.pBlobData = ServiceTypeInfoBuffer;
|
|
serviceInfo.ServiceSpecificInfo.cbSize = sizeof(ServiceTypeInfoBuffer) ;
|
|
|
|
//
|
|
// The "blob" receives operation-specific information. In this
|
|
// case, fill it with a SERVICE_TYPE_INFO_ABS structure and associated
|
|
// information. For Appletalk there is no service specific information.
|
|
//
|
|
|
|
lpServiceNsTypeInfo = (LPSERVICE_TYPE_INFO_ABS) ServiceTypeInfoBuffer ;
|
|
|
|
lpServiceNsTypeInfo->dwValueCount = 0 ;
|
|
lpServiceNsTypeInfo->lpTypeName = SERVICE_TYPE_NAME ;
|
|
|
|
|
|
//
|
|
// Finally, call SetService to actually perform the ADD operation.
|
|
//
|
|
|
|
err = SetService(
|
|
NS_DEFAULT, // all default name spaces
|
|
SERVICE_ADD_TYPE, // either ADD or DELETE
|
|
0, // dwFlags not used
|
|
&serviceInfo, // the service info structure
|
|
NULL, // lpServiceAsyncInfo
|
|
&statusFlags // additional status information
|
|
);
|
|
|
|
if ( err != NO_ERROR ) {
|
|
Print( "SetService failed: %ld\n", GetLastError( ) );
|
|
exit(1);
|
|
}
|
|
|
|
Print( "SetService succeeded, status flags = %ld\n", statusFlags );
|
|
#endif
|
|
|
|
Print("\n============= Name Space \'NS_DEFAULT' ===============\n");
|
|
Test_SetService_GetService( NS_DEFAULT, &ServiceTypeGuid );
|
|
|
|
Print("\n============= Name Space \'NS_NBP' ==================\n");
|
|
Test_SetService_GetService( NS_NBP, &ServiceTypeGuid );
|
|
|
|
#if 0
|
|
|
|
//
|
|
// Finally, call SetService to perform the DELETE operation.
|
|
//
|
|
|
|
lpServiceNsTypeInfo = (LPSERVICE_TYPE_INFO_ABS) ServiceTypeInfoBuffer ;
|
|
lpServiceNsTypeInfo->dwValueCount = 0 ;
|
|
lpServiceNsTypeInfo->lpTypeName = SERVICE_TYPE_NAME ;
|
|
|
|
err = SetService(
|
|
NS_DEFAULT, // all default name spaces
|
|
SERVICE_DELETE_TYPE, // either ADD or DELETE
|
|
0, // dwFlags not used
|
|
&serviceInfo, // the service info structure
|
|
NULL, // lpServiceAsyncInfo
|
|
&statusFlags // additional status information
|
|
);
|
|
|
|
if ( err != NO_ERROR ) {
|
|
Print( "SetService DELETE_TYPE failed: %ld\n", GetLastError( ) );
|
|
exit(1);
|
|
}
|
|
|
|
Print( "SetService DELETE_TYPE succeeded, status flags = %ld\n", statusFlags );
|
|
#endif
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Test_SetService_GetService
|
|
//
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
void Test_SetService_GetService(
|
|
DWORD dwNS,
|
|
LPGUID pGUID )
|
|
{
|
|
|
|
SERVICE_INFO SrvInfo;
|
|
BYTE svcAddrs[sizeof(SERVICE_ADDRESSES) + (sizeof(SERVICE_ADDRESS) * 3)];
|
|
SERVICE_ADDRESSES *psvcAddrs = (SERVICE_ADDRESSES *) svcAddrs;
|
|
BYTE address0[12];
|
|
BYTE address1[15];
|
|
SOCKADDR_AT address2 = {AF_APPLETALK, 0, 0, 0};
|
|
SOCKET s = INVALID_SOCKET;
|
|
int i, socketType = SOCK_STREAM, protocol = ATPROTO_ADSP;
|
|
int err, addrsize;
|
|
|
|
//
|
|
// init address & blob data to easily recognizable values
|
|
//
|
|
for ( i = 0; i < 10; i++ )
|
|
blob_buffer[i] = 'A'+i;
|
|
|
|
for ( i = 0; i < 12; i++ )
|
|
address0[i] = i;
|
|
|
|
for ( i = 0; i < 15; i++ )
|
|
address1[i] = 15-i;
|
|
|
|
// Open a socket on ADSP (stream or message) or PAP then getsockname
|
|
// into address2
|
|
s = socket( AF_APPLETALK,
|
|
socketType,
|
|
protocol );
|
|
if ( s == INVALID_SOCKET ) {
|
|
Print("Test_SetService_GetService: socket failed (%d)\n", GetLastError());
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Bind the socket to the local address specified.
|
|
//
|
|
|
|
err = bind( s,
|
|
(struct sockaddr *)&address2,
|
|
sizeof(address2) );
|
|
if ( err != NO_ERROR ) {
|
|
closesocket( s );
|
|
Print("Test_SetService_GetService: bind failed (%d)\n", GetLastError());
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Call getsockname() to get the local association for the socket.
|
|
//
|
|
addrsize = sizeof(address2);
|
|
err = getsockname(s,
|
|
(struct sockaddr *)&address2,
|
|
&addrsize);
|
|
|
|
if (err == SOCKET_ERROR)
|
|
{
|
|
closesocket( s );
|
|
Print("Test_SetService_GetService: getsockname failed (%d)\n", GetLastError());
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
Print("Test_SetService_GetService: getsockname returned net=%d node=%d socket=%d\n",
|
|
address2.sat_net, address2.sat_node, address2.sat_socket);
|
|
}
|
|
|
|
|
|
//
|
|
// init the addressing structures
|
|
//
|
|
psvcAddrs->dwAddressCount = 3;
|
|
psvcAddrs->Addresses[0].dwAddressType = AF_UNIX;
|
|
psvcAddrs->Addresses[0].dwAddressLength = sizeof( address1 );
|
|
psvcAddrs->Addresses[0].lpAddress = address1;
|
|
psvcAddrs->Addresses[1].dwAddressType = AF_INET;
|
|
psvcAddrs->Addresses[1].dwAddressLength = sizeof( address0 );
|
|
psvcAddrs->Addresses[1].lpAddress = address0;
|
|
psvcAddrs->Addresses[2].dwAddressType = AF_APPLETALK;
|
|
psvcAddrs->Addresses[2].dwAddressLength = sizeof( address2 );
|
|
psvcAddrs->Addresses[2].lpAddress = (PBYTE)&address2;
|
|
|
|
//
|
|
// setup the structure
|
|
//
|
|
SrvInfo.lpServiceType = pGUID;
|
|
SrvInfo.lpServiceName = SERVICE_NAME ;
|
|
SrvInfo.lpComment = __TEXT("Just for test");
|
|
SrvInfo.lpLocale = NULL;
|
|
SrvInfo.dwDisplayHint = 1;
|
|
SrvInfo.dwVersion = 2;
|
|
SrvInfo.dwTime = 45;
|
|
SrvInfo.lpMachineName = __TEXT("\\\\FooBarServer");
|
|
SrvInfo.lpServiceAddress = psvcAddrs;
|
|
//Blob ServiceSpecificInfo is filled in by each variation
|
|
|
|
// Small_Buf( dwNS, &SrvInfo, pGUID );
|
|
|
|
// Invalid_Operation( dwNS, &SrvInfo, pGUID );
|
|
|
|
All_are_Valid( dwNS, &SrvInfo, pGUID );
|
|
|
|
closesocket( s );
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Small_Buf
|
|
//
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
void Small_Buf(
|
|
DWORD dwNS,
|
|
LPSERVICE_INFO lpSrvInfo,
|
|
LPGUID pGUID )
|
|
{
|
|
|
|
DWORD dwBufSize = 1;
|
|
DWORD dwStatusFlags;
|
|
BYTE Buf[4000];
|
|
|
|
Fill_Blob( dwNS, SERVICE_ADD_TYPE, lpSrvInfo );
|
|
Print( "\nVariation %d: pass SERVICE_ADD_TYPE with SERVICE_FLAG_HARD\n", ++var );
|
|
Call_SetService( -1, 0, dwNS, SERVICE_ADD_TYPE,
|
|
SERVICE_FLAG_HARD, lpSrvInfo, NULL,
|
|
&dwStatusFlags );
|
|
|
|
Fill_Blob( dwNS, SERVICE_DELETE_TYPE, lpSrvInfo );
|
|
Print( "\nVariation %d: pass SERVICE_DELETE_TYPE with SERVICE_FLAG_HARD\n", ++var );
|
|
Call_SetService( -1, 0, dwNS, SERVICE_DELETE_TYPE,
|
|
SERVICE_FLAG_HARD, lpSrvInfo, NULL,
|
|
&dwStatusFlags );
|
|
|
|
// For NBP you will get ERROR_SERVICE_NOT_FOUND ??
|
|
Print( "\nVariation %d: pass PROP_ALL to get service before set the service\n", ++var );
|
|
Call_GetService( 0, 0, dwNS, pGUID, SERVICE_NAME,
|
|
PROP_ALL, Buf, &dwBufSize, NULL);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Invalid_Operation
|
|
//
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
void Invalid_Operation(
|
|
DWORD dwNS,
|
|
LPSERVICE_INFO lpSrvInfo,
|
|
LPGUID pGUID )
|
|
{
|
|
|
|
DWORD dwStatusFlags;
|
|
|
|
// Service type has not been added to registry
|
|
Fill_Blob( dwNS, SERVICE_REGISTER, lpSrvInfo );
|
|
Print( "\nVariation %d: pass SERVICE_FLAG_HARD|SERVICE_FLAG_DEFER to SERVICE_REGISTER\n", ++var );
|
|
Call_SetService( -1, ERROR_SERVICE_NOT_FOUND, dwNS, SERVICE_REGISTER,
|
|
SERVICE_FLAG_HARD|SERVICE_FLAG_DEFER, lpSrvInfo, NULL,
|
|
&dwStatusFlags );
|
|
|
|
|
|
// Service type has not been added to registry
|
|
Print( "\nVariation %d: pass SERVICE_FLAG_HARD|SERVICE_FLAG_DEFER to SERVICE_DEREGISTER\n", ++var );
|
|
Fill_Blob( dwNS, SERVICE_DEREGISTER, lpSrvInfo );
|
|
Call_SetService( -1, ERROR_SERVICE_NOT_FOUND, dwNS, SERVICE_DEREGISTER,
|
|
SERVICE_FLAG_HARD|SERVICE_FLAG_DEFER, lpSrvInfo, NULL,
|
|
&dwStatusFlags );
|
|
|
|
// Service type has not been added to registry
|
|
Print( "\nVariation %d: pass SERVICE_FLAG_HARD|SERVICE_FLAG_DEFER to SERVICE_FLUSH\n", ++var );
|
|
Fill_Blob( dwNS, SERVICE_FLUSH, lpSrvInfo );
|
|
Call_SetService( -1, ERROR_SERVICE_NOT_FOUND, dwNS, SERVICE_FLUSH,
|
|
SERVICE_FLAG_HARD|SERVICE_FLAG_DEFER, lpSrvInfo, NULL,
|
|
&dwStatusFlags );
|
|
|
|
// BUGBUG why would this return an error??
|
|
Print( "\nVariation %d: pass SERVICE_FLAG_HARD|SERVICE_FLAG_DEFER to SERVICE_ADD_TYPE\n", ++var );
|
|
Fill_Blob( dwNS, SERVICE_ADD_TYPE, lpSrvInfo );
|
|
Call_SetService( -1, ERROR_SERVICE_NOT_FOUND, dwNS, SERVICE_ADD_TYPE,
|
|
SERVICE_FLAG_HARD|SERVICE_FLAG_DEFER, lpSrvInfo, NULL,
|
|
&dwStatusFlags );
|
|
|
|
// BUGBUG why would this return an error??
|
|
Print( "\nVariation %d: pass SERVICE_FLAG_HARD|SERVICE_FLAG_DEFER to SERVICE_DELETE_TYPE\n", ++var );
|
|
Fill_Blob( dwNS, SERVICE_DELETE_TYPE, lpSrvInfo );
|
|
Call_SetService( -1, ERROR_SERVICE_NOT_FOUND, dwNS, SERVICE_DELETE_TYPE,
|
|
SERVICE_FLAG_HARD|SERVICE_FLAG_DEFER, lpSrvInfo, NULL,
|
|
&dwStatusFlags );
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
//
|
|
// All_are_Valid
|
|
//
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
void All_are_Valid(
|
|
DWORD dwNS,
|
|
LPSERVICE_INFO lpSrvInfo,
|
|
LPGUID pGUID )
|
|
{
|
|
|
|
BYTE Buf[4000];
|
|
DWORD dwBufSize = 1;
|
|
DWORD dwStatusFlags;
|
|
int ch;
|
|
|
|
// Add the test type to registry
|
|
Print("\n============= Add test type to Registry ===============\n");
|
|
Fill_Blob( dwNS, SERVICE_ADD_TYPE, lpSrvInfo );
|
|
Print( "\nVariation %d: pass SERVICE_ADD_TYPE with SERVICE_FLAG_HARD\n", ++var );
|
|
Call_SetService( -1, 0, dwNS, SERVICE_ADD_TYPE,
|
|
SERVICE_FLAG_HARD, lpSrvInfo, NULL,
|
|
&dwStatusFlags );
|
|
|
|
Print( "\nVariation %d: pass all valid to register a service\n", ++var );
|
|
Fill_Blob( dwNS, SERVICE_REGISTER, lpSrvInfo );
|
|
Call_SetService( 0, 0, dwNS, SERVICE_REGISTER,
|
|
SERVICE_FLAG_HARD, lpSrvInfo, NULL,
|
|
&dwStatusFlags );
|
|
|
|
Print("press a key when ready to deregister the service...");
|
|
ch = getch();
|
|
Print("\n");
|
|
|
|
#if 0
|
|
Print( "\nVariation %d: register the same service again\n", ++var );
|
|
Fill_Blob( dwNS, SERVICE_REGISTER, lpSrvInfo );
|
|
Call_SetService( -1, ERROR_ALREADY_REGISTERED, dwNS, SERVICE_REGISTER,
|
|
SERVICE_FLAG_HARD, lpSrvInfo, NULL,
|
|
&dwStatusFlags );
|
|
#endif
|
|
|
|
Print( "\nVariation %d: pass all valid to deregister a service\n", ++var );
|
|
Fill_Blob( dwNS, SERVICE_DEREGISTER, lpSrvInfo );
|
|
Call_SetService( 0, 0, dwNS, SERVICE_DEREGISTER,
|
|
SERVICE_FLAG_HARD, lpSrvInfo, NULL,
|
|
&dwStatusFlags );
|
|
#if 0
|
|
Print( "\nVariation %d: deregister the same service again\n", ++var );
|
|
Fill_Blob( dwNS, SERVICE_DEREGISTER, lpSrvInfo );
|
|
Call_SetService( -1, ERROR_SERVICE_NOT_FOUND, dwNS, SERVICE_DEREGISTER,
|
|
SERVICE_FLAG_HARD, lpSrvInfo, NULL,
|
|
&dwStatusFlags );
|
|
|
|
Print( "\nVariation %d: register a service with SERVICE_FLAG_DEFER\n", ++var );
|
|
Fill_Blob( dwNS, SERVICE_REGISTER, lpSrvInfo );
|
|
Call_SetService( 0, 0, dwNS, SERVICE_REGISTER,
|
|
SERVICE_FLAG_DEFER,lpSrvInfo, NULL,
|
|
&dwStatusFlags );
|
|
|
|
Print( "\nVariation %d: flush a service with SERVICE_FLAG_DEFER\n", ++var );
|
|
Fill_Blob( dwNS, SERVICE_FLUSH, lpSrvInfo );
|
|
Call_SetService( 0, 0, dwNS, SERVICE_FLUSH,
|
|
SERVICE_FLAG_DEFER,lpSrvInfo, NULL,
|
|
&dwStatusFlags );
|
|
|
|
// BUGBUG why would this fail??
|
|
Print( "\nVariation %d: deregister a service with SERVICE_FLAG_HARD should fail\n", ++var );
|
|
Fill_Blob( dwNS, SERVICE_DEREGISTER, lpSrvInfo );
|
|
Call_SetService( -1, ERROR_SERVICE_NOT_FOUND, dwNS, SERVICE_DEREGISTER,
|
|
SERVICE_FLAG_HARD, lpSrvInfo, NULL,
|
|
&dwStatusFlags );
|
|
|
|
Print( "\nVariation %d: flush a service with SERVICE_FLAG_HARD\n", ++var );
|
|
Fill_Blob( dwNS, SERVICE_FLUSH, lpSrvInfo );
|
|
Call_SetService( 0, 0, dwNS, SERVICE_FLUSH,
|
|
SERVICE_FLAG_HARD, lpSrvInfo, NULL,
|
|
&dwStatusFlags );
|
|
|
|
// BUGBUG at this point the service is no longer registered??!!
|
|
Print( "\nVariation %d: deregister a service with SERVICE_FLAG_HARD\n", ++var );
|
|
Fill_Blob( dwNS, SERVICE_DEREGISTER, lpSrvInfo );
|
|
Call_SetService( 0, 0, dwNS, SERVICE_DEREGISTER,
|
|
SERVICE_FLAG_HARD, lpSrvInfo, NULL,
|
|
&dwStatusFlags );
|
|
|
|
Print( "\nVariation %d: register a service with SERVICE_FLAG_DEFER\n", ++var );
|
|
Fill_Blob( dwNS, SERVICE_REGISTER, lpSrvInfo );
|
|
Call_SetService( 0, 0, dwNS, SERVICE_REGISTER,
|
|
SERVICE_FLAG_DEFER,lpSrvInfo, NULL,
|
|
&dwStatusFlags );
|
|
|
|
Print( "\nVariation %d: flush a service with SERVICE_FLAG_HARD\n", ++var );
|
|
Fill_Blob( dwNS, SERVICE_FLUSH, lpSrvInfo );
|
|
Call_SetService( 0, 0, dwNS, SERVICE_FLUSH,
|
|
SERVICE_FLAG_HARD, lpSrvInfo, NULL,
|
|
&dwStatusFlags );
|
|
|
|
Print( "\nVariation %d: deregister a service with SERVICE_FLAG_DEFER\n", ++var );
|
|
Fill_Blob( dwNS, SERVICE_DEREGISTER, lpSrvInfo );
|
|
Call_SetService( 0, 0, dwNS, SERVICE_DEREGISTER,
|
|
SERVICE_FLAG_DEFER,lpSrvInfo, NULL,
|
|
&dwStatusFlags );
|
|
|
|
Print( "\nVariation %d: Get the service just registered\n", ++var );
|
|
Call_GetService( 0, 0, dwNS, pGUID, SERVICE_NAME, PROP_ALL, Buf, &dwBufSize, NULL );
|
|
|
|
#endif
|
|
|
|
// Delete the test type from registry
|
|
Print("\n============= Delete test type from Registry ===============\n");
|
|
Fill_Blob( dwNS, SERVICE_DELETE_TYPE, lpSrvInfo );
|
|
Print( "\nVariation %d: pass SERVICE_DELETE_TYPE with SERVICE_FLAG_HARD\n", ++var );
|
|
Call_SetService( -1, 0, dwNS, SERVICE_DELETE_TYPE,
|
|
SERVICE_FLAG_HARD, lpSrvInfo, NULL,
|
|
&dwStatusFlags );
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Call_SetService
|
|
//
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
void Call_SetService(
|
|
int ExpectedReturn,
|
|
DWORD ExpectedError,
|
|
DWORD dwNameSpace,
|
|
DWORD dwOperation,
|
|
DWORD dwFlags,
|
|
LPSERVICE_INFO lpServiceInfo,
|
|
LPSERVICE_ASYNC_INFO lpServiceAsyncInfo,
|
|
LPDWORD lpdwStatusFlags )
|
|
{
|
|
int r;
|
|
BOOL fPass = TRUE;
|
|
|
|
Print( "SetService\n"
|
|
"\tdwNameSpace = 0x%08x\n"
|
|
"\tdwOperation = 0x%08x\n"
|
|
"\tdwFlags = 0x%08x\n"
|
|
"\tlpServiceInfo = 0x%08x\n"
|
|
"\tlpServiceAsyncInfo = 0x%08x\n"
|
|
"\tlpdwStatusFlags = 0x%08x\n",
|
|
dwNameSpace,
|
|
dwOperation,
|
|
dwFlags,
|
|
lpServiceInfo,
|
|
lpServiceAsyncInfo,
|
|
lpdwStatusFlags );
|
|
|
|
r = SetService( dwNameSpace,
|
|
dwOperation,
|
|
dwFlags,
|
|
lpServiceInfo,
|
|
lpServiceAsyncInfo,
|
|
lpdwStatusFlags );
|
|
|
|
if ( r != ExpectedReturn )
|
|
{
|
|
Print("VARIATION FAILED : expected return = %d, but actual return = %d, StatusFlag = %d\n",
|
|
ExpectedReturn,
|
|
r,
|
|
*lpdwStatusFlags);
|
|
fPass = FALSE;
|
|
}
|
|
|
|
if ( r < 0 )
|
|
{
|
|
if ( GetLastError() != ExpectedError )
|
|
{
|
|
Print("VARIATION FAILED : expected error = %d, but actual error = %d, StatusFlag = %d\n",
|
|
ExpectedError,
|
|
GetLastError(),
|
|
*lpdwStatusFlags);
|
|
fPass = FALSE;
|
|
}
|
|
}
|
|
|
|
if ( fPass )
|
|
Print("VARIATION PASSED : expected/actual return = %d\n", r );
|
|
|
|
fPass ? passed++ : failed++;
|
|
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Call_GetService
|
|
//
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
void Call_GetService(
|
|
int ExpectedReturn,
|
|
DWORD ExpectedError,
|
|
DWORD dwNameSpace,
|
|
LPGUID lpGuid,
|
|
LPTSTR lpServiceName,
|
|
DWORD dwProperties,
|
|
LPVOID lpBuffer,
|
|
LPDWORD lpdwBufferSize,
|
|
LPSERVICE_ASYNC_INFO lpServiceAsyncInfo )
|
|
{
|
|
int r;
|
|
BOOL fPass = TRUE;
|
|
|
|
Print( "GetService()\n"
|
|
"\tdwNameSpace = 0x%08x\n"
|
|
"\tlpGuid = 0x%08x\n",
|
|
dwNameSpace,
|
|
lpGuid );
|
|
|
|
if ( !lpServiceName )
|
|
{
|
|
Print( "\tlpServiceName = NULL\n" );
|
|
}
|
|
else
|
|
{
|
|
char szProt[500];
|
|
|
|
#ifdef UNICODE
|
|
WideCharToMultiByte(CP_ACP, 0, lpServiceName, -1,
|
|
szProt, 500, NULL, NULL);
|
|
#else
|
|
strcpy( szProt, lpServiceName );
|
|
#endif
|
|
|
|
Print( "\t*lpServiceName = %s\n", szProt );
|
|
}
|
|
|
|
Print( "\tdwProperties = 0x%08x\n"
|
|
"\tlpBuffer = 0x%08x\n"
|
|
"\tlpServiceAsyncInfo = 0x%08x\n",
|
|
lpBuffer,
|
|
lpdwBufferSize,
|
|
lpServiceAsyncInfo );
|
|
|
|
( !lpdwBufferSize ) ? Print( "\tlpdwBufferSize = NULL\n" ) :
|
|
Print( "\t*lpdwBufferSize = 0x%08x\n", *lpdwBufferSize );
|
|
|
|
r = GetService( dwNameSpace,
|
|
lpGuid,
|
|
lpServiceName,
|
|
dwProperties,
|
|
lpBuffer,
|
|
lpdwBufferSize,
|
|
lpServiceAsyncInfo );
|
|
|
|
|
|
if ( r != ExpectedReturn )
|
|
{
|
|
Print("VARIATION FAILED : expected return = %d, but actual return = %d\n",
|
|
ExpectedReturn,
|
|
r );
|
|
fPass = FALSE;
|
|
}
|
|
|
|
if ( r < 0 )
|
|
{
|
|
if ( GetLastError() != ExpectedError )
|
|
{
|
|
Print("VARIATION FAILED : expected error = %d, but actual error = %d\n",
|
|
ExpectedError,
|
|
GetLastError() );
|
|
fPass = FALSE;
|
|
}
|
|
}
|
|
|
|
if ( r > 0 && lpBuffer )
|
|
Print_Service( r, lpBuffer );
|
|
|
|
if ( fPass )
|
|
Print("VARIATION PASSED : expected/actual return = %d\n", r );
|
|
|
|
fPass ? passed++ : failed++;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Print_Service
|
|
//
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
void Print_Service (
|
|
int r,
|
|
LPVOID lbBuffer )
|
|
{
|
|
|
|
LPNS_SERVICE_INFO lpNsSvcInfo = (LPNS_SERVICE_INFO) lbBuffer ;
|
|
char szProt[500];
|
|
|
|
for ( ; r > 0; r--,lpNsSvcInfo++)
|
|
{
|
|
LPSERVICE_INFO pServiceInfo ;
|
|
|
|
Print("Name Space :%d\n", lpNsSvcInfo->dwNameSpace);
|
|
|
|
pServiceInfo = &(lpNsSvcInfo->ServiceInfo);
|
|
|
|
if ( pServiceInfo->lpServiceType == NULL )
|
|
Print("Service Type:NULL\n");
|
|
else
|
|
Print("Service Type: 0x%08x\n", pServiceInfo->lpServiceType);
|
|
|
|
if ( pServiceInfo->lpServiceName == NULL )
|
|
Print("Service Name:NULL\n");
|
|
else
|
|
{
|
|
#ifdef UNICODE
|
|
WideCharToMultiByte(CP_ACP, 0, pServiceInfo->lpServiceName, -1,
|
|
szProt, 500, NULL, NULL);
|
|
#else
|
|
strcpy( szProt, pServiceInfo->lpServiceName );
|
|
#endif
|
|
|
|
Print("Service Name:%s\n", szProt);
|
|
}
|
|
|
|
|
|
if ( pServiceInfo->lpComment == NULL )
|
|
Print("Comment:NULL\n");
|
|
else
|
|
{
|
|
#ifdef UNICODE
|
|
WideCharToMultiByte(CP_ACP, 0, pServiceInfo->lpComment, -1,
|
|
szProt, 500, NULL, NULL);
|
|
#else
|
|
strcpy( szProt, pServiceInfo->lpComment );
|
|
#endif
|
|
|
|
Print("Comment:%s\n", szProt);
|
|
}
|
|
|
|
|
|
if ( pServiceInfo->lpLocale == NULL )
|
|
Print("Locale:NULL\n");
|
|
else
|
|
{
|
|
#ifdef UNICODE
|
|
WideCharToMultiByte(CP_ACP, 0, pServiceInfo->lpLocale, -1,
|
|
szProt, 500, NULL, NULL);
|
|
#else
|
|
strcpy( szProt, pServiceInfo->lpLocale);
|
|
#endif
|
|
|
|
Print("Locale:%s\n", szProt);
|
|
}
|
|
|
|
|
|
Print("Version:%d\n", pServiceInfo->dwVersion );
|
|
Print("Time:%d\n", pServiceInfo->dwTime );
|
|
|
|
if ( pServiceInfo->lpMachineName == NULL )
|
|
Print("Machine Name:NULL\n");
|
|
else
|
|
{
|
|
#ifdef UNICODE
|
|
WideCharToMultiByte(CP_ACP, 0, pServiceInfo->lpMachineName, -1,
|
|
szProt, 500, NULL, NULL);
|
|
#else
|
|
strcpy( szProt, pServiceInfo->lpMachineName);
|
|
#endif
|
|
|
|
Print("Machine Name:%s\n", szProt);
|
|
}
|
|
|
|
if ( pServiceInfo->lpServiceAddress == NULL )
|
|
Print("Service Address:NULL\n");
|
|
else
|
|
dump_svc_addresses( pServiceInfo->lpServiceAddress) ;
|
|
|
|
Print("Blob Data Size:%d\n",
|
|
pServiceInfo->ServiceSpecificInfo.cbSize );
|
|
|
|
|
|
if ( pServiceInfo->ServiceSpecificInfo.pBlobData == NULL )
|
|
Print("Specific Data:NULL\n");
|
|
else
|
|
dump_bytes("\tBlob Data:",
|
|
(LPBYTE)pServiceInfo->ServiceSpecificInfo.pBlobData,
|
|
pServiceInfo->ServiceSpecificInfo.cbSize );
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
//
|
|
// dump_bytes
|
|
//
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
void dump_bytes(LPSTR string, LPBYTE p, int n)
|
|
{
|
|
Print("%s ",string) ;
|
|
while(n--)
|
|
{
|
|
Print("%2x ", *p++) ;
|
|
}
|
|
|
|
Print("\n") ;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
//
|
|
// dump_svc_addresses
|
|
//
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
void dump_svc_addresses(LPSERVICE_ADDRESSES p)
|
|
{
|
|
int n = p->dwAddressCount ;
|
|
LPSERVICE_ADDRESS p1 = &(p->Addresses[0]) ;
|
|
|
|
while(n--)
|
|
{
|
|
Print("Address type %d, size %d\n",
|
|
p1->dwAddressType, p1->dwAddressLength) ;
|
|
dump_bytes("\tAddress Data:",(LPBYTE) (p1->lpAddress),
|
|
p1->dwAddressLength) ;
|
|
p1++ ;
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Fill_Blob
|
|
//
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
void Fill_Blob(
|
|
DWORD dwNS,
|
|
DWORD dwOperation,
|
|
LPSERVICE_INFO lpSrvInfo )
|
|
{
|
|
if ((dwOperation == SERVICE_ADD_TYPE) ||
|
|
(dwOperation == SERVICE_DELETE_TYPE))
|
|
{
|
|
// point past structure
|
|
lpServiceNsTypeInfo = (LPSERVICE_TYPE_INFO_ABS) ServiceTypeInfoBuffer ;
|
|
|
|
lpServiceNsTypeInfo->dwValueCount = 2 ;
|
|
lpServiceNsTypeInfo->lpTypeName = SERVICE_TYPE_NAME;
|
|
lpSvcTypeValues = lpServiceNsTypeInfo->Values ;
|
|
|
|
lpSvcTypeValues[0].dwNameSpace = dwNS ;
|
|
lpSvcTypeValues[0].dwValueType = REG_DWORD ;
|
|
lpSvcTypeValues[0].dwValueSize = 4 ;
|
|
lpSvcTypeValues[0].lpValueName = __TEXT("SapID");
|
|
lpSvcTypeValues[0].lpValue = &dwSapValue ;
|
|
|
|
lpSvcTypeValues[1].dwNameSpace = dwNS;
|
|
lpSvcTypeValues[1].dwValueType = REG_DWORD ;
|
|
lpSvcTypeValues[1].dwValueSize = 4 ;
|
|
lpSvcTypeValues[1].lpValueName = __TEXT("MyID1");
|
|
lpSvcTypeValues[1].lpValue = &dwValue1 ;
|
|
|
|
lpSrvInfo->ServiceSpecificInfo.pBlobData = ServiceTypeInfoBuffer;
|
|
lpSrvInfo->ServiceSpecificInfo.cbSize = sizeof(SERVICE_TYPE_INFO_ABS);
|
|
}
|
|
else
|
|
{
|
|
lpSrvInfo->ServiceSpecificInfo.cbSize = 10;
|
|
lpSrvInfo->ServiceSpecificInfo.pBlobData = blob_buffer;
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Usage
|
|
//
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
void Usage()
|
|
{
|
|
printf("Usage: gssrvce -[TCP|NW|AT] [-ol logname]\n");
|
|
ExitProcess ( 0 );
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
//
|
|
// End of gssrvce.c
|
|
//
|
|
//////////////////////////////////////////////////////////////////////
|
|
|