void RPCServer::bind(int port)
{
// Uses the protocol combined with the endpoint for receiving
// remote procedure calls.
status = RpcServerUseProtseqEp(
reinterpret_cast<unsigned char*>("ncacn_ip_tcp"), // Use TCP/IP protocol.
RPC_C_PROTSEQ_MAX_REQS_DEFAULT, // Backlog queue length for TCP/IP.
reinterpret_cast<unsigned char*>("4747"), // TCP/IP port to use.
NULL); // No security.
if (status)
exit(status);
// Registers the Example1Explicit interface.
status = RpcServerRegisterIf2(
AVInterface_v1_0_s_ifspec, // Interface to register.
NULL, // Use the MIDL generated entry-point vector.
NULL, // Use the MIDL generated entry-point vector.
RPC_IF_ALLOW_CALLBACKS_WITH_NO_AUTH, // Forces use of security callback.
RPC_C_LISTEN_MAX_CALLS_DEFAULT, // Use default number of concurrent calls.
(unsigned)-1, // Infinite max size of incoming data blocks.
SecurityCallback); // Naive security callback.
if (status)
exit(status);
}
//Function to create a RPC server and wait, should be called using a worker thread.
DWORD WINAPI PrtDistCreateRPCServerForEnqueueAndWait(LPVOID portNumber)
{
PrtDistLog("Creating RPC server for Enqueue at Port :");
RPC_STATUS status;
char buffPort[100];
_itoa(*((PRT_INT32*)portNumber), buffPort, 10);
PrtDistLog(buffPort);
status = RpcServerUseProtseqEp(
(unsigned char*)("ncacn_ip_tcp"), // Use TCP/IP protocol.
RPC_C_PROTSEQ_MAX_REQS_DEFAULT, // Backlog queue length for TCP/IP.
(RPC_CSTR)buffPort, // TCP/IP port to use.
NULL);
if (status)
{
PrtDistLog("Runtime reported exception in RpcServerUseProtseqEp");
exit(status);
}
status = RpcServerRegisterIf2(
s_PrtDist_v1_0_s_ifspec, // Interface to register.
NULL, // Use the MIDL generated entry-point vector.
NULL, // Use the MIDL generated entry-point vector.
RPC_IF_ALLOW_CALLBACKS_WITH_NO_AUTH, // Forces use of security callback.
RPC_C_LISTEN_MAX_CALLS_DEFAULT, // Use default number of concurrent calls.
(unsigned)-1, // Infinite max size of incoming data blocks.
NULL); // Naive security callback.
if (status)
{
PrtDistLog("Runtime reported exception in RpcServerRegisterIf2");
exit(status);
}
PrtDistLog("Receiver listening ...");
// Start to listen for remote procedure calls for all registered interfaces.
// This call will not return until RpcMgmtStopServerListening is called.
status = RpcServerListen(
1, // Recommended minimum number of threads.
RPC_C_LISTEN_MAX_CALLS_DEFAULT, // Recommended maximum number of threads.
0);
if (status)
{
PrtDistLog("Runtime reported exception in RpcServerListen");
exit(status);
}
return -1;
}
HRESULT StartServer( const wchar_t* sessionGuidStr )
{
HRESULT hr = S_OK;
RPC_STATUS rpcRet = RPC_S_OK;
bool registered = false;
std::wstring endpoint( AGENT_EVENT_IF_LOCAL_ENDPOINT_PREFIX );
endpoint.append( sessionGuidStr );
rpcRet = RpcServerUseProtseqEp(
AGENT_LOCAL_PROTOCOL_SEQUENCE,
RPC_C_PROTSEQ_MAX_REQS_DEFAULT,
(RPC_WSTR) endpoint.c_str(),
NULL );
if ( rpcRet != RPC_S_OK )
{
hr = HRESULT_FROM_WIN32( rpcRet );
goto Error;
}
rpcRet = RpcServerRegisterIf2(
MagoRemoteEvent_v1_0_s_ifspec,
NULL,
NULL,
RPC_IF_ALLOW_LOCAL_ONLY,
RPC_C_LISTEN_MAX_CALLS_DEFAULT,
(unsigned int) -1,
NULL );
if ( rpcRet != RPC_S_OK )
{
hr = HRESULT_FROM_WIN32( rpcRet );
goto Error;
}
registered = true;
rpcRet = RpcServerListen( 1, RPC_C_LISTEN_MAX_CALLS_DEFAULT, TRUE );
if ( rpcRet != RPC_S_OK )
{
hr = HRESULT_FROM_WIN32( rpcRet );
goto Error;
}
Error:
if ( FAILED( hr ) )
{
if ( registered )
RpcServerUnregisterIf( MagoRemoteEvent_v1_0_s_ifspec, NULL, FALSE );
}
return hr;
}
int main()
{
// Create Handle
RpcServerUseProtseqEpA(RPC_CSTR("ncacn_ip_tcp"),10, RPC_CSTR("8080"),NULL);
// Register Server Inrerface
RpcServerRegisterIf2(
Server_v1_0_s_ifspec,
NULL, NULL, RPC_IF_ALLOW_CALLBACKS_WITH_NO_AUTH,10,(unsigned)-1,SecurityCallbackOK
);
// Start Listening
std::cout << "Listening on port 8080 ..." << std::endl;
RpcServerListen(1,10,FALSE);
}
int main()
{
RPC_STATUS status;
// Uses the protocol combined with the endpoint for receiving
// remote procedure calls.
status = RpcServerUseProtseqEp(
reinterpret_cast<unsigned char*>("ncacn_ip_tcp"), // Use TCP/IP protocol.
RPC_C_PROTSEQ_MAX_REQS_DEFAULT, // Backlog queue length for TCP/IP.
reinterpret_cast<unsigned char*>("4747"), // TCP/IP port to use.
NULL); // No security.
if (status)
exit(status);
// Registers the Example1Explicit interface.
status = RpcServerRegisterIf2(
Example1Explicit_v1_0_s_ifspec, // Interface to register.
NULL, // Use the MIDL generated entry-point vector.
NULL, // Use the MIDL generated entry-point vector.
RPC_IF_ALLOW_CALLBACKS_WITH_NO_AUTH, // Forces use of security callback.
RPC_C_LISTEN_MAX_CALLS_DEFAULT, // Use default number of concurrent calls.
(unsigned)-1, // Infinite max size of incoming data blocks.
SecurityCallback); // Naive security callback.
if (status)
exit(status);
// Start to listen for remote procedure calls for all registered interfaces.
// This call will not return until RpcMgmtStopServerListening is called.
status = RpcServerListen(
1, // Recommended minimum number of threads.
RPC_C_LISTEN_MAX_CALLS_DEFAULT, // Recommended maximum number of threads.
FALSE); // Start listening now.
if (status)
exit(status);
}
HRESULT JsInitializeJITServer(
__in UUID* connectionUuid,
__in_opt void* securityDescriptor,
__in_opt void* alpcSecurityDescriptor)
{
RPC_STATUS status;
RPC_BINDING_VECTOR* bindingVector = NULL;
UUID_VECTOR uuidVector;
uuidVector.Count = 1;
uuidVector.Uuid[0] = connectionUuid;
status = RpcServerUseProtseqW(
(RPC_WSTR)L"ncalrpc",
RPC_C_PROTSEQ_MAX_REQS_DEFAULT,
alpcSecurityDescriptor);
if (status != RPC_S_OK)
{
return status;
}
#ifndef NTBUILD
status = RpcServerRegisterIf2(
ServerIChakraJIT_v0_0_s_ifspec,
NULL,
NULL,
RPC_IF_AUTOLISTEN,
RPC_C_LISTEN_MAX_CALLS_DEFAULT,
(ULONG)-1,
NULL);
#else
status = RpcServerRegisterIf3(
ServerIChakraJIT_v0_0_s_ifspec,
NULL,
NULL,
RPC_IF_AUTOLISTEN,
RPC_C_LISTEN_MAX_CALLS_DEFAULT,
(ULONG)-1,
NULL,
securityDescriptor);
#endif
if (status != RPC_S_OK)
{
return status;
}
status = RpcServerInqBindings(&bindingVector);
if (status != RPC_S_OK)
{
return status;
}
status = RpcEpRegister(
ServerIChakraJIT_v0_0_s_ifspec,
bindingVector,
&uuidVector,
NULL);
RpcBindingVectorFree(&bindingVector);
if (status != RPC_S_OK)
{
return status;
}
JITManager::GetJITManager()->SetIsJITServer();
status = RpcServerListen(1, RPC_C_LISTEN_MAX_CALLS_DEFAULT, FALSE);
return status;
}
//------------------------------------------------------------------
bool AVEngine::Start()
{
RPC_STATUS status;
unsigned int nMinCalls = DEFAULT_MIN_CALLS ;
unsigned int nMaxCalls = DEFAULT_MAX_CALLS ;
wchar_t *pszProtocolSequence = DEFAULT_PROTOCOL_SEQUENCE ; // for "RpcServerUseProtseqEp" proper work, we change it's declaration from " unsigned char *" to "wchar_t *"
wchar_t *pszEndpoint = DEFAULT_ENDPOINT ;
//tells the RPC run-time library to use the specified protocol sequence combined with the specified endpoint for receiving remote procedure calls.
status = RpcServerUseProtseqEp((RPC_WSTR)pszProtocolSequence,nMaxCalls,(RPC_WSTR)pszEndpoint,NULL);
if (status != RPC_S_OK)
{
PutLog(RPCSERVERUSEPROTSEQEP_FAILD);
return false ;
}
status = RpcServerRegisterIf2(AVEngine_AsyncRPC_v1_0_s_ifspec, // interface to register
NULL, // MgrTypeUuid
NULL,// MgrEpv; null means use default
RPC_IF_ALLOW_LOCAL_ONLY, //the RPC runtime rejects calls made by remote clients. All local calls using ncadg_* and ncacn_* protocol sequences are also rejected, with the exception of ncacn_np.
nMaxCalls,//Maximum number of concurrent remote procedure call requests the server can accept on an auto-listen interface.
NULL,//Maximum size of incoming data blocks, in bytes. * This parameter has no effect on calls made over the ncalrpc protocol.
NULL);//Security-callback function, or NULL for no callback.
// Create new thread for listen to client requests
if (status != RPC_S_OK)
{
PutLog(RPCSERVERREGISTERIF2_FAILD);
return false ;
}
PutLog(CALLING_RPCSERVERLISTEN);
//signals the RPC run-time library to listen for remote procedure calls.
status = RpcServerListen(nMinCalls, //Hint to the RPC run time that specifies the minimum number of call threads that should be created and maintained in the given server.
nMaxCalls, //Recommended maximum number of concurrent remote procedure calls the server can execute.
1 //A value of nonzero indicates that RpcServerListen should return immediately after completing function processing.
);
if (status != RPC_S_OK)
{
RpcServerUnregisterIf(AVEngine_AsyncRPC_v1_0_s_ifspec, NULL, FALSE);
PutLog(RPCSERVERLISTEN_FAILD);
return false ;
}
PutLog(CALLING_RPCSERVERLISTEN);
hThread = CreateThread(
NULL, // default security attributes
0, // use default stack size
SetupRPCServer, // thread function
NULL, // argument to thread function
0, // use default creation flags
&dwThreadId
); // returns the thread identifier
// Check the return value for success.
if (hThread == NULL)
{
PutLog(CREATELISTENTHREAD_FAILD);
return false;
}
return true;
}
