VOID
LWNetFilterFromBlackList(
IN DWORD dwBlackListCount,
IN OPTIONAL PSTR* ppszAddressBlackList,
IN OUT PDWORD pdwServerCount,
IN OUT PDNS_SERVER_INFO pServerArray
)
{
DWORD dwServerRead = 0;
DWORD dwServerWrote = 0;
DWORD dwBlackIndex = 0;
BOOLEAN bBlackListed = FALSE;
LWNET_LOG_INFO("Filtering list of %d servers with list of %d black listed servers", *pdwServerCount, dwBlackListCount);
if (!dwBlackListCount)
{
return;
}
for (dwServerRead = 0; dwServerRead < *pdwServerCount; dwServerRead++)
{
bBlackListed = FALSE;
for (dwBlackIndex = 0;
!bBlackListed && dwBlackIndex < dwBlackListCount;
dwBlackIndex++)
{
if (!strcmp(pServerArray[dwServerRead].pszAddress,
ppszAddressBlackList[dwBlackIndex]))
{
bBlackListed = TRUE;
LWNET_LOG_INFO("Filtering server %s since it is black listed",
pServerArray[dwServerRead].pszAddress);
}
}
/* If bBlackListed is true, this server array entry will get
* overwritten with the next non-blacklisted entry. The address and
* name strings inside of the entry do not need to be freed because
* they are allocated in the same memory block as the array.
*/
if (!bBlackListed)
{
pServerArray[dwServerWrote++] = pServerArray[dwServerRead];
}
}
*pdwServerCount = dwServerWrote;
}
NTSTATUS
LWNetSvcmRefresh(
PLW_SVCM_INSTANCE pInstance
)
{
DWORD dwError = 0;
HANDLE hServer = NULL;
LWNET_LOG_INFO("Refreshing configuration");
dwError = LWNetSrvOpenServer(
getuid(),
getgid(),
&hServer);
BAIL_ON_LWNET_ERROR(dwError);
dwError = LWNetSrvRefreshConfiguration(hServer);
BAIL_ON_LWNET_ERROR(dwError);
LWNET_LOG_INFO("Refreshed configuration successfully");
cleanup:
if (hServer != NULL)
{
LWNetSrvCloseServer(hServer);
}
return LwWin32ErrorToNtStatus(dwError);
error:
LWNET_LOG_ERROR("Failed to refresh configuration. [Error code:%u]", dwError);
goto cleanup;
}
NTSTATUS
LWNetSvcmStop(
PLW_SVCM_INSTANCE pInstance
)
{
LWNET_LOG_VERBOSE("LWNet main cleaning up");
// Post service stopped event to eventlog
LWNetSrvLogProcessStoppedEvent(ERROR_SUCCESS);
LWNetSrvStopListenThread();
LWNetSrvApiShutdown();
LWNET_LOG_INFO("LWNET Service exiting...");
return STATUS_SUCCESS;
}
VOID *LWNetSrvStartNetBiosThreadRoutine(VOID *ctx)
{
DWORD dwError = 0;
struct pollfd pollfds[1];
int sts = 0;
int sock = 0;
UINT8 *NetBiosReply = NULL;
struct sockaddr_in dgAddr;
int NetBiosReplyAddrLen = 0;
void *pNetBiosReplyAddrLen = &NetBiosReplyAddrLen;
PLWNET_SRV_NETBIOS_CONTEXT pNbCtx = (PLWNET_SRV_NETBIOS_CONTEXT) ctx;
int allowBroadcast = 1;
UINT8 Flags = 0;
UINT16 respTransactionId = 0;
PSTR NbName = NULL;
struct in_addr *addrs = NULL;
DWORD addrsLen = 0;
struct timeval tp = {0};
struct timespec cvTimeout = {0};
dwError = LWNetAllocateMemory(
LWNB_NETBIOS_UDP_MAX,
(PVOID*) &NetBiosReply);
sock = socket(AF_INET, SOCK_DGRAM, 0);
if (sock == -1)
{
dwError = ERROR_INVALID_HANDLE;
BAIL_ON_LWNET_ERROR(dwError);
}
sts = setsockopt(sock,
SOL_SOCKET,
SO_BROADCAST,
&allowBroadcast,
sizeof(allowBroadcast));
if (sts == -1)
{
dwError = ERROR_INVALID_HANDLE;
BAIL_ON_LWNET_ERROR(dwError);
}
pthread_mutex_lock(&pNbCtx->mutex);
pNbCtx->sock = sock;
pthread_mutex_unlock(&pNbCtx->mutex);
do
{
memset(pollfds, 0, sizeof(pollfds));
pollfds[0].fd = sock;
pollfds[0].events = POLLIN;
sts = poll(pollfds, 1, -1);
if (sts > 0 && pollfds[0].revents)
{
sts = recvfrom(
sock,
NetBiosReply,
LWNB_NETBIOS_UDP_MAX,
0, /* flags */
(struct sockaddr *) &dgAddr,
pNetBiosReplyAddrLen);
if (sts > 0)
{
dwError = LWNetNbParseNameQueryResponse(
NetBiosReply,
sts,
0, // remove this argument
&respTransactionId,
&NbName,
NULL,
&Flags,
&addrs,
&addrsLen);
pthread_mutex_lock(&pNbCtx->mutex);
pNbCtx->respError = dwError;
pNbCtx->transactionId = respTransactionId;
pNbCtx->addrs = addrs;
pNbCtx->addrsLen = addrsLen;
pNbCtx->bNbRepsponse = TRUE;
pthread_mutex_lock(&pNbCtx->mutexAck);
pthread_mutex_unlock(&pNbCtx->mutex);
pthread_cond_broadcast(&pNbCtx->cv);
// Wait for LWNetNbResolveName ack address received
do
{
gettimeofday(&tp, NULL);
cvTimeout.tv_sec =
tp.tv_sec + pNbCtx->udpTimeout;
cvTimeout.tv_nsec = tp.tv_usec * 1000;
sts = pthread_cond_timedwait(
&pNbCtx->cvAck,
&pNbCtx->mutexAck,
&cvTimeout);
} while (!pNbCtx->bAck && sts != ETIMEDOUT);
pNbCtx->bAck = FALSE;
pthread_mutex_unlock(&pNbCtx->mutexAck);
}
}
} while (!pNbCtx->bShutdown);
LWNET_LOG_INFO("Stopping NetBIOS listener thread");
cleanup:
LWNET_SAFE_FREE_MEMORY(NetBiosReply);
LWNET_SAFE_FREE_STRING(NbName);
if (sock != -1)
{
close(sock);
}
return NULL;
error:
goto cleanup;
}