void GetAgentInfo(AgentSystemInfo *info)
{
SYSTEM_INFO siSysInfo;
// get cpu info
GetSystemInfo(&siSysInfo);
switch(siSysInfo.wProcessorArchitecture)
{
case PROCESSOR_ARCHITECTURE_AMD64:
info->cpu = "x64";
break;
case PROCESSOR_ARCHITECTURE_IA64:
info->cpu = "IA64";
break;
case PROCESSOR_ARCHITECTURE_INTEL:
info->cpu = "x86";
break;
default:
info->cpu = "Unknown";
break;
}
// get dns hostname
DWORD dwSize = 0;
// first get the buffer size
GetComputerNameEx(ComputerNameDnsFullyQualified, NULL, &dwSize);
char *name_buf = new char[dwSize + 1];
// second get the host name, dns full qualified
if (!GetComputerNameEx(ComputerNameDnsFullyQualified, name_buf, &dwSize))
{
Log::Error("Get dns fully qualified name failed, exit now!");
exit(-1);
info->hostname = "Unknown";
}
else
{
info->hostname = string(name_buf, dwSize);
}
delete [] name_buf;
info->system = "Windows";
char buf[255];
// get release and version
OSVERSIONINFO osvi;
ZeroMemory(&osvi, sizeof(OSVERSIONINFO));
osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
GetVersionEx(&osvi);
sprintf(buf, "%d.%d", osvi.dwMajorVersion, osvi.dwMinorVersion);
info->release = buf;
TCHAR szOS[BUFSIZE];
if( GetOSDisplayString(szOS))
{
info->version = szOS;
}
else
{
info->version = "Unknown";
}
info->agent_version = AGENT_VERSION;
}
HRESULT
ceGetMachineDnsName(
OUT WCHAR **ppwszDnsName)
{
HRESULT hr;
WCHAR *pwszDnsName = NULL;
DWORD cwc;
COMPUTER_NAME_FORMAT NameType = ComputerNameDnsFullyQualified;
*ppwszDnsName = NULL;
while (TRUE)
{
cwc = 0;
if (!GetComputerNameEx(NameType, NULL, &cwc))
{
hr = ceHLastError();
if (HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) == hr &&
ComputerNameDnsFullyQualified == NameType)
{
_PrintError(hr, "GetComputerNameEx(DnsFullyQualified) -- switching to NetBIOS");
NameType = ComputerNameNetBIOS;
continue;
}
if (HRESULT_FROM_WIN32(ERROR_MORE_DATA) != hr)
{
_JumpError(hr, error, "GetComputerNameEx");
}
break;
}
}
pwszDnsName = (WCHAR *) LocalAlloc(LMEM_FIXED, cwc * sizeof(WCHAR));
if (NULL == pwszDnsName)
{
hr = E_OUTOFMEMORY;
_JumpError(hr, error, "LocalAlloc");
}
if (!GetComputerNameEx(NameType, pwszDnsName, &cwc))
{
hr = ceHLastError();
_JumpError(hr, error, "GetComputerNameEx");
}
*ppwszDnsName = pwszDnsName;
pwszDnsName = NULL;
hr = S_OK;
error:
if (NULL != pwszDnsName)
{
LocalFree(pwszDnsName);
}
return(hr);
}
/**
* Runs the DNS-SD sequence to discover the sFlow server settings,
* collector addresses and ports and sampling rates and polling interval
* settings.
* The DNS query is scoped to query for entries in the domain (zone)
* configured as the domain override in the registry (if set), or the
* primary domain name configured on the system if there is no domain
* override.
* Note that the DNS query could fail or return no results if we are
* unable to discover the primary domain of the system.
* HSP *sp used to update the min TTL for DNS entries so that the
* next DNS request can be scheduled.
* HSPSFlowSettings *settings in which sFlow collector addresses and ports
* and sampling and polling settings will be populated.
* Returns the number of sFlow collectors discovered or -1 on failure.
*/
int dnsSD(HSP *sp, HSPSFlowSettings *settings)
{
char request[HSP_MAX_DNS_LEN];
if (sp->DNSSD_domain) {
sprintf_s(request, HSP_MAX_DNS_LEN, "%s%s", SFLOW_DNS_SD, sp->DNSSD_domain);
} else {
char domain[MAX_HOSTNAME_LEN];
memset(domain, 0, MAX_HOSTNAME_LEN);
DWORD len = MAX_HOSTNAME_LEN;
char *dot = "";
if (GetComputerNameEx(ComputerNameDnsDomain, domain, &len) == 0) {
DWORD err = GetLastError();
logErr(LOG_ERR, err, "dnsSD: cannot determined DNS domain for this computer error=%u", err);
} else if (len == 0) {
myLog(LOG_ERR, "dnsSD: DNS domain for this computer not set");
} else {
dot = ".";
}
sprintf_s(request, HSP_MAX_DNS_LEN, "%s%s%s", SFLOW_DNS_SD, dot, domain);
}
myLog(LOG_INFO, "dnsSD: request=%s", request);
int num_servers = dnsSD_Request(sp, settings, request, DNS_TYPE_SRV);
dnsSD_Request(sp, settings, request, DNS_TYPE_TEXT);
// it's ok even if only the SRV request succeeded
return num_servers; // -1 on error
}
/*!
@brief ユーザ情報の表示
*/
void CUserInfoDlg::ExecUserInfo()
{
TCHAR szUserName[UNLEN + 1];
DWORD nUserNameSize = sizeof(szUserName) / sizeof(TCHAR);
GetUserName(szUserName, &nUserNameSize);
m_strUserName = szUserName;
TCHAR szDomainName[DNLEN + 1];
DWORD nDomainNameSize = sizeof(szDomainName) / sizeof(TCHAR);
GetComputerNameEx(ComputerNameDnsDomain, szDomainName, & nDomainNameSize);
m_strDomainName = szDomainName;
TCHAR szFullUserName[UNLEN + 1];
ZeroMemory(szFullUserName, sizeof(szFullUserName));
GetFullName(szUserName, szDomainName, szFullUserName);
m_strFullUserName = szFullUserName;
m_bAdminUser = IsUserAnAdmin();
TCHAR szGroupName[(GNLEN + 1) * 5];
ZeroMemory(szGroupName, sizeof(szGroupName));
GetGroupName(szUserName, szGroupName);
m_strGroupName = szGroupName;
m_strGroupName.TrimLeft(_T(','));
UpdateData(FALSE);
}
int gethostname(char* name, size_t len) {
/* GetComputerName is not the right thing. gethostname from <winsock2.h>
would be right, but requires linking with -lws2_32. So we use
GetComputerNameEx. */
DWORD size = (len <= (DWORD)~0 ? len : (DWORD)~0);
if (!GetComputerNameEx(ComputerNameDnsHostname, name, &size)) {
return -1;
}
return 0;
}
std::wstring getFqdn( )
{
BOOL result;
wchar_t buffer[400];
DWORD size = _countof(buffer) - 1;
result = GetComputerNameEx( ComputerNameDnsFullyQualified, buffer, &size );
if( !result ) {
throw Win32Exception( "Trying to get computer name" );
}
return std::wstring(buffer);
}
/**
* Populates the host_descr structure with, computer name for hostname,
* processor architecture, os_name (Windows), os version, and BIOS UUID.
*/
void readHidCounters(HSP *sp, SFLHost_hid_counters *hid){
DWORD dwRes;
OSVERSIONINFO osvi;
SYSTEM_INFO si;
#define MAX_FDQN_CHARS 255
char dnsBuf[MAX_FDQN_CHARS+1];
DWORD dnsLen = MAX_FDQN_CHARS;
if (GetComputerNameEx(ComputerNameDnsHostname,dnsBuf,&dnsLen)) {
uint32_t copyLen = dnsLen < SFL_MAX_HOSTNAME_CHARS ? dnsLen : SFL_MAX_HOSTNAME_CHARS;
memcpy(hid->hostname.str, dnsBuf, copyLen);
hid->hostname.str[copyLen] = '\0';
hid->hostname.len = copyLen;
}
hid->os_name = SFLOS_windows;
ZeroMemory(&osvi, sizeof(OSVERSIONINFO));
osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
dwRes = GetVersionEx(&osvi);
if (dwRes){
sprintf_s(hid->os_release.str, SFL_MAX_OSRELEASE_CHARS,"%d.%d.%d %s",
osvi.dwMajorVersion,
osvi.dwMinorVersion,
osvi.dwBuildNumber,
osvi.szCSDVersion);
hid->os_release.len = (uint32_t)strnlen(hid->os_release.str, SFL_MAX_OSRELEASE_CHARS);
}
GetNativeSystemInfo(&si);
hid->machine_type = SFLMT_unknown;
switch(si.wProcessorArchitecture){
case PROCESSOR_ARCHITECTURE_AMD64:
hid->machine_type = SFLMT_x86_64;
break;
case PROCESSOR_ARCHITECTURE_IA64:
hid->machine_type = SFLMT_ia64;
break;
case PROCESSOR_ARCHITECTURE_INTEL:
hid->machine_type = SFLMT_x86;
break;
}
dwRes = readSystemUUID(hid->uuid);
if (LOG_INFO <= debug) {
u_char uuidbuf[FORMATTED_GUID_LEN+1];
printUUID(hid->uuid, uuidbuf, FORMATTED_GUID_LEN);
myLog(LOG_INFO,"readHidCounters:\n\thostname:\t%s\n\trelease:\t%s\n\tmachine_type:\t%d\n\tuuid:\t%s\n",
hid->hostname.str, hid->os_release.str, hid->machine_type, uuidbuf);
}
}
int uname(struct utsname *name)
{
DWORD nodeNameSize = sizeof(name->nodename) - 1;
memset(name, 0, sizeof(struct utsname));
if (!GetComputerNameEx
(ComputerNameDnsFullyQualified, name->nodename, &nodeNameSize))
ERR("GetComputerNameEx failed");
strncpy(name->sysname, "Windows", sizeof(name->sysname) - 1);
/* FIXME - these should be easy to fetch */
strncpy(name->release, "-", sizeof(name->release) - 1);
strncpy(name->version, "-", sizeof(name->version) - 1);
strncpy(name->machine, "-", sizeof(name->machine) - 1);
return 0;
}
int
sethostname (const char *name, size_t len)
{
char name_asciz[HOST_NAME_MAX + 1];
char old_name[HOST_NAME_MAX + 1];
DWORD old_name_len;
/* Ensure the string isn't too long. glibc does allow setting an
empty hostname so no point in enforcing a lower bound. */
if (len > HOST_NAME_MAX)
{
errno = EINVAL;
return -1;
}
/* Prepare a NUL-terminated copy of name. */
memcpy (name_asciz, name, len);
name_asciz[len] = '\0';
/* Save the old NetBIOS name. */
old_name_len = sizeof (old_name) - 1;
if (! GetComputerNameEx (ComputerNamePhysicalNetBIOS,
old_name, &old_name_len))
old_name_len = 0;
/* Set both the NetBIOS and the first part of the IP / DNS name. */
if (! SetComputerNameEx (ComputerNamePhysicalNetBIOS, name_asciz))
{
errno = (GetLastError () == ERROR_ACCESS_DENIED ? EPERM : EINVAL);
return -1;
}
if (! SetComputerNameEx (ComputerNamePhysicalDnsHostname, name_asciz))
{
errno = (GetLastError () == ERROR_ACCESS_DENIED ? EPERM : EINVAL);
/* Restore the old NetBIOS name. */
if (old_name_len > 0)
{
old_name[old_name_len] = '\0';
SetComputerNameEx (ComputerNamePhysicalNetBIOS, old_name);
}
return -1;
}
/* Note that the new host name becomes effective only after a reboot! */
return 0;
}
int _tmain(int argc, _TCHAR* argv[])
{
setup();
//Prepare Audio Manager
RawAudio audio_manager = RawAudio();
//setup destination location
//get the computer name
DWORD name_length = MAX_COMPUTERNAME_LENGTH + 1;
LPWSTR computer_name = (LPWSTR)malloc(MAX_COMPUTERNAME_LENGTH + 1);
GetComputerNameEx(ComputerNameDnsHostname, computer_name, &name_length);
/* Determine the transmitter and receiver by comparing this computer's
name with communicator names */
if (wcscmp(computer_name, COMMUNICATOR_ONE_NAME) == 0)
{
audio_manager.SetupStream("CommunicatorOne", "CommunicatorTwo");
}
else
{
audio_manager.SetupStream("CommunicatorTwo", "CommunicatorOne");
}
//Play startup noise, set Ready Light on
audio_manager.PlayWavFile(L"C:\\Communicator\\aud\\ready.wav", DAC_CS_PIN);
digitalWrite(READY_LED, 1);
while (true)
{
if (digitalRead(CONTROL_BUTTON) == 1)
{
//stream out when the button is pressed, in 1 second clips
audio_manager.StreamOutAnalog(DAC_CS_PIN, MICROPHONE_INPUT, CONTROL_BUTTON, 1);
}
else
{
//stream in 1 second clips
audio_manager.StreamInAnalog(DAC_CS_PIN, CONTROL_BUTTON, 1);
}
}
}
void Get_NET_info()
{
DWORD temp;
DWORD ComputerName_Size = (MAX_COMPUTERNAME_LENGTH+1);
TCHAR ComputerName[MAX_COMPUTERNAME_LENGTH+1];
temp = ComputerName_Size;
GetComputerNameEx(ComputerNameNetBIOS,ComputerName,&temp);
printf("ComputerNameNetBIOS : %s\n",ComputerName);
temp = ComputerName_Size;
GetComputerNameEx(ComputerNameDnsHostname,ComputerName,&temp);
printf("ComputerNameDnsHostname : %s\n",ComputerName);
temp = ComputerName_Size;
GetComputerNameEx( ComputerNameDnsDomain,ComputerName,&temp);
printf(" ComputerNameDnsDomain : %s\n",ComputerName);
temp = ComputerName_Size;
GetComputerNameEx(ComputerNameDnsFullyQualified,ComputerName,&temp);
printf("ComputerNameDnsFullyQualified : %s\n",ComputerName);
temp = ComputerName_Size;
GetComputerNameEx(ComputerNamePhysicalDnsHostname,ComputerName,&temp);
printf("ComputerNamePhysicalDnsHostname : %s\n",ComputerName);
temp = ComputerName_Size;
GetComputerNameEx(ComputerNamePhysicalDnsDomain,ComputerName,&temp);
printf("ComputerNamePhysicalDnsDomain : %s\n",ComputerName);
temp = ComputerName_Size;
GetComputerNameEx(ComputerNamePhysicalDnsFullyQualified,ComputerName,&temp);
printf("ComputerNamePhysicalDnsFullyQualified : %s\n",ComputerName);
temp = ComputerName_Size;
GetComputerNameEx(ComputerNameMax,ComputerName,&temp);
printf("ComputerNameMax : %s\n",ComputerName);
}
//********************************************************************************************
// Function: InitializeDrt
//
// Description: Initializes and brings a DRT instance online
// 1) Brings up an ipv6 transport layer
// 2) Attaches a security provider (according to user's choice)
// 3) Attaches a bootstrap provider (according to user's choice)
// 4) Calls DrtOpen to bring the DRT instance online
//
//********************************************************************************************
bool InitializeDrt(DRT_CONTEXT *Drt)
{
HRESULT hr = S_OK;
DWORD dwSize = 0;
PWSTR pwszCompName = NULL;
WCHAR pwszBootstrapHostname[1024] = {0};
USHORT usBootstrapPort = 0;
//
// Initialize DrtSettings
//
Drt->port = 0;
Drt->settings.pwzDrtInstancePrefix = L"Local_DRT";
Drt->settings.dwSize = sizeof(DRT_SETTINGS);
Drt->settings.cbKey = KEYSIZE;
Drt->settings.ulMaxRoutingAddresses = 4;
Drt->settings.bProtocolMajorVersion = 0x6;
Drt->settings.bProtocolMinorVersion = 0x65;
Drt->settings.eSecurityMode = DRT_SECURE_CONFIDENTIALPAYLOAD;
Drt->settings.hTransport = NULL;
Drt->settings.pSecurityProvider = NULL;
Drt->settings.pBootstrapProvider = NULL;
Drt->hDrt = NULL;
//
// *Transport*
//
hr = DrtCreateIpv6UdpTransport(
DRT_GLOBAL_SCOPE,
0,
300,
&Drt->port,
&Drt->settings.hTransport
);
VERIFY_OR_ABORT("DrtCreateTransport",hr);
//
// *Security Provider*
//
if(Drt->SecurityProviderType == 0) //Null Security Provider
{
hr = DrtCreateNullSecurityProvider(&Drt->settings.pSecurityProvider);
}
else if(Drt->SecurityProviderType == 1) //Derived Key Security Provider
{
hr = ReadCertFromFile(L"RootCertificate.cer", &Drt->pRoot, NULL);
if (FAILED(hr))
{
wprintf(L"No RootCertificate.cer file found in the current directory, Creating a new root certificate.\n");
hr = MakeCert(L"RootCertificate.cer", L"RootCert", NULL, NULL);
VERIFY_OR_ABORT(L"MakeCert",hr);
hr = ReadCertFromFile(L"RootCertificate.cer", &Drt->pRoot, NULL);
VERIFY_OR_ABORT(L"ReadCertFromFile", hr);
}
// We now have a root cert, read an existing local cert or create one based on root cert
hr = ReadCertFromFile(L"LocalCertificate.cer", &Drt->pLocal, NULL);
if (FAILED(hr))
{
wprintf(L"No LocalCertificate.cer file found in the current directory, Creating a new local certificate.\n");
hr = MakeCert(L"LocalCertificate.cer", L"LocalCert", L"RootCertificate.cer", L"RootCert");
VERIFY_OR_ABORT(L"MakeCert",hr);
hr = ReadCertFromFile(L"LocalCertificate.cer", &Drt->pLocal, NULL);
VERIFY_OR_ABORT(L"ReadCertFromFile", hr);
}
hr = DrtCreateDerivedKeySecurityProvider(
Drt->pRoot,
Drt->pLocal,
&Drt->settings.pSecurityProvider
);
}
else if(Drt->SecurityProviderType == 2) //Custom Security Provider
{
hr = DrtCreateCustomSecurityProvider(&Drt->settings.pSecurityProvider);
}
else
{
wprintf(L"Invalid Security Provider passed to InitializeDrt");
hr = E_FAIL;
}
VERIFY_OR_ABORT("DrtCreateSecurityProvider",hr);
//
// *Bootstrap Provider*
//
if(Drt->BootstrapProviderType == 0) //DNS Bootstrap Provider
{
GetComputerNameEx(ComputerNameDnsFullyQualified, NULL, &dwSize );
pwszCompName = new WCHAR[dwSize+1];
if(pwszCompName == NULL)
{
hr = E_OUTOFMEMORY;
wprintf(L"Out of memory");
goto Cleanup;
}
::GetComputerNameEx(ComputerNameDnsFullyQualified, pwszCompName, &dwSize);
wprintf(L"Enter 'hostname port' for DNS Bootstrap Provider (currently %s %i):\n", pwszCompName, Drt->port);
if(wscanf_s(L"%s %hu",pwszBootstrapHostname, 1024, &usBootstrapPort) < 2)
{
FlushCurrentLine();
hr = E_INVALIDARG;
wprintf(L"Invalid hostname:port\n");
goto Cleanup;
}
wprintf(L"DNS Bootstrapping from: %s:%i\n",pwszBootstrapHostname, usBootstrapPort);
FlushCurrentLine();
hr = DrtCreateDnsBootstrapResolver(
usBootstrapPort,
pwszBootstrapHostname,
&Drt->settings.pBootstrapProvider
);
}
else if (Drt->BootstrapProviderType == 1) //PNRP Bootstrap Provider
{
wprintf(L"Enter a PNRP name for PNRP Bootstrap Provider (IE 0.DemoName)\n");
if(wscanf_s(L"%s",pwszBootstrapHostname, 1024) < 1)
{
FlushCurrentLine();
wprintf(L"Invalid PNRP name\n");
goto Cleanup;
}
wprintf(L"PNRP Bootstrapping from: %s\n",pwszBootstrapHostname);
FlushCurrentLine();
hr = DrtCreatePnrpBootstrapResolver(
TRUE,
pwszBootstrapHostname,
L"Global_",
NULL,
&Drt->settings.pBootstrapProvider
);
}
else if (Drt->BootstrapProviderType == 2) //Custom Bootstrap Provider
{
GetComputerNameEx(ComputerNameDnsFullyQualified, NULL, &dwSize );
pwszCompName = new WCHAR[dwSize+1];
::GetComputerNameEx(ComputerNameDnsFullyQualified, pwszCompName, &dwSize);
if(pwszCompName == NULL)
{
hr = E_OUTOFMEMORY;
wprintf(L"Out of memory");
goto Cleanup;
}
wprintf(L"Enter 'hostname port' for Custom Bootstrap Provider (currently %s %i\n", pwszCompName, Drt->port);
if(wscanf_s(L"%s %hu",pwszBootstrapHostname, 1024, &usBootstrapPort) < 2)
{
FlushCurrentLine();
hr = E_INVALIDARG;
wprintf(L"Invalid hostname:port\n");
goto Cleanup;
}
wprintf(L"Custom Bootstrapping from: %s:%i\n",pwszBootstrapHostname, usBootstrapPort);
FlushCurrentLine();
hr = DrtCreateCustomBootstrapResolver(
usBootstrapPort,
pwszBootstrapHostname,
&Drt->settings.pBootstrapProvider
);
}
else
{
wprintf(L"Invalid Bootstrap Provider passed to InitializeDrt");
hr = E_FAIL;
}
VERIFY_OR_ABORT("DrtCreateBootstrapResolver",hr);
//
// *Make sure the Windows Firewall is open*
// Also open port 3540 (used by PNRP, if the PNRP bootstrap provider is chosen)
//
if(Drt->BootstrapProviderType==1)
hr = OpenFirewallForDrtSdkSample(TRUE);
else
hr = OpenFirewallForDrtSdkSample(FALSE);
VERIFY_OR_ABORT("OpenFirewallForDrtSdkSample",hr);
//
// Open the DRT
//
Drt->eventHandle = CreateEvent(NULL, FALSE, FALSE, NULL);
if(NULL == Drt->eventHandle)
{
hr = E_OUTOFMEMORY;
goto Cleanup;
}
hr = DrtOpen(&Drt->settings, Drt->eventHandle, NULL, &Drt->hDrt);
VERIFY_OR_ABORT("DrtOpen", hr);
//
// Register a callback to handle DRT Events
//
RegisterWaitForSingleObject(&Drt->DrtWaitEvent, Drt->eventHandle, (WAITORTIMERCALLBACK)DrtEventCallback, Drt, INFINITE, WT_EXECUTEDEFAULT);
Cleanup:
if(pwszCompName)
delete pwszCompName;
return SUCCEEDED(hr);
}
/*
** Name: check_host
**
** Description:
** Test the characters in thehostnames as returned from
** the operating system.
**
** Inputs:
** None
**
** Output:
** error_msg pointer to the area where an error message should be
** copied
**
** Returns:
** None.
**
** History:
** 24-Jun-2002 (fanra01)
** Created.
** 07-Dec-2004 (wansh01)
** Bug 113521
** Changed nsize to MAX_COMPUTERNAME_LENGTH +1 for GetComputerName()
** for NT platform to avoid rc=10 error.
**
*/
static i4
check_host()
{
i4 result;
char compname[MAX_COMPNAME + 1] = { 0 };
char hostname[MAX_HOSTNAME + 1] = { 0 };
i4 nsize = MAX_COMPNAME;
#if defined(UNIX)
struct passwd *p_pswd, pwd;
char pwuid_buf[BUFSIZ];
int size = BUFSIZ;
#else
WSADATA wsadata;
WORD wVersionRequested;
#endif
#if defined(NT_GENERIC)
/*
** Get the computer name as defined for the system.
*/
nsize = MAX_COMPNAME + 1;
if (GetComputerNameEx( ComputerNameDnsHostname, compname, &nsize ))
{
/*
** Check the computer name for any characters that we do not support
*/
if (!CMvalidhostname( compname ))
{
result = II_INVALID_HOST;
return(result);
}
}
else
{
result = II_GET_COMPUTER_FAIL;
return(result);
}
/*
** Minimum version of the sockets implementation that we require.
*/
wVersionRequested = MAKEWORD( 1, 1 );
/*
** Check the version we require with the one that is available
*/
if (WSAStartup( wVersionRequested, &wsadata ) != 0)
{
result = II_GET_HOST_FAIL;
return(result);
}
#endif /* NT_GENERIC */
/*
** Get the network hostname
*/
nsize = MAX_HOSTNAME + 1;
if (gethostname( hostname, nsize ) == 0)
{
/*
** Check if the computer is defined as different from the network name
*/
#if defined(NT_GENERIC)
if (stricmp( compname, hostname ) != 0)
{
result = II_UNMATCHED_NAME;
return(result);
}
#endif /* NT_GENERIC */
/*
** Check if the hostname contains unsupported characters
*/
if (!CMvalidhostname( hostname ))
{
result = II_INVALID_HOST;
return(result);
}
}
else
{
result = II_GET_HOST_FAIL;
return(result);
}
result = II_SUCCESSFUL;
return(result);
}
static int start_root_smpd(char *host, int len, int *port, PROCESS_HANDLE_TYPE *pHnd)
{
mpiexec_rsh_rsmpd_args_t rsmpdArgs;
#ifdef HAVE_WINDOWS_H
DWORD dwLength = len;
#else
int pipe_fd[2];
int result;
#endif
if(!host){
smpd_err_printf("Invalid host name - NULL - provided\n");
return SMPD_FAIL;
}
if(len <= 0){
smpd_err_printf("Invalid host name length (%d) provided\n", len);
return SMPD_FAIL;
}
if(!port){
smpd_err_printf("Invalid port - NULL - provided\n");
return SMPD_FAIL;
}
if(!pHnd){
smpd_err_printf("Invalid pointer to process handle - NULL - provided\n");
return SMPD_FAIL;
}
#ifdef HAVE_WINDOWS_H
if(!(rsmpdArgs.hRootSMPDRdyEvent = CreateEvent(NULL, TRUE, FALSE, NULL))){
smpd_err_printf("unable to create the root listener synchronization event, error: %d\n",
GetLastError());
return SMPD_FAIL;
}
rsmpdArgs.pRootPort = port;
/* FIXME: Do we need a generic handle type for smpd thread/proc ? */
if(!(*pHnd = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)root_smpd, &rsmpdArgs, 0, NULL))){
smpd_err_printf("unable to create the root listener thread: error %d\n", GetLastError());
return SMPD_FAIL;
}
/* Wait for 1 minute for root smpd thread to start */
if (WaitForSingleObject(rsmpdArgs.hRootSMPDRdyEvent, 60000) != WAIT_OBJECT_0){
smpd_err_printf("the root process thread failed to initialize.\n");
return SMPD_FAIL;
}
CloseHandle(rsmpdArgs.hRootSMPDRdyEvent);
/*GetComputerName(host, &dwLength);*/
GetComputerNameEx(ComputerNameDnsFullyQualified, host, &dwLength);
#else
pipe(pipe_fd);
result = fork();
if (result == -1){
smpd_err_printf("unable to fork the root listener, errno %d\n", errno);
return SMPD_FAIL;
}
if (result == 0){
/* child process */
close(pipe_fd[0]); /* close the read end of the pipe */
rsmpdArgs.pipe_fd = pipe_fd[1];
result = root_smpd(&rsmpdArgs);
exit(result);
}
/* parent process */
PROCESS_HANDLE_SET_PID(*pHnd, result);
/* close the write end of the pipe */
close(pipe_fd[1]);
/* read the port from the root_smpd process */
readbuf(pipe_fd[0], port, sizeof(int));
/* read the kvs name */
readbuf(pipe_fd[0], smpd_process.kvs_name, SMPD_MAX_DBS_NAME_LEN);
/* close the read end of the pipe */
close(pipe_fd[0]);
gethostname(host, len);
#endif
return SMPD_SUCCESS;
}
int smpd_get_default_hosts()
{
char hosts[8192];
char *host;
char *ncpu;
smpd_host_node_t *cur_host, *iter;
#ifdef HAVE_WINDOWS_H
DWORD len;
#else
int dynamic = SMPD_FALSE;
char myhostname[SMPD_MAX_HOST_LENGTH];
int found;
#endif
smpd_enter_fn(FCNAME);
if (smpd_process.default_host_list != NULL && smpd_process.cur_default_host != NULL)
{
smpd_dbg_printf("default list already populated, returning success.\n");
smpd_exit_fn(FCNAME);
return SMPD_SUCCESS;
}
if (smpd_get_smpd_data("hosts", hosts, 8192) != SMPD_SUCCESS)
{
#ifdef HAVE_WINDOWS_H
len = 8192;
/*if (GetComputerName(hosts, &len))*/
if (GetComputerNameEx(ComputerNameDnsFullyQualified, hosts, &len))
{
smpd_process.default_host_list = (smpd_host_node_t*)MPIU_Malloc(sizeof(smpd_host_node_t));
if (smpd_process.default_host_list == NULL)
{
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
strcpy(smpd_process.default_host_list->host, hosts);
smpd_process.default_host_list->alt_host[0] = '\0';
smpd_process.default_host_list->nproc = 1;
smpd_process.default_host_list->connected = SMPD_FALSE;
smpd_process.default_host_list->connect_cmd_tag = -1;
smpd_process.default_host_list->next = smpd_process.default_host_list;
smpd_process.default_host_list->left = NULL;
smpd_process.default_host_list->right = NULL;
smpd_process.cur_default_host = smpd_process.default_host_list;
smpd_exit_fn(FCNAME);
return SMPD_SUCCESS;
}
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
#else
if (smpd_option_on("no_dynamic_hosts"))
{
if (smpd_get_hostname(myhostname, SMPD_MAX_HOST_LENGTH) == SMPD_SUCCESS)
{
smpd_process.default_host_list = (smpd_host_node_t*)MPIU_Malloc(sizeof(smpd_host_node_t));
if (smpd_process.default_host_list == NULL)
{
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
strcpy(smpd_process.default_host_list->host, myhostname);
smpd_process.default_host_list->alt_host[0] = '\0';
smpd_process.default_host_list->nproc = 1;
smpd_process.default_host_list->connected = SMPD_FALSE;
smpd_process.default_host_list->connect_cmd_tag = -1;
smpd_process.default_host_list->next = smpd_process.default_host_list;
smpd_process.default_host_list->left = NULL;
smpd_process.default_host_list->right = NULL;
smpd_process.cur_default_host = smpd_process.default_host_list;
smpd_exit_fn(FCNAME);
return SMPD_SUCCESS;
}
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
smpd_lock_smpd_data();
if (smpd_get_smpd_data(SMPD_DYNAMIC_HOSTS_KEY, hosts, 8192) != SMPD_SUCCESS)
{
smpd_unlock_smpd_data();
if (smpd_get_hostname(hosts, 8192) == 0)
{
smpd_process.default_host_list = (smpd_host_node_t*)MPIU_Malloc(sizeof(smpd_host_node_t));
if (smpd_process.default_host_list == NULL)
{
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
strcpy(smpd_process.default_host_list->host, hosts);
smpd_process.default_host_list->alt_host[0] = '\0';
smpd_process.default_host_list->nproc = 1;
smpd_process.default_host_list->connected = SMPD_FALSE;
smpd_process.default_host_list->connect_cmd_tag = -1;
smpd_process.default_host_list->next = smpd_process.default_host_list;
smpd_process.default_host_list->left = NULL;
smpd_process.default_host_list->right = NULL;
smpd_process.cur_default_host = smpd_process.default_host_list;
/* add this host to the dynamic_hosts key */
strcpy(myhostname, hosts);
smpd_lock_smpd_data();
hosts[0] = '\0';
smpd_get_smpd_data(SMPD_DYNAMIC_HOSTS_KEY, hosts, 8192);
if (strlen(hosts) > 0)
{
/* FIXME this could overflow */
strcat(hosts, " ");
strcat(hosts, myhostname);
}
else
{
strcpy(hosts, myhostname);
}
smpd_set_smpd_data(SMPD_DYNAMIC_HOSTS_KEY, hosts);
smpd_unlock_smpd_data();
smpd_exit_fn(FCNAME);
return SMPD_SUCCESS;
}
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
smpd_unlock_smpd_data();
if (smpd_get_hostname(myhostname, SMPD_MAX_HOST_LENGTH) != 0)
{
dynamic = SMPD_FALSE;
myhostname[0] = '\0';
}
else
{
dynamic = SMPD_TRUE;
}
#endif
}
/* FIXME: Insert code here to parse a compressed host string */
/* For now, just use a space separated list of host names */
host = strtok(hosts, " \t\r\n");
while (host)
{
cur_host = (smpd_host_node_t*)MPIU_Malloc(sizeof(smpd_host_node_t));
if (cur_host != NULL)
{
/*printf("default host: %s\n", host);*/
strcpy(cur_host->host, host);
cur_host->alt_host[0] = '\0';
cur_host->nproc = 1;
ncpu = strstr(cur_host->host, ":");
if (ncpu)
{
*ncpu = '\0';
ncpu++;
cur_host->nproc = atoi(ncpu);
if (cur_host->nproc < 1)
cur_host->nproc = 1;
}
cur_host->connected = SMPD_FALSE;
cur_host->connect_cmd_tag = -1;
cur_host->next = NULL;
cur_host->left = NULL;
cur_host->right = NULL;
if (smpd_process.default_host_list == NULL)
{
smpd_process.default_host_list = cur_host;
}
else
{
iter = smpd_process.default_host_list;
while (iter->next)
iter = iter->next;
iter->next = cur_host;
}
}
host = strtok(NULL, " \t\r\n");
}
if (smpd_process.default_host_list)
{
#ifndef HAVE_WINDOWS_H
if (dynamic)
{
found = SMPD_FALSE;
iter = smpd_process.default_host_list;
while (iter)
{
if (strcmp(iter->host, myhostname) == 0)
{
found = SMPD_TRUE;
break;
}
iter = iter->next;
}
if (!found)
{
/* add this host to the dynamic_hosts key */
smpd_lock_smpd_data();
hosts[0] = '\0';
smpd_get_smpd_data(SMPD_DYNAMIC_HOSTS_KEY, hosts, 8192);
if (strlen(hosts) > 0)
{
/* FIXME this could overflow */
strcat(hosts, " ");
strcat(hosts, myhostname);
}
else
{
strcpy(hosts, myhostname);
}
smpd_set_smpd_data(SMPD_DYNAMIC_HOSTS_KEY, hosts);
smpd_unlock_smpd_data();
}
}
#endif
/* make the default list into a ring */
iter = smpd_process.default_host_list;
while (iter->next)
iter = iter->next;
iter->next = smpd_process.default_host_list;
/* point the cur_default_host to the first node in the ring */
smpd_process.cur_default_host = smpd_process.default_host_list;
}
smpd_exit_fn(FCNAME);
return SMPD_SUCCESS;
}
