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; }