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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Telnet客户端 > 查看源码
CTelnetView.cpp
资源名称：telnetClient　[点击查看]
上传用户：cbyxjia
上传日期：2007-01-14
资源大小：132k
文件大小：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. if(cSock != NULL)
  64. delete cSock;
  65. cSock = NULL;
  66. }
  68. BOOL CTelnetView::PreCreateWindow(CREATESTRUCT& cs)
  69. {
  70. // TODO: Modify the Window class or styles here by modifying
  71. //  the CREATESTRUCT cs
  73. return CScrollView::PreCreateWindow(cs);
  74. }
  76. /////////////////////////////////////////////////////////////////////////////
  77. // CTelnetView drawing
  79. void CTelnetView::OnDraw(CDC* pDC)
  80. {
  81. CTelnetDoc* pDoc = GetDocument();
  82. ASSERT_VALID(pDoc);
  84. pDC->SelectObject(GetStockObject(ANSI_FIXED_FONT));
  86. DrawCursor(pDC,FALSE);
  87. DoDraw(pDC);
  88. DrawCursor(pDC,TRUE);
  89. }
  91. void CTelnetView::DoDraw(CDC* pDC)
  92. {
  93. CString strLine;
  94. BOOL bSkip = FALSE;
  95. CRect clip;
  96. pDC->GetClipBox(clip);
  97. clip.top -= dtY;
  99. pDC->SetTextColor(cTextColor);
  100. pDC->SetBkColor(cBackgroundColor);
  102. char text[2] = {0x00, 0x00};
  104. for(int y = 0; y < bufferLines; y++)
  105. {
  106. if(y * dtY >= clip.top)
  107. {
  108. for(int x = 0; x < 80; x++)
  109. {
  110. text[0] = cText[x][y];
  111. if(text[0] == 27)
  112. bSkip = TRUE;
  113. if(!bSkip)
  114. strLine += text[0];
  115. if(text[0] == 'm' && bSkip)
  116. bSkip = FALSE;
  117. }
  118. pDC->TextOut(0, y * dtY, strLine);
  119. strLine.Empty();
  120. }
  121. }
  122. }
  124. void CTelnetView::OnInitialUpdate()
  125. {
  126. CScrollView::OnInitialUpdate();
  127. CSize sizeTotal;
  128. // TODO: calculate the total size of this view
  129. sizeTotal.cx = dtX * 80 + 3;
  130. sizeTotal.cy = dtY * bufferLines + 3;
  131. SetScrollSizes(MM_TEXT, sizeTotal);
  133. ScrollToPosition(CPoint(0, bufferLines * 1000)); //go way past the end
  135. CHostDialog host;
  136. host.DoModal();
  137. cHostName = host.m_HostName;
  139. //create the socket and hook up to the host
  140. BOOL bOK;
  141. cSock = new CClientSocket(this);
  142. if(cSock != NULL)
  143. {
  144. bOK = cSock->Create();
  145. if(bOK == TRUE)
  146. {
  147. cSock->AsyncSelect(FD_READ | FD_WRITE | FD_CLOSE | FD_CONNECT | FD_OOB);
  148. cSock->Connect(cHostName, 23);
  149. GetDocument()->SetTitle(cHostName);
  150. Sleep(90);
  151. }
  152. else
  153. {
  154. ASSERT(FALSE);  //Did you remember to call AfxSocketInit()?
  155. delete cSock;
  156. cSock = NULL;
  157. }
  158. }
  159. else
  160. {
  161. AfxMessageBox("Could not create new socket",MB_OK);
  162. }
  164. }
  166. /////////////////////////////////////////////////////////////////////////////
  167. // CTelnetView printing
  169. BOOL CTelnetView::OnPreparePrinting(CPrintInfo* pInfo)
  170. {
  171. // default preparation
  172. return DoPreparePrinting(pInfo);
  173. }
  175. void CTelnetView::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
  176. {
  177. // TODO: add extra initialization before printing
  178. }
  180. void CTelnetView::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
  181. {
  182. // TODO: add cleanup after printing
  183. }
  185. /////////////////////////////////////////////////////////////////////////////
  186. // CTelnetView diagnostics
  188. #ifdef _DEBUG
  189. void CTelnetView::AssertValid() const
  190. {
  191. CScrollView::AssertValid();
  192. }
  194. void CTelnetView::Dump(CDumpContext& dc) const
  195. {
  196. CScrollView::Dump(dc);
  197. }
  199. CTelnetDoc* CTelnetView::GetDocument() // non-debug version is inline
  200. {
  201. ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CTelnetDoc)));
  202. return (CTelnetDoc*)m_pDocument;
  203. }
  204. #endif //_DEBUG
  206. /////////////////////////////////////////////////////////////////////////////
  207. // CTelnetView message handlers
  211. void CTelnetView::ProcessMessage(CClientSocket * pSock)
  212. {
  213. if(!IsWindow(m_hWnd)) return;
  214. if(!IsWindowVisible()) return;
  215. int nBytes = pSock->Receive(m_bBuf ,ioBuffSize );
  216. if(nBytes != SOCKET_ERROR)
  217. {
  218. int ndx = 0;
  219. while(GetLine(m_bBuf, nBytes, ndx) != TRUE);
  220. ProcessOptions();
  221. MessageReceived(m_strNormalText);
  222. }
  223. m_strLine.Empty();
  224. m_strResp.Empty();
  225. }
  228. void CTelnetView::ProcessOptions()
  229. {
  230. CString m_strTemp;
  231. CString m_strOption;
  232. unsigned char ch;
  233. int ndx;
  234. int ldx;
  235. BOOL bScanDone = FALSE;
  237. m_strTemp = m_strLine;
  239. while(!m_strTemp.IsEmpty() && bScanDone != TRUE)
  240. {
  241. ndx = m_strTemp.Find(IAC);
  242. if(ndx != -1)
  243. {
  244. m_strNormalText += m_strTemp.Left(ndx);
  245. ch = m_strTemp.GetAt(ndx + 1);
  246. switch(ch)
  247. {
  248. case DO:
  249. case DONT:
  250. case WILL:
  251. case WONT:
  252. m_strOption = m_strTemp.Mid(ndx, 3);
  253. m_strTemp = m_strTemp.Mid(ndx + 3);
  254. m_strNormalText = m_strTemp.Left(ndx);
  255. m_ListOptions.AddTail(m_strOption);
  256. break;
  257. case IAC:
  258. m_strNormalText = m_strTemp.Left(ndx);
  259. m_strTemp = m_strTemp.Mid(ndx + 1);
  260. break;
  261. case SB:
  262. m_strNormalText = m_strTemp.Left(ndx);
  263. ldx = Find(m_strTemp, SE);
  264. m_strOption = m_strTemp.Mid(ndx, ldx);
  265. m_ListOptions.AddTail(m_strOption);
  266. m_strTemp = m_strTemp.Mid(ldx);
  267. //AfxMessageBox(m_strOption,MB_OK);
  268. break;
  269. default:
  270. bScanDone = TRUE;
  271. }
  272. }
  273. else
  274. {
  275. m_strNormalText = m_strTemp;
  276. bScanDone = TRUE;
  277. }
  278. } 
  280. RespondToOptions();
  281. }
  284. void CTelnetView::RespondToOptions()
  285. {
  286. CString strOption;
  288. while(!m_ListOptions.IsEmpty())
  289. {
  290. strOption = m_ListOptions.RemoveHead();
  292. ArrangeReply(strOption);
  293. }
  295. DispatchMessage(m_strResp);
  296. m_strResp.Empty();
  297. }
  299. void CTelnetView::ArrangeReply(CString strOption)
  300. {
  302. unsigned char Verb;
  303. unsigned char Option;
  304. unsigned char Modifier;
  305. unsigned char ch;
  306. BOOL bDefined = FALSE;
  308. if(strOption.GetLength() < 3) return;
  310. Verb = strOption.GetAt(1);
  311. Option = strOption.GetAt(2);
  313. switch(Option)
  314. {
  315. case 1: // Echo
  316. case 3: // Suppress Go-Ahead
  317. bDefined = TRUE;
  318. break;
  319. }
  321. m_strResp += IAC;
  323. if(bDefined == TRUE)
  324. {
  325. switch(Verb)
  326. {
  327. case DO:
  328. ch = WILL;
  329. m_strResp += ch;
  330. m_strResp += Option;
  331. break;
  332. case DONT:
  333. ch = WONT;
  334. m_strResp += ch;
  335. m_strResp += Option;
  336. break;
  337. case WILL:
  338. ch = DO;
  339. m_strResp += ch;
  340. m_strResp += Option;
  341. break;
  342. case WONT:
  343. ch = DONT;
  344. m_strResp += ch;
  345. m_strResp += Option;
  346. break;
  347. case SB:
  348. Modifier = strOption.GetAt(3);
  349. if(Modifier == SEND)
  350. {
  351. ch = SB;
  352. m_strResp += ch;
  353. m_strResp += Option;
  354. m_strResp += IS;
  355. m_strResp += IAC;
  356. m_strResp += SE;
  357. }
  358. break;
  359. }
  360. }
  362. else
  363. {
  364. switch(Verb)
  365. {
  366. case DO:
  367. ch = WONT;
  368. m_strResp += ch;
  369. m_strResp += Option;
  370. break;
  371. case DONT:
  372. ch = WONT;
  373. m_strResp += ch;
  374. m_strResp += Option;
  375. break;
  376. case WILL:
  377. ch = DONT;
  378. m_strResp += ch;
  379. m_strResp += Option;
  380. break;
  381. case WONT:
  382. ch = DONT;
  383. m_strResp += ch;
  384. m_strResp += Option;
  385. break;
  386. }
  387. }
  388. }
  390. //send to the telnet server
  391. void CTelnetView::DispatchMessage(CString strText)
  392. {
  393. ASSERT(cSock);
  394. cSock->Send(strText, strText.GetLength());
  395. }
  397. BOOL CTelnetView::GetLine( unsigned char * bytes, int nBytes, int& ndx )
  398. {
  399. BOOL bLine = FALSE;
  400. while ( bLine == FALSE && ndx < nBytes )
  401. {
  402. unsigned char ch = bytes[ndx];
  404. switch( ch )
  405. {
  406. case 'r': // ignore
  407. m_strLine += "rn"; //"CR";
  408. break;
  409. case 'n': // end-of-line
  410. break;
  411. default:   // other....
  412. m_strLine += ch;
  413. break;
  414. } 
  416. ndx ++;
  418. if (ndx == nBytes)
  419. {
  420. bLine = TRUE;
  421. }
  422. }
  423. return bLine;
  424. }
  426. void CTelnetView::MessageReceived(LPCSTR pText)
  427. {
  428. BOOL bSkip = FALSE;
  429. CDC * pDC = GetDC();
  430. OnPrepareDC(pDC);
  431. DrawCursor(pDC,FALSE);
  432. CMainFrame * frm = (CMainFrame*)GetTopLevelFrame();
  433. pDC->SetTextColor(cTextColor);
  434. pDC->SetBkColor(cBackgroundColor);
  436. pDC->SelectObject(GetStockObject(ANSI_FIXED_FONT));
  437. int length = strlen(pText);
  438. char text[2] = {0x00, 0x00};
  439. for(int loop = 0; loop < length; loop++)
  440. {
  441. switch(pText[loop])
  442. {
  443. case 8: //Backspace
  444. cCursX--;
  445. if(cCursX < 0) cCursX = 0;
  446. break;
  447. case 9: //TAB
  448. cCursX++; //TBD make this smarter
  449. break;
  450. case 13: //CR
  451. m_strline.Empty();
  452. cCursX = 0;
  453. break;
  454. case 27:
  455. bSkip = TRUE;
  456. break;
  457. case 10: //LF
  458. {
  459. for(int row = 0; row < bufferLines-1; row++)
  460. {
  461. for(int  col = 0; col < 80; col++)
  462. {
  463. cText[col][row] = cText[col][row+1];
  464. }
  465. }
  466. for(int  col = 0; col < 80; col++)
  467. {
  468. cText[col][bufferLines-1] = ' ';
  469. }
  470. DoDraw(pDC);
  471. }
  472. break;
  473. case 'H':
  474. case 'K':
  475. case 'm':
  476. if(bSkip){
  477. bSkip = FALSE;
  478. break;
  479. }
  480. default:
  481. {
  482. if(!bSkip){
  483. cText[cCursX][bufferLines-1] = pText[loop];
  484. text[0] = cText[cCursX][bufferLines-1];
  485. m_strline += text[0];
  486. pDC->TextOut(0, (bufferLines-1) * dtY, m_strline);
  487. cCursX++;
  488. }
  490. if(cCursX >= 80)
  491. {
  492. // pDC->TextOut(0, (bufferLines-1) * dtY, m_strline);
  493. m_strline.Empty();
  494. for(int row = 0; row < bufferLines-1; row++)
  495. {
  496. for(int  col = 0; col < 80; col++)
  497. {
  498. cText[col][row] = cText[col][row+1];
  499. }
  500. }
  501. for(int  col = 0; col < 80; col++)
  502. {
  503. cText[col][bufferLines-1] = ' ';
  504. }
  505. cCursX = 0;
  506. DoDraw(pDC);
  507. }
  508. }
  509. break;
  510. }
  511. }
  512. DrawCursor(pDC,TRUE);
  513. ReleaseDC(pDC);
  514. }
  516. void CTelnetView::OnChar(UINT nChar, UINT nRepCnt, UINT nFlags) 
  517. {
  518. if (nChar == VK_RETURN)
  519. {
  520. DispatchMessage("rn");
  521. }
  522. else
  523. {
  524. DispatchMessage(nChar);
  525. }
  526. }
  528. void CTelnetView::DrawCursor(CDC * pDC, BOOL pDraw)
  529. {
  530. COLORREF color;
  531. CMainFrame * frm = (CMainFrame*)GetTopLevelFrame();
  532. if(pDraw) //draw
  533. {
  534. color = cTextColor;
  535. }
  536. else //erase
  537. {
  538. color = cBackgroundColor;
  539. }
  540. CRect rect(cCursX * dtX + 2, (bufferLines-1) * dtY + 1, 
  541. cCursX * dtX + dtX - 2, (bufferLines-1) * dtY + dtY -1);
  542. pDC->FillSolidRect(rect, color);
  543. }
  545. void CTelnetView::OnSize(UINT nType, int cx, int cy) 
  546. {
  547. CScrollView::OnSize(nType, cx, cy);
  548. if(IsWindow(m_hWnd))
  549. {
  550. if(IsWindowVisible())
  551. {
  552. ScrollToPosition(CPoint(0, bufferLines * 1000)); //go way past the end
  553. }
  554. }
  555. }
  557. BOOL CTelnetView::OnEraseBkgnd(CDC* pDC) 
  558. {
  559. CRect clip;
  560. pDC->GetClipBox(clip);
  561. CMainFrame * frm = (CMainFrame*)GetTopLevelFrame();
  562. pDC->FillSolidRect(clip,cBackgroundColor);
  563. return TRUE;
  564. }
  566. int CTelnetView::Find(CString str, char ch)
  567. {
  568. char* data = str.GetBuffer(0);
  569. int len = str.GetLength();
  570. int i = 0;
  571. for(i = 0; i < len; i++){
  572. if(data[i] == ch)
  573. break;
  574. }
  575. str.ReleaseBuffer();
  576. return i;
  577. }