archive
/
windows-xp
mirror of https://github.com/tongzx/nt5src
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Source code of Windows XP (NT5)
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.
6 Commits
1 Branch
0 Tags
2.0 GiB
 
 
 
 
 
 
Branch: master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
windows-xp/Source/XPSP1/NT/com/rpc/midl/codegen/netmon.cxx

1318 lines
39 KiB
Raw Permalink Blame History

/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Copyright (c) 1998-2000 Microsoft Corporation
Module Name:
netmon.cxx
Abstract:
Generate C code for the stub DLL's used for Netmon debugging
Notes:
Two files are generated by this file:
xxx_netmon_stub.c
xxx_netmob_stub_obj.c
History:
- Created 7/28/98 by Max Attar Feingold
----------------------------------------------------------------------------*/
#include "becls.hxx"
// Stub version
#define NETMON_STUB_VERSION "(float) 1.0"
#pragma hdrstop
CG_STATUS
CG_NETMONSTUB_FILE::GenCode(
CCB * pCCB)
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Routine Description:
Generate the Netmon stub file for classic and object interfaces
Arguments:
pCCB - The code gen controller block.
Return Value:
CG_OK if all is well.
Notes:
----------------------------------------------------------------------------*/
{
ISTREAM Stream( GetFileName(), 4 );
ISTREAM * pStream = pCCB->SetStream( &Stream, this );
m_pCCB = pCCB;
m_pStream = pStream;
// Scan for interfaces of the appropriate type
ScanInterfaces();
if (!m_bDoObject && !m_bClassic ||
m_bDoObject && !m_bObject) {
m_pStream->Close();
return CG_OK;
}
// If m_bDoObject is TRUE, then we're producing a stub file for object interfaces;
// otherwise, we're doing classic interfaces
if (m_bDoObject) {
EmitFileHeadingBlock (pCCB, "code for an object interface Netmon stub DLL",
"This file should be compiled as source for a DLL, linked with rpcrt4.lib");
} else {
EmitFileHeadingBlock (pCCB, "code for a classic interface Netmon stub DLL",
"This file should be compiled as source for a DLL, linked with rpcrt4.lib");
}
// Write standard include files
EmitStandardIncludes();
// Write local include files
EmitLocalIncludes();
// Write definitions (#defines and variables needed by the code)
EmitDefinitions();
if (m_bDoObject) {
// We seem to need this to solve a link error
OpenComment();
EmitComment ("This implementation is needed to solve a link error");
CloseComment();
pStream->NewLine();
pStream->Write ("ULONG STDMETHODCALLTYPE CStdStubBuffer_Release "\
"(IRpcStubBuffer *This) { ULONG u = 0; return u; }");
// Write the special data for object interfaces
EmitObjectInterfaceData();
}
// Write the server and client debug procedures for each interface
EmitDebugProcedures();
// Write the data tables
EmitDataTables();
// Close the header block
EmitFileClosingBlock( pCCB );
// Close the stream
pStream->Close();
return CG_OK;
}
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Routine Descriptions:
Determine which types of interfaces (object or classic) we have and how many,
adding the names to the interface table
Arguments:
Return Value:
TRUE if yes
FALSE if no
Notes:
----------------------------------------------------------------------------*/
CG_STATUS CG_NETMONSTUB_FILE::ScanInterfaces() {
CG_ITERATOR I;
CG_NDR * pCG;
GetMembers( I );
while( ITERATOR_GETNEXT( I, pCG ) )
{
// We check GetChild()'s non-nullness here and elsewhere in the code because
// there are object interfaces without children that cause problems, such as IUnknown
if (pCG->GetChild()) {
switch(pCG->GetCGID())
{
case ID_CG_INTERFACE:
m_bClassic = TRUE;
m_lNumClassicInterfaces ++;
m_itInterfaceTable.AddInterface (((CG_INTERFACE*)pCG)->GetInterfaceName());
break;
case ID_CG_OBJECT_INTERFACE:
m_bObject = TRUE;
m_lNumObjectInterfaces ++;
m_itInterfaceTable.AddInterface (((CG_INTERFACE*)pCG)->GetInterfaceName());
break;
default:
break;
}
}
}
return CG_OK;
}
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Routine Descriptions:
Respectively,
-Open a comment block
-Write comments
-Close a comment block
Arguments:
pszString is the comment that should be emitted
Return Value:
CG_OK if all is well.
Notes:
----------------------------------------------------------------------------*/
CG_STATUS CG_NETMONSTUB_FILE::OpenComment() {
m_pStream->NewLine();
m_pStream->NewLine();
m_pStream->Write ("/*");
return CG_OK;
}
CG_STATUS CG_NETMONSTUB_FILE::EmitComment (char* pszString) {
m_pStream->NewLine();
m_pStream->Write (" * ");
m_pStream->Write (pszString);
return CG_OK;
}
CG_STATUS CG_NETMONSTUB_FILE::CloseComment() {
m_pStream->NewLine();
m_pStream->Write (" */");
return CG_OK;
}
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Routine Description:
Generate the standard includes for the netmon stub dll
Arguments:
Return Value:
CG_OK if all is well.
Notes:
----------------------------------------------------------------------------*/
CG_STATUS CG_NETMONSTUB_FILE::EmitStandardIncludes() {
m_pStream->NewLine();
m_pStream->Write ("#include <stdio.h>");
return CG_OK;
}
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Routine Description:
Generate the local includes for the netmon stub dll.
Arguments:
Return Value:
CG_OK if all is well.
Notes:
Local includes are the proxy and iid files for object interfaces
and the stub file for classic interfaces.
----------------------------------------------------------------------------*/
CG_STATUS CG_NETMONSTUB_FILE::EmitLocalIncludes() {
m_pStream->NewLine(2);
// This is defined to avoid target errors
m_pStream->Write ("#define _WIN32_DCOM");
// Write includes
m_pStream->NewLine();
if (m_bDoObject) {
m_pStream->Write ("#include \"");
m_pStream->Write (pCommand->GetProxyFName());
m_pStream->Write ("\"");
m_pStream->NewLine();
m_pStream->Write ("#include \"");
m_pStream->Write (pCommand->GetIIDFName());
m_pStream->Write ("\"");
m_pStream->NewLine();
} else {
m_pStream->Write ("#include \"");
m_pStream->Write (pCommand->GetSstubFName());
m_pStream->Write ("\"");
m_pStream->NewLine();
}
return CG_OK;
}
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Routine Description:
Generate any definitions needed by the netmon stub dll.
Arguments:
Return Value:
CG_OK if all is well.
Notes:
----------------------------------------------------------------------------*/
const char* ppszIncludeBlock[] = {
"#define DLL_EXPORT_PROC(x) __declspec(dllexport) GLOBAL_INTERFACE_DATA* GetGlobalInterfaceData__##x () { return &GlobalInterfaceData__##x ; }",
"#define NetmonStubAllocate(x) malloc(x)",
"#define Debug() *pNull = 0",
"static DWORD* pNull = NULL;",
NULL
};
const char* ppszGlobalInterfaceDataStructure[] = {
"float Version;",
"char* InterfaceName;",
"DWORD ProcFormatStringSize;",
"DWORD NumProcedures;",
"char** ProcedureNames;",
"SERVER_ROUTINE* ServerRoutineTable;",
"SERVER_ROUTINE* ClientRoutineTable;",
"RPC_SERVER_INTERFACE* RpcServerInterface;",
"void* DebugArgumentBuffer;",
NULL
};
CG_STATUS CG_NETMONSTUB_FILE::EmitDefinitions() {
if (!m_bDoObject) {
m_pStream->NewLine();
m_pStream->Write ("#pragma warning (disable : 4700) /* No warnings from the "\
"use of uninitialized variables */");
m_pStream->NewLine();
}
m_pStream->WriteBlock (ppszIncludeBlock);
OpenComment();
EmitComment ("Structure used to encapsulate all relevant interface information");
CloseComment();
m_pStream->NewLine(2);
m_pStream->Write ("typedef struct _GLOBAL_INTERFACE_DATA {");
Out_IndentInc( m_pCCB );
m_pStream->WriteBlock (ppszGlobalInterfaceDataStructure);
Out_IndentDec( m_pCCB );
m_pStream->NewLine();
m_pStream->Write ("} GLOBAL_INTERFACE_DATA;");
OpenComment();
EmitComment ("Function used to view unmarshalled argument buffers");
CloseComment();
m_pStream->NewLine();
m_pStream->Write ("static void DebugArgumentBuffer (BYTE* ArgumentBuffer, DWORD BufferSize) "\
"{ Debug(); }");
return CG_OK;
}
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Routine Description:
Generate the data used specifically by object interfaces.
Arguments:
Return Value:
CG_OK if all is well.
Notes:
----------------------------------------------------------------------------*/
CG_STATUS CG_NETMONSTUB_FILE::EmitObjectInterfaceData() {
CG_ITERATOR I;
CG_NDR * pCG;
OpenComment();
EmitComment ("Data used specifically by object interfaces");
CloseComment();
// Loop through all interfaces
GetMembers( I );
while( ITERATOR_GETNEXT( I, pCG ) ) {
if (pCG->GetChild()) {
switch(pCG->GetCGID()) {
case ID_CG_OBJECT_INTERFACE:
// Emit the object interface RPC_SERVER_INTERFACE structures
OpenComment();
EmitComment ("RPC_SERVER_INTERFACE structure for object interface ");
m_pStream->Write (pCG->GetSymName());
CloseComment();
EmitRPCServerInterface ((CG_INTERFACE*) pCG);
break;
default:
break;
}
}
}
return CG_OK;
}
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Routine Description:
Generate an RPC_SERVER_INTERFACE structure for the given interface
Arguments:
Return Value:
CG_OK if all is well.
Notes:
Most of the code was taken from misccls.cxx -> CG_INTERFACE::GenServerStub
----------------------------------------------------------------------------*/
CG_STATUS CG_NETMONSTUB_FILE::EmitRPCServerInterface (CG_INTERFACE* pCG) {
GUID_STRS TransferSyntaxGuid( TRANSFER_SYNTAX_GUID_STR_1,
TRANSFER_SYNTAX_GUID_STR_2,
TRANSFER_SYNTAX_GUID_STR_3,
TRANSFER_SYNTAX_GUID_STR_4,
TRANSFER_SYNTAX_GUID_STR_5);
GUID_STRS GuidStrs;
unsigned short M, m;
char Buffer[ _MAX_DRIVE + _MAX_DIR + _MAX_FNAME + _MAX_EXT + 1 ];
long ProtSeqEPCount = 0;
ITERATOR * pProtSeqIterator;
GuidStrs = pCG->GetGuidStrs();
m_pCCB->SetInterfaceCG (pCG);
m_pCCB->SetInterfaceName (pCG->GetInterfaceName());
m_pCCB->GetVersion( &M,&m );
sprintf( Buffer,
"&%s_%s_DispatchTable",
pCG->GetInterfaceName(),
m_pCCB->GenMangledName()
);
if ( ( pProtSeqIterator = pCG->GetProtSeqEps() ) != 0 )
{
ProtSeqEPCount = ITERATOR_GETCOUNT( *pProtSeqIterator );
Out_EP_Info( m_pCCB, pProtSeqIterator );
}
Out_IFInfo( m_pCCB, // controller block.
RPC_S_INT_INFO_TYPE_NAME, // interface info type name.
RPC_S_INT_INFO_STRUCT_NAME, // variable name.
SIZEOF_RPC_SERVER_INTERFACE, // string speicifying size.
GuidStrs, // Guid specified in idl
M, // user specified major version
m, // user specified minor version
// TransferSyntaxGuid, // ndr identifying guid.
// NDR_UUID_MAJOR_VERSION, // ndr's version
// NDR_UUID_MINOR_VERSION,
NULL, //Buffer,
ProtSeqEPCount, // if this is 0, then the next
// 2 fields are ignored by the call.
PROTSEQ_EP_TYPE_NAME, // RPC_PROTSEQ_ENDPOINT
PROTSEQ_EP_VAR_NAME, // ___RpcProtSeqEndpoint
m_pCCB->IsNoDefaultEpv(),
1,
pCG->HasPipes()
);
return CG_OK;
}
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Routine Description:
Generate the debug procedures for all interfaces
Arguments:
Return Value:
CG_OK if all is well.
Notes:
----------------------------------------------------------------------------*/
CG_STATUS CG_NETMONSTUB_FILE::EmitDebugProcedures() {
CG_ITERATOR I;
CG_NDR * pCG;
CG_PROC * pProc;
CG_INTERFACE * pInt;
ID_CG idCg;
ITERATOR IProc;
char* pszInterfaceName, * pszLastInterfaceName, * pszOurInterfaceName;
// Write midl malloc and free if we're writing a classic interface stub
if (!m_bDoObject) {
OpenComment();
EmitComment ("Procedures used by the runtime to allocate and free memory");
CloseComment();
m_pStream->NewLine(2);
m_pStream->Write (
"static void * __RPC_API midl_user_allocate(size_t len) { return NetmonStubAllocate(len); }");
m_pStream->NewLine();
m_pStream->Write (
"static void __RPC_API midl_user_free(void * ptr) { free(ptr); }");
}
OpenComment();
EmitComment ("Implementation of debug server and client functions for all ");
if (m_bDoObject) {
m_pStream->Write ("object");
} else {
m_pStream->Write ("classic");
}
m_pStream->Write (" interfaces");
CloseComment();
// Loop through all interfaces
GetMembers( I );
while( ITERATOR_GETNEXT( I, pCG ) )
{
if (pCG->GetChild()) {
pInt = (CG_INTERFACE*) pCG;
idCg = pCG->GetCGID();
switch(idCg) {
case ID_CG_INTERFACE:
if (!m_bDoObject) {
// Loop through all member functions
pInt->GetAllMemberFunctions( IProc );
while( ITERATOR_GETNEXT( IProc, pProc ) ) {
EmitServerClientDebugProcedure (pProc, FALSE);
// Emit the procedure as is (to avoid link errors)
m_pStream->NewLine(2);
m_pStream->Write ("static");
Out_ClientProcedureProlog( m_pCCB, pProc->GetType() );
Out_IndentInc( m_pCCB );
// Return a variable of the appropriate return value
if (((node_proc*) pProc->GetType())->HasReturn()) {
m_pStream->Spaces( STANDARD_STUB_TAB );
m_pStream->Write( pProc->GetReturnType()->GetSymName() );
m_pStream->Write(" RetVal;");
m_pStream->NewLine();
m_pStream->Write( "return RetVal;" );
}
// Close the procedure
Out_IndentDec( m_pCCB );
Out_ProcClosingBrace( m_pCCB );
}
}
break;
case ID_CG_OBJECT_INTERFACE:
if (m_bDoObject) {
pszOurInterfaceName = pInt->GetInterfaceName();
pszLastInterfaceName = NULL;
// Loop through all member functions
pInt->GetAllMemberFunctions ( IProc);
while( ITERATOR_GETNEXT( IProc, pProc ) ) {
// Get the procedure's real interface name
pszInterfaceName = pProc->GetInterfaceNode()->GetInterfaceName();
// Write the function if:
// a) We're its real interface.
// b) The interface hasn't been used yet and it's not IUnknown
// c) The interface name is the same as the last one we used
// (so it's OK to use it again)
if (strcmp (pszInterfaceName, pszOurInterfaceName) == 0 ||
(!m_itOutputInterfaceTable.FindInterface (pszInterfaceName) &&
strcmp (pszInterfaceName, "IUnknown") != 0) ||
(pszLastInterfaceName != NULL &&
strcmp (pszInterfaceName, pszLastInterfaceName) == 0)
) {
// Write the server and client debug procedures
EmitServerClientDebugProcedure (pProc, TRUE);
// Add the interface name to the table of used interfaces
m_itOutputInterfaceTable.AddInterface (pszInterfaceName);
// Record the last interface name used
pszLastInterfaceName = pszInterfaceName;
}
}
}
break;
default:
break;
}
}
}
return CG_OK;
}
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Routine Description:
Generate server, client and link stub procedures for a given procedure
Arguments:
pProc -> The procedure to be processed
bIsObject -> TRUE if the procedure belongs to an object interface
FALSE otherwise
Return Value:
CG_OK if all is well.
Notes:
This function is long and ugly
----------------------------------------------------------------------------*/
CG_STATUS CG_NETMONSTUB_FILE::EmitServerClientDebugProcedure (CG_PROC* pProc, BOOL bIsObject) {
PNAME pszProcName, pszNewProcName;
node_proc * pNodeProc = ((node_proc*) pProc->GetType());
node_param * pRetValParam, * pThisParam, * pParam;
node_skl * pOldRetType;
node_base_type * pVoidBaseType;
type_node_list ITypeNodeList;
short i, siNumArgs;
PNAME* ppszOldArgName;
PNAME* ppszNewArgName;
node_base_attr * pNodeAttribIn, * pNodeAttribOut;
BOOL bHasReturn = pNodeProc->HasReturn();
// Get the procedure name
pszProcName = pProc->GetSymName();
// Rename the procedure to Server__InterfaceName__ProcName
pszNewProcName = new char [strlen (pProc->GetInterfaceName()) +
strlen (pszProcName) + 11];
sprintf ( pszNewProcName, "Server__%s__%s", pProc->GetInterfaceName(), pszProcName );
pNodeProc->SetSymName ( pszNewProcName );
// Set void type
pVoidBaseType = new node_base_type( NODE_VOID, ATTR_BASE );
pVoidBaseType->SetSymName( "void" );
pOldRetType = pNodeProc->GetChild();
pNodeProc->SetChild( pVoidBaseType );
// Rename the arguments to IN__Name, OUT__Name or IN_OUT__name
i = 0;
siNumArgs = pNodeProc->GetNumberOfArguments();
ppszOldArgName = new PNAME [siNumArgs];
ppszNewArgName = new PNAME [siNumArgs];
pNodeProc->GetParameterList (&ITypeNodeList);
while( ITERATOR_GETNEXT( ITypeNodeList, pParam ) ) {
MIDL_ASSERT (i < siNumArgs);
ppszOldArgName[i] = pParam->GetSymName();
ppszNewArgName[i] = new char [strlen (ppszOldArgName[i]) + 10];
if ((pNodeAttribIn = pParam->GetAttribute (ATTR_IN)) &&
(pNodeAttribOut = pParam->GetAttribute (ATTR_OUT))) {
sprintf (ppszNewArgName[i], "IN_OUT__%s", ppszOldArgName[i]);
} else {
if (pNodeAttribIn) {
sprintf (ppszNewArgName[i], "IN__%s", ppszOldArgName[i]);
} else {
sprintf (ppszNewArgName[i], "OUT__%s", ppszOldArgName[i]);
}
}
pParam->SetSymName (ppszNewArgName[i]);
i ++;
}
// If proc belongs to an object interface, add the 'this' pointer
if (bIsObject) {
pThisParam = new node_param();
pThisParam->SetAttribute (ATTR_IN);
pThisParam->SetSymName ("this");
pThisParam->SetBasicType( (node_skl *) new node_def( "void*" ));
pThisParam->SetEdgeType( EDGE_USE );
pNodeProc->AddFirstMember (pThisParam);
}
// Emit the server procedure
m_pStream->NewLine(2);
m_pStream->Write ("static");
Out_ClientProcedureProlog( m_pCCB, pNodeProc );
Out_IndentInc( m_pCCB );
m_pStream->Spaces( STANDARD_STUB_TAB );
m_pStream->Write( "Debug();" );
Out_IndentDec( m_pCCB );
Out_ProcClosingBrace( m_pCCB );
// Rename the procedure to Client__InterfaceName__ProcName
sprintf( pszNewProcName, "Client__%s__%s", pProc->GetInterfaceName(), pszProcName );
// Add a RetVal parameter to the param list if the function isn't void
if (bHasReturn) {
pRetValParam = new node_param();
pRetValParam->SetAttribute (ATTR_IN);
pRetValParam->SetSymName ("RetVal");
pRetValParam->SetBasicType( (node_skl *) new node_def( pProc->GetReturnType()->GetSymName() ));
pRetValParam->SetEdgeType( EDGE_USE );
pNodeProc->AddLastMember (pRetValParam);
}
// Emit the client procedure
m_pStream->NewLine(2);
m_pStream->Write ("static");
Out_ClientProcedureProlog( m_pCCB, pNodeProc );
Out_IndentInc( m_pCCB );
m_pStream->Spaces( STANDARD_STUB_TAB );
m_pStream->Write( "Debug();" );
Out_IndentDec( m_pCCB );
Out_ProcClosingBrace( m_pCCB );
// Delete the this parameter we created
if (bIsObject) {
pNodeProc->RemoveFirstMember();
delete pThisParam;
}
// Delete the RetVal from the param List
if (bHasReturn) {
pNodeProc->RemoveLastMember();
delete pRetValParam;
}
// Restore the procedure's name
pNodeProc->SetSymName( pszProcName );
// Restore the procedure's parameter names
if (siNumArgs > 0) {
i = 0;
pNodeProc->GetParameterList (&ITypeNodeList);
while( ITERATOR_GETNEXT( ITypeNodeList, pParam ) ) {
pParam->SetSymName (ppszOldArgName[i]);
delete [] ppszNewArgName[i];
i ++;
}
delete [] ppszNewArgName;
delete [] ppszOldArgName;
}
// Restore the node's return type
pNodeProc->SetChild( pOldRetType );
// Delete the fake void type node we created
delete pVoidBaseType;
// Delete the new name we created
delete [] pszNewProcName;
return CG_OK;
}
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Routine Description:
Generate data tables for each interface
Arguments:
Return Value:
CG_OK if all is well.
Notes:
----------------------------------------------------------------------------*/
CG_STATUS CG_NETMONSTUB_FILE::EmitDataTables() {
// Write procedure name tables for each interface
EmitProcNameTables();
// Write the server and client lookup tables for each interface
EmitServerClientTables();
// Write the global_interface_data structures and exports for each interface
EmitGlobalInterfaceData();
return CG_OK;
}
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Routine Description:
Generate tables with each interface's procedure names and the number of
procedures in each interface.
Arguments:
Return Value:
CG_OK if all is well.
Notes:
----------------------------------------------------------------------------*/
CG_STATUS CG_NETMONSTUB_FILE::EmitProcNameTables() {
CG_ITERATOR I;
CG_NDR * pCG;
CG_INTERFACE* pInt;
ITERATOR IProc;
CG_PROC * pProc;
long lNumProcs;
BOOL bBeenHereBefore;
char* pszInterfaceName;
char pszTemp [1024];
GetMembers( I );
while( ITERATOR_GETNEXT( I, pCG ) ) {
if (pCG->GetChild()) {
pInt = (CG_INTERFACE*) pCG;
if (m_bDoObject && pCG->GetCGID() == ID_CG_OBJECT_INTERFACE ||
!m_bDoObject && pCG->GetCGID() == ID_CG_INTERFACE) {
lNumProcs = 0;
bBeenHereBefore = FALSE;
pszInterfaceName = pInt->GetInterfaceName();
OpenComment();
EmitComment ("Procedure tables for interface ");
m_pStream->Write (pszInterfaceName);
CloseComment();
m_pStream->NewLine();
sprintf (pszTemp, "static char* %s__ProcedureNames[] = {", pszInterfaceName);
m_pStream->Write (pszTemp);
Out_IndentInc( m_pCCB );
pInt->GetAllMemberFunctions ( IProc);
while( ITERATOR_GETNEXT( IProc, pProc ) ) {
pszInterfaceName = pProc->GetInterfaceNode()->GetInterfaceName();
if (strcmp (pszInterfaceName, "IUnknown") != 0) {
// Write a comma if we're not the first function in the list
if (bBeenHereBefore) {
m_pStream->Write (",");
} else {
bBeenHereBefore = TRUE;
}
// Write procedure name enclosed in quotes
m_pStream->NewLine();
m_pStream->Write ("\"");
m_pStream->Write (pProc->GetSymName());
m_pStream->Write ("\"");
// Increment procedure count
lNumProcs ++;
}
}
Out_IndentDec( m_pCCB );
m_pStream->NewLine();
m_pStream->Write ("};");
// Set number of procedures in interface table
m_itInterfaceTable.SetNumProcedures (pszInterfaceName, lNumProcs);
}
} // if
} // while
return CG_OK;
}
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Routine Description:
Generate the server and client lookup tables for each interface
Arguments:
Return Value:
CG_OK if all is well.
Notes:
----------------------------------------------------------------------------*/
CG_STATUS CG_NETMONSTUB_FILE::EmitServerClientTables() {
CG_ITERATOR I;
CG_NDR * pCG;
CG_INTERFACE* pInt;
ITERATOR IProc;
CG_PROC * pProc;
char* pszInterfaceName;
GetMembers( I );
while( ITERATOR_GETNEXT( I, pCG ) ) {
if (pCG->GetChild()) {
if (m_bDoObject && pCG->GetCGID() == ID_CG_OBJECT_INTERFACE ||
!m_bDoObject && pCG->GetCGID() == ID_CG_INTERFACE) {
pInt = (CG_INTERFACE*) pCG;
pszInterfaceName = pInt->GetInterfaceName();
// Write the server table
OpenComment();
EmitComment ("Debug server procedures for interface ");
m_pStream->Write (pszInterfaceName);
CloseComment();
m_pStream->NewLine();
m_pStream->Write ("static SERVER_ROUTINE ");
m_pStream->Write (pszInterfaceName);
m_pStream->Write ("__ServerRoutineTable[] = {");
Out_IndentInc( m_pCCB );
// If we're processing an object interface,
// we have to make room for the 3 IUnknown procedures
if (m_bDoObject) {
m_pStream->NewLine();
m_pStream->Write ("NULL,");
m_pStream->NewLine();
m_pStream->Write ("NULL,");
m_pStream->NewLine();
m_pStream->Write ("NULL,");
}
pInt->GetAllMemberFunctions ( IProc);
while( ITERATOR_GETNEXT( IProc, pProc ) ) {
pszInterfaceName = pProc->GetInterfaceNode()->GetInterfaceName();
if (strcmp (pszInterfaceName, "IUnknown") != 0) {
m_pStream->NewLine();
m_pStream->Write ("(SERVER_ROUTINE)Server__");
m_pStream->Write (pProc->GetInterfaceNode()->GetSymName());
m_pStream->Write ("__");
m_pStream->Write (pProc->GetSymName());
m_pStream->Write (",");
}
}
Out_IndentDec( m_pCCB );
m_pStream->NewLine();
m_pStream->Write ("};");
// Write client table
OpenComment();
EmitComment ("Debug client procedures for interface ");
m_pStream->Write (pszInterfaceName);
CloseComment();
m_pStream->NewLine();
m_pStream->Write ("static SERVER_ROUTINE ");
m_pStream->Write (pszInterfaceName);
m_pStream->Write ("__ClientRoutineTable[] = {");
Out_IndentInc( m_pCCB );
// If we're processing an object interface,
// we have to make room for the 3 IUnknown procedures
if (m_bDoObject) {
m_pStream->NewLine();
m_pStream->Write ("NULL,");
m_pStream->NewLine();
m_pStream->Write ("NULL,");
m_pStream->NewLine();
m_pStream->Write ("NULL,");
}
pInt->GetAllMemberFunctions ( IProc);
while( ITERATOR_GETNEXT( IProc, pProc ) ) {
pszInterfaceName = pProc->GetInterfaceNode()->GetInterfaceName();
if (strcmp (pszInterfaceName, "IUnknown") != 0) {
m_pStream->NewLine();
m_pStream->Write ("(SERVER_ROUTINE)Client__");
m_pStream->Write (pProc->GetInterfaceNode()->GetSymName());
m_pStream->Write ("__");
m_pStream->Write (pProc->GetSymName());
m_pStream->Write (",");
}
}
Out_IndentDec( m_pCCB );
m_pStream->NewLine();
m_pStream->Write ("};");
}
}
}
return CG_OK;
}
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Routine Description:
Generate the global interface data structures for each interface, as well
as the export functions that return them
Arguments:
Return Value:
CG_OK if all is well.
Notes:
----------------------------------------------------------------------------*/
CG_STATUS CG_NETMONSTUB_FILE::EmitGlobalInterfaceData() {
CG_ITERATOR I;
CG_NDR * pCG;
ID_CG idCG;
char pszTemp [100], * pszInterfaceName, * pszFixedUuid;
char * p1, * p2, * p3, * p4, * p5;
long lNumProcs;
size_t lLength;
GetMembers( I );
while( ITERATOR_GETNEXT( I, pCG ) ) {
idCG = pCG->GetCGID();
if (((idCG == ID_CG_OBJECT_INTERFACE && m_bDoObject) ||
(idCG == ID_CG_INTERFACE && !m_bDoObject)) &&
pCG->GetChild()) {
// Get the underscored uuid
((CG_INTERFACE*) pCG)->GetGuidStrs().GetStrs (p1, p2, p3, p4, p5);
lLength = (long) strlen (p1) + strlen (p2) + strlen (p3) + strlen (p4) + strlen (p5);
pszFixedUuid = new char [lLength + 5];
sprintf (pszFixedUuid, "%s_%s_%s_%s_%s", p1, p2, p3, p4, p5);
pszFixedUuid = _strlwr (pszFixedUuid);
// Get the interface name
pszInterfaceName = pCG->GetSymName();
// Write a comment
OpenComment();
EmitComment ("GLOBAL_INTERFACE_DATA structure for interface ");
m_pStream->Write (pszInterfaceName);
CloseComment();
// Header
m_pStream->NewLine();
m_pStream->Write ("static GLOBAL_INTERFACE_DATA GlobalInterfaceData__");
m_pStream->Write (pszFixedUuid);
m_pStream->Write (" = {");
Out_IndentInc( m_pCCB );
// Version
m_pStream->NewLine();
m_pStream->Write (NETMON_STUB_VERSION);
m_pStream->Write (",");
// Name
m_pStream->NewLine();
m_pStream->Write ("\"");
m_pStream->Write (pszInterfaceName);
m_pStream->Write ("\",");
// Proc format string size
m_pStream->NewLine();
m_pStream->Write ("PROC_FORMAT_STRING_SIZE,");
// NumProcs
m_pStream->NewLine();
if (m_itInterfaceTable.GetNumProcedures (pszInterfaceName, &lNumProcs)) {
m_pStream->Write (_itoa (lNumProcs, pszTemp, 10));
} else {
MIDL_ASSERT (FALSE);
}
m_pStream->Write (",");
// Proc name table
m_pStream->NewLine();
m_pStream->Write (pszInterfaceName);
m_pStream->Write ("__ProcedureNames,");
// Server routine table
m_pStream->NewLine();
m_pStream->Write (pszInterfaceName);
m_pStream->Write ("__ServerRoutineTable,");
// Client routine table
m_pStream->NewLine();
m_pStream->Write (pszInterfaceName);
m_pStream->Write ("__ClientRoutineTable,");
// Rpc server interface pointer
m_pStream->NewLine();
m_pStream->Write ("(RPC_SERVER_INTERFACE*) &");
m_pStream->Write (pszInterfaceName);
m_pStream->Write ("___RpcServerInterface,");
// DebugArgumentBuffer
m_pStream->NewLine();
m_pStream->Write ("(void*) DebugArgumentBuffer");
Out_IndentDec( m_pCCB );
m_pStream->NewLine();
m_pStream->Write ("};");
// Export function
OpenComment();
EmitComment ("Export function for interface ");
m_pStream->Write (pszInterfaceName);
CloseComment();
m_pStream->NewLine();
m_pStream->Write ("DLL_EXPORT_PROC (");
m_pStream->Write (pszFixedUuid);
m_pStream->Write (")");
delete [] pszFixedUuid;
}
}
return CG_OK;
}
/****************************************************
* InterfaceTable implementations
****************************************************/
#define NUM_BUCKETS 100
NetmonStubFileInterfaceTable::NetmonStubFileInterfaceTable() {
m_pTable = new NetmonStubFileInterfaceList [NUM_BUCKETS];
}
NetmonStubFileInterfaceTable::~NetmonStubFileInterfaceTable() {
delete [] m_pTable;
}
void NetmonStubFileInterfaceTable::AddInterface (char* pszInterface) {
m_pTable[GetHashValue (pszInterface)].AddInterface (pszInterface);
}
// Return true if the interface name was found
BOOL NetmonStubFileInterfaceTable::FindInterface (char* pszInterface) {
return m_pTable[GetHashValue (pszInterface)].FindInterface (pszInterface);
}
// Set the number of procedures in the interface
BOOL NetmonStubFileInterfaceTable::SetNumProcedures (char* pszInterface, long lNumProcs) {
return m_pTable[GetHashValue (pszInterface)].SetNumProcedures (pszInterface, lNumProcs);
}
// Get the number of procedures in the interface
BOOL NetmonStubFileInterfaceTable::GetNumProcedures (char* pszInterface, long* plNumProcs) {
return m_pTable[GetHashValue (pszInterface)].GetNumProcedures (pszInterface, plNumProcs);
}
// The hash value is just the sum of the characters in the interface name
// mod the number of buckets in the table
long NetmonStubFileInterfaceTable::GetHashValue (char* pszInterface) {
long i, lSum = 0, lLen = (long) strlen (pszInterface);
for (i = 0; i < lLen; i ++) {
lSum += (long) pszInterface[i];
}
return lSum % NUM_BUCKETS;
}
/* InterfaceNode */
NetmonStubFileInterfaceNode::NetmonStubFileInterfaceNode (char* pszInterface) {
m_pszInterface = new char [strlen (pszInterface) + 1];
strcpy (m_pszInterface, pszInterface);
m_pNext = NULL;
m_lNumProcs = 0;
}
NetmonStubFileInterfaceNode::~NetmonStubFileInterfaceNode() {
delete [] m_pszInterface;
}
void NetmonStubFileInterfaceNode::SetNext (NetmonStubFileInterfaceNode* pNext) {
m_pNext = pNext;
}
NetmonStubFileInterfaceNode* NetmonStubFileInterfaceNode::GetNext() {
return m_pNext;
}
char* NetmonStubFileInterfaceNode::GetInterface() {
return m_pszInterface;
}
void NetmonStubFileInterfaceNode::SetNumProcedures (long lNumProcs) {
m_lNumProcs = lNumProcs;
}
long NetmonStubFileInterfaceNode::GetNumProcedures() {
return m_lNumProcs;
}
/* InterfaceList */
NetmonStubFileInterfaceList::NetmonStubFileInterfaceList() {
m_pHead = NULL;
m_pTail = NULL;
}
NetmonStubFileInterfaceList::~NetmonStubFileInterfaceList() {
NetmonStubFileInterfaceNode* pNode = m_pHead, *pDeleteNode;
while (pNode != NULL) {
pDeleteNode = pNode;
pNode = pNode->GetNext();
delete pDeleteNode;
}
}
void NetmonStubFileInterfaceList::AddInterface (char* pszInterface) {
NetmonStubFileInterfaceNode* pNode = new NetmonStubFileInterfaceNode (pszInterface);
if (m_pHead == NULL) {
m_pHead = m_pTail = pNode;
} else {
m_pTail->SetNext (pNode);
m_pTail = pNode;
}
}
BOOL NetmonStubFileInterfaceList::FindInterface (char* pszInterface) {
NetmonStubFileInterfaceNode* pNode = m_pHead;
while (pNode != NULL) {
if (strcmp (pszInterface, pNode->GetInterface()) == 0) {
return TRUE;
}
pNode = pNode->GetNext();
}
return FALSE;
}
BOOL NetmonStubFileInterfaceList::SetNumProcedures (char* pszInterface, long lNumProcs) {
NetmonStubFileInterfaceNode* pNode = m_pHead;
while (pNode != NULL) {
if (strcmp (pszInterface, pNode->GetInterface()) == 0) {
pNode->SetNumProcedures (lNumProcs);
return TRUE;
}
pNode = pNode->GetNext();
}
return FALSE;
}
BOOL NetmonStubFileInterfaceList::GetNumProcedures (char* pszInterface, long* plNumProcs) {
NetmonStubFileInterfaceNode* pNode = m_pHead;
while (pNode != NULL) {
if (strcmp (pszInterface, pNode->GetInterface()) == 0) {
*plNumProcs = pNode->GetNumProcedures();
return TRUE;
}
pNode = pNode->GetNext();
}
return FALSE;
}