findhostsdlg.cpp

MPICH是MPI的重要研究,提供了一系列的接口函数,为并行计算的实现提供了编程环境.

// FindHostsDlg.cpp : implementation file
//

#include "stdafx.h"
#include "MPIConfig.h"
#include "FindHostsDlg.h"
#include "DomainDlg.h"
#include "mpd.h"
#include "PwdDialog.h"
#include "mpdutil.h"
#include "qvs.h"
#include "MPDConnectionOptionsDlg.h"
#include "ConnectToHost.h"
#include "WildStrDlg.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CFindHostsDlg dialog


CFindHostsDlg::CFindHostsDlg(CWnd* pParent /*=NULL*/)
	: CDialog(CFindHostsDlg::IDD, pParent)
{
    //{{AFX_DATA_INIT(CFindHostsDlg)
    m_encoded_hosts = _T("");
	m_nofm = _T("");
	//}}AFX_DATA_INIT
    m_domain = "";
    m_num_threads = 0;
    m_hFindThread = NULL;
    m_bNeedPassword = false;
    m_bFastConnect = false;
    m_bInitDialogCalled = false;
    m_pszPhrase[0] = '\0';
    m_nPort = MPD_DEFAULT_PORT;
    m_num_items = 0;
    m_pImageList = NULL;
    m_bWildcard = false;
    m_wildstr = "*";
}


void CFindHostsDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CFindHostsDlg)
	DDX_Control(pDX, IDC_N_OF_M_STATIC, m_nofm_static);
	DDX_Control(pDX, IDC_PROGRESS, m_progress);
	DDX_Control(pDX, IDOK, m_ok_btn);
	DDX_Control(pDX, IDCANCEL, m_cancel_btn);
	DDX_Control(pDX, IDC_ENCODED_HOSTS, m_encoded_hosts_edit);
	DDX_Control(pDX, IDC_DOMAIN_HOST_LIST, m_list);
	DDX_Text(pDX, IDC_ENCODED_HOSTS, m_encoded_hosts);
	DDX_Text(pDX, IDC_N_OF_M_STATIC, m_nofm);
	//}}AFX_DATA_MAP
}


BEGIN_MESSAGE_MAP(CFindHostsDlg, CDialog)
	//{{AFX_MSG_MAP(CFindHostsDlg)
	ON_COMMAND(ID_FILE_CHANGEDOMAIN, OnChangedomain)
	ON_COMMAND(ID_FILE_EXIT, OnFileExit)
	ON_COMMAND(ID_FILE_FINDHOSTS, OnFindhosts)
	ON_COMMAND(ID_FILE_LOADLIST, OnLoadlist)
	ON_COMMAND(ID_FILE_SAVELIST, OnSavelist)
	ON_WM_SIZE()
	ON_COMMAND(ID_FILE_VERIFY, OnVerify)
	ON_NOTIFY(NM_CLICK, IDC_DOMAIN_HOST_LIST, OnClickDomainHostList)
	ON_COMMAND(ID_FILE_CONNECTIONOPTIONS, OnConnectionOptions)
	ON_COMMAND(ID_ACTION_WILDCARDSCANHOSTS, OnActionWildcardScanHosts)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CFindHostsDlg message handlers

void CFindHostsDlg::ParseRegistry()
{
    HKEY tkey;
    DWORD result, len;
    char path[MAX_PATH];
    
    // Set the defaults.
    m_nPort = MPD_DEFAULT_PORT;
    gethostname(m_pszHost, 100);
    
    m_bNeedPassword = true;

    // Open the root key
    if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, MPD_REGISTRY_KEY,
	0, KEY_ALL_ACCESS, &tkey) != ERROR_SUCCESS)
    {
	printf("Unable to open SOFTWARE\\MPICH\\MPD registry key, error %d\n", GetLastError());
	return;
    }
    
    // Read the port
    len = sizeof(int);
    result = RegQueryValueEx(tkey, "port", 0, NULL, (unsigned char *)&m_nPort, &len);
    
    // Read the passphrase
    len = 100;
    result = RegQueryValueEx(tkey, "phrase", 0, NULL, (unsigned char *)m_pszPhrase, &len);
    if (result == ERROR_SUCCESS)
	m_bNeedPassword = false;
    
    // Read the path
    len = MAX_PATH;
    result = RegQueryValueEx(tkey, "path", 0, NULL, (unsigned char *)path, &len);
    if (result == ERROR_SUCCESS)
    {
	m_filename = path;
	m_filename.TrimRight(".exe");
	m_filename += "_hosts.txt";
    }

    RegCloseKey(tkey);
}

void CFindHostsDlg::OnChangedomain() 
{
    CDomainDlg dlg;

    UpdateData();

    dlg.m_domain = m_domain;
    if (dlg.DoModal() == IDOK)
    {
	m_domain = dlg.m_domain;
	UpdateData(FALSE);
	Refresh();
    }
}

void CFindHostsDlg::OnFileExit() 
{
    EndDialog(IDOK);
}

#include <lmerr.h>
#include <lmcons.h>
#include <lmapibuf.h>
#include <lmserver.h>

#ifndef LMCSTR
#define LMCSTR LPCWSTR
#endif

void CFindHostsDlg::Refresh()
{
    DWORD num_read=0, total=0, size;
    int index;
    SERVER_INFO_100 *pBuf = NULL;
    char tBuf[100], tLocalHost[100];
    DWORD ret_val;

    UpdateData();

    HCURSOR hOldCursor = SetCursor( LoadCursor(NULL, IDC_WAIT) );
    
    if (m_domain == "")
    {
	ret_val = NetServerEnum(
	    NULL, 
	    100,
	    (LPBYTE*)&pBuf,
	    MAX_PREFERRED_LENGTH,
	    &num_read,
	    &total,
	    SV_TYPE_NT, 
	    NULL,
	    0);
    }
    else
    {
	WCHAR wDomain[100];
	mbstowcs(wDomain, m_domain, 100);
	ret_val = NetServerEnum(
	    NULL, 
	    100,
	    (LPBYTE*)&pBuf,
	    MAX_PREFERRED_LENGTH,
	    &num_read,
	    &total,
	    SV_TYPE_NT, 
	    (LMCSTR)wDomain,
	    0);
    }
    
    if (ret_val == NERR_Success)
    {
	size = 100;
	GetComputerName(tLocalHost, &size);
	m_list.DeleteAllItems();
	if (num_read == 0)
	{
	    //m_list.InsertItem(0, tLocalHost, 0);
	    //m_list.SetItemState(0, LVIS_SELECTED, LVIS_SELECTED);
	    InsertHost(tLocalHost);
	    SelectHost(tLocalHost);
	}
	else
	{
	    index = -1;
	    for (unsigned int i=0; i<num_read; i++)
	    {
		wcstombs(tBuf, (WCHAR*)pBuf[i].sv100_name, wcslen((WCHAR*)pBuf[i].sv100_name)+1);
		InsertHost(tBuf);
		/*
		index = m_list.InsertItem(0, tBuf, 0);
		if (stricmp(tBuf, tLocalHost) == 0)
		    index = ret_val;
		else
		    index = -1;
		*/
	    }
	    /*
	    if (index != -1)
	    {
		m_list.SetItemState(index, LVIS_SELECTED, LVIS_SELECTED);
	    }
	    */
	    SelectHost(tLocalHost);
	}
	NetApiBufferFree(pBuf);
    }
    else
    {
	sprintf(tBuf, "error: %d", ret_val);
	MessageBox(tBuf, "Unable to retrieve network host names");
    }
    
    SetCursor(hOldCursor);
}

static int wildcmp(LPCTSTR wild, LPCTSTR string)
{
    LPCTSTR cp;
    LPCTSTR mp;
    
    while ((*string) && (*wild != '*'))
    {
	if ((*wild != *string) && (*wild != '?'))
	{
	    return 0;
	}
	wild++;
	string++;
    }
    
    while (*string)
    {
	if (*wild == '*')
	{
	    if (!*++wild)
	    {
		return 1;
	    }
	    mp = wild;
	    cp = string+1;
	}
	else if ((*wild == *string) || (*wild == '?'))
	{
	    wild++;
	    string++;
	}
	else
	{
	    wild = mp;
	    string = cp++;
	}
    }
    
    while (*wild == '*')
    {
	wild++;
    }
    return !*wild;
}

struct FindThreadSingleArg
{
    CListCtrl *list;
    int i;
    HWND hWnd;
    int port;
    char phrase[100];
    bool fast;
    bool wildcard;
    CString wildstr;
};

