MU_TEST(client_server, handle_invalidation)
{
LWMsgContext* context = NULL;
LWMsgProtocol* protocol = NULL;
LWMsgPeer* client = NULL;
LWMsgPeer* server = NULL;
CounterHandle* handle = NULL;
CounterRequest request;
LWMsgCall* call;
LWMsgSession* session = NULL;
LWMsgParams in = LWMSG_PARAMS_INITIALIZER;
LWMsgParams out = LWMSG_PARAMS_INITIALIZER;
LWMsgHandleType locality = 0;
struct timespec ts = {0, 50000000};
MU_TRY(lwmsg_context_new(NULL, &context));
MU_TRY(lwmsg_protocol_new(context, &protocol));
MU_TRY(lwmsg_protocol_add_protocol_spec(protocol, counterprotocol_spec));
MU_TRY(lwmsg_peer_new(context, protocol, &server));
MU_TRY(lwmsg_peer_add_dispatch_spec(server, counter_dispatch));
MU_TRY(lwmsg_peer_add_listen_endpoint(server, LWMSG_CONNECTION_MODE_LOCAL, TEST_ENDPOINT, 0600));
MU_TRY(lwmsg_peer_start_listen(server));
MU_TRY(lwmsg_peer_new(context, protocol, &client));
MU_TRY(lwmsg_peer_add_connect_endpoint(client, LWMSG_CONNECTION_MODE_LOCAL, TEST_ENDPOINT));
request.counter = 0;
MU_TRY(lwmsg_peer_acquire_call(client, &call));
session = lwmsg_call_get_session(call);
in.tag = COUNTER_OPEN;
in.data = &request;
MU_TRY(lwmsg_call_dispatch(call, &in, &out, NULL, NULL));
MU_ASSERT_EQUAL(MU_TYPE_INTEGER, out.tag, COUNTER_OPEN_SUCCESS);
lwmsg_call_release(call);
handle = out.data;
MU_TRY(lwmsg_peer_stop_listen(server));
nanosleep(&ts, NULL);
MU_TRY(lwmsg_peer_start_listen(server));
MU_TRY(lwmsg_peer_acquire_call(client, &call));
MU_ASSERT_EQUAL(MU_TYPE_INTEGER, lwmsg_session_get_handle_location(session, handle, &locality), LWMSG_STATUS_INVALID_HANDLE);
MU_TRY(lwmsg_session_release_handle(session, handle));
MU_TRY(lwmsg_peer_disconnect(client));
lwmsg_peer_delete(client);
MU_TRY(lwmsg_peer_stop_listen(server));
lwmsg_peer_delete(server);
}
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;
}
MU_TEST(stress, parallel_print_protocol)
{
LWMsgContext* context = NULL;
LWMsgDataContext* dcontext = NULL;
LWMsgProtocol* protocol = NULL;
char* text = NULL;
MU_TRY(lwmsg_context_new(NULL, &context));
MU_TRY(lwmsg_data_context_new(context, &dcontext));
MU_TRY(lwmsg_protocol_new(context, &protocol));
MU_TRY(lwmsg_protocol_add_protocol_spec(protocol, counterprotocol_spec));
MU_TRY(lwmsg_protocol_print_alloc(protocol, 4, &text));
MU_VERBOSE("\n%s", text);
}
LSASS_API
DWORD
LsaAdEnumGroupsFromCache(
IN HANDLE hLsaConnection,
IN OPTIONAL PCSTR pszDomainName,
IN PSTR* ppszResume,
IN DWORD dwMaxNumGroups,
OUT PDWORD pdwGroupsFound,
OUT PLSA_SECURITY_OBJECT** pppObjects
)
{
DWORD dwError = 0;
PSTR pszTargetProvider = NULL;
DWORD dwOutputBufferSize = 0;
PVOID pOutputBuffer = NULL;
PVOID pBlob = NULL;
size_t BlobSize = 0;
LWMsgContext* context = NULL;
LWMsgDataContext* pDataContext = NULL;
LSA_AD_IPC_ENUM_GROUPS_FROM_CACHE_REQ request;
PLSA_AD_IPC_ENUM_GROUPS_FROM_CACHE_RESP response = NULL;
memset(&request, 0, sizeof(request));
if (geteuid() != 0)
{
dwError = LW_ERROR_ACCESS_DENIED;
BAIL_ON_LSA_ERROR(dwError);
}
if (pszDomainName)
{
dwError = LwAllocateStringPrintf(
&pszTargetProvider,
"%s:%s",
LSA_PROVIDER_TAG_AD,
pszDomainName);
BAIL_ON_LSA_ERROR(dwError);
}
// marshal the request
request.pszResume = *ppszResume;
request.dwMaxNumGroups = dwMaxNumGroups;
dwError = MAP_LWMSG_ERROR(lwmsg_context_new(NULL, &context));
BAIL_ON_LSA_ERROR(dwError);
dwError = MAP_LWMSG_ERROR(lwmsg_data_context_new(context, &pDataContext));
BAIL_ON_LSA_ERROR(dwError);
dwError = MAP_LWMSG_ERROR(lwmsg_data_marshal_flat_alloc(
pDataContext,
LsaAdIPCGetEnumGroupsFromCacheReqSpec(),
&request,
&pBlob,
&BlobSize));
BAIL_ON_LSA_ERROR(dwError);
dwError = LsaProviderIoControl(
hLsaConnection,
pszTargetProvider ? pszTargetProvider : LSA_PROVIDER_TAG_AD,
LSA_AD_IO_ENUMGROUPSCACHE,
BlobSize,
pBlob,
&dwOutputBufferSize,
&pOutputBuffer);
BAIL_ON_LSA_ERROR(dwError);
dwError = MAP_LWMSG_ERROR(lwmsg_data_unmarshal_flat(
pDataContext,
LsaAdIPCGetEnumGroupsFromCacheRespSpec(),
pOutputBuffer,
dwOutputBufferSize,
(PVOID*)&response));
BAIL_ON_LSA_ERROR(dwError);
*pdwGroupsFound = response->dwNumGroups;
*pppObjects = response->ppObjects;
response->ppObjects = NULL;
if ( *ppszResume )
{
LwFreeMemory(*ppszResume);
*ppszResume = NULL;
}
*ppszResume = response->pszResume;
response->pszResume = NULL;
cleanup:
if ( response )
{
lwmsg_data_free_graph(
pDataContext,
LsaAdIPCGetEnumGroupsFromCacheRespSpec(),
response);
}
if (pDataContext)
{
lwmsg_data_context_delete(pDataContext);
}
if ( context )
{
lwmsg_context_delete(context);
}
if ( pBlob )
{
LwFreeMemory(pBlob);
}
if ( pOutputBuffer )
{
LwFreeMemory(pOutputBuffer);
}
LW_SAFE_FREE_STRING(pszTargetProvider);
return dwError;
error:
if ( *ppszResume )
{
LwFreeMemory(*ppszResume);
*ppszResume = NULL;
}
*pdwGroupsFound = 0;
*pppObjects = NULL;
goto cleanup;
}
DWORD
AD_IoctlGetMachineAccount(
IN HANDLE hProvider,
IN DWORD dwInputBufferSize,
IN PVOID pInputBuffer,
OUT DWORD* pdwOutputBufferSize,
OUT PVOID* ppOutputBuffer
)
{
DWORD dwError = 0;
PVOID pOutputBuffer = NULL;
size_t outputBufferSize = 0;
LWMsgContext* pContext = NULL;
LWMsgDataContext* pDataContext = NULL;
PSTR pszDnsDomainName = NULL;
PLSA_MACHINE_ACCOUNT_INFO_A pAccountInfo = NULL;
//
// Everyone can call this, so no access check.
//
//
// Do request
//
dwError = MAP_LWMSG_ERROR(lwmsg_context_new(NULL, &pContext));
BAIL_ON_LSA_ERROR(dwError);
LsaAdIPCSetMemoryFunctions(pContext);
dwError = MAP_LWMSG_ERROR(lwmsg_data_context_new(pContext, &pDataContext));
BAIL_ON_LSA_ERROR(dwError);
dwError = MAP_LWMSG_ERROR(lwmsg_data_unmarshal_flat(
pDataContext,
LsaAdIPCGetStringSpec(),
pInputBuffer,
dwInputBufferSize,
OUT_PPVOID(&pszDnsDomainName)));
BAIL_ON_LSA_ERROR(dwError);
dwError = AD_GetMachineAccountInfoA(pszDnsDomainName, &pAccountInfo);
BAIL_ON_LSA_ERROR(dwError);
dwError = MAP_LWMSG_ERROR(lwmsg_data_marshal_flat_alloc(
pDataContext,
LsaAdIPCGetMachineAccountInfoSpec(),
pAccountInfo,
&pOutputBuffer,
&outputBufferSize));
BAIL_ON_LSA_ERROR(dwError);
error:
if (dwError)
{
if (pOutputBuffer)
{
LwFreeMemory(pOutputBuffer);
}
pOutputBuffer = NULL;
outputBufferSize = 0;
}
LW_SAFE_FREE_STRING(pszDnsDomainName);
if (pAccountInfo)
{
LsaSrvFreeMachineAccountInfoA(pAccountInfo);
}
if (pDataContext)
{
lwmsg_data_context_delete(pDataContext);
}
if (pContext)
{
lwmsg_context_delete(pContext);
}
*pdwOutputBufferSize = (DWORD) outputBufferSize;
*ppOutputBuffer = pOutputBuffer;
return dwError;
}
DWORD
AD_IoctlGetComputerDn(
IN HANDLE hProvider,
IN DWORD dwInputBufferSize,
IN PVOID pInputBuffer,
OUT DWORD* pdwOutputBufferSize,
OUT PVOID* ppOutputBuffer
)
{
DWORD dwError = 0;
PVOID pOutputBuffer = NULL;
size_t outputBufferSize = 0;
PAD_PROVIDER_CONTEXT pProviderContext = (PAD_PROVIDER_CONTEXT)hProvider;
LWMsgContext* pContext = NULL;
LWMsgDataContext* pDataContext = NULL;
PSTR pszDnsDomainName = NULL;
PSTR pszComputerDn = NULL;
//
// Do access check
//
if (pProviderContext->uid)
{
dwError = LW_ERROR_ACCESS_DENIED;
BAIL_ON_LSA_ERROR(dwError);
}
//
// Do request
//
dwError = MAP_LWMSG_ERROR(lwmsg_context_new(NULL, &pContext));
BAIL_ON_LSA_ERROR(dwError);
LsaAdIPCSetMemoryFunctions(pContext);
dwError = MAP_LWMSG_ERROR(lwmsg_data_context_new(pContext, &pDataContext));
BAIL_ON_LSA_ERROR(dwError);
dwError = MAP_LWMSG_ERROR(lwmsg_data_unmarshal_flat(
pDataContext,
LsaAdIPCGetStringSpec(),
pInputBuffer,
dwInputBufferSize,
OUT_PPVOID(&pszDnsDomainName)));
BAIL_ON_LSA_ERROR(dwError);
dwError = AD_GetComputerDn(pszDnsDomainName, &pszComputerDn);
BAIL_ON_LSA_ERROR(dwError);
dwError = MAP_LWMSG_ERROR(lwmsg_data_marshal_flat_alloc(
pDataContext,
LsaAdIPCGetStringSpec(),
pszComputerDn,
&pOutputBuffer,
&outputBufferSize));
BAIL_ON_LSA_ERROR(dwError);
error:
if (dwError)
{
if (pOutputBuffer)
{
LwFreeMemory(pOutputBuffer);
}
pOutputBuffer = NULL;
outputBufferSize = 0;
}
LW_SAFE_FREE_STRING(pszDnsDomainName);
LW_SAFE_FREE_STRING(pszComputerDn);
if (pDataContext)
{
lwmsg_data_context_delete(pDataContext);
}
if (pContext)
{
lwmsg_context_delete(pContext);
}
*pdwOutputBufferSize = (DWORD) outputBufferSize;
*ppOutputBuffer = pOutputBuffer;
return dwError;
}
DWORD
LWNetSrvStartListenThread(
void
)
{
PSTR pszCachePath = NULL;
PSTR pszCommPath = NULL;
BOOLEAN bDirExists = FALSE;
DWORD dwError = 0;
dwError = LWNetSrvGetCachePath(&pszCachePath);
BAIL_ON_LWNET_ERROR(dwError);
dwError = LwCheckFileTypeExists(
pszCachePath,
LWFILE_DIRECTORY,
&bDirExists);
BAIL_ON_LWNET_ERROR(dwError);
if (!bDirExists)
{
// Directory should be RWX for root and accessible to all
// (so they can see the socket.
mode_t mode = S_IRWXU | S_IRGRP| S_IXGRP | S_IROTH | S_IXOTH;
dwError = LwCreateDirectory(pszCachePath, mode);
BAIL_ON_LWNET_ERROR(dwError);
}
dwError = LwAllocateStringPrintf(&pszCommPath, "%s/%s",
pszCachePath, LWNET_SERVER_FILENAME);
BAIL_ON_LWNET_ERROR(dwError);
dwError = MAP_LWMSG_ERROR(lwmsg_context_new(NULL, &gpContext));
BAIL_ON_LWNET_ERROR(dwError);
lwmsg_context_set_log_function(gpContext, LWNetSrvLogIpc, NULL);
/* Set up IPC protocol object */
dwError = MAP_LWMSG_ERROR(lwmsg_protocol_new(gpContext, &gpProtocol));
BAIL_ON_LWNET_ERROR(dwError);
dwError = MAP_LWMSG_ERROR(lwmsg_protocol_add_protocol_spec(
gpProtocol,
LWNetIPCGetProtocolSpec()));
BAIL_ON_LWNET_ERROR(dwError);
/* Set up IPC server object */
dwError = MAP_LWMSG_ERROR(lwmsg_peer_new(gpContext, gpProtocol, &gpServer));
BAIL_ON_LWNET_ERROR(dwError);
dwError = MAP_LWMSG_ERROR(lwmsg_peer_add_dispatch_spec(
gpServer,
LWNetSrvGetDispatchSpec()));
BAIL_ON_LWNET_ERROR(dwError);
dwError = MAP_LWMSG_ERROR(lwmsg_peer_add_listen_endpoint(
gpServer,
LWMSG_ENDPOINT_DIRECT,
"netlogon",
0));
BAIL_ON_LWNET_ERROR(dwError);
dwError = MAP_LWMSG_ERROR(lwmsg_peer_add_listen_endpoint(
gpServer,
LWMSG_ENDPOINT_LOCAL,
pszCommPath,
0666));
BAIL_ON_LWNET_ERROR(dwError);
dwError = MAP_LWMSG_ERROR(lwmsg_peer_start_listen(gpServer));
error:
LWNET_SAFE_FREE_STRING(pszCachePath);
LWNET_SAFE_FREE_STRING(pszCommPath);
if (dwError)
{
if (gpServer)
{
lwmsg_peer_stop_listen(gpServer);
lwmsg_peer_delete(gpServer);
gpServer = NULL;
}
}
return dwError;
}
DWORD
RegSrvStartListenThread(
void
)
{
PSTR pszCachePath = NULL;
PSTR pszCommPath = NULL;
BOOLEAN bDirExists = FALSE;
DWORD dwError = 0;
static LWMsgTime idleTimeout = {30, 0};
dwError = RegSrvGetCachePath(&pszCachePath);
BAIL_ON_REG_ERROR(dwError);
dwError = RegCheckDirectoryExists(pszCachePath, &bDirExists);
BAIL_ON_REG_ERROR(dwError);
if (!bDirExists)
{
// Directory should be RWX for root and accessible to all
// (so they can see the socket.
mode_t mode = S_IRWXU | S_IRGRP| S_IXGRP | S_IROTH | S_IXOTH;
dwError = RegCreateDirectory(pszCachePath, mode);
BAIL_ON_REG_ERROR(dwError);
}
dwError = LwRtlCStringAllocatePrintf(&pszCommPath, "%s/%s",
pszCachePath, REG_SERVER_FILENAME);
BAIL_ON_REG_ERROR(dwError);
dwError = MAP_LWMSG_ERROR(lwmsg_context_new(NULL, &gpContext));
BAIL_ON_REG_ERROR(dwError);
lwmsg_context_set_log_function(gpContext, RegSrvLogIpc, NULL);
/* Set up IPC protocol object */
dwError = MAP_LWMSG_ERROR(lwmsg_protocol_new(gpContext, &gpProtocol));
BAIL_ON_REG_ERROR(dwError);
dwError = MAP_LWMSG_ERROR(lwmsg_protocol_add_protocol_spec(
gpProtocol,
RegIPCGetProtocolSpec()));
BAIL_ON_REG_ERROR(dwError);
/* Set up IPC server object */
dwError = MAP_LWMSG_ERROR(lwmsg_peer_new(gpContext, gpProtocol, &gpServer));
BAIL_ON_REG_ERROR(dwError);
dwError = MAP_LWMSG_ERROR(lwmsg_peer_add_dispatch_spec(
gpServer,
RegSrvGetDispatchSpec()));
BAIL_ON_REG_ERROR(dwError);
dwError = MAP_LWMSG_ERROR(lwmsg_peer_add_listen_endpoint(
gpServer,
LWMSG_ENDPOINT_DIRECT,
"lwreg",
0));
BAIL_ON_REG_ERROR(dwError);
dwError = MAP_LWMSG_ERROR(lwmsg_peer_add_listen_endpoint(
gpServer,
LWMSG_ENDPOINT_LOCAL,
pszCommPath,
0666));
BAIL_ON_REG_ERROR(dwError);
dwError = MAP_LWMSG_ERROR(lwmsg_peer_set_max_listen_clients(
gpServer,
MAX_CLIENTS));
BAIL_ON_REG_ERROR(dwError);
dwError = MAP_LWMSG_ERROR(lwmsg_peer_set_max_listen_backlog(
gpServer,
REG_MAX(5, MAX_CLIENTS / 4)));
BAIL_ON_REG_ERROR(dwError);
dwError = MAP_LWMSG_ERROR(lwmsg_peer_set_timeout(
gpServer,
LWMSG_TIMEOUT_IDLE,
&idleTimeout));
BAIL_ON_REG_ERROR(dwError);
dwError = MAP_LWMSG_ERROR(lwmsg_peer_set_listen_session_functions(
gpServer,
RegSrvIpcConstructSession,
RegSrvIpcDestructSession,
NULL));
BAIL_ON_REG_ERROR(dwError);
dwError = MAP_LWMSG_ERROR(lwmsg_peer_start_listen(gpServer));
error:
LWREG_SAFE_FREE_STRING(pszCachePath);
LWREG_SAFE_FREE_STRING(pszCommPath);
if (dwError)
{
if (gpServer)
{
lwmsg_peer_stop_listen(gpServer);
lwmsg_peer_delete(gpServer);
gpServer = NULL;
}
}
return dwError;
}
MU_TEST(stress, parallel)
{
Data data;
pthread_t threads[NUM_THREADS];
int i;
LWMsgContext* context = NULL;
LWMsgProtocol* protocol = NULL;
LWMsgPeer* client = NULL;
LWMsgPeer* server = NULL;
CounterRequest request;
CounterReply* reply;
LWMsgCall* call;
LWMsgParams in = LWMSG_PARAMS_INITIALIZER;
LWMsgParams out = LWMSG_PARAMS_INITIALIZER;
LWMsgTime timeout = {1, 0};
MU_TRY(lwmsg_context_new(NULL, &context));
lwmsg_context_set_log_function(context, lwmsg_test_log_function, NULL);
MU_TRY(lwmsg_protocol_new(context, &protocol));
MU_TRY(lwmsg_protocol_add_protocol_spec(protocol, counterprotocol_spec));
MU_TRY(lwmsg_peer_new(context, protocol, &server));
MU_TRY(lwmsg_peer_add_dispatch_spec(server, counter_dispatch));
MU_TRY(lwmsg_peer_add_listen_endpoint(server, LWMSG_CONNECTION_MODE_LOCAL, TEST_ENDPOINT, 0600));
MU_TRY(lwmsg_peer_set_max_listen_clients(server, MAX_CLIENTS));
MU_TRY(lwmsg_peer_set_timeout(server, LWMSG_TIMEOUT_IDLE, &timeout));
MU_TRY(lwmsg_peer_start_listen(server));
MU_TRY(lwmsg_peer_new(context, protocol, &client));
MU_TRY(lwmsg_peer_add_connect_endpoint(client, LWMSG_CONNECTION_MODE_LOCAL, TEST_ENDPOINT));
request.counter = 0;
MU_TRY(lwmsg_peer_acquire_call(client, &call));
in.tag = COUNTER_OPEN;
in.data = &request;
MU_TRY(lwmsg_call_dispatch(call, &in, &out, NULL, NULL));
MU_ASSERT_EQUAL(MU_TYPE_INTEGER, out.tag, COUNTER_OPEN_SUCCESS);
lwmsg_call_release(call);
data.client = client;
data.handle = out.data;
data.iters = NUM_ITERS;
data.go = 0;
pthread_mutex_init(&data.lock, NULL);
pthread_cond_init(&data.event, NULL);
pthread_mutex_lock(&data.lock);
for (i = 0; i < NUM_THREADS; i++)
{
pthread_create(&threads[i], NULL, add_thread, &data);
}
data.go = 1;
pthread_cond_broadcast(&data.event);
pthread_mutex_unlock(&data.lock);
for (i = 0; i < NUM_THREADS; i++)
{
pthread_join(threads[i], NULL);
}
MU_TRY(lwmsg_peer_acquire_call(client, &call));
in.tag = COUNTER_READ;
in.data = data.handle;
MU_TRY(lwmsg_call_dispatch(call, &in, &out, NULL, NULL));
MU_ASSERT_EQUAL(MU_TYPE_INTEGER, out.tag, COUNTER_READ_SUCCESS);
reply = out.data;
MU_ASSERT_EQUAL(MU_TYPE_INTEGER, reply->counter, NUM_THREADS * NUM_ITERS);
lwmsg_call_destroy_params(call, &out);
lwmsg_call_release(call);
MU_TRY(lwmsg_peer_acquire_call(client, &call));
in.tag = COUNTER_CLOSE;
in.data = data.handle;
MU_TRY(lwmsg_call_dispatch(call, &in, &out, NULL, NULL));
MU_ASSERT_EQUAL(MU_TYPE_INTEGER, out.tag, COUNTER_CLOSE_SUCCESS);
lwmsg_call_destroy_params(call, &out);
lwmsg_call_release(call);
MU_TRY(lwmsg_peer_disconnect(client));
lwmsg_peer_delete(client);
MU_TRY(lwmsg_peer_stop_listen(server));
lwmsg_peer_delete(server);
pthread_mutex_destroy(&data.lock);
pthread_cond_destroy(&data.event);
}
int main(int argc, char** argv)
{
int ret = 0;
LWMsgStatus status = LWMSG_STATUS_SUCCESS;
LWMsgContext* context = NULL;
LWMsgProtocol* protocol = NULL;
LWMsgPeer* server = NULL;
/* Create context */
status = lwmsg_context_new(NULL, &context);
if (status)
{
goto error;
}
/* Set log function */
lwmsg_context_set_log_function(context, log_message, NULL);
/* Create protocol */
status = lwmsg_protocol_new(context, &protocol);
if (status)
{
goto error;
}
/* Add protocol spec */
status = lwmsg_protocol_add_protocol_spec(protocol, fserv_get_protocol());
if (status)
{
goto error;
}
/* Create peer */
status = lwmsg_peer_new(context, protocol, &server);
if (status)
{
goto error;
}
/* Add dispatch spec */
status = lwmsg_peer_add_dispatch_spec(server, fserver_get_dispatch());
if (status)
{
goto error;
}
/* Add listen endpoint */
status = lwmsg_peer_add_listen_endpoint(server, LWMSG_ENDPOINT_LOCAL, FSERV_SOCKET_PATH, (S_IRWXU | S_IRWXG | S_IRWXO));
if (status)
{
goto error;
}
ret = run(server);
error:
if (server)
{
lwmsg_peer_delete(server);
}
if (protocol)
{
lwmsg_protocol_delete(protocol);
}
if (status != LWMSG_STATUS_SUCCESS)
{
ret = -1;
}
exit(ret ? 1 : 0);
}