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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 网络截获/分析 > 查看源码
SnifferDlg.cpp
资源名称：MSSniffer.zip　[点击查看]
上传用户：benyan892
上传日期：2010-01-28
资源大小：158k
文件大小：17k
源码类别：

网络截获/分析

开发平台：

Visual C++

SnifferDlg.cpp：源码内容
  1. // SnifferDlg.cpp : implementation file
  2. //
  4. #include "stdafx.h"
  5. #include "Sniffer.h"
  6. #include "SnifferDlg.h"
  8. #ifdef _DEBUG
  9. #define new DEBUG_NEW
  10. #endif
  13. inline CString GetNiceString(LPCTSTR pString)
  14. {
  15. const int numDots = 40 - _tcslen(pString);
  17. CString dotString(_T('.'),numDots);
  20. CString s = CString(pString) + dotString + CString(_T(" "));
  22. return s;
  23. }
  26. // CAboutDlg dialog used for App About
  28. class CAboutDlg : public CDialog
  29. {
  30. public:
  31. CAboutDlg();
  33. // Dialog Data
  34. enum { IDD = IDD_ABOUTBOX };
  36. protected:
  37. virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
  39. // Implementation
  40. protected:
  41. DECLARE_MESSAGE_MAP()
  42. };
  44. CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD)
  45. {
  46. }
  48. void CAboutDlg::DoDataExchange(CDataExchange* pDX)
  49. {
  50. CDialog::DoDataExchange(pDX);
  51. }
  53. BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)
  54. END_MESSAGE_MAP()
  57. // CSnifferDlg dialog
  61. CSnifferDlg::CSnifferDlg(CWnd* pParent /*=NULL*/)
  62. : CDialog(CSnifferDlg::IDD, pParent)
  63. , m_SelInterface(_T(""))
  64. {
  65. m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
  67. Init();
  68. }
  70. void CSnifferDlg::DoDataExchange(CDataExchange* pDX)
  71. {
  72. CDialog::DoDataExchange(pDX);
  73. DDX_Control(pDX, IDC_CMB_INTERFACES, m_CmbInterfaces);
  74. DDX_Control(pDX, IDC_FRM_INTERFACES, m_FrmInterfaces);
  75. DDX_Control(pDX, IDC_STARTSNIFFING, m_BtnStartSniffing);
  76. DDX_Control(pDX, IDC_TV_PACKETS, m_TVPackets);
  77. }
  79. BEGIN_MESSAGE_MAP(CSnifferDlg, CDialog)
  80. ON_WM_SYSCOMMAND()
  81. ON_WM_PAINT()
  82. ON_WM_QUERYDRAGICON()
  83. //}}AFX_MSG_MAP
  84. ON_WM_SIZE()
  85. ON_BN_CLICKED(IDC_STARTSNIFFING, OnBnClickedStartsniffing)
  86. ON_WM_CLOSE()
  87. END_MESSAGE_MAP()
  90. // CSnifferDlg message handlers
  92. BOOL CSnifferDlg::OnInitDialog()
  93. {
  94. CDialog::OnInitDialog();
  96. // Add "About..." menu item to system menu.
  98. // IDM_ABOUTBOX must be in the system command range.
  99. ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
  100. ASSERT(IDM_ABOUTBOX < 0xF000);
  102. CMenu* pSysMenu = GetSystemMenu(FALSE);
  103. if (pSysMenu != NULL)
  104. {
  105. CString strAboutMenu;
  106. strAboutMenu.LoadString(IDS_ABOUTBOX);
  107. if (!strAboutMenu.IsEmpty())
  108. {
  109. pSysMenu->AppendMenu(MF_SEPARATOR);
  110. pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
  111. }
  112. }
  114. // Set the icon for this dialog.  The framework does this automatically
  115. //  when the application's main window is not a dialog
  116. SetIcon(m_hIcon, TRUE); // Set big icon
  117. SetIcon(m_hIcon, FALSE); // Set small icon
  119. // TODO: Add extra initialization here
  120. for ( int i = 0 ; i < m_Interfaces.GetSize(); i ++ )
  121. {
  122. m_CmbInterfaces.AddString( m_Interfaces.GetAt(i) );
  123. }
  125. m_CmbInterfaces.SetCurSel( 0 );
  127. m_IL.Create(16,16,ILC_COLOR32 | ILC_MASK, 0,1);
  129. m_IL.Add( LoadIcon(AfxGetInstanceHandle(), MAKEINTRESOURCE(IDI_COMP2COMP ) ) );
  130. m_IL.Add( LoadIcon(AfxGetInstanceHandle(), MAKEINTRESOURCE(IDI_IPHeader ) ) );
  131. m_IL.Add( LoadIcon(AfxGetInstanceHandle(), MAKEINTRESOURCE(IDI_TCPHEADER ) ) );
  133. m_TVPackets.SetImageList( &m_IL,TVSIL_NORMAL );
  135. // ShowWindow( SW_SHOWMAXIMIZED );
  136. ResizeForm();
  138. LOGFONT logFont;
  139. CFont* pFont = new CFont();
  141. RtlZeroMemory( &logFont, sizeof(logFont) );
  143. _tcscpy(logFont.lfFaceName, _T("Lucida Console"));
  144. logFont.lfHeight = 12;
  146. pFont->CreateFontIndirect( &logFont );
  148. m_TVPackets.SetFont( pFont, TRUE );
  153. return TRUE;  // return TRUE  unless you set the focus to a control
  154. }
  156. void CSnifferDlg::OnSysCommand(UINT nID, LPARAM lParam)
  157. {
  158. if ((nID & 0xFFF0) == IDM_ABOUTBOX)
  159. {
  160. CAboutDlg dlgAbout;
  161. dlgAbout.DoModal();
  162. }
  163. else
  164. {
  165. CDialog::OnSysCommand(nID, lParam);
  166. }
  167. }
  169. // If you add a minimize button to your dialog, you will need the code below
  170. //  to draw the icon.  For MFC applications using the document/view model,
  171. //  this is automatically done for you by the framework.
  173. void CSnifferDlg::OnPaint() 
  174. {
  175. if (IsIconic())
  176. {
  177. CPaintDC dc(this); // device context for painting
  179. SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0);
  181. // Center icon in client rectangle
  182. int cxIcon = GetSystemMetrics(SM_CXICON);
  183. int cyIcon = GetSystemMetrics(SM_CYICON);
  184. CRect rect;
  185. GetClientRect(&rect);
  186. int x = (rect.Width() - cxIcon + 1) / 2;
  187. int y = (rect.Height() - cyIcon + 1) / 2;
  189. // Draw the icon
  190. dc.DrawIcon(x, y, m_hIcon);
  191. }
  192. else
  193. {
  194. CDialog::OnPaint();
  195. }
  196. }
  198. // The system calls this function to obtain the cursor to display while the user drags
  199. //  the minimized window.
  200. HCURSOR CSnifferDlg::OnQueryDragIcon()
  201. {
  202. return static_cast<HCURSOR>(m_hIcon);
  203. }
  205. // Starts the sniffing process
  206. bool CSnifferDlg::StartSniffing(void)
  207. {
  208. SOCKET        s = INVALID_SOCKET;
  209. WSABUF        wbuf = {0};
  210. DWORD         dwBytesRet = 0, dwFlags = 0;
  211. unsigned int  optval = 0;
  212. char         *rcvbuf=NULL;
  213. int           rc = 0, err;
  217. if ( m_ulFilterMask & (FILTER_MASK_SOURCE_ADDRESS | FILTER_MASK_SOURCE_PORT) )
  218. {
  219. printf("Source address filter     : ");
  220. //PrintAddress((SOCKADDR *)&m_saSourceAddress, sizeof(m_saSourceAddress));
  221. printf("n");
  222. }
  223. if ( m_ulFilterMask & (FILTER_MASK_DESTINATION_ADDRESS | FILTER_MASK_DESTINATION_PORT) )
  224. {
  225. printf("Destination address filter: ");
  226. //PrintAddress((SOCKADDR *)&g_saDestinationAddress, sizeof(g_saDestinationAddress));
  227. printf("n");
  228. }
  230. //
  231. // Create a raw socket for receiving IP datagrams
  232. //
  233. s = WSASocket(AF_INET, SOCK_RAW, IPPROTO_IP, NULL, 0, WSA_FLAG_OVERLAPPED);
  234. if (s == INVALID_SOCKET)
  235. {
  236. printf("WSASocket() failed: %dn", WSAGetLastError());
  237. return false;
  238. }
  240. //
  241. // This socket MUST be bound before calling the ioctl
  242. //
  244. sockaddr_in sa;
  245. sa.sin_family = AF_INET;
  246. sa.sin_addr.s_addr = inet_addr(m_SelInterface);
  247. sa.sin_port = INADDR_ANY;//htons(7000);
  249. rc = bind(s, (SOCKADDR *)&sa, sizeof(sa));
  250. if (rc == SOCKET_ERROR)
  251. {
  252. printf("bind() failed: %dn", WSAGetLastError());
  253. if (INVALID_SOCKET != s)
  254. {
  255. closesocket(s);
  256. s = INVALID_SOCKET;
  257. }
  258. WSACleanup();
  259. return false;
  260. }
  261. printf("Binding to: ");
  262. //PrintAddress((SOCKADDR *)&g_saLocalInterface, sizeof(g_saLocalInterface));
  263. printf("n");
  265. //
  266. // Set the SIO_RCVALLxxx ioctl
  267. //
  268. optval = 1;
  269. rc = WSAIoctl(s, SIO_RCVALL, &optval, sizeof(optval),
  270. NULL, 0, &dwBytesRet, NULL, NULL);
  271. if (rc == SOCKET_ERROR)
  272. {
  273. printf("WSAIotcl(0x%x) failed: %dn", SIO_RCVALL,
  274. (err = WSAGetLastError()));
  275. if (err == WSAEINVAL)
  276. {
  277. printf("NOTE: IPv6 does not currently support the SIO_RCVALL* ioctlsn");
  278. }
  280. if (INVALID_SOCKET != s)
  281. {
  282. closesocket(s);
  283. s = INVALID_SOCKET;
  284. }
  285. WSACleanup();
  286. return false;
  287. }
  289. //
  290. // Allocate a buffer for receiving data
  291. //
  292. rcvbuf = (char *)HeapAlloc(GetProcessHeap(), 0, MAX_IP_SIZE);
  293. if (rcvbuf == NULL)
  294. {
  295. fprintf(stderr, "HeapAlloc failed: %dn", GetLastError());
  296. if (INVALID_SOCKET != s)
  297. {
  298. closesocket(s);
  299. s = INVALID_SOCKET;
  300. }
  301. WSACleanup();
  302. return false;
  303. }
  305. //
  306. // Start receiving IP datagrams until interrupted
  307. // 
  308. while ( !m_bExit )
  309. {
  310. wbuf.len = MAX_IP_SIZE;
  311. wbuf.buf = rcvbuf;
  312. dwFlags  = 0;
  314. rc = WSARecv(s, &wbuf, 1, &dwBytesRet, &dwFlags, NULL, NULL);
  315. if (rc == SOCKET_ERROR)
  316. {
  317. printf("WSARecv() failed: %dn", WSAGetLastError());
  318. break;
  319. }
  321. DecodePacket(rcvbuf , dwBytesRet );
  324. }
  325. //
  326. // Cleanup
  327. //
  329. if (rcvbuf) 
  330. HeapFree(GetProcessHeap(), 0, rcvbuf);
  332. if (INVALID_SOCKET != s)
  333. {
  334. closesocket(s);
  335. s = INVALID_SOCKET;
  336. }
  337. WSACleanup();
  339. return true;
  340. }
  342. bool CSnifferDlg::Init(void)
  343. {
  344. try
  345. {
  346. m_bExit = false;
  347. m_hThread = NULL;
  348. m_dwThreadID = 0;
  350. m_ulFilterMask = 0;
  352. m_Logger.Open( _T("Logger.txt"),CFile::modeCreate | CFile::modeWrite | CFile::shareDenyNone);
  354. int           rc = 0;
  355. WSADATA       wsd;
  356. //
  357. // Load Winsock
  358. //
  359. if ((rc = WSAStartup(MAKEWORD(2,2), &wsd)) != 0)
  360. {
  361. printf("WSAStartup() failed: %dn", rc);
  362. return false;
  363. }
  365. GetInterfaces( m_Interfaces );
  368. return true;
  369. }
  370. catch(...)
  371. {
  372. return false;
  373. }
  375. }
  377. // Decodes the packet
  378. bool CSnifferDlg::DecodePacket(char* pData, DWORD dwSize)
  379. {
  381. try
  382. {
  384. if (dwSize < sizeof(char))
  385. return false;
  387. // Check the IP version
  388. const int ip_version = HI_BYTE(*pData);
  390. CString source, destination;
  392. if ( ip_version == 4)
  393. {
  394. IPV4_HDR* pHeader;
  395. int headerLen = 0;
  398. // Verify the buffer is large enough
  399. if (dwSize  < sizeof(IPV4_HDR))
  400. return false;
  402. // Get length of IPv4 header to determine where next protocol header begins
  403. headerLen = LO_BYTE(*pData) * 4;
  405. pHeader = (IPV4_HDR *)pData;
  407. ConvertAddress( pHeader->ip_srcaddr, source );
  408. ConvertAddress( pHeader->ip_destaddr, destination);
  410. switch (pHeader->ip_protocol)
  411. {
  413. case IPPROTO_TCP:
  415. TCP_HDR* pTCPHeader;
  417. pTCPHeader = (TCP_HDR *) &pData[headerLen];
  419. ParseTCPPacket(source, destination, pTCPHeader, pData, dwSize - headerLen );
  421. break;
  423. default:
  425. //TRACE(_T("Not a TCP packet"));
  426. return false;
  428. }
  430. }
  431. else
  432. {
  433. //TRACE( _T("IP version 6") );
  434. return false;
  435. }
  437. /*
  438. struct in_addr sa4 = {0};
  440. char* pAddress = NULL;
  442. // sa4.S_un.sin_family = AF_INET;
  443. //    sa4.sin_port   = 0;
  445. sa4.S_un.S_addr = pIPHeader->ip_srcaddr;
  447. pAddress = inet_ntoa( sa4);
  448. */
  449. return true;
  450. }
  451. catch(...)
  452. {
  453. return false;
  454. }
  457. }
  460. bool CSnifferDlg::ParseTCPPacket(const CString& source, const CString& destination, TCP_HDR* pTCPHeader, char* pData, unsigned long len )
  461. {
  462. try
  463. {
  464. if ( len < sizeof(*pTCPHeader) )
  465. return false;
  467. len -= sizeof(*pTCPHeader);
  468. pData += sizeof(*pTCPHeader);
  470. unsigned int sourcePort, destPort;
  472. sourcePort = htons(pTCPHeader->src_portno);
  473. destPort = htons(pTCPHeader->dest_portno);
  475. // if ( sourcePort != 25 && destPort != 25 )
  476. // return false;
  478. Session* pSide = NULL;
  479. CString strError;
  481. INT_PTR arrayIndex = -1;
  483. for ( int i = 0 ; i < m_Array.GetSize(); i++ )
  484. {
  485. Session* pCur = m_Array.GetAt(i);
  487. if ( pCur->sourceIP == source && pCur->sourcePort == sourcePort 
  488. && pCur->destIP == destination && pCur->destPort == destPort)
  489. {
  490. pSide = pCur;
  491. arrayIndex = i; // Save the position in the array
  492. break;
  493. }
  495. }
  497. const bool sideExist = (pSide != NULL );
  499. const tcp_seq curSeq = ntohl(pTCPHeader->seq_num);
  501. // if the packet is a SYN packet then don't count the gap
  502. const USHORT flg = (ntohs(pTCPHeader->lenflags) & 0x3F);
  505. if ( !pSide )  // A new session
  506. {
  507. // Only if the packet is a SYN packet then
  508. if ( (flg & TH_SYN ) )
  509. {
  510. pSide = new Session();
  512. pSide->sourceIP = source;
  513. pSide->destIP = destination;
  514. pSide->sourcePort = sourcePort;
  515. pSide->destPort = destPort;
  516. pSide->len = len;
  517. pSide->ISN = curSeq;
  518. pSide->pOtherSide = NULL;
  520. arrayIndex = m_Array.Add( pSide );
  522. strError = _T(" /*New session*/ ");
  523. }
  525. }
  528. // Make sure the gap in sequences is less than 10 MB and is positive
  529. if ( sideExist )
  530. {
  531. const long gap = curSeq - pSide->ISN;
  533. pSide->len = len;
  535. if ( (flg & TH_SYN) != TH_SYN )
  536. {
  538. if ( (flg & TH_RST ) || ( flg & TH_FIN) )
  539. {
  540. m_Array.RemoveAt( arrayIndex );
  541. }
  542. else
  543. {
  544. // Only if the size is greater than 0 do the checking
  545. if ( len > 0 )
  546. {
  548. // ASSERT( gap >= 0 );
  549. if ( gap < 0 )
  550. strError += _T(" { Gap < 0 }");
  552. // ASSERT ( gap <= 10 * 1024 * 1000 );
  554. if ( gap >  10 * 1024 * 1000 )
  555. strError += _T(" { Gap > 10 MB }");
  556. }
  557. }
  558. }
  559. else
  560. pSide->ISN = curSeq;
  562. }
  564. // if ( sourcePort == 25 || destPort == 25 )
  565. PrintPacket( source, destination, pTCPHeader, len, strError);
  568. return true;
  570. }
  571. catch(...)
  572. {
  573. return false;
  574. }
  576. }
  579. void CSnifferDlg::ConvertAddress( unsigned int address, CString& strAddress )
  580. {
  581. IN_ADDR ad;
  583. ad.S_un.S_addr = address;
  585. strAddress = inet_ntoa( ad );
  586. }
  589. void CSnifferDlg::PrintSession( Session* pSession )
  590. {
  593. }
  596. void CSnifferDlg::PrintPacket( const CString& source, const CString& destination,TCP_HDR* pTCPHeader, DWORD dwSize, const CString& errors ) 
  597. {
  598. CString s, from, to, flags, sequence, ack ;
  600. from = source;
  601. to = destination;
  603. unsigned int sourcePort, destPort;
  605. sourcePort = htons(pTCPHeader->src_portno);
  606. destPort = htons(pTCPHeader->dest_portno);
  608. // if the packet is a SYN packet then don't count the gap
  609. const USHORT flg = (ntohs(pTCPHeader->lenflags) & 0x3F);
  611. if ( flg & TH_SYN ) 
  612. {
  613. if ( flags.GetLength() > 0 )
  614. flags += _T(",");
  615. flags += _T("SYN");
  617. }
  618. if ( flg & TH_RST ) 
  619. {
  620. if ( flags.GetLength() > 0 )
  621. flags += _T(",");
  622. flags += _T("RST");
  623. }
  625. if ( flg & TH_FIN ) 
  626. {
  627. if ( flags.GetLength() > 0 )
  628. flags += _T(",");
  629. flags += _T("FIN");
  630. }
  632. if ( flg & TH_ACK ) 
  633. {
  634. if ( flags.GetLength() > 0 )
  635. flags += _T(",");
  636. flags += _T("ACK");
  637. }
  639. if ( flg & TH_URG ) 
  640. {
  641. if ( flags.GetLength() > 0 )
  642. flags += _T(",");
  643. flags += _T("URG");
  644. }
  647. if ( flg & TH_PUSH ) 
  648. {
  649. if ( flags.GetLength() > 0 )
  650. flags += _T(",");
  651. flags += _T("PUSH");
  652. }
  654. if ( flg & TH_TAPI ) 
  655. {
  656. if ( flags.GetLength() > 0 )
  657. flags += _T(",");
  658. flags += _T("TAPI");
  659. }
  661. if ( flg & TH_NETDEV ) 
  662. {
  663. if ( flags.GetLength() > 0 )
  664. flags += _T(",");
  665. flags += _T("NETDEV");
  666. }
  668. sequence.Format(_T("%lu"),ntohl(pTCPHeader->seq_num));
  669. ack.Format(_T("%lu"),ntohl(pTCPHeader->ack_num) );
  671. s.Format(_T("%s - %s {%ld-%ld}, len: %ld, seq: %s,ack: %s, Flags: %s %srn"), from, to, sourcePort, destPort, dwSize, sequence,ack, flags, errors);
  673. m_Logger.Write( (LPCTSTR)s, s.GetLength() * sizeof(TCHAR) );
  676. CString szSourcePort, szDestPort, szSize;
  678. szSourcePort.Format( _T("%ld"), sourcePort );
  679. szDestPort.Format( _T("%ld"), destPort );
  681. szSize.Format( _T("%ld"), dwSize );
  683. TVPacketItem packetItem(source, szSourcePort, destination, szDestPort, szSize, flags, sequence, ack);
  685. InsertPacketToTV( packetItem );
  687. }
  688. bool CSnifferDlg::GetInterfaces(CStringArray& interfaces)
  689. {
  690. try
  691. {
  694. char     Hostname[MAX_PATH];
  695. HOSTENT *pHostEnt;
  696. int      nAdapter = 0;
  697. struct sockaddr_in   address;
  699. gethostname( Hostname, sizeof( Hostname ));
  700. pHostEnt = gethostbyname( Hostname );
  702. while ( pHostEnt->h_addr_list[nAdapter] )
  703. {
  704. memcpy(&address.sin_addr,pHostEnt->h_addr_list[nAdapter], pHostEnt->h_length);
  706. interfaces.Add(inet_ntoa(address.sin_addr));
  707. nAdapter++;
  708. } 
  710. return true;
  711. }
  712. catch(...)
  713. {
  714. return false;
  715. }
  716. }
  717. void CSnifferDlg::OnSize(UINT nType, int cx, int cy)
  718. {
  719. CDialog::OnSize(nType, cx, cy);
  721. ResizeForm();
  722. }
  724. void CSnifferDlg::ResizeForm(void)
  725. {
  726. if ( !IsWindowVisible() || !m_CmbInterfaces.IsWindowVisible() ||  !m_FrmInterfaces.IsWindowVisible() || !m_TVPackets.IsWindowVisible())
  727. return;
  729. CRect rect, dlgRect;
  731. GetClientRect( &dlgRect );
  733. rect = dlgRect;
  735. rect.top = 100;
  737. m_TVPackets.MoveWindow( &rect );
  738. }
  740. void CSnifferDlg::OnBnClickedStartsniffing()
  741. {
  742. m_CmbInterfaces.GetLBText( m_CmbInterfaces.GetCurSel(), m_SelInterface );
  744. m_hThread = CreateThread(NULL, 0,SnifferThread,this,0,&m_dwThreadID);
  747. }
  750. ULONG WINAPI CSnifferDlg::SnifferThread(LPVOID pParam)
  751. {
  753. CSnifferDlg* pDlg = (CSnifferDlg*)pParam;
  755. pDlg->StartSniffing();
  757. return S_OK;
  758. }
  760. void CSnifferDlg::OnClose()
  761. {
  762. m_bExit = true;
  764. DWORD dwValue = WaitForSingleObject( m_hThread, 5000);
  766. if ( dwValue == WAIT_TIMEOUT )
  767. TerminateThread( m_hThread,0);
  769. CDialog::OnClose();
  770. }
  772. void CSnifferDlg::InsertPacketToTV(const TVPacketItem& packetItem)
  773. {
  774. const CString caption = packetItem.m_SourceIP + CString(_T(" - ")) + packetItem.m_DestIP;
  776. HTREEITEM hItem = m_TVPackets.InsertItem( caption,0,0 );
  778. m_TVPackets.SetItemData( hItem, DWORD_PTR(&packetItem) );
  780. HTREEITEM hIPHeader = m_TVPackets.InsertItem(_T("IP Header"),1,1,hItem);
  782. CString str;
  784. str = GetNiceString(_T("Source IP:")) + packetItem.m_SourceIP;
  786. m_TVPackets.InsertItem(str,2,2,hIPHeader);
  788. str = GetNiceString(_T("Destination IP:")) + packetItem.m_DestIP;
  790. m_TVPackets.InsertItem(str,2,2,hIPHeader);
  792. HTREEITEM hTCPHeader = m_TVPackets.InsertItem(_T("TCP Header"),1,1,hItem);
  794. str = GetNiceString(_T("Source Port:")) + packetItem.m_SourcePort;
  796. m_TVPackets.InsertItem(str,2,2,hTCPHeader);
  798. str = GetNiceString(_T("Destination Port:")) + packetItem.m_DestPort;
  800. m_TVPackets.InsertItem(str,2,2,hTCPHeader);
  802. str = GetNiceString(_T("Size:")) + packetItem.m_Size;
  804. m_TVPackets.InsertItem(str,2,2,hTCPHeader);
  806. str = GetNiceString(_T("Flags:")) + packetItem.m_Flags;
  808. m_TVPackets.InsertItem(str,2,2,hTCPHeader);
  810. str = GetNiceString(_T("Sequence:")) + packetItem.m_Sequence;
  812. m_TVPackets.InsertItem(str,2,2,hTCPHeader);
  814. str = GetNiceString(_T("Ack:")) + packetItem.m_Ack;
  816. m_TVPackets.InsertItem(str,2,2,hTCPHeader);
  818. }