开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Telnet客户端 > 查看源码
CTelnetView.cpp
资源名称：telnet_client.rar　[点击查看]
上传用户：dzbfjx
上传日期：2015-04-22
资源大小：42k
文件大小：11k
源码类别：

Telnet客户端

开发平台：

Visual C++

CTelnetView.cpp：源码内容
  1. // CTelnetView.cpp : implementation of the CTelnetView class
  2. //
  4. #include "stdafx.h"
  5. #include "CTelnet.h"
  7. #include "CTelnetDoc.h"
  8. #include "CTelnetView.h"
  9. #include "MainFrm.h"
  10. #include "ClientSocket.h"
  11. #include "Process.h"
  13. #include "HostDialog.h"
  15. #ifdef _DEBUG
  16. #define new DEBUG_NEW
  17. #undef THIS_FILE
  18. static char THIS_FILE[] = __FILE__;
  19. #endif
  21. extern CMultiDocTemplate * pDocTemplate;
  24. /////////////////////////////////////////////////////////////////////////////
  25. // CTelnetView
  27. IMPLEMENT_DYNCREATE(CTelnetView, CScrollView)
  29. BEGIN_MESSAGE_MAP(CTelnetView, CScrollView)
  30. //{{AFX_MSG_MAP(CTelnetView)
  31. ON_WM_CHAR()
  32. ON_WM_SIZE()
  33. ON_WM_ERASEBKGND()
  34. //}}AFX_MSG_MAP
  35. // Standard printing commands
  36. ON_COMMAND(ID_FILE_PRINT, CScrollView::OnFilePrint)
  37. ON_COMMAND(ID_FILE_PRINT_DIRECT, CScrollView::OnFilePrint)
  38. ON_COMMAND(ID_FILE_PRINT_PREVIEW, CScrollView::OnFilePrintPreview)
  39. END_MESSAGE_MAP()
  41. /////////////////////////////////////////////////////////////////////////////
  42. // CTelnetView construction/destruction
  44. CTelnetView::CTelnetView()
  45. {
  46. cTextColor = RGB(200,200,000);
  47. cBackgroundColor = RGB(000,000,222);
  48. cSock = NULL;
  49. bOptionsSent = FALSE;
  50. TempCounter = 0;
  51. cCursX = 0;
  52. for(int x = 0; x < 80; x++)
  53. {
  54. for(int y = 0; y < bufferLines; y++)
  55. {
  56. cText[x][y] = ' ';
  57. }
  58. }
  59. }
  61. CTelnetView::~CTelnetView()
  62. {
  63. }
  65. BOOL CTelnetView::PreCreateWindow(CREATESTRUCT& cs)
  66. {
  67. // TODO: Modify the Window class or styles here by modifying
  68. //  the CREATESTRUCT cs
  70. return CScrollView::PreCreateWindow(cs);
  71. }
  73. /////////////////////////////////////////////////////////////////////////////
  74. // CTelnetView drawing
  76. void CTelnetView::OnDraw(CDC* pDC)
  77. {
  78. CTelnetDoc* pDoc = GetDocument();
  79. ASSERT_VALID(pDoc);
  81. // pDC->SelectObject(GetStockObject(SYSTEM_FONT));
  82. pDC->SelectObject(GetStockObject(ANSI_FIXED_FONT));
  84. DrawCursor(pDC,FALSE);
  85. DoDraw(pDC);
  86. DrawCursor(pDC,FALSE);
  87. }
  89. void CTelnetView::DoDraw(CDC* pDC)
  90. {
  91. CRect clip;
  92. pDC->GetClipBox(clip);
  93. clip.top -= dtY;
  95. pDC->SetTextColor(cTextColor);
  96. pDC->SetBkColor(cBackgroundColor);
  98. char text[2] = {0x00, 0x00};
  100. for(int y = 0; y < bufferLines; y++)
  101. {
  102. if(y * dtY >= clip.top)
  103. {
  104. for(int x = 0; x < 80; x++)
  105. {
  106. text[0] = cText[x][y];
  107. if(text[0] == ' ')
  108. {
  109. pDC->FillSolidRect(CRect(x * dtX, y * dtY, 
  110. x * dtX + dtX, y * dtY + dtY), 
  111. cBackgroundColor);
  112. }
  113. else
  114. {
  115. pDC->TextOut(x * dtX, y * dtY, text);
  116. }
  117. }
  118. }
  119. }
  120. }
  122. void CTelnetView::OnInitialUpdate()
  123. {
  124. CScrollView::OnInitialUpdate();
  125. CSize sizeTotal;
  126. // TODO: calculate the total size of this view
  127. sizeTotal.cx = dtX * 80 + 3;
  128. sizeTotal.cy = dtY * bufferLines + 3;
  129. SetScrollSizes(MM_TEXT, sizeTotal);
  131. ScrollToPosition(CPoint(0, bufferLines * 1000)); //go way past the end
  133. CHostDialog host;
  134. host.DoModal();
  135. cHostName = host.m_HostName;
  137. //create the socket and hook up to the host
  138. BOOL bOK;
  139. cSock = new CClientSocket(this);
  140. if(cSock != NULL)
  141. {
  142. bOK = cSock->Create();
  143. if(bOK == TRUE)
  144. {
  145. cSock->AsyncSelect(FD_READ | FD_WRITE | FD_CLOSE | FD_CONNECT | FD_OOB);
  146. cSock->Connect(cHostName, 23);
  147. GetDocument()->SetTitle(cHostName);
  148. Sleep(90);
  149. }
  150. else
  151. {
  152. ASSERT(FALSE);  //Did you remember to call AfxSocketInit()?
  153. delete cSock;
  154. cSock = NULL;
  155. }
  156. }
  157. else
  158. {
  159. AfxMessageBox("Could not create new socket",MB_OK);
  160. }
  162. }
  164. /////////////////////////////////////////////////////////////////////////////
  165. // CTelnetView printing
  167. BOOL CTelnetView::OnPreparePrinting(CPrintInfo* pInfo)
  168. {
  169. // default preparation
  170. return DoPreparePrinting(pInfo);
  171. }
  173. void CTelnetView::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
  174. {
  175. // TODO: add extra initialization before printing
  176. }
  178. void CTelnetView::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
  179. {
  180. // TODO: add cleanup after printing
  181. }
  183. /////////////////////////////////////////////////////////////////////////////
  184. // CTelnetView diagnostics
  186. #ifdef _DEBUG
  187. void CTelnetView::AssertValid() const
  188. {
  189. CScrollView::AssertValid();
  190. }
  192. void CTelnetView::Dump(CDumpContext& dc) const
  193. {
  194. CScrollView::Dump(dc);
  195. }
  197. CTelnetDoc* CTelnetView::GetDocument() // non-debug version is inline
  198. {
  199. ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CTelnetDoc)));
  200. return (CTelnetDoc*)m_pDocument;
  201. }
  202. #endif //_DEBUG
  204. /////////////////////////////////////////////////////////////////////////////
  205. // CTelnetView message handlers
  209. void CTelnetView::ProcessMessage(CClientSocket * pSock)
  210. {
  211. if(!IsWindow(m_hWnd)) return;
  212. if(!IsWindowVisible()) return;
  213. int nBytes = pSock->Receive(m_bBuf ,ioBuffSize );
  214. if(nBytes != SOCKET_ERROR)
  215. {
  216. int ndx = 0;
  217. while(GetLine(m_bBuf, nBytes, ndx) != TRUE);
  218. ProcessOptions();
  219. MessageReceived(m_strNormalText);
  220. }
  221. m_strLine.Empty();
  222. m_strResp.Empty();
  223. }
  226. void CTelnetView::ProcessOptions()
  227. {
  228. CString m_strTemp;
  229. CString m_strOption;
  230. unsigned char ch;
  231. int ndx;
  232. int ldx;
  233. BOOL bScanDone = FALSE;
  235. m_strTemp = m_strLine;
  237. while(!m_strTemp.IsEmpty() && bScanDone != TRUE)
  238. {
  239. ndx = m_strTemp.Find(IAC);
  240. if(ndx != -1)
  241. {
  242. m_strNormalText += m_strTemp.Left(ndx);
  243. ch = m_strTemp.GetAt(ndx + 1);
  244. switch(ch)
  245. {
  246. case DO:
  247. case DONT:
  248. case WILL:
  249. case WONT:
  250. m_strOption = m_strTemp.Mid(ndx, 3);
  251. m_strTemp = m_strTemp.Mid(ndx + 3);
  252. m_strNormalText = m_strTemp.Left(ndx);
  253. m_ListOptions.AddTail(m_strOption);
  254. break;
  255. case IAC:
  256. m_strNormalText = m_strTemp.Left(ndx);
  257. m_strTemp = m_strTemp.Mid(ndx + 1);
  258. break;
  259. case SB:
  260. m_strNormalText = m_strTemp.Left(ndx);
  261. ldx = m_strTemp.Find(SE);
  262. m_strOption = m_strTemp.Mid(ndx, ldx);
  263. m_ListOptions.AddTail(m_strOption);
  264. m_strTemp = m_strTemp.Mid(ldx);
  265. AfxMessageBox(m_strOption,MB_OK);
  266. break;
  267. }
  268. }
  270. else
  271. {
  272. m_strNormalText = m_strTemp;
  273. bScanDone = TRUE;
  274. }
  275. } 
  277. RespondToOptions();
  278. }
  281. void CTelnetView::RespondToOptions()
  282. {
  283. CString strOption;
  285. while(!m_ListOptions.IsEmpty())
  286. {
  287. strOption = m_ListOptions.RemoveHead();
  289. ArrangeReply(strOption);
  290. }
  292. DispatchMessage(m_strResp);
  293. m_strResp.Empty();
  294. }
  296. void CTelnetView::ArrangeReply(CString strOption)
  297. {
  299. unsigned char Verb;
  300. unsigned char Option;
  301. unsigned char Modifier;
  302. unsigned char ch;
  303. BOOL bDefined = FALSE;
  305. if(strOption.GetLength() < 3) return;
  307. Verb = strOption.GetAt(1);
  308. Option = strOption.GetAt(2);
  310. switch(Option)
  311. {
  312. case 1: // Echo
  313. case 3: // Suppress Go-Ahead
  314. bDefined = TRUE;
  315. break;
  316. }
  318. m_strResp += IAC;
  320. if(bDefined == TRUE)
  321. {
  322. switch(Verb)
  323. {
  324. case DO:
  325. ch = WILL;
  326. m_strResp += ch;
  327. m_strResp += Option;
  328. break;
  329. case DONT:
  330. ch = WONT;
  331. m_strResp += ch;
  332. m_strResp += Option;
  333. break;
  334. case WILL:
  335. ch = DO;
  336. m_strResp += ch;
  337. m_strResp += Option;
  338. break;
  339. case WONT:
  340. ch = DONT;
  341. m_strResp += ch;
  342. m_strResp += Option;
  343. break;
  344. case SB:
  345. Modifier = strOption.GetAt(3);
  346. if(Modifier == SEND)
  347. {
  348. ch = SB;
  349. m_strResp += ch;
  350. m_strResp += Option;
  351. m_strResp += IS;
  352. m_strResp += IAC;
  353. m_strResp += SE;
  354. }
  355. break;
  356. }
  357. }
  359. else
  360. {
  361. switch(Verb)
  362. {
  363. case DO:
  364. ch = WONT;
  365. m_strResp += ch;
  366. m_strResp += Option;
  367. break;
  368. case DONT:
  369. ch = WONT;
  370. m_strResp += ch;
  371. m_strResp += Option;
  372. break;
  373. case WILL:
  374. ch = DONT;
  375. m_strResp += ch;
  376. m_strResp += Option;
  377. break;
  378. case WONT:
  379. ch = DONT;
  380. m_strResp += ch;
  381. m_strResp += Option;
  382. break;
  383. }
  384. }
  385. }
  387. //send to the telnet server
  388. void CTelnetView::DispatchMessage(CString strText)
  389. {
  390. ASSERT(cSock);
  391. cSock->Send(strText, strText.GetLength());
  392. }
  394. BOOL CTelnetView::GetLine( unsigned char * bytes, int nBytes, int& ndx )
  395. {
  396. BOOL bLine = FALSE;
  397. while ( bLine == FALSE && ndx < nBytes )
  398. {
  399. unsigned char ch = bytes[ndx];
  401. switch( ch )
  402. {
  403. case 'r': // ignore
  404. m_strLine += "rn"; //"CR";
  405. break;
  406. case 'n': // end-of-line
  407. // m_strLine += 'n'; //"LF";
  408. // bLine = TRUE;
  409. break;
  410. default:   // other....
  411. m_strLine += ch;
  412. break;
  413. } 
  415. ndx ++;
  417. if (ndx == nBytes)
  418. {
  419. bLine = TRUE;
  420. }
  421. }
  422. return bLine;
  423. }
  425. void CTelnetView::MessageReceived(LPCSTR pText)
  426. {
  427. CDC * pDC = GetDC();
  428. OnPrepareDC(pDC);
  429. DrawCursor(pDC,FALSE);
  430. CMainFrame * frm = (CMainFrame*)GetTopLevelFrame();
  431. pDC->SetTextColor(cTextColor);
  432. pDC->SetBkColor(cBackgroundColor);
  434. // dc.SelectObject(GetStockObject(SYSTEM_FONT));
  435. pDC->SelectObject(GetStockObject(ANSI_FIXED_FONT));
  436. int length = strlen(pText);
  437. char text[2] = {0x00, 0x00};
  438. for(int loop = 0; loop < length; loop++)
  439. {
  440. switch(pText[loop])
  441. {
  442. case 8: //Backspace
  443. cCursX--;
  444. if(cCursX < 0) cCursX = 0;
  445. break;
  446. case 9: //TAB
  447. cCursX++; //TBD make this smarter
  448. break;
  449. case 13: //CR
  450. cCursX = 0;
  451. break;
  452. case 10: //LF
  453. {
  454. for(int row = 0; row < bufferLines-1; row++)
  455. {
  456. for(int  col = 0; col < 80; col++)
  457. {
  458. cText[col][row] = cText[col][row+1];
  459. }
  460. }
  461. for(int  col = 0; col < 80; col++)
  462. {
  463. cText[col][bufferLines-1] = ' ';
  464. }
  465. DoDraw(pDC);
  466. }
  467. break;
  468. default:
  469. {
  470. cText[cCursX][bufferLines-1] = pText[loop];
  471. text[0] = cText[cCursX][bufferLines-1];
  472. if(text[0] == ' ')
  473. {
  474. pDC->FillSolidRect(CRect(cCursX * dtX, (bufferLines-1) * dtY, 
  475. cCursX * dtX + dtX, (bufferLines-1) * dtY + dtY), 
  476. cBackgroundColor);
  477. }
  478. else
  479. {
  480. pDC->TextOut(cCursX * dtX, (bufferLines-1) * dtY, text);
  481. }
  482. cCursX++;
  483. if(cCursX >= 80)
  484. {
  485. for(int row = 0; row < bufferLines-1; row++)
  486. {
  487. for(int  col = 0; col < 80; col++)
  488. {
  489. cText[col][row] = cText[col][row+1];
  490. }
  491. }
  492. for(int  col = 0; col < 80; col++)
  493. {
  494. cText[col][bufferLines-1] = ' ';
  495. }
  496. cCursX = 0;
  497. DoDraw(pDC);
  498. }
  499. }
  500. break;
  501. }
  502. }
  503. DrawCursor(pDC,TRUE);
  504. ReleaseDC(pDC);
  505. }
  507. void CTelnetView::OnChar(UINT nChar, UINT nRepCnt, UINT nFlags) 
  508. {
  509. if (nChar == VK_RETURN)
  510. {
  511. DispatchMessage("rn");
  512. }
  513. else
  514. {
  515. DispatchMessage(nChar);
  516. }
  517. }
  519. void CTelnetView::DrawCursor(CDC * pDC, BOOL pDraw)
  520. {
  521. COLORREF color;
  522. CMainFrame * frm = (CMainFrame*)GetTopLevelFrame();
  523. if(pDraw) //draw
  524. {
  525. color = cTextColor;
  526. }
  527. else //erase
  528. {
  529. color = cBackgroundColor;
  530. }
  531. CRect rect(cCursX * dtX + 2, (bufferLines-1) * dtY + 1, 
  532. cCursX * dtX + dtX - 2, (bufferLines-1) * dtY + dtY -1);
  533. pDC->FillSolidRect(rect, color);
  534. }
  538. void CTelnetView::OnSize(UINT nType, int cx, int cy) 
  539. {
  540. CScrollView::OnSize(nType, cx, cy);
  541. if(IsWindow(m_hWnd))
  542. {
  543. if(IsWindowVisible())
  544. {
  545. ScrollToPosition(CPoint(0, bufferLines * 1000)); //go way past the end
  546. }
  547. }
  548. }
  550. BOOL CTelnetView::OnEraseBkgnd(CDC* pDC) 
  551. {
  552. CRect clip;
  553. pDC->GetClipBox(clip);
  554. CMainFrame * frm = (CMainFrame*)GetTopLevelFrame();
  555. pDC->FillSolidRect(clip,cBackgroundColor);
  556. return TRUE;
  557. }