VOID
LWNetDnsFreeSRVInfoRecord(
IN OUT PDNS_SRV_INFO_RECORD pRecord
)
{
LWNET_SAFE_FREE_STRING(pRecord->pszAddress);
LWNET_SAFE_FREE_STRING(pRecord->pszTarget);
LWNetFreeMemory(pRecord);
}
DWORD
LWNetGetErrorMessageForLoggingEvent(
DWORD dwErrCode,
PSTR* ppszErrorMsg
)
{
DWORD dwErrorBufferSize = 0;
DWORD dwError = 0;
DWORD dwLen = 0;
PSTR pszErrorMsg = NULL;
PSTR pszErrorBuffer = NULL;
dwErrorBufferSize = LwGetErrorString(dwErrCode, NULL, 0);
if (!dwErrorBufferSize)
goto cleanup;
dwError = LWNetAllocateMemory(
dwErrorBufferSize,
(PVOID*)&pszErrorBuffer);
BAIL_ON_LWNET_ERROR(dwError);
dwLen = LwGetErrorString(dwErrCode, pszErrorBuffer, dwErrorBufferSize);
if ((dwLen == dwErrorBufferSize) && !IsNullOrEmptyString(pszErrorBuffer))
{
dwError = LwAllocateStringPrintf(
&pszErrorMsg,
"Error: %s [error code: %d]",
pszErrorBuffer,
dwErrCode);
BAIL_ON_LWNET_ERROR(dwError);
}
*ppszErrorMsg = pszErrorMsg;
cleanup:
LWNET_SAFE_FREE_STRING(pszErrorBuffer);
return dwError;
error:
LWNET_SAFE_FREE_STRING(pszErrorMsg);
*ppszErrorMsg = NULL;
goto cleanup;
}
LWNET_API
LW_VOID
LWNetFreeDCList(
LW_IN LW_OUT PLWNET_DC_ADDRESS pDcList,
LW_IN DWORD dwDcCount
)
{
DWORD i = 0;
for (i = 0; i < dwDcCount; i++)
{
LWNET_SAFE_FREE_STRING(pDcList[i].pszDomainControllerName);
LWNET_SAFE_FREE_STRING(pDcList[i].pszDomainControllerAddress);
}
LWNetFreeMemory(pDcList);
}
DWORD
LWNetSrvGetPrefixPath(
PSTR* ppszPath
)
{
DWORD dwError = 0;
PSTR pszPath = NULL;
BOOLEAN bInLock = FALSE;
LWNET_LOCK_SERVERINFO(bInLock);
if (IsNullOrEmptyString(gpLwnetServerInfo->szPrefixPath)) {
dwError = ERROR_PATH_NOT_FOUND;
BAIL_ON_LWNET_ERROR(dwError);
}
dwError = LWNetAllocateString(gpLwnetServerInfo->szPrefixPath, &pszPath);
BAIL_ON_LWNET_ERROR(dwError);
*ppszPath = pszPath;
cleanup:
LWNET_UNLOCK_SERVERINFO(bInLock);
return dwError;
error:
LWNET_SAFE_FREE_STRING(pszPath);
*ppszPath = NULL;
goto cleanup;
}
VOID
LWNetSrvLogProcessStartedEvent(
VOID
)
{
DWORD dwError = 0;
PSTR pszDescription = NULL;
dwError = LwAllocateStringPrintf(
&pszDescription,
"The Likewise site manager service was started.");
BAIL_ON_LWNET_ERROR(dwError);
LWNetSrvLogInformationEvent(
LWNET_EVENT_INFO_SERVICE_STARTED,
SERVICE_EVENT_CATEGORY,
pszDescription,
NULL);
cleanup:
LWNET_SAFE_FREE_STRING(pszDescription);
return;
error:
goto cleanup;
}
VOID
LWNetSrvLogProcessStoppedEvent(
DWORD dwExitCode
)
{
DWORD dwError = 0;
PSTR pszDescription = NULL;
PSTR pszData = NULL;
dwError = LwAllocateStringPrintf(
&pszDescription,
"The Likewise site manager service was stopped");
BAIL_ON_LWNET_ERROR(dwError);
dwError = LWNetGetErrorMessageForLoggingEvent(
dwExitCode,
&pszData);
BAIL_ON_LWNET_ERROR(dwError);
if (dwExitCode)
{
LWNetSrvLogErrorEvent(
LWNET_EVENT_ERROR_SERVICE_STOPPED,
SERVICE_EVENT_CATEGORY,
pszDescription,
pszData);
}
else
{
LWNetSrvLogInformationEvent(
LWNET_EVENT_INFO_SERVICE_STOPPED,
SERVICE_EVENT_CATEGORY,
pszDescription,
pszData);
}
cleanup:
LWNET_SAFE_FREE_STRING(pszDescription);
LWNET_SAFE_FREE_STRING(pszData);
return;
error:
goto cleanup;
}
DWORD
LWNetDnsGetSrvRecordQuestion(
OUT PSTR* ppszQuestion,
IN PCSTR pszDomainName,
IN OPTIONAL PCSTR pszSiteName,
IN DWORD dwDsFlags
)
{
DWORD dwError = 0;
PSTR question = NULL;
PCSTR kind = "dc";
PCSTR service = "_ldap";
if (dwDsFlags & DS_PDC_REQUIRED)
{
kind = "pdc";
service = "_ldap";
}
else if (dwDsFlags & DS_GC_SERVER_REQUIRED)
{
kind = "gc";
service = "_ldap";
}
else if (dwDsFlags & DS_KDC_REQUIRED)
{
kind = "dc";
service = "_kerberos";
}
else
{
kind = "dc";
service = "_ldap";
}
if (IsNullOrEmptyString(pszSiteName))
{
dwError = LwAllocateStringPrintf(&question,
"%s._tcp.%s._msdcs.%s",
service, kind,
pszDomainName);
BAIL_ON_LWNET_ERROR(dwError);
}
else
{
dwError = LwAllocateStringPrintf(&question,
"%s._tcp.%s._sites.%s._msdcs.%s",
service, pszSiteName, kind,
pszDomainName);
BAIL_ON_LWNET_ERROR(dwError);
}
error:
if (dwError)
{
LWNET_SAFE_FREE_STRING(question);
}
*ppszQuestion = question;
return dwError;
}
VOID
LWNetDnsFreeRecord(
IN OUT PDNS_RECORD pRecord
)
{
LWNET_SAFE_FREE_STRING(pRecord->pszName);
LWNetFreeMemory(pRecord);
}
LWNET_API
VOID
LWNetFreeDCInfo(
PLWNET_DC_INFO pDCInfo
)
{
LWNET_SAFE_FREE_STRING(pDCInfo->pszDomainControllerName);
LWNET_SAFE_FREE_STRING(pDCInfo->pszDomainControllerAddress);
LWNET_SAFE_FREE_STRING(pDCInfo->pszNetBIOSDomainName);
LWNET_SAFE_FREE_STRING(pDCInfo->pszFullyQualifiedDomainName);
LWNET_SAFE_FREE_STRING(pDCInfo->pszDnsForestName);
LWNET_SAFE_FREE_STRING(pDCInfo->pszDCSiteName);
LWNET_SAFE_FREE_STRING(pDCInfo->pszClientSiteName);
LWNET_SAFE_FREE_STRING(pDCInfo->pszNetBIOSHostName);
LWNET_SAFE_FREE_STRING(pDCInfo->pszUserName);
LWNetFreeMemory(pDCInfo);
}
VOID
LWNetSrvLogProcessFailureEvent(
DWORD dwErrCode
)
{
DWORD dwError = 0;
PSTR pszDescription = NULL;
PSTR pszData = NULL;
dwError = LwAllocateStringPrintf(
&pszDescription,
"The Likewise site manager service stopped running due to an error");
BAIL_ON_LWNET_ERROR(dwError);
dwError = LWNetGetErrorMessageForLoggingEvent(
dwErrCode,
&pszData);
BAIL_ON_LWNET_ERROR(dwError);
LWNetSrvLogErrorEvent(
LWNET_EVENT_ERROR_SERVICE_START_FAILURE,
SERVICE_EVENT_CATEGORY,
pszDescription,
pszData);
cleanup:
LWNET_SAFE_FREE_STRING(pszDescription);
LWNET_SAFE_FREE_STRING(pszData);
return;
error:
goto cleanup;
}
int
main(
int argc,
char* argv[]
)
{
DWORD dwError = 0;
PSTR pszTargetFQDN = NULL;
PSTR pszSiteName = NULL;
PSTR pszPrimaryDomain = NULL;
PLWNET_DC_INFO pDCInfo = NULL;
DWORD dwFlags = 0;
CHAR szErrorBuf[1024];
INT i = 0;
dwError = ParseArgs(
argc,
argv,
&pszTargetFQDN,
&pszSiteName,
&pszPrimaryDomain,
&dwFlags
);
BAIL_ON_LWNET_ERROR(dwError);
lwnet_init_logging_to_file(LWNET_LOG_LEVEL_VERBOSE, TRUE, "");
dwError = LWNetGetDCNameExt(
NULL,
pszTargetFQDN,
pszSiteName,
pszPrimaryDomain,
dwFlags,
0,
NULL,
&pDCInfo
);
BAIL_ON_LWNET_ERROR(dwError);
printf("Printing LWNET_DC_INFO fields:\n");
printf("===============================\n");
if(pDCInfo == NULL)
{
printf("<NULL>");
}
else
{
printf("dwDomainControllerAddressType = %u\n", pDCInfo->dwDomainControllerAddressType);
printf("dwFlags = %u\n", pDCInfo->dwFlags);
printf("dwVersion = %u\n", pDCInfo->dwVersion);
printf("wLMToken = %u\n", pDCInfo->wLMToken);
printf("wNTToken = %u\n", pDCInfo->wNTToken);
safePrintString("pszDomainControllerName", pDCInfo->pszDomainControllerName);
safePrintString("pszDomainControllerAddress", pDCInfo->pszDomainControllerAddress);
printf("pucDomainGUID(hex) = ");
for(i = 0; i < LWNET_GUID_SIZE; i++)
{
printf("%.2X ", pDCInfo->pucDomainGUID[i]);
}
printf("\n");
safePrintString("pszNetBIOSDomainName", pDCInfo->pszNetBIOSDomainName);
safePrintString("pszFullyQualifiedDomainName", pDCInfo->pszFullyQualifiedDomainName);
safePrintString("pszDnsForestName", pDCInfo->pszDnsForestName);
safePrintString("pszDCSiteName", pDCInfo->pszDCSiteName);
safePrintString("pszClientSiteName", pDCInfo->pszClientSiteName);
safePrintString("pszNetBIOSHostName", pDCInfo->pszNetBIOSHostName);
safePrintString("pszUserName", pDCInfo->pszUserName);
}
error:
if (dwError)
{
DWORD dwLen = LwGetErrorString(dwError, szErrorBuf, 1024);
if (dwLen)
{
fprintf(
stderr,
"Failed communication with the LWNET Agent. Error code %u (%s).\n%s\n",
dwError,
LW_PRINTF_STRING(LwWin32ExtErrorToName(dwError)),
szErrorBuf);
}
else
{
fprintf(
stderr,
"Failed communication with the LWNET Agent. Error code %u (%s).\n",
dwError,
LW_PRINTF_STRING(LwWin32ExtErrorToName(dwError)));
}
}
LWNET_SAFE_FREE_DC_INFO(pDCInfo);
LWNET_SAFE_FREE_STRING(pszTargetFQDN);
LWNET_SAFE_FREE_STRING(pszSiteName);
return dwError;
}
DWORD
LWNetDnsGetNameServerList(
OUT PSTR** pppszNameServerList,
OUT PDWORD pdwNumServers
)
// Call LWNET_SAFE_FREE_STRING_ARRAY on returned server list
{
DWORD dwError = 0;
PSTR* ppszNameServerList = NULL;
DWORD dwNumServers = 0;
FILE* fp = NULL;
BOOLEAN bFileExists = FALSE;
PCSTR pszConfigFilePath = "/etc/resolv.conf";
const DWORD dwMaxLineLen = 1024;
CHAR szBuf[dwMaxLineLen + 1];
regex_t rx;
PDLINKEDLIST pNameServerList = NULL;
PSTR pszNameServer = NULL;
memset(&rx, 0, sizeof(rx));
if (regcomp(&rx, "^nameserver[[:space:]].*$", REG_EXTENDED) < 0) {
dwError = ERROR_BAD_FORMAT;
BAIL_ON_LWNET_ERROR(dwError);
}
dwError = LwCheckFileTypeExists(
pszConfigFilePath,
LWFILE_REGULAR,
&bFileExists);
BAIL_ON_LWNET_ERROR(dwError);
if (!bFileExists) {
*pppszNameServerList = NULL;
*pdwNumServers = 0;
goto cleanup;
}
if ((fp = fopen(pszConfigFilePath, "r")) == NULL) {
dwError = LwMapErrnoToLwError(errno);
BAIL_ON_LWNET_ERROR(dwError);
}
while (1)
{
if (fgets(szBuf, dwMaxLineLen, fp) == NULL) {
if (!feof(fp)) {
dwError = LwMapErrnoToLwError(errno);
BAIL_ON_LWNET_ERROR(dwError);
} else {
break;
}
}
LwStripWhitespace(szBuf, TRUE, TRUE);
if (!LWNetDnsConfigLineIsComment(szBuf) &&
!regexec(&rx, szBuf, (size_t)0, NULL, 0))
{
PSTR pszLocation = NULL;
PCSTR pszSearchString = "nameserver";
if ((pszLocation = strstr(szBuf, pszSearchString))) {
pszLocation += strlen(pszSearchString);
if (!IsNullOrEmptyString(pszLocation)) {
dwError = LWNetAllocateString(pszLocation, &pszNameServer);
BAIL_ON_LWNET_ERROR(dwError);
}
dwError = LWNetDLinkedListAppend(
&pNameServerList,
pszNameServer);
BAIL_ON_LWNET_ERROR(dwError);
pszNameServer = NULL;
dwNumServers++;
}
}
}
if (dwNumServers)
{
PDLINKEDLIST pListMember = NULL;
DWORD iMember = 0;
dwError = LWNetAllocateMemory(dwNumServers * sizeof(PSTR), (PVOID*)&ppszNameServerList);
BAIL_ON_LWNET_ERROR(dwError);
pListMember = pNameServerList;
while (pListMember)
{
ppszNameServerList[iMember++] = (PSTR)pListMember->pItem;
pListMember->pItem = NULL;
pListMember = pListMember->pNext;
}
}
*pppszNameServerList = ppszNameServerList;
*pdwNumServers = dwNumServers;
cleanup:
regfree(&rx);
LWNetDLinkedListFree(pNameServerList);
LWNET_SAFE_FREE_STRING(pszNameServer);
if (fp) {
fclose(fp);
}
return dwError;
error:
*pppszNameServerList = NULL;
*pdwNumServers = 0;
if (ppszNameServerList) {
LWNetFreeStringArray(ppszNameServerList, dwNumServers);
}
goto cleanup;
}
DWORD
LWNetDnsSrvQuery(
IN PCSTR pszDnsDomainName,
IN OPTIONAL PCSTR pszSiteName,
IN DWORD dwDsFlags,
OUT PDNS_SERVER_INFO* ppServerArray,
OUT PDWORD pdwServerCount
)
// Call LWNET_SAFE_FREE_MEMORY on returned server array
{
DWORD dwError = 0;
PSTR pszQuestion = NULL;
const size_t dwBufferSize = (64 * 1024);
PVOID pBuffer = NULL;
PDNS_RESPONSE_HEADER pResponse = NULL;
DWORD dwResponseSize = 0;
PDLINKEDLIST pAnswersList = NULL;
PDLINKEDLIST pAdditionalsList = NULL;
PDLINKEDLIST pSRVRecordList = NULL;
PDNS_SERVER_INFO pServerArray = NULL;
DWORD dwServerCount = 0;
// TODO - Handle trailing dot in domain; handle no dots in domain
dwError = LWNetDnsGetSrvRecordQuestion(&pszQuestion, pszDnsDomainName,
pszSiteName, dwDsFlags);
BAIL_ON_LWNET_ERROR(dwError);
dwError = LWNetAllocateMemory(dwBufferSize, &pBuffer);
BAIL_ON_LWNET_ERROR(dwError);
dwError = LWNetDnsQueryWithBuffer(pszQuestion, TRUE, FALSE,
pBuffer, dwBufferSize,
&dwResponseSize);
BAIL_ON_LWNET_ERROR(dwError);
pResponse = (PDNS_RESPONSE_HEADER) pBuffer;
if (LWNetDnsIsTruncatedResponse(pResponse))
{
dwError = LWNetDnsQueryWithBuffer(pszQuestion, FALSE, TRUE,
pBuffer, dwBufferSize,
&dwResponseSize);
BAIL_ON_LWNET_ERROR(dwError);
}
// TODO: Add dwResponseSize validation to parsing.
// Decode DNS response w/o taking into account record type
dwError = LWNetDnsParseQueryResponse(pResponse,
&pAnswersList,
NULL,
&pAdditionalsList);
BAIL_ON_LWNET_ERROR(dwError);
// Decode SRV records
dwError = LWNetDnsBuildSRVRecordList(pResponse,
pAnswersList,
pAdditionalsList,
&pSRVRecordList);
BAIL_ON_LWNET_ERROR(dwError);
// Create list of server names and addresses
dwError = LWNetDnsBuildServerArray(pSRVRecordList,
&pServerArray, &dwServerCount);
BAIL_ON_LWNET_ERROR(dwError);
error:
LWNET_SAFE_FREE_STRING(pszQuestion);
LWNET_SAFE_FREE_MEMORY(pBuffer);
LWNET_SAFE_FREE_DNS_RECORD_LINKED_LIST(pAnswersList);
LWNET_SAFE_FREE_DNS_RECORD_LINKED_LIST(pAdditionalsList);
LWNET_SAFE_FREE_SRV_INFO_LINKED_LIST(pSRVRecordList);
if (dwError)
{
LWNET_SAFE_FREE_MEMORY(pServerArray);
dwServerCount = 0;
}
*ppServerArray= pServerArray;
*pdwServerCount = dwServerCount;
return dwError;
}
DWORD
LWNetDnsGetHostInfoEx(
OUT OPTIONAL PSTR* ppszHostname,
OUT OPTIONAL PSTR* ppszFqdn,
OUT OPTIONAL PSTR* ppszDomain
)
{
DWORD dwError = 0;
struct hostent * host = NULL;
CHAR szBuffer[256] = { 0 };
PSTR pszDot = NULL;
PSTR pszFoundFqdn = NULL;
PSTR pszFoundDomain = NULL;
PSTR pszHostname = NULL;
PSTR pszDomain = NULL;
PSTR pszFqdn = NULL;
if (!ppszHostname && !ppszFqdn && !ppszDomain)
{
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_LWNET_ERROR(dwError);
}
if (gethostname(szBuffer, sizeof(szBuffer)-1) != 0)
{
dwError = LwMapErrnoToLwError(errno);
BAIL_ON_LWNET_ERROR(dwError);
}
/* Test to see if the name is still dotted. If so we will chop it down to
just the hostname field. */
pszDot = strchr(szBuffer, '.');
if (pszDot)
{
pszDot[0] = '\0';
}
if (ppszHostname)
{
dwError = LWNetAllocateString(szBuffer, &pszHostname);
BAIL_ON_LWNET_ERROR(dwError);
}
if (!ppszFqdn && !ppszDomain)
{
// done, so bail out
dwError = 0;
goto error;
}
host = gethostbyname(szBuffer);
if ( !host )
{
dwError = LwMapHErrnoToLwError(h_errno);
BAIL_ON_LWNET_ERROR(dwError);
}
//
// We look for the first name that looks like an FQDN. This is
// the same heuristics used by other software such as Kerberos and
// Samba.
//
pszDot = strchr(host->h_name, '.');
if (pszDot)
{
pszFoundFqdn = host->h_name;
pszFoundDomain = pszDot + 1;
}
else
{
int i;
for (i = 0; host->h_aliases[i]; i++)
{
pszDot = strchr(host->h_aliases[i], '.');
if (pszDot)
{
pszFoundFqdn = host->h_aliases[i];
pszFoundDomain = pszDot + 1;
break;
}
}
}
// If we still have nothing, just return the first name, but no Domain part.
if (!pszFoundFqdn)
{
pszFoundFqdn = host->h_name;
}
if (pszFoundFqdn && !pszFoundFqdn[0])
{
pszFoundFqdn = NULL;
}
if (pszFoundDomain && !pszFoundDomain[0])
{
pszFoundDomain = NULL;
}
if (ppszFqdn)
{
if (pszFoundFqdn)
{
dwError = LWNetAllocateString(pszFoundFqdn, &pszFqdn);
BAIL_ON_LWNET_ERROR(dwError);
}
else
{
dwError = ERROR_NOT_FOUND;
BAIL_ON_LWNET_ERROR(dwError);
}
}
if (ppszDomain)
{
if (pszFoundDomain)
{
dwError = LWNetAllocateString(pszFoundDomain, &pszDomain);
BAIL_ON_LWNET_ERROR(dwError);
}
else
{
dwError = ERROR_NOT_FOUND;
BAIL_ON_LWNET_ERROR(dwError);
}
}
error:
if (dwError)
{
LWNET_SAFE_FREE_STRING(pszHostname);
LWNET_SAFE_FREE_STRING(pszFqdn);
LWNET_SAFE_FREE_STRING(pszDomain);
}
if (ppszHostname)
{
*ppszHostname = pszHostname;
}
if (ppszDomain)
{
*ppszDomain = pszDomain;
}
if (ppszFqdn)
{
*ppszFqdn = pszFqdn;
}
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;
}
static
DWORD
LWNetSrvPingCLdapBegin(
IN PLWNET_CLDAP_CONNECTION_CONTEXT pContext,
IN PDNS_SERVER_INFO pServerInfo,
IN PCSTR pszDnsDomainName,
IN DWORD dwTimeout
)
{
DWORD dwError = 0;
PSTR pszQuery = NULL;
PSTR szAttributeList[] = { NETLOGON_LDAP_ATTRIBUTE_NAME, NULL };
struct timeval timeout = {0};
LDAP *ld = NULL;
pContext->hDirectory = NULL;
pContext->pServerInfo = pServerInfo;
dwError = LwAllocateStringPrintf(&pszQuery,
"(&(DnsDomain=%s)(NtVer=\\06\\00\\00\\80))",
pszDnsDomainName);
BAIL_ON_LWNET_ERROR(dwError);
dwError = LwCLdapOpenDirectory(pServerInfo->pszAddress, &pContext->hDirectory);
BAIL_ON_LWNET_ERROR(dwError);
dwError = LwLdapBindDirectoryAnonymous(pContext->hDirectory);
BAIL_ON_LWNET_ERROR(dwError);
timeout.tv_sec = 0;
timeout.tv_usec = dwTimeout;
dwError = LWNetGetSystemTimeInMs(&pContext->StartTime);
BAIL_ON_LWNET_ERROR(dwError);
ld = LwLdapGetSession(pContext->hDirectory);
dwError = ldap_search_ext(
ld,
"",
LDAP_SCOPE_BASE,
pszQuery,
szAttributeList,
0,
NULL,
NULL,
&timeout,
0,
&pContext->msgid);
dwError = LwMapLdapErrorToLwError(dwError);
BAIL_ON_LWNET_ERROR(dwError);
dwError = ldap_get_option(
ld,
LDAP_OPT_DESC,
&pContext->fd);
dwError = LwMapLdapErrorToLwError(dwError);
BAIL_ON_LWNET_ERROR(dwError);
error:
if (dwError)
{
if (pContext->hDirectory)
{
LWNetSrvPingCLdapEnd(pContext);
}
}
LWNET_SAFE_FREE_STRING(pszQuery);
return dwError;
}
DWORD
LWNetDnsParseRecord(
IN PDNS_RESPONSE_HEADER pHeader,
IN PBYTE pData,
OUT PDNS_RECORD* ppRecord,
OUT PDWORD pdwBytesToAdvance
)
{
DWORD dwError = 0;
PBYTE pCurrent = pData;
PSTR pszName = NULL;
PDNS_RECORD pRecord = NULL;
DWORD dwBytesToAdvance = 0;
DWORD dwNameBytesToAdvance = 0;
WORD wDataLen = 0; /* As read from DNS record response data */
dwError = LWNetDnsParseName(pHeader, pCurrent, &dwNameBytesToAdvance, &pszName);
BAIL_ON_LWNET_ERROR(dwError);
dwBytesToAdvance += dwNameBytesToAdvance;
dwBytesToAdvance += sizeof(WORD); /* Type */
dwBytesToAdvance += sizeof(WORD); /* Class */
dwBytesToAdvance += sizeof(DWORD); /* TTL */
pCurrent += dwBytesToAdvance;
wDataLen = LWNetDnsReadWORD( pCurrent );
dwBytesToAdvance += wDataLen + sizeof(WORD);
dwError = LWNetAllocateMemory(sizeof(DNS_RECORD) + wDataLen, (PVOID*)&pRecord);
BAIL_ON_LWNET_ERROR(dwError);
// Fill in new record from buffer
pCurrent = pData;
pCurrent += dwNameBytesToAdvance;
pRecord->pszName = pszName;
pszName = NULL;
pRecord->wType = LWNetDnsReadWORD(pCurrent);
pCurrent += sizeof(WORD);
pRecord->wClass = LWNetDnsReadWORD(pCurrent);
pCurrent += sizeof(WORD);
pRecord->dwTTL = LWNetDnsReadDWORD(pCurrent);
pCurrent += sizeof(DWORD);
pRecord->wDataLen = LWNetDnsReadWORD(pCurrent);
pCurrent += sizeof(WORD);
pRecord->pData = (PBYTE)pRecord + sizeof(DNS_RECORD);
memcpy(pRecord->pData, pCurrent, pRecord->wDataLen);
error:
LWNET_SAFE_FREE_STRING(pszName);
if (dwError)
{
if (pRecord)
{
LWNetDnsFreeRecord(pRecord);
pRecord = NULL;
}
dwBytesToAdvance = 0;
}
*pdwBytesToAdvance = dwBytesToAdvance;
*ppRecord = pRecord;
return dwError;
}
DWORD
LWNetDnsGetAddressForServer(
IN PDLINKEDLIST pAdditionalsList,
IN PCSTR pszHostname,
OUT PSTR* ppszAddress
)
{
DWORD dwError = 0;
PSTR pszAddress = NULL;
PDLINKEDLIST pListMember = NULL;
pListMember = pAdditionalsList;
while (pListMember)
{
PDNS_RECORD pRecord = (PDNS_RECORD)pListMember->pItem;
if ( (pRecord->wType == ns_t_a ) &&
!strcasecmp( pRecord->pszName, pszHostname ) )
{
dwError = LwAllocateStringPrintf(&pszAddress, "%d.%d.%d.%d",
pRecord->pData[0],
pRecord->pData[1],
pRecord->pData[2],
pRecord->pData[3]);
BAIL_ON_LWNET_ERROR(dwError);
break;
}
pListMember = pListMember->pNext;
}
if (IsNullOrEmptyString(pszAddress))
{
struct hostent * host;
LWNET_LOG_VERBOSE("Getting address for '%s'", pszHostname);
host = gethostbyname(pszHostname);
if (host && host->h_name)
{
// ISSUE-2008/07/01-dalmeida -- Need to check that address type is IPv4
dwError = LWNetAllocateString(inet_ntoa(*(struct in_addr*)(host->h_addr_list[0])),
&pszAddress);
BAIL_ON_LWNET_ERROR(dwError);
}
}
if (IsNullOrEmptyString(pszAddress))
{
LWNET_LOG_WARNING("Unable to get IP address for '%s'", pszHostname);
dwError = ERROR_NOT_FOUND;
BAIL_ON_LWNET_ERROR(dwError);
}
error:
if (dwError)
{
LWNET_SAFE_FREE_STRING(pszAddress);
}
*ppszAddress = pszAddress;
return dwError;
}
DWORD
ParseArgs(
int argc,
char* argv[],
PSTR* ppszTargetFQDN,
PSTR* ppszSiteName,
PSTR* ppszPrimaryDomain,
PDWORD pdwFlags
)
{
typedef enum {
PARSE_MODE_OPEN = 0,
PARSE_MODE_SITENAME,
PARSE_MODE_PREFERRED_DOMAIN,
PARSE_MODE_OPTIONS
} ParseMode;
DWORD dwError = 0;
int iArg = 1;
PSTR pszArg = NULL;
ParseMode parseMode = PARSE_MODE_OPEN;
PSTR pszTargetFQDN = NULL;
PSTR pszSiteName = NULL;
PSTR pszPrimaryDomain = NULL;
DWORD dwFlags = 0;
do {
pszArg = argv[iArg++];
if (IsNullOrEmptyString(pszArg))
{
break;
}
switch (parseMode)
{
case PARSE_MODE_OPEN:
if ((strcmp(pszArg, "--help") == 0) ||
(strcmp(pszArg, "-h") == 0))
{
ShowUsage();
exit(0);
}
else
{
dwError = LWNetAllocateString(pszArg, &pszTargetFQDN);
BAIL_ON_LWNET_ERROR(dwError);
parseMode = PARSE_MODE_OPTIONS;
}
break;
case PARSE_MODE_OPTIONS:
if(strcmp(pszArg, "--site") == 0)
{
parseMode = PARSE_MODE_SITENAME;
}
else if(strcmp(pszArg, "--preferred-domain") == 0)
{
parseMode = PARSE_MODE_PREFERRED_DOMAIN;
}
else if(strcmp(pszArg, "--force") == 0)
{
dwError = AddFlag(DS_FORCE_REDISCOVERY, &dwFlags);
BAIL_ON_LWNET_ERROR(dwError);
}
else if(strcmp(pszArg, "--ds-required") == 0)
{
dwError = AddFlag(DS_DIRECTORY_SERVICE_REQUIRED, &dwFlags);
BAIL_ON_LWNET_ERROR(dwError);
}
else if(strcmp(pszArg, "--gc-required") == 0)
{
dwError = AddFlag(DS_GC_SERVER_REQUIRED, &dwFlags);
BAIL_ON_LWNET_ERROR(dwError);
}
else if(strcmp(pszArg, "--pdc-required") == 0)
{
dwError = AddFlag(DS_PDC_REQUIRED, &dwFlags);
BAIL_ON_LWNET_ERROR(dwError);
}
else if(strcmp(pszArg, "--background-only") == 0)
{
dwError = AddFlag(DS_BACKGROUND_ONLY, &dwFlags);
BAIL_ON_LWNET_ERROR(dwError);
}
else if(strcmp(pszArg, "--kdc-required") == 0)
{
dwError = AddFlag(DS_KDC_REQUIRED, &dwFlags);
BAIL_ON_LWNET_ERROR(dwError);
}
else if(strcmp(pszArg, "--timeserv-required") == 0)
{
dwError = AddFlag(DS_TIMESERV_REQUIRED, &dwFlags);
BAIL_ON_LWNET_ERROR(dwError);
}
else if(strcmp(pszArg, "--writeable-required") == 0)
{
dwError = AddFlag(DS_WRITABLE_REQUIRED, &dwFlags);
BAIL_ON_LWNET_ERROR(dwError);
}
else if(strcmp(pszArg, "--good-timeserv-required") == 0)
{
dwError = AddFlag(DS_GOOD_TIMESERV_REQUIRED, &dwFlags);
BAIL_ON_LWNET_ERROR(dwError);
}
else if(strcmp(pszArg, "--avoid-self") == 0)
{
dwError = AddFlag(DS_AVOID_SELF, &dwFlags);
BAIL_ON_LWNET_ERROR(dwError);
}
else
{
LWNET_LOG_ERROR("Invalid argument: %s", pszArg);
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_LWNET_ERROR(dwError);
}
break;
case PARSE_MODE_SITENAME:
if(!IsNullOrEmptyString(pszSiteName))
{
LWNET_LOG_ERROR("Invalid argument: %s", pszArg);
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_LWNET_ERROR(dwError);
}
dwError = LWNetAllocateString(pszArg, &pszSiteName);
BAIL_ON_LWNET_ERROR(dwError);
parseMode = PARSE_MODE_OPTIONS;
break;
case PARSE_MODE_PREFERRED_DOMAIN:
if(!IsNullOrEmptyString(pszPrimaryDomain))
{
LWNET_LOG_ERROR("Invalid argument: %s", pszArg);
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_LWNET_ERROR(dwError);
}
dwError = LWNetAllocateString(pszArg, &pszPrimaryDomain);
BAIL_ON_LWNET_ERROR(dwError);
parseMode = PARSE_MODE_OPTIONS;
break;
}
} while (iArg < argc);
if(IsNullOrEmptyString(pszTargetFQDN))
{
ShowUsage();
exit(0);
}
error:
if (dwError)
{
LWNET_SAFE_FREE_STRING(pszTargetFQDN);
LWNET_SAFE_FREE_STRING(pszSiteName);
LWNET_SAFE_FREE_STRING(pszPrimaryDomain);
dwFlags = 0;
}
*ppszTargetFQDN = pszTargetFQDN;
*ppszSiteName = pszSiteName;
*ppszPrimaryDomain = pszPrimaryDomain;
*pdwFlags = dwFlags;
return dwError;
}
DWORD
LWNetReadString(
OUT PSTR *ppszDest,
IN PACKED_ARRAY *pArray
)
{
// Decode a string according to RFC1035
DWORD dwError = 0;
PSTR pszOut = NULL;
size_t outOffset = 0;
BYTE *followingCur;
size_t followOffset;
size_t copyLen;
BYTE **pCur = &pArray->pCur;
// A valid string can't be longer than the packet it comes from
dwError = LWNetAllocateMemory(pArray->totalSize, (PVOID*)&pszOut);
BAIL_ON_LWNET_ERROR(dwError);
while (**pCur != '\0')
{
switch (**pCur & 0xC0)
{
case 0xC0:
// This is a string reference
followOffset = (((WORD)(*pCur)[0] << 8) | (*pCur)[1]) & 0x3FFF;
if (followOffset >= pArray->totalSize)
{
//Offset out of bounds
dwError = DNS_ERROR_BAD_PACKET;
goto error;
}
*pCur += 2;
pCur = &followingCur;
followingCur = pArray->pStart + followOffset;
if ((**pCur & 0xC0) == 0xC0)
{
// This is definitely redundant, and it could be an infinite
// loop.
dwError = DNS_ERROR_BAD_PACKET;
goto error;
}
break;
case 0x00:
// This is a string component
copyLen = (*pCur)[0];
(*pCur)++;
if (copyLen + 2 + outOffset > pArray->totalSize)
{
// This goes out of bounds of the output buffer. There must be
// an infinite loop in the encoding.
dwError = DNS_ERROR_BAD_PACKET;
goto error;
}
if (copyLen + 1 + *pCur - pArray->pStart > pArray->totalSize)
{
// The label goes out of bounds of the message
dwError = DNS_ERROR_BAD_PACKET;
goto error;
}
if (outOffset > 0)
{
//Add a dot to separate the components
pszOut[outOffset++] = '.';
}
memcpy(pszOut + outOffset, *pCur, copyLen);
*pCur += copyLen;
outOffset += copyLen;
break;
default:
// Illegal reserved value
dwError = DNS_ERROR_BAD_PACKET;
goto error;
}
}
*pCur += 1;
pszOut[outOffset++] = '\0';
error:
if (dwError)
{
LWNET_SAFE_FREE_STRING(pszOut);
}
*ppszDest = pszOut;
return dwError;
}
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;
}
int
main(
int argc,
char* argv[]
)
{
DWORD dwError = 0;
PSTR pszHostName = NULL;
PWSTR pwszHostName = NULL;
PWSTR pwszCanonName = NULL;
PSTR pszCanonName = NULL;
PLWNET_RESOLVE_ADDR *ppAddressList = NULL;
DWORD dwAddressListLen = 0;
DWORD i = 0;
CHAR ipAddressBuf[INET_ADDRSTRLEN];
PCSTR pszAddress = NULL;
DWORD ipAddressLen = 0;
DWORD ipAddrFamily = 0;
PBYTE pIpAddr = NULL;
lwnet_init_logging_to_file(LWNET_LOG_LEVEL_VERBOSE, TRUE, "");
ParseArgs(argc, argv);
if (argc == 1)
{
printf("usage: %s hostname\n", argv[0]);
return 0;
}
pszHostName = argv[1];
dwError = LwRtlWC16StringAllocateFromCString(&pwszHostName,
pszHostName);
BAIL_ON_LWNET_ERROR(dwError);
dwError = LWNetResolveName(
(PCWSTR) pwszHostName,
&pwszCanonName,
&ppAddressList,
&dwAddressListLen);
BAIL_ON_LWNET_ERROR(dwError);
dwError = LwRtlCStringAllocateFromWC16String(&pszCanonName,
pwszCanonName);
BAIL_ON_LWNET_ERROR(dwError);
for (i=0; i<dwAddressListLen; i++)
{
if (ppAddressList[i]->AddressType == LWNET_IP_ADDR_V4)
{
ipAddressLen = 4;
ipAddrFamily = PF_INET;
pIpAddr = ppAddressList[i]->Address.Ip4Addr;
}
else if (ppAddressList[i]->AddressType == LWNET_IP_ADDR_V6)
{
ipAddressLen = 16;
ipAddrFamily = PF_INET6;
pIpAddr = ppAddressList[i]->Address.Ip4Addr;
}
pszAddress = inet_ntop(ipAddrFamily,
pIpAddr,
ipAddressBuf,
sizeof(ipAddressBuf));
if (pszAddress)
{
printf("IP Address = %s\n", pszAddress);
}
}
printf("Responses = %d Host: '%s'\n", dwAddressListLen, pszCanonName);
cleanup:
LWNetResolveNameFree(pwszCanonName, ppAddressList, dwAddressListLen);
LWNET_SAFE_FREE_MEMORY(pwszHostName);
LWNET_SAFE_FREE_STRING(pszCanonName);
return (dwError);
error:
if (dwError == ERROR_BAD_NET_NAME)
{
printf("LWNetResolveName() failed DNS/NetBIOS name resolution\n");
}
else
{
LWNET_LOG_ERROR("Failed communication with likewise-netlogond. "
"Error code [%d]\n", dwError);
}
goto cleanup;
}