static
void
__LwSmIpcCallInit(
void
)
{
DWORD dwError = 0;
dwError = MAP_LWMSG_STATUS(lwmsg_protocol_new(NULL, &gpProtocol));
BAIL_ON_ERROR(dwError);
dwError = MAP_LWMSG_STATUS(lwmsg_protocol_add_protocol_spec(
gpProtocol,
LwSmIpcGetProtocolSpec()));
BAIL_ON_ERROR(dwError);
dwError = MAP_LWMSG_STATUS(lwmsg_peer_new(NULL, gpProtocol, &gpClient));
BAIL_ON_ERROR(dwError);
dwError = MAP_LWMSG_STATUS(lwmsg_peer_add_connect_endpoint(
gpClient,
(LWMsgEndpointType)LWMSG_CONNECTION_MODE_LOCAL,
SM_ENDPOINT));
BAIL_ON_ERROR(dwError);
dwError = MAP_LWMSG_STATUS(lwmsg_peer_connect(
gpClient,
&gpSession));
BAIL_ON_ERROR(dwError);
cleanup:
gOnceError = dwError;
return;
error:
if (gpClient)
{
lwmsg_peer_delete(gpClient);
}
if (gpProtocol)
{
lwmsg_protocol_delete(gpProtocol);
}
goto cleanup;
}
DWORD
LwSmSetServiceLogTarget(
LW_SERVICE_HANDLE hHandle,
LW_PCSTR pszFacility,
LW_SM_LOGGER_TYPE type,
PCSTR pszTarget
)
{
DWORD dwError = 0;
LWMsgCall* pCall = NULL;
LWMsgParams in = LWMSG_PARAMS_INITIALIZER;
LWMsgParams out = LWMSG_PARAMS_INITIALIZER;
SM_SET_LOG_INFO_REQ info = {0};
info.hHandle = (LWMsgHandle*) hHandle;
info.pFacility = (PSTR) pszFacility;
info.type = type;
info.pszTarget = (PSTR) pszTarget;
in.tag = SM_IPC_SET_LOG_INFO_REQ;
in.data = &info;
dwError = LwSmIpcAcquireCall(&pCall);
BAIL_ON_ERROR(dwError);
dwError = MAP_LWMSG_STATUS(lwmsg_call_dispatch(pCall, &in, &out, NULL, NULL));
BAIL_ON_ERROR(dwError);
switch (out.tag)
{
case SM_IPC_SET_LOG_INFO_RES:
break;
case SM_IPC_ERROR:
dwError = *(PDWORD) out.data;
BAIL_ON_ERROR(dwError);
break;
default:
dwError = LW_ERROR_INTERNAL;
BAIL_ON_ERROR(dwError);
break;
}
cleanup:
if (pCall)
{
lwmsg_call_destroy_params(pCall, &out);
lwmsg_call_release(pCall);
}
return dwError;
error:
goto cleanup;
}
DWORD
LwSmWaitService(
LW_SERVICE_HANDLE hHandle,
LW_SERVICE_STATE currentState,
PLW_SERVICE_STATE pNewState
)
{
DWORD dwError = 0;
LWMsgCall* pCall = NULL;
LWMsgParams in = LWMSG_PARAMS_INITIALIZER;
LWMsgParams out = LWMSG_PARAMS_INITIALIZER;
SM_IPC_WAIT_STATE_CHANGE_REQ req = {0};
req.hHandle = (LWMsgHandle*) hHandle;
req.state = currentState;
in.tag = SM_IPC_WAIT_SERVICE_REQ;
in.data = &req;
dwError = LwSmIpcAcquireCall(&pCall);
BAIL_ON_ERROR(dwError);
dwError = MAP_LWMSG_STATUS(lwmsg_call_dispatch(pCall, &in, &out, NULL, NULL));
BAIL_ON_ERROR(dwError);
switch (out.tag)
{
case SM_IPC_WAIT_SERVICE_RES:
*pNewState = *(PLW_SERVICE_STATE) out.data;
break;
case SM_IPC_ERROR:
dwError = *(PDWORD) out.data;
BAIL_ON_ERROR(dwError);
break;
default:
dwError = LW_ERROR_INTERNAL;
BAIL_ON_ERROR(dwError);
break;
}
cleanup:
if (pCall)
{
lwmsg_call_destroy_params(pCall, &out);
lwmsg_call_release(pCall);
}
return dwError;
error:
goto cleanup;
}
DWORD
LwSmQueryServiceInfo(
LW_SERVICE_HANDLE hHandle,
PLW_SERVICE_INFO* ppInfo
)
{
DWORD dwError = 0;
LWMsgCall* pCall = NULL;
LWMsgParams in = LWMSG_PARAMS_INITIALIZER;
LWMsgParams out = LWMSG_PARAMS_INITIALIZER;
in.tag = SM_IPC_QUERY_SERVICE_INFO_REQ;
in.data = hHandle;
dwError = LwSmIpcAcquireCall(&pCall);
BAIL_ON_ERROR(dwError);
dwError = MAP_LWMSG_STATUS(lwmsg_call_dispatch(pCall, &in, &out, NULL, NULL));
BAIL_ON_ERROR(dwError);
switch (out.tag)
{
case SM_IPC_QUERY_SERVICE_INFO_RES:
*ppInfo = out.data;
out.data = NULL;
break;
case SM_IPC_ERROR:
dwError = *(PDWORD) out.data;
BAIL_ON_ERROR(dwError);
break;
default:
dwError = LW_ERROR_INTERNAL;
BAIL_ON_ERROR(dwError);
break;
}
cleanup:
if (pCall)
{
lwmsg_call_destroy_params(pCall, &out);
lwmsg_call_release(pCall);
}
return dwError;
error:
*ppInfo = NULL;
goto cleanup;
}
DWORD
LwSmAcquireServiceHandle(
LW_PCWSTR pwszServiceName,
PLW_SERVICE_HANDLE phHandle
)
{
DWORD dwError = 0;
LWMsgCall* pCall = NULL;
LWMsgParams in = LWMSG_PARAMS_INITIALIZER;
LWMsgParams out = LWMSG_PARAMS_INITIALIZER;
in.tag = SM_IPC_ACQUIRE_SERVICE_HANDLE_REQ;
in.data = (PVOID) pwszServiceName;
dwError = LwSmIpcAcquireCall(&pCall);
BAIL_ON_ERROR(dwError);
dwError = MAP_LWMSG_STATUS(lwmsg_call_dispatch(pCall, &in, &out, NULL, NULL));
BAIL_ON_ERROR(dwError);
switch (out.tag)
{
case SM_IPC_ACQUIRE_SERVICE_HANDLE_RES:
*phHandle = out.data;
out.data = NULL;
break;
case SM_IPC_ERROR:
dwError = *(PDWORD) out.data;
BAIL_ON_ERROR(dwError);
break;
default:
dwError = LW_ERROR_INTERNAL;
BAIL_ON_ERROR(dwError);
break;
}
cleanup:
if (pCall)
{
lwmsg_call_destroy_params(pCall, &out);
lwmsg_call_release(pCall);
}
return dwError;
error:
*phHandle = NULL;
goto cleanup;
}
DWORD
LwSmEnumerateServices(
PWSTR** pppwszServiceNames
)
{
DWORD dwError = 0;
LWMsgCall* pCall = NULL;
LWMsgParams in = LWMSG_PARAMS_INITIALIZER;
LWMsgParams out = LWMSG_PARAMS_INITIALIZER;
in.tag = SM_IPC_ENUMERATE_SERVICES_REQ;
in.data = NULL;
dwError = LwSmIpcAcquireCall(&pCall);
BAIL_ON_ERROR(dwError);
dwError = MAP_LWMSG_STATUS(lwmsg_call_dispatch(pCall, &in, &out, NULL, NULL));
BAIL_ON_ERROR(dwError);
switch (out.tag)
{
case SM_IPC_ENUMERATE_SERVICES_RES:
*pppwszServiceNames = (PWSTR*) out.data;
out.data = NULL;
break;
case SM_IPC_ERROR:
dwError = *(PDWORD) out.data;
BAIL_ON_ERROR(dwError);
break;
default:
dwError = LW_ERROR_INTERNAL;
BAIL_ON_ERROR(dwError);
break;
}
cleanup:
if (pCall)
{
lwmsg_call_destroy_params(pCall, &out);
lwmsg_call_release(pCall);
}
return dwError;
error:
*pppwszServiceNames = NULL;
goto cleanup;
}
LW_NTSTATUS
LwIoQueryStateDriver(
LW_PWSTR pwszDriverName,
PLWIO_DRIVER_STATE pState
)
{
NTSTATUS status = 0;
LWMsgCall* pCall = NULL;
LWMsgParams in = LWMSG_PARAMS_INITIALIZER;
LWMsgParams out = LWMSG_PARAMS_INITIALIZER;
status = LwIoConnectionAcquireCall(&pCall);
BAIL_ON_NT_STATUS(status);
in.tag = LWIO_QUERY_STATE_DRIVER;
in.data = pwszDriverName;
status = MAP_LWMSG_STATUS(lwmsg_call_dispatch(pCall, &in, &out, NULL, NULL));
BAIL_ON_NT_STATUS(status);
switch (out.tag)
{
case LWIO_QUERY_STATE_DRIVER_SUCCESS:
*pState = *((PLWIO_DRIVER_STATE) out.data);
break;
case LWIO_QUERY_STATE_DRIVER_FAILED:
status = ((PLWIO_STATUS_REPLY) out.data)->dwError;
BAIL_ON_LWIO_ERROR(status);
break;
default:
status = STATUS_INTERNAL_ERROR;
BAIL_ON_LWIO_ERROR(status);
break;
}
cleanup:
if (pCall)
{
lwmsg_call_destroy_params(pCall, &out);
lwmsg_call_release(pCall);
}
return status;
error:
goto cleanup;
}
DWORD
LwSmReleaseServiceHandle(
LW_SERVICE_HANDLE hHandle
)
{
DWORD dwError = 0;
LWMsgCall* pCall = NULL;
LWMsgParams in = LWMSG_PARAMS_INITIALIZER;
LWMsgParams out = LWMSG_PARAMS_INITIALIZER;
in.tag = SM_IPC_RELEASE_SERVICE_HANDLE_REQ;
in.data = (PVOID) hHandle;
dwError = LwSmIpcAcquireCall(&pCall);
BAIL_ON_ERROR(dwError);
dwError = MAP_LWMSG_STATUS(lwmsg_call_dispatch(pCall, &in, &out, NULL, NULL));
BAIL_ON_ERROR(dwError);
switch (out.tag)
{
case SM_IPC_RELEASE_SERVICE_HANDLE_RES:
break;
case SM_IPC_ERROR:
dwError = *(PDWORD) out.data;
BAIL_ON_ERROR(dwError);
break;
default:
dwError = LW_ERROR_INTERNAL;
BAIL_ON_ERROR(dwError);
break;
}
cleanup:
if (pCall)
{
/* Destroying the in parameters will free the handle */
lwmsg_call_destroy_params(pCall, &in);
lwmsg_call_destroy_params(pCall, &out);
lwmsg_call_release(pCall);
}
return dwError;
error:
goto cleanup;
}
DWORD
LwSmShutdown(
VOID
)
{
DWORD dwError = 0;
LWMsgCall* pCall = NULL;
LWMsgParams in = LWMSG_PARAMS_INITIALIZER;
LWMsgParams out = LWMSG_PARAMS_INITIALIZER;
in.tag = SM_IPC_SHUTDOWN_REQ;
in.data = NULL;
dwError = LwSmIpcAcquireCall(&pCall);
BAIL_ON_ERROR(dwError);
dwError = MAP_LWMSG_STATUS(lwmsg_call_dispatch(pCall, &in, &out, NULL, NULL));
BAIL_ON_ERROR(dwError);
switch (out.tag)
{
case SM_IPC_SHUTDOWN_RES:
break;
case SM_IPC_ERROR:
dwError = *(PDWORD) out.data;
BAIL_ON_ERROR(dwError);
break;
default:
dwError = LW_ERROR_INTERNAL;
BAIL_ON_ERROR(dwError);
break;
}
cleanup:
if (pCall)
{
lwmsg_call_destroy_params(pCall, &out);
lwmsg_call_release(pCall);
}
return dwError;
error:
goto cleanup;
}
static
DWORD
LwSmIpcInit(
VOID
)
{
DWORD dwError = ERROR_SUCCESS;
dwError = MAP_LWMSG_STATUS(lwmsg_context_new(NULL, &gState.pIpcContext));
BAIL_ON_ERROR(dwError);
lwmsg_context_set_log_function(
gState.pIpcContext,
LwSmLogIpc,
NULL);
dwError = MAP_LWMSG_STATUS(lwmsg_protocol_new(gState.pIpcContext, &gState.pContainerProtocol));
BAIL_ON_ERROR(dwError);
dwError = MAP_LWMSG_STATUS(lwmsg_protocol_add_protocol_spec(
gState.pContainerProtocol,
LwSmGetContainerProtocolSpec()));
BAIL_ON_ERROR(dwError);
dwError = MAP_LWMSG_STATUS(lwmsg_peer_new(
gState.pIpcContext,
gState.pContainerProtocol,
&gState.pDirectServer));
BAIL_ON_ERROR(dwError);
dwError = MAP_LWMSG_STATUS(lwmsg_peer_add_listen_endpoint(
gState.pDirectServer,
LWMSG_ENDPOINT_DIRECT,
"Container",
0));
BAIL_ON_ERROR(dwError);
dwError = MAP_LWMSG_STATUS(lwmsg_peer_add_dispatch_spec(
gState.pDirectServer,
LwSmGetContainerDispatchSpec()));
BAIL_ON_ERROR(dwError);
dwError = MAP_LWMSG_STATUS(lwmsg_peer_start_listen(gState.pDirectServer));
BAIL_ON_ERROR(dwError);
error:
return dwError;
}
DWORD
LwSmIpcAcquireCall(
LWMsgCall** ppCall
)
{
DWORD dwError = 0;
dwError = LwSmIpcCallInit();
BAIL_ON_ERROR(dwError);
dwError = MAP_LWMSG_STATUS(lwmsg_peer_acquire_call(gpClient, ppCall));
BAIL_ON_ERROR(dwError);
error:
return dwError;
}
LW_NTSTATUS
LwFileInfoMarshalGetInfoInParameters(
PFILE_INFO_GET_INFO_IN_PARAMS pParams,
PBYTE* ppBuffer,
ULONG* pulBufferSize
)
{
NTSTATUS ntStatus = 0;
VOID* pBuffer = NULL;
size_t ulBufferSize = 0;
LWMsgDataContext* pDataContext = NULL;
ntStatus = LwSrvInfoAcquireDataContext(&pDataContext);
BAIL_ON_NT_STATUS(ntStatus);
ntStatus = MAP_LWMSG_STATUS(
lwmsg_data_marshal_flat_alloc(
pDataContext,
gFileInfoGetInParamsSpec,
pParams,
&pBuffer,
&ulBufferSize));
BAIL_ON_NT_STATUS(ntStatus);
*ppBuffer = pBuffer;
*pulBufferSize = (ULONG) ulBufferSize;
cleanup:
LwSrvInfoReleaseDataContext(pDataContext);
return ntStatus;
error:
*ppBuffer = NULL;
*pulBufferSize = 0;
if (pBuffer)
{
RtlMemoryFree(pBuffer);
}
goto cleanup;
}
LW_NTSTATUS
LwFileInfoUnmarshalCloseParameters(
PBYTE pBuffer,
ULONG ulBufferSize,
PFILE_INFO_CLOSE_PARAMS* ppParams
)
{
NTSTATUS Status = STATUS_SUCCESS;
PFILE_INFO_CLOSE_PARAMS pParams = NULL;
LWMsgDataContext* pDataContext = NULL;
Status = LwSrvInfoAcquireDataContext(&pDataContext);
BAIL_ON_NT_STATUS(Status);
Status = MAP_LWMSG_STATUS(
lwmsg_data_unmarshal_flat(
pDataContext,
gFileInfoCloseParamsSpec,
pBuffer,
ulBufferSize,
OUT_PPVOID(&pParams)));
BAIL_ON_NT_STATUS(Status);
*ppParams = pParams;
cleanup:
LwSrvInfoReleaseDataContext(pDataContext);
return Status;
error:
*ppParams = NULL;
if (pParams)
{
lwmsg_data_free_graph(pDataContext, gFileInfoCloseParamsSpec, pParams);
}
goto cleanup;
}
DWORD
LwSmGetServiceLogState(
LW_SERVICE_HANDLE hHandle,
LW_PCSTR pFacility,
PLW_SM_LOGGER_TYPE pType,
LW_PSTR* ppTarget,
PLW_SM_LOG_LEVEL pLevel
)
{
DWORD dwError = 0;
LWMsgCall* pCall = NULL;
LWMsgParams in = LWMSG_PARAMS_INITIALIZER;
LWMsgParams out = LWMSG_PARAMS_INITIALIZER;
SM_GET_LOG_STATE_REQ req = {0};
PSM_GET_LOG_STATE_RES pRes = NULL;
req.hHandle = (LWMsgHandle*) hHandle;
req.pFacility = (PSTR) pFacility;
in.tag = SM_IPC_GET_LOG_STATE_REQ;
in.data = &req;
dwError = LwSmIpcAcquireCall(&pCall);
BAIL_ON_ERROR(dwError);
dwError = MAP_LWMSG_STATUS(lwmsg_call_dispatch(pCall, &in, &out, NULL, NULL));
BAIL_ON_ERROR(dwError);
switch (out.tag)
{
case SM_IPC_GET_LOG_STATE_RES:
pRes = out.data;
*pType = pRes->type;
*ppTarget = pRes->pszTarget;
*pLevel = pRes->Level;
pRes->pszTarget = NULL;
break;
case SM_IPC_ERROR:
dwError = *(PDWORD) out.data;
BAIL_ON_ERROR(dwError);
break;
default:
dwError = LW_ERROR_INTERNAL;
BAIL_ON_ERROR(dwError);
break;
}
cleanup:
if (pCall)
{
lwmsg_call_destroy_params(pCall, &out);
lwmsg_call_release(pCall);
}
return dwError;
error:
goto cleanup;
}
LW_NTSTATUS
LwFileInfoUnmarshalGetInfoOutParameters(
PBYTE pBuffer,
ULONG ulBufferSize,
DWORD dwInfoLevel,
PFILE_INFO_UNION* ppFileInfo
)
{
NTSTATUS Status = STATUS_SUCCESS;
LWMsgBuffer mbuf =
{
.base = pBuffer,
.end = pBuffer + ulBufferSize,
.cursor = pBuffer,
.wrap = NULL
};
PFILE_INFO_UNION pFileInfo = NULL;
LWMsgDataContext* pDataContext = NULL;
Status = LwSrvInfoAcquireDataContext(&pDataContext);
BAIL_ON_NT_STATUS(Status);
Status = MAP_LWMSG_STATUS(
lwmsg_data_alloc_memory(
pDataContext,
sizeof(FILE_INFO_UNION),
OUT_PPVOID(&pFileInfo)));
BAIL_ON_NT_STATUS(Status);
switch (dwInfoLevel)
{
case 2:
Status = MAP_LWMSG_STATUS(
lwmsg_data_alloc_memory(
pDataContext,
sizeof(FILE_INFO_2),
OUT_PPVOID(&pFileInfo->p2)));
BAIL_ON_NT_STATUS(Status);
Status = MAP_LWMSG_STATUS(
lwmsg_data_unmarshal_into(
pDataContext,
gFileInfo2Spec,
&mbuf,
pFileInfo->p2,
sizeof(FILE_INFO_2)));
break;
case 3:
Status = MAP_LWMSG_STATUS(
lwmsg_data_alloc_memory(
pDataContext,
sizeof(FILE_INFO_3),
OUT_PPVOID(&pFileInfo->p3)));
BAIL_ON_NT_STATUS(Status);
Status = MAP_LWMSG_STATUS(
lwmsg_data_unmarshal_into(
pDataContext,
gFileInfo3Spec,
&mbuf,
pFileInfo->p3,
sizeof(FILE_INFO_3)));
break;
default:
Status = STATUS_INVALID_INFO_CLASS;
break;
}
BAIL_ON_NT_STATUS(Status);
*ppFileInfo = pFileInfo;
cleanup:
LwSrvInfoReleaseDataContext(pDataContext);
return Status;
error:
*ppFileInfo = NULL;
if (pFileInfo)
{
LwFileInfoFreeInternal(
pDataContext,
dwInfoLevel,
1,
pFileInfo);
}
goto cleanup;
}
LW_NTSTATUS
LwFileInfoMarshalCloseParameters(
PFILE_INFO_CLOSE_PARAMS pParams,
PBYTE* ppBuffer,
ULONG* pulBufferSize
)
{
NTSTATUS Status = STATUS_SUCCESS;
VOID* pBuffer = NULL;
size_t ulBufferSize = 0;
LWMsgDataContext* pDataContext = NULL;
Status = LwSrvInfoAcquireDataContext(&pDataContext);
BAIL_ON_NT_STATUS(Status);
Status = MAP_LWMSG_STATUS(
lwmsg_data_marshal_flat_alloc(
pDataContext,
gFileInfoCloseParamsSpec,
pParams,
&pBuffer,
&ulBufferSize));
BAIL_ON_NT_STATUS(Status);
*ppBuffer = pBuffer;
*pulBufferSize = (ULONG) ulBufferSize;
cleanup:
LwSrvInfoReleaseDataContext(pDataContext);
return Status;
error:
*ppBuffer = NULL;
*pulBufferSize = 0;
if (pBuffer)
{
RtlMemoryFree(pBuffer);
}
goto cleanup;
}
static
DWORD
LwSmStopIpcServer(
VOID
)
{
DWORD dwError = 0;
if (gState.pControlServer)
{
dwError = MAP_LWMSG_STATUS(lwmsg_peer_stop_listen(gState.pControlServer));
BAIL_ON_ERROR(dwError);
}
if (gState.pContainerServer)
{
if (gState.pGroup)
{
dwError = MAP_LWMSG_STATUS(lwmsg_peer_disconnect(gState.pContainerServer));
BAIL_ON_ERROR(dwError);
}
else
{
dwError = MAP_LWMSG_STATUS(lwmsg_peer_stop_listen(gState.pContainerServer));
BAIL_ON_ERROR(dwError);
}
}
if (gState.pDirectServer)
{
dwError = MAP_LWMSG_STATUS(lwmsg_peer_stop_listen(gState.pDirectServer));
BAIL_ON_ERROR(dwError);
}
cleanup:
if (gState.pControlServer)
{
lwmsg_peer_delete(gState.pControlServer);
}
if (gState.pContainerServer)
{
lwmsg_peer_delete(gState.pContainerServer);
}
if (gState.pDirectServer)
{
lwmsg_peer_delete(gState.pDirectServer);
}
if (gState.pContolProtocol)
{
lwmsg_protocol_delete(gState.pContolProtocol);
}
if (gState.pContainerProtocol)
{
lwmsg_protocol_delete(gState.pContainerProtocol);
}
if (gState.pIpcContext)
{
lwmsg_context_delete(gState.pIpcContext);
}
return dwError;
error:
goto cleanup;
}
DWORD
LwSmGetGlobal(
LW_IN LW_SM_GLOBAL_SETTING Setting,
...
)
{
DWORD dwError = 0;
LWMsgCall* pCall = NULL;
LWMsgParams in = LWMSG_PARAMS_INITIALIZER;
LWMsgParams out = LWMSG_PARAMS_INITIALIZER;
SM_GET_GLOBAL_REQ req = {0};
PSM_GLOBAL_VALUE pValue = NULL;
va_list ap;
req.Setting = Setting;
in.tag = SM_IPC_GET_GLOBAL_REQ;
in.data = &req;
dwError = LwSmIpcAcquireCall(&pCall);
BAIL_ON_ERROR(dwError);
dwError = MAP_LWMSG_STATUS(lwmsg_call_dispatch(pCall, &in, &out, NULL, NULL));
BAIL_ON_ERROR(dwError);
switch (out.tag)
{
case SM_IPC_GET_GLOBAL_RES:
pValue = out.data;
break;
case SM_IPC_ERROR:
dwError = *(PDWORD) out.data;
BAIL_ON_ERROR(dwError);
break;
default:
dwError = LW_ERROR_INTERNAL;
BAIL_ON_ERROR(dwError);
break;
}
va_start(ap, Setting);
switch (Setting)
{
case LW_SM_GLOBAL_SETTING_WATCHDOG:
if (pValue->Type != SM_GLOBAL_TYPE_BOOLEAN)
{
dwError = LW_ERROR_INTERNAL;
}
else
{
*(va_arg(ap, PBOOLEAN)) = pValue->Value.Boolean;
}
break;
default:
dwError = ERROR_INVALID_PARAMETER;
break;
}
va_end(ap);
BAIL_ON_ERROR(dwError);
cleanup:
if (pCall)
{
lwmsg_call_destroy_params(pCall, &out);
lwmsg_call_release(pCall);
}
return dwError;
error:
goto cleanup;
}
static
DWORD
LwSmStartIpcServer(
VOID
)
{
DWORD dwError = 0;
SM_LOG_VERBOSE("Starting IPC server");
if (!gState.bContainer)
{
dwError = MAP_LWMSG_STATUS(lwmsg_protocol_new(gState.pIpcContext, &gState.pContolProtocol));
BAIL_ON_ERROR(dwError);
dwError = MAP_LWMSG_STATUS(lwmsg_protocol_add_protocol_spec(
gState.pContolProtocol,
LwSmIpcGetProtocolSpec()));
BAIL_ON_ERROR(dwError);
dwError = MAP_LWMSG_STATUS(lwmsg_peer_new(
gState.pIpcContext,
gState.pContolProtocol,
&gState.pControlServer));
BAIL_ON_ERROR(dwError);
dwError = MAP_LWMSG_STATUS(lwmsg_peer_add_dispatch_spec(
gState.pControlServer,
LwSmGetDispatchSpec()));
BAIL_ON_ERROR(dwError);
dwError = MAP_LWMSG_STATUS(lwmsg_peer_add_listen_endpoint(
gState.pControlServer,
LWMSG_ENDPOINT_LOCAL,
SM_ENDPOINT,
0666));
BAIL_ON_ERROR(dwError);
dwError = MAP_LWMSG_STATUS(lwmsg_peer_start_listen(gState.pControlServer));
BAIL_ON_ERROR(dwError);
}
dwError = MAP_LWMSG_STATUS(lwmsg_peer_new(
gState.pIpcContext,
gState.pContainerProtocol,
&gState.pContainerServer));
BAIL_ON_ERROR(dwError);
if (gState.bContainer)
{
dwError = MAP_LWMSG_STATUS(lwmsg_peer_add_dispatch_spec(
gState.pContainerServer,
LwSmGetContainerDispatchSpec()));
BAIL_ON_ERROR(dwError);
if (!gState.pGroup)
{
dwError = MAP_LWMSG_STATUS(lwmsg_peer_accept_fd(
gState.pContainerServer,
LWMSG_ENDPOINT_PAIR,
4));
BAIL_ON_ERROR(dwError);
}
else
{
dwError = MAP_LWMSG_STATUS(lwmsg_peer_add_connect_endpoint(
gState.pContainerServer,
LWMSG_ENDPOINT_LOCAL,
SC_ENDPOINT));
BAIL_ON_ERROR(dwError);
dwError = LwSmContainerRegister(gState.pContainerServer, gState.pGroup);
BAIL_ON_ERROR(dwError);
}
}
else
{
dwError = MAP_LWMSG_STATUS(lwmsg_peer_add_listen_endpoint(
gState.pContainerServer,
LWMSG_ENDPOINT_LOCAL,
SC_ENDPOINT,
0666));
dwError = MAP_LWMSG_STATUS(lwmsg_peer_add_dispatch_spec(
gState.pContainerServer,
LwSmGetContainerRegisterDispatchSpec()));
BAIL_ON_ERROR(dwError);
dwError = MAP_LWMSG_STATUS(lwmsg_peer_start_listen(gState.pContainerServer));
BAIL_ON_ERROR(dwError);
}
cleanup:
return dwError;
error:
goto cleanup;
}
LW_NTSTATUS
LwFileInfoMarshalEnumOutputPreamble(
PBYTE pBuffer,
ULONG ulBufferSize,
PFILE_INFO_ENUM_OUT_PREAMBLE pPreamble,
PULONG pulBytesUsed
)
{
NTSTATUS status = STATUS_SUCCESS;
LWMsgDataContext* pDataContext = NULL;
LWMsgBuffer mbuf =
{
.base = pBuffer,
.end = pBuffer + ulBufferSize,
.cursor = pBuffer,
.wrap = NULL
};
status = LwSrvInfoAcquireDataContext(&pDataContext);
BAIL_ON_NT_STATUS(status);
status = MAP_LWMSG_STATUS(
lwmsg_data_marshal(
pDataContext,
gFileInfoEnumOutParamsPreambleSpec,
pPreamble,
&mbuf));
BAIL_ON_NT_STATUS(status);
*pulBytesUsed = mbuf.cursor - mbuf.base;
cleanup:
LwSrvInfoReleaseDataContext(pDataContext);
return status;
error:
*pulBytesUsed = 0;
goto cleanup;
}
LW_NTSTATUS
LwFileInfoMarshalEnumOutputInfo_level_2(
PFILE_INFO_2 pFileInfo,
PBYTE pBuffer,
ULONG ulBufferSize,
PULONG pulBytesUsed
)
{
NTSTATUS status = STATUS_SUCCESS;
LWMsgDataContext* pDataContext = NULL;
LWMsgBuffer mbuf =
{
.base = pBuffer,
.end = pBuffer + ulBufferSize,
.cursor = pBuffer,
.wrap = NULL
};
status = LwSrvInfoAcquireDataContext(&pDataContext);
BAIL_ON_NT_STATUS(status);
status = MAP_LWMSG_STATUS(
lwmsg_data_marshal(
pDataContext,
gFileInfo2Spec,
pFileInfo,
&mbuf));
BAIL_ON_NT_STATUS(status);
*pulBytesUsed = mbuf.cursor - mbuf.base;
cleanup:
LwSrvInfoReleaseDataContext(pDataContext);
return status;
error:
*pulBytesUsed = 0;
goto cleanup;
}
LW_NTSTATUS
LwFileInfoMarshalEnumOutputInfo_level_3(
PFILE_INFO_3 pFileInfo,
PBYTE pBuffer,
ULONG ulBufferSize,
PULONG pulBytesUsed
)
{
NTSTATUS status = STATUS_SUCCESS;
LWMsgDataContext* pDataContext = NULL;
LWMsgBuffer mbuf =
{
.base = pBuffer,
.end = pBuffer + ulBufferSize,
.cursor = pBuffer,
.wrap = NULL
};
status = LwSrvInfoAcquireDataContext(&pDataContext);
BAIL_ON_NT_STATUS(status);
status = MAP_LWMSG_STATUS(
lwmsg_data_marshal(
pDataContext,
gFileInfo3Spec,
pFileInfo,
&mbuf));
BAIL_ON_NT_STATUS(status);
*pulBytesUsed = mbuf.cursor - mbuf.base;
cleanup:
LwSrvInfoReleaseDataContext(pDataContext);
return status;
error:
*pulBytesUsed = 0;
goto cleanup;
}
LW_NTSTATUS
LwFileInfoUnmarshalEnumOutputParameters(
PBYTE pBuffer,
ULONG ulBufferSize,
PFILE_INFO_ENUM_OUT_PREAMBLE* ppPreamble,
PFILE_INFO_UNION* ppFileInfo
)
{
NTSTATUS Status = STATUS_SUCCESS;
LWMsgBuffer mbuf =
{
.base = pBuffer,
.end = pBuffer + ulBufferSize,
.cursor = pBuffer,
.wrap = NULL
};
ULONG ulBytesUsed = 0;
PFILE_INFO_ENUM_OUT_PREAMBLE pPreamble = NULL;
PFILE_INFO_UNION pFileInfo = NULL;
LWMsgDataContext* pDataContext = NULL;
Status = LwSrvInfoAcquireDataContext(&pDataContext);
BAIL_ON_NT_STATUS(Status);
Status = MAP_LWMSG_STATUS(
lwmsg_data_unmarshal(
pDataContext,
gFileInfoEnumOutParamsPreambleSpec,
&mbuf,
OUT_PPVOID(&pPreamble)));
BAIL_ON_NT_STATUS(Status);
ulBytesUsed = mbuf.cursor - mbuf.base;
if (pPreamble->dwEntriesRead)
{
ULONG iInfo = 0;
Status = MAP_LWMSG_STATUS(
lwmsg_data_alloc_memory(
pDataContext,
sizeof(FILE_INFO_UNION),
OUT_PPVOID(&pFileInfo)));
BAIL_ON_NT_STATUS(Status);
switch (pPreamble->dwInfoLevel)
{
case 2:
Status = MAP_LWMSG_STATUS(
lwmsg_data_alloc_memory(
pDataContext,
sizeof(FILE_INFO_2) * pPreamble->dwEntriesRead,
OUT_PPVOID(&pFileInfo->p2)));
break;
case 3:
Status = MAP_LWMSG_STATUS(
lwmsg_data_alloc_memory(
pDataContext,
sizeof(FILE_INFO_3) * pPreamble->dwEntriesRead,
OUT_PPVOID(&pFileInfo->p3)));
break;
default:
Status = STATUS_INVALID_INFO_CLASS;
break;
}
BAIL_ON_NT_STATUS(Status);
for (; iInfo < pPreamble->dwEntriesRead; iInfo++)
{
mbuf.cursor = pBuffer + ulBytesUsed;
switch (pPreamble->dwInfoLevel)
{
case 2:
Status = MAP_LWMSG_STATUS(
lwmsg_data_unmarshal_into(
pDataContext,
gFileInfo2Spec,
&mbuf,
&pFileInfo->p2[iInfo],
sizeof(pFileInfo->p2[iInfo])));
break;
case 3:
Status = MAP_LWMSG_STATUS(
lwmsg_data_unmarshal_into(
pDataContext,
gFileInfo3Spec,
&mbuf,
&pFileInfo->p3[iInfo],
sizeof(pFileInfo->p3[iInfo])));
break;
default:
Status = STATUS_INVALID_INFO_CLASS;
break;
}
BAIL_ON_NT_STATUS(Status);
ulBytesUsed = mbuf.cursor - mbuf.base;
}
}
*ppPreamble = pPreamble;
*ppFileInfo = pFileInfo;
cleanup:
LwSrvInfoReleaseDataContext(pDataContext);
return Status;
error:
*ppPreamble = NULL;
*ppFileInfo = NULL;
if (pFileInfo)
{
LwFileInfoFreeInternal(
pDataContext,
pPreamble->dwInfoLevel,
pPreamble->dwEntriesRead,
pFileInfo);
}
if (pPreamble)
{
LwFileInfoFreeEnumOutPreambleInternal(pDataContext, pPreamble);
}
goto cleanup;
}
LW_NTSTATUS
LwFileInfoFreeEnumOutPreamble(
PFILE_INFO_ENUM_OUT_PREAMBLE pPreamble
)
{
NTSTATUS status = STATUS_SUCCESS;
LWMsgDataContext* pDataContext = NULL;
status = LwSrvInfoAcquireDataContext(&pDataContext);
BAIL_ON_NT_STATUS(status);
LwFileInfoFreeEnumOutPreambleInternal(pDataContext, pPreamble);
cleanup:
LwSrvInfoReleaseDataContext(pDataContext);
return status;
error:
goto cleanup;
}