void FindThreadSingle(FindThreadSingleArg *arg)
{
    TCHAR host[100];
    char str[100];
    SOCKET sock;
    
    if (arg->list->GetItemText(arg->i, 0, host, 100) == 0)
    {
	::PostMessage(arg->hWnd, WM_USER+1, arg->i, FALSE);
	delete arg;
	return;
    }

    if (arg->wildcard && (!wildcmp(arg->wildstr, host)))
    {
	::PostMessage(arg->hWnd, WM_USER+1, arg->i, FALSE);
	delete arg;
	return;
    }
    
    ::PostMessage(arg->hWnd, WM_USER+1, arg->i, TRUE);
    
    if (!ConnectToHost(host, arg->port, arg->phrase, &sock, arg->fast))
    {
	::PostMessage(arg->hWnd, WM_USER+1, arg->i, FALSE);
	delete arg;
	return;
    }
    
    if (WriteString(sock, "version") == SOCKET_ERROR)
    {
	printf("WriteString failed after attempting passphrase authentication: %d\n", WSAGetLastError());fflush(stdout);
	easy_closesocket(sock);
	::PostMessage(arg->hWnd, WM_USER+1, arg->i, FALSE);
	delete arg;
	return;
    }
    if (!ReadString(sock, str))
    {
	::PostMessage(arg->hWnd, WM_USER+1, arg->i, FALSE);
	delete arg;
	return;
    }
    WriteString(sock, "done");
    easy_closesocket(sock);
    
    if (mpd_version_string_to_int(str) == 0)
	::PostMessage(arg->hWnd, WM_USER+1, arg->i, FALSE);
    else
	::PostMessage(arg->hWnd, WM_USER+2, arg->i, TRUE);
    delete arg;
}

#define FIND_NUM_PER_THREAD MAXIMUM_WAIT_OBJECTS

void OnFindBtnThread(CFindHostsDlg *pDlg)
{
    int n;
    DWORD count = pDlg->m_list.GetItemCount();
    pDlg->m_num_threads = count;

    if (count < 1)
    {
	CloseHandle(pDlg->m_hFindThread);
	pDlg->m_hFindThread = NULL;
	return;
    }

    if (pDlg->m_bNeedPassword)
    {
	CPwdDialog dlg;
	dlg.DoModal();
	if (dlg.m_bUseDefault)
	    strcpy(pDlg->m_pszPhrase, MPD_DEFAULT_PASSPHRASE);
	else
	    strcpy(pDlg->m_pszPhrase, dlg.m_password);
    }

    DWORD dwThreadID;
    HANDLE hThread[FIND_NUM_PER_THREAD];
    int index;
    for (DWORD i=0; i<count; i++)
    {
	FindThreadSingleArg *arg = new FindThreadSingleArg;
	arg->wildcard = pDlg->m_bWildcard;
	arg->wildstr = pDlg->m_wildstr;
	arg->hWnd = pDlg->m_hWnd;
	arg->list = &pDlg->m_list;
	arg->i = i;
	arg->port = pDlg->m_nPort;
	arg->fast = pDlg->m_bFastConnect;
	if (strlen(pDlg->m_pszPhrase) < 100)
	    strcpy(arg->phrase, pDlg->m_pszPhrase);
	else
	    arg->phrase[0] = '\0';
	index = i % FIND_NUM_PER_THREAD;
	hThread[index] = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)FindThreadSingle, arg, 0, &dwThreadID);
	if (hThread[index] == NULL)
	{
	    pDlg->m_num_threads--;
	    ::PostMessage(arg->hWnd, WM_USER+1, arg->i, FALSE);
	    delete arg;
	}
	if (index == FIND_NUM_PER_THREAD-1)
	{
	    WaitForMultipleObjects(FIND_NUM_PER_THREAD, hThread, TRUE, 120000);
	    for (n=0; n<FIND_NUM_PER_THREAD; n++)
		CloseHandle(hThread[n]);
	}
    }

    CloseHandle(pDlg->m_hFindThread);
    pDlg->m_hFindThread = NULL;
}

void CFindHostsDlg::OnActionWildcardScanHosts() 
{
    DWORD dwThreadID;
    CWildStrDlg dlg;

    dlg.m_wildstr = m_wildstr;
    if (dlg.DoModal() == IDOK)
    {
	m_bWildcard = true;
	m_wildstr = dlg.m_wildstr;
	
	UpdateData();