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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > IP电话/视频会议 > 查看源码
DlgStatistics.cpp
资源名称：Client_win_src.rar　[点击查看]
上传用户：gnaf34
上传日期：2022-04-22
资源大小：1657k
文件大小：25k
源码类别：

IP电话/视频会议

开发平台：

Visual C++

DlgStatistics.cpp：源码内容
  1. /*
  2.  * DlgStatistics.cxx
  3.  *
  4.  * Implementation file
  5.  *
  6.  * Copyright (c) ITEC-Ohio, 2002.
  7.  *
  8.  * The contents of this file are subject to the Mozilla Public License
  9.  * Version 1.0 (the "License"); you may not use this file except in
  10.  * compliance with the License. You may obtain a copy of the License at
  11.  * http://www.mozilla.org/MPL/
  12.  *
  13.  * Software distributed under the License is distributed on an "AS IS"
  14.  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
  15.  * the License for the specific language governing rights and limitations
  16.  * under the License.
  17.  *
  18.  * The Original Code is Open H323 Library available at http://www.openh323.org
  19.  * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
  20.  *
  21.  */
  23. #include "stdafx.h"
  24. #include <iostream.h>
  25. #include <fstream.h>
  26. #include <ptlib.h>
  27. #include <string.h>
  28. //#include <winsock.h>
  29. #include "main.h"
  30. #include "ping.h"
  32. #include "BeaconClient.h"
  33. #include "DlgStatistics.h"
  37. #include <time.h>
  40. #ifdef _DEBUG
  41. #define new DEBUG_NEW
  42. #undef THIS_FILE
  43. static char THIS_FILE[] = __FILE__;
  44. #endif
  46. /////////////////////////////////////////////////////////////////////////////
  47. // CDlgStatistics dialog
  49. extern BeaconClient* globalInstance;
  50. extern const char* globalEndReason;
  51. extern int FlagEndPoint;
  52. extern char CurrentDrive_tmp1[MAX_PATH];
  53. extern char tmpCurrDrvStr[MAX_PATH];
  54. extern CString consoleStr;
  56. //For Statistics Part
  57. extern int StartTimeGlobalYear;
  58. extern int StartTimeGlobalMonth;
  59. extern int StartTimeGlobalDay;
  60. extern int StartTimeGlobalHour;
  61. extern int  StartTimeGlobalMinute;
  62. extern int StartTimeGlobalSecond;
  63. extern DWORD RoundTripTimeDelayGlobal;
  64. extern PStringStream DurationTimeGlobal;
  66. extern DWORD AudioFrameRateGlobal;
  67. extern DWORD PacketSentGlobal;
  68. extern DWORD OctetSendGlobal;
  69. extern DWORD MaximumSendTimeGlobal;
  70. extern DWORD AverageSendTimeGlobal;
  71. extern DWORD MinimumSendTimeGlobal;
  72. extern DWORD PacketsReceivedGlobal;
  73. extern DWORD OctetsReceivedGlobal;
  74. extern DWORD MaximumReceiveTimeGlobal;
  75. extern DWORD AverageReceiveTimeGlobal;
  76. extern DWORD MinimumReceiveTimeGlobal;
  77. extern DWORD PacketsLostGlobal;
  78. extern DWORD PacketsOutOfOrderGlobal;
  79. extern DWORD PacketsOutTooLateGlobal;
  80. extern DWORD JitterTimeGlobal;
  82. extern PString PayloadTypeGlobal;
  83. extern PString ReceivedDTMFMessages;
  84. PString TmpReceivedDTMFMessages;
  86. UINT StatisticTimer;
  87. extern UINT ConnectionTimer;
  88. extern int is_MsgBox_Display; // 0 means globalendReason has NOT been displayed, 
  89. extern bool bCalling;
  90. extern CString ipglobal;
  91. int   prevpingresult = 0;
  92. int   pingresult;
  93. hostent *host1 = NULL;
  94. char hostname[80];
  95. CString localmachine;
  96. int PacketSentStat = 0;
  97. int DurationHour;
  98. int DurationMinute;
  99. int DurationSecond;
  101. CString sessionStartTime;
  102. CString sessionEndTime;
  103. CString sessionDate;
  106. //Ping Report Variables
  107. CString avgPingLatency;
  108. CString medianPingLatency;
  109. CString sdPingLatency;
  110. CString minPingLatency;
  111. CString maxPingLatency;
  112. CString P50PingLatency;
  113. CString P90PingLatency;
  115. //Codec Latency Report Variables
  116. CString avgCodecLatency;
  117. CString medianCodecLatency;
  118. CString sdCodecLatency;
  119. CString minCodecLatency;
  120. CString maxCodecLatency;
  121. CString P50CodecLatency;
  122. CString P90CodecLatency;
  124. //Jitter Report Variables
  125. CString avgJitterLatency;
  126. CString medianJitterLatency;
  127. CString sdJitterLatency;
  128. CString minJitterLatency;
  129. CString maxJitterLatency;
  130. CString P50JitterLatency;
  131. CString P90JitterLatency;
  133. //PacketLoss Report Variables
  134. CString avgPacketLossLatency;
  135. CString medianPacketLossLatency;
  136. CString sdPacketLossLatency;
  137. CString minPacketLossLatency;
  138. CString maxPacketLossLatency;
  139. CString P50PacketLossLatency;
  140. CString P90PacketLossLatency;
  143. extern CString ReportStr;
  145. //Initialize GNUPlot markers to define good/acceptable/unacceptable for statistics
  147. // Packet Lost
  148. const char *pktlost_good = "0.0";
  149. const char *pktlost_acceptable = "0.5";
  150. const char *pktlost_unacceptable = "1.5";
  152. // Round Trip Time / Latency
  153. const char *rtd_good = "0";
  154. const char *rtd_acceptable = "200";
  155. const char *rtd_unacceptable = "400";
  157. // Audio Jitter
  158. //This information is got from ITU G.114 as stated in
  159. //Wainhouse Research Whitepaper available at-
  160. //http://www.wainhouse.com/files/papers/wr-qos-in-ip-networks.pdf
  161. //Defaults for Audio Jitter:
  162. //audjitter_good = "0";
  163. //audjitter_acceptable = "20";
  164. //audjitter_unacceptable = "50";
  166. const char *audjitter_good = "0";
  167. const char *audjitter_acceptable = "20";
  168. const char *audjitter_unacceptable = "50";
  170. CDlgStatistics::CDlgStatistics(CWnd* pParent /*=NULL*/)
  171. : CDialog(CDlgStatistics::IDD, pParent)
  172. {
  173. //{{AFX_DATA_INIT(CDlgStatistics)
  174. // NOTE: the ClassWizard will add member initialization here
  175. //}}AFX_DATA_INIT}
  177. gethostname(hostname, sizeof(hostname));
  178. host1 = gethostbyname(hostname);
  179. localmachine = inet_ntoa(*(reinterpret_cast<in_addr*>(host1->h_addr)));
  180. }
  183. void CDlgStatistics::DoDataExchange(CDataExchange* pDX)
  184. {
  185. CDialog::DoDataExchange(pDX);
  186. //{{AFX_DATA_MAP(CDlgStatistics)
  187. // NOTE: the ClassWizard will add DDX and DDV calls here
  188. //}}AFX_DATA_MAP
  189. }
  192. BEGIN_MESSAGE_MAP(CDlgStatistics, CDialog)
  193. //{{AFX_MSG_MAP(CDlgStatistics)
  194. ON_BN_CLICKED(IDC_BUTTON_START, OnButtonStart)
  195. ON_WM_PAINT()
  196. ON_WM_TIMER()
  197. ON_WM_CREATE()
  198. ON_WM_CANCELMODE()
  199. ON_WM_CAPTURECHANGED()
  200. //}}AFX_MSG_MAP
  201. END_MESSAGE_MAP()
  205. /////////////////////////////////////////////////////////////////////////////
  206. // CDlgStatistics message handlers
  208. //BeaconClient *instance;
  210. void CDlgStatistics::OnButtonStart() 
  211. {
  213. }
  217. void CDlgStatistics::OnPaint() 
  218. {
  220. TRY {
  221. CPaintDC dc(this); // device context for painting
  224. // For statistic part, we are using WM_TIMER to collect
  225. // statistic for every second by command SetTimer(1,1000,0) 
  226. // where 1000 = 1000 mile second
  228. CDlgStatistics::KillTimer(StatisticTimer);
  230. if (globalInstance != NULL){
  232. if (globalInstance->endpoint != NULL){
  233. StatisticTimer = CDlgStatistics::SetTimer(20,1000,0);
  234. }
  235. else{
  236. CDlgStatistics::KillTimer(StatisticTimer);
  237. }
  238. }
  239. // Do not call CDialog::OnPaint() for painting messages
  240. } // End TRY
  241. CATCH_ALL(e){
  242. // Put some delay here
  243. }
  244. END_CATCH_ALL
  245.   
  246. }
  251. void CDlgStatistics::OnTimer(UINT nIDEvent) 
  252. {
  253. // TODO: Add your message handler code here and/or call default
  254. // Collect statistic for every second (Using WM_TIMER)
  255. // Display it to window
  257. char buffer[200];
  258. CString strtext;
  259. CString strhour;
  260. CString strminute;
  261. CString strsecond;
  262. CString StartTime;
  263. CString CurrentTimeStat;
  264. CString PayloadTypeName;
  267. CString strCurrentYear;
  268. CString strCurrentMonth;
  269. CString strCurrentDay;
  270. CString strCurrentHour;
  271. CString strCurrentMinute;
  272. CString strCurrentSecond;
  276. int CurrentHour;
  277. int CurrentMinute;
  278. int CurrentSecond;
  279. int CurrentYear;
  280. int CurrentMonth;
  281. int CurrentDay;
  283. CString strCurrentMonth_tmp;
  284. CString tmpStrVar;
  285. CString CurrentDateTimeStat;
  286. CString str;
  287. int stat;
  289. TRY {
  291. CTime time = CTime::GetCurrentTime();
  293. CEdit *p_FrameRate = (CEdit *)GetDlgItem(IDC_EDIT_FrameRate);
  294. CEdit *p_PacketSent = (CEdit *)GetDlgItem(IDC_EDIT_PACKET_SENT);
  295. CEdit *p_OctetSend = (CEdit *)GetDlgItem(IDC_EDIT_OCTET_SENT);
  296. CEdit *p_MaxSendTime = (CEdit *)GetDlgItem(IDC_EDIT_MAXIMUM_SENDTIME);
  297. CEdit *p_AvSendTime = (CEdit *)GetDlgItem(IDC_EDIT_AVERAGE_SENDTIME);
  298. CEdit *p_MinSendTime = (CEdit *)GetDlgItem(IDC_EDIT_MINIMUM_SENDTIME);
  299. CEdit *p_PacketReceived = (CEdit *)GetDlgItem(IDC_EDIT_PACKET_RECEIVED);
  300. CEdit *p_OctetReceived = (CEdit *)GetDlgItem(IDC_EDIT_OCTET_RECEIVED);
  301. CEdit *p_MaxRecTime = (CEdit *)GetDlgItem(IDC_EDIT_MAXIMUM_RECEIVETIME);
  302. CEdit *p_AvRecTime = (CEdit *)GetDlgItem(IDC_EDIT_AVERAGE_RECEIVETIME);
  303. CEdit *p_MinRecTime = (CEdit *)GetDlgItem(IDC_MINIMUM_RECEIVETIME);
  304. CEdit *p_PacketLoss = (CEdit *)GetDlgItem(IDC_EDIT_PL);
  305. CEdit *p_PacketOutOfOrder = (CEdit *)GetDlgItem(IDC_Packet_Out_Of_Order2);
  306. CEdit *p_PacketTooLate = (CEdit *)GetDlgItem(IDC_Packet_Too_Late2);
  307. CEdit *p_AudioJitter = (CEdit *)GetDlgItem(IDC_EDIT_AJ);
  308. CEdit *p_StartTime = (CEdit *)GetDlgItem(IDC_StartTime1);
  309. CEdit *p_RoundTripDelay = (CEdit *)GetDlgItem(IDC_RoundTripTime);
  312. // Server IP
  313. CEdit *p_ServerIP = (CEdit *)GetDlgItem(IDC_SERVER_IP);
  315. //Client IP
  316. CEdit *p_ClientIP = (CEdit *)GetDlgItem(IDC_CLIENT_IP);
  317. CEdit *p_PayloadType = (CEdit *)GetDlgItem(IDC_PayloadType);
  319. // Open All necessary files to capture all statistic in real time
  320. // Fields to be captured:
  321. // Date and Time Stamp
  322. // Frame Rate
  323. // Packet Sent
  324. // Octet Sent
  325. // Maximum Send Time
  326. // Average Send Time
  327. // Minimum Send Time
  328. // Packet Received
  329. // Octet Received
  330. // Maximum Receive Time
  331. // Average Receive Time
  332. // Minimum Receive Time
  333. // Packet Loss
  334. // Packet Out Of Order
  335. // Packet Too Late
  336. // Audio Jitter
  338. sprintf(tmpCurrDrvStr,"%s\\%s",CurrentDrive_tmp1,"timestamp.txt");
  339. fstream fs1(  tmpCurrDrvStr, ios::out | ios::app ); // Date and Time Stamp
  341. sprintf(tmpCurrDrvStr,"%s\\%s",CurrentDrive_tmp1,"ploadtype.txt");
  342. fstream fs2(  tmpCurrDrvStr, ios::out | ios::app ); // Payload Type
  344. sprintf(tmpCurrDrvStr,"%s\\%s",CurrentDrive_tmp1,"pktloss.txt");
  345. fstream fs3(  tmpCurrDrvStr, ios::out | ios::app ); // Packet Loss
  347. sprintf(tmpCurrDrvStr,"%s\\%s",CurrentDrive_tmp1,"audjitter.txt");
  348. fstream fs4(  tmpCurrDrvStr, ios::out | ios::app ); // Audio Jitter
  350. sprintf(tmpCurrDrvStr,"%s\\%s",CurrentDrive_tmp1,"rtd.txt");
  351. fstream fs5(  tmpCurrDrvStr, ios::out | ios::app ); // Round Trip Delay
  353. sprintf(tmpCurrDrvStr,"%s\\%s",CurrentDrive_tmp1,"pktsent.txt");
  354. fstream fs6( tmpCurrDrvStr, ios::out | ios::app ); // Packet Sent
  356. sprintf(tmpCurrDrvStr,"%s\\%s",CurrentDrive_tmp1,"octsent.txt");
  357. fstream fs7( tmpCurrDrvStr, ios::out | ios::app ); // Octet Sent
  359. sprintf(tmpCurrDrvStr,"%s\\%s",CurrentDrive_tmp1,"pktrecvd.txt");
  360. fstream fs8(  tmpCurrDrvStr, ios::out | ios::app ); // Packet Received
  362. sprintf(tmpCurrDrvStr,"%s\\%s",CurrentDrive_tmp1,"octrecvd.txt");
  363. fstream fs9(  tmpCurrDrvStr, ios::out | ios::app  ); // Octet Received
  365. //GNUPlot related files
  366. sprintf(tmpCurrDrvStr,"%s\\%s",CurrentDrive_tmp1,"pktloss_gplot.txt");
  367. fstream fs3gplot(  tmpCurrDrvStr, ios::out | ios::app ); // Packet Loss_gnuplot
  369. sprintf(tmpCurrDrvStr,"%s\\%s",CurrentDrive_tmp1,"audjitter_gplot.txt");
  370. fstream fs4gplot(  tmpCurrDrvStr, ios::out | ios::app ); // Audio Jitter_gnuplot
  372. sprintf(tmpCurrDrvStr,"%s\\%s",CurrentDrive_tmp1,"rtd_gplot.txt");
  373. fstream fs5gplot(  tmpCurrDrvStr, ios::out | ios::app ); // Round Trip Delay_gnuplot
  374.  
  375. if (globalInstance->endpoint != NULL){
  377. stat = globalInstance->GetStatistics();
  379. if (stat == 0){
  381. SetDlgItemText(IDC_EDIT_CALLSTATUS, "In Session");
  383. CTime  start_time = CTime(StartTimeGlobalYear,StartTimeGlobalMonth,StartTimeGlobalDay,StartTimeGlobalHour,StartTimeGlobalMinute,StartTimeGlobalSecond);
  384. CTimeSpan dur = time - start_time;
  386. DurationHour = dur.GetTotalHours();
  387. DurationMinute = dur.GetMinutes();
  388. DurationSecond = dur.GetSeconds();
  391. CurrentHour = time.GetHour();
  392. CurrentMinute = time.GetMinute();
  393. CurrentSecond = time.GetSecond();
  394. CurrentYear = time.GetYear();
  395. CurrentMonth = time.GetMonth();
  396. CurrentDay = time.GetDay();
  399. // Implement Time Difference because we want to
  400. // Map difference between PTime and CTime
  401. // Get Duration
  402. strhour = _itoa(DurationHour,buffer,10);
  403. strminute = _itoa(DurationMinute,buffer,10);
  404. strsecond = _itoa(DurationSecond,buffer,10);
  407. strCurrentHour = _itoa(CurrentHour,buffer,10);
  408. strCurrentMinute = _itoa(CurrentMinute,buffer,10);
  409. strCurrentSecond = _itoa(CurrentSecond,buffer,10);
  410. strCurrentYear = _itoa(CurrentYear,buffer,10);
  411. strCurrentMonth = time.Format("%B");      // _itoa(CurrentMonth,buffer,10);
  412. strCurrentDay = _itoa(CurrentDay,buffer,10);
  414. strCurrentMonth_tmp = _itoa(CurrentMonth,buffer,10);
  415. StartTime = strhour + ":" + strminute + ":" + strsecond; // Duration Time
  417. CurrentTimeStat = strCurrentHour + ":" + strCurrentMinute + ":" + strCurrentSecond;
  418. CurrentDateTimeStat = strCurrentYear + "-"+ strCurrentMonth_tmp 
  419. + "-" + strCurrentDay + "_" + CurrentTimeStat;
  420. // End of Duration
  422. //Calculation of session start time and session end time
  423. sessionEndTime = CurrentTimeStat;
  424. sessionStartTime = (CString)_itoa(CurrentHour-DurationHour,buffer,10)+":"+ (CString)_itoa(CurrentMinute-DurationMinute,buffer,10)+":"+ (CString)_itoa(CurrentSecond-DurationSecond,buffer,10);
  425. sessionDate = strCurrentMonth_tmp + "/" + strCurrentDay + "/" + strCurrentYear;
  427. // Payload Type
  430. /*
  431.   PCMU,         // G.711 u-Law
  432.   FS1016,       // Federal Standard 1016 CELP
  433.   G721,         // ADPCM - Subsumed by G.726
  434.   G726 = G721,
  435.   GSM,          // GSM 06.10
  436.   G7231,        // G.723.1 at 6.3kbps or 5.3 kbps
  437.   DVI4_8k,      // DVI4 at 8kHz sample rate
  438.   DVI4_16k,     // DVI4 at 16kHz sample rate
  439.   LPC,          // LPC-10 Linear Predictive CELP
  440.   PCMA,         // G.711 A-Law
  441.   G722,         // G.722
  442.   L16_Stereo,   // 16 bit linear PCM
  443.   L16_Mono,     // 16 bit linear PCM
  444.   G723,         // G.723
  445.   CN,           // Confort Noise
  446.   MPA,          // MPEG1 or MPEG2 audio
  447.   G728,         // G.728 16kbps CELP
  448.   DVI4_11k,     // DVI4 at 11kHz sample rate
  449.   DVI4_22k,     // DVI4 at 22kHz sample rate
  450.   G729,         // G.729 8kbps
  451.   Cisco_CN,     // Cisco systems comfort noise (unofficial)
  453.   CelB = 25,    // Sun Systems Cell-B video
  454.   JPEG,         // Motion JPEG
  455.   H261 = 31,    // H.261
  456.   MPV,          // MPEG1 or MPEG2 video
  457.   MP2T,         // MPEG2 transport system
  458.   H263,         // H.263
  459. */
  461. switch (atoi(PayloadTypeGlobal)){
  462. case 0: PayloadTypeName = "G.711 u-Law";
  463. break;
  464. case 1: PayloadTypeName = "Federal Standard 1016 CELP";
  465. break;
  466. case 2: PayloadTypeName = "ADPCM - Subsumed by G.726";
  467. break;
  468. case 3: PayloadTypeName = "GSM 06.10";
  469. break;
  470. case 4: PayloadTypeName = "G.723.1 at 6.3kbps or 5.3 kbps";
  471. break;
  472. case 5: PayloadTypeName = "GDVI4 at 8kHz sample rate";
  473. break;
  474. case 6: PayloadTypeName = "DVI4 at 16kHz sample rate";
  475. break;
  476. case 7: PayloadTypeName = "LPC-10 Linear Predictive CELP";
  477. break;
  478. case 8: PayloadTypeName = "G.711 A-Law";
  479. break;
  480. case 9: PayloadTypeName = "G.722";
  481. break;
  482. case 10:PayloadTypeName = "16 bit linear PCM";
  483. break;
  484. case 11:PayloadTypeName = "16 bit linear PCM";
  485. break;
  486. case 12:PayloadTypeName = "G.723";
  487. break;
  488. case 13:PayloadTypeName = "Confort Noise";
  489. break;
  490. case 14:PayloadTypeName = "MPEG1 or MPEG2 audio";
  491. break;
  492. case 15:PayloadTypeName = "G.728 16kbps CELP";
  493. break;
  494. case 16:PayloadTypeName = "DVI4 at 11kHz sample rate";
  495. break;
  496. case 17:PayloadTypeName = "DVI4 at 22kHz sample rate";
  497. break;
  498. case 18:PayloadTypeName = "G.729 8kbps";
  499. break;
  500. case 19:PayloadTypeName = "Cisco systems comfort noise (unofficial)";
  501. break;
  502. case 20:PayloadTypeName = "Sun Systems Cell-B video";
  503. break;
  504. case 21:PayloadTypeName = "Motion JPEG";
  505. break;
  506. case 22:PayloadTypeName = "H.261";
  507. break;
  508. case 23:PayloadTypeName = "MPEG1 or MPEG2 video";
  509. break;
  510. case 24:PayloadTypeName = "MPEG2 transport system";
  511. break;
  512. case 25:PayloadTypeName = "H.263";
  513. break;
  514. default:PayloadTypeName = "Unknown";
  515. }
  517. // end Payload Type
  520. // Call Date and Timestamp
  521. if (FlagEndPoint == 0){
  522. p_StartTime->SetWindowText(StartTime);
  523. p_StartTime->UpdateWindow();
  526. if (fs1.is_open()){
  527. fs1 << CurrentDateTimeStat << "n"; 
  528. fs1.close();
  529. }
  530. }
  534. // Payload Type
  535. p_PayloadType->SetWindowText(PayloadTypeName);
  536. p_PayloadType->UpdateWindow();
  538. if (fs2.is_open()){
  539. fs2 << PayloadTypeName << "n"; 
  540. fs2.close();
  541. }
  544. // Packet Lost
  545. str = _itoa(PacketsLostGlobal,buffer,10);
  546.   p_PacketLoss->SetWindowText(str);
  547.   p_PacketLoss->UpdateWindow();
  549. if (fs3.is_open()){
  550. fs3 << str << "n";
  551. fs3.close();
  552. }
  554. //GNUPlot related files
  555. tmpStrVar = CurrentDateTimeStat + "       " + str + "       " + pktlost_good + "       " + pktlost_acceptable + "       " + pktlost_unacceptable;
  556. if (fs3gplot.is_open()) {
  557. fs3gplot << tmpStrVar << "n";
  558. fs3gplot.close();
  559. }
  561. // Audio Jitter
  562. str = _itoa(JitterTimeGlobal,buffer,10);
  563.   p_AudioJitter->SetWindowText(str);
  564.   p_AudioJitter->UpdateWindow();
  566. if (fs4.is_open()){
  567. fs4 << str << "n";
  568. fs4.close();
  569. }
  571. //GNUPlot related file
  572. tmpStrVar = CurrentDateTimeStat + "       " + str + "       " + audjitter_good + "       " + audjitter_acceptable + "       " + audjitter_unacceptable;
  573. if (fs4gplot.is_open()){
  574. fs4gplot << tmpStrVar << "n";
  575. fs4gplot.close();
  576. }
  579. // Round Trip Delay
  580. CDlgStatistics::Ping(ipglobal);
  582. //str = _itoa(pingresult,buffer,10);
  583. str = _itoa(RoundTripTimeDelayGlobal,buffer,10);
  584. p_RoundTripDelay->SetWindowText(str);
  585. p_RoundTripDelay->UpdateWindow();
  587. if (fs5.is_open()){
  588. fs5 << str << "n";
  589. fs5.close();
  590. }
  592. //GNUPlot related file
  593. tmpStrVar = CurrentDateTimeStat + "       " + str + "       " + rtd_good  + "       " + rtd_acceptable + "       " + rtd_unacceptable;
  594. if (fs5gplot.is_open()){
  595. fs5gplot << tmpStrVar << "n";
  596. fs5gplot.close();
  597. }
  599. // Packet Sent
  600. str = _itoa(PacketSentGlobal,buffer,10);
  601.   p_PacketSent->SetWindowText(str);
  602.   p_PacketSent->UpdateWindow();
  603. if (fs6.is_open()){
  604. fs6 << str << "n";
  605. fs6.close();
  606. }
  609. // Octet Sent
  610. str = _itoa(OctetSendGlobal,buffer,10);
  611.   p_OctetSend->SetWindowText(str);
  612.   p_OctetSend->UpdateWindow();
  613. if (fs7.is_open()){
  614. fs7 << str << "n";
  615. fs7.close();
  616. }
  620. // Packet Received
  621. str = _itoa(PacketsReceivedGlobal,buffer,10);
  622.   p_PacketReceived->SetWindowText(str);
  623.   p_PacketReceived->UpdateWindow();
  625. if (fs8.is_open()){
  626. fs8 << str << "n";
  627. fs8.close();
  628. }
  631. // Octet Received
  632. str = _itoa(OctetsReceivedGlobal,buffer,10);
  633.   p_OctetReceived->SetWindowText(str);
  634.   p_OctetReceived->UpdateWindow();
  636. if (fs9.is_open()){
  637. fs9 << str << "n";
  638. fs9.close();
  639. }
  641. // Server IP
  642. p_ServerIP->SetWindowText(ipglobal);
  643. p_ServerIP->UpdateWindow();
  645. // Client IP
  646. p_ClientIP->SetWindowText(localmachine);
  647. p_ClientIP->UpdateWindow();
  649. p_PayloadType->SetWindowText(PayloadTypeName);
  650. p_PayloadType->UpdateWindow();
  654. CDialog::OnTimer(nIDEvent);
  655. }
  656. else{
  657. CWnd::KillTimer(ConnectionTimer);
  658. CDlgStatistics::KillTimer(StatisticTimer);
  661.  if (is_MsgBox_Display == 1){
  662.   // Message Box globalEndReason has been displayed
  663. }
  664.  else{
  665. if (globalEndReason = "") {
  666. // Do Nothing
  667. }
  668. else{
  670. }
  672. }
  675. FlagEndPoint = 1;
  677. }  /// stat == 0
  679. } //globalinstance->endpoint
  681. else{
  682. FlagEndPoint = 1;
  683. }
  684. } // End TRY
  685. CATCH_ALL(e){
  686. // Put some delay here
  687. }
  688. END_CATCH_ALL
  690. }
  692. int CDlgStatistics::OnCreate(LPCREATESTRUCT lpCreateStruct) 
  693. {
  694. if (CDialog::OnCreate(lpCreateStruct) == -1)
  695. return -1;
  697. // TODO: Add your specialized creation code here
  699. return 0;
  700. }
  704. // New addition for ping command
  706. // Ping()
  707. // Calls SendEchoRequest() and
  708. // RecvEchoReply() and prints results
  711. void CDlgStatistics::Ping(LPCSTR pstrHost)
  712. {
  713. SOCKET   rawSocket;
  714. LPHOSTENT lpHost;
  715. struct    sockaddr_in saDest;
  716. struct    sockaddr_in saSrc;
  717. DWORD   dwTimeSent;
  718. DWORD   dwElapsed;
  719. u_char    cTTL;
  720. int       nLoop;
  721. int       nRet;
  723. // Create a Raw socket
  724. rawSocket = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP);
  725. if (rawSocket == SOCKET_ERROR) {
  726. ReportError("socket()");
  727. return;
  728. }
  730. // Lookup host
  731. lpHost = gethostbyname(pstrHost);
  732. if (lpHost == NULL){
  734. return;
  735. }
  737. // Setup destination socket address
  738. saDest.sin_addr.s_addr = *((u_long FAR *) (lpHost->h_addr));
  739. saDest.sin_family = AF_INET;
  740. saDest.sin_port = 0;
  742. // Ping multiple times
  743. for (nLoop = 0; nLoop < 1; nLoop++){
  744. // Send ICMP echo request
  745. CDlgStatistics::SendEchoRequest(rawSocket, &saDest);
  747. // Use select() to wait for data to be received
  748. nRet = CDlgStatistics::WaitForEchoReply(rawSocket);
  749. if (nRet == SOCKET_ERROR){
  750. ReportError("select()");
  751. break;
  752. }
  753. if (!nRet){
  754. printf("nTimeOut");
  755. break;
  756. }
  758. // Receive reply
  759. dwTimeSent = CDlgStatistics::RecvEchoReply(rawSocket, &saSrc, &cTTL);
  761. // Calculate elapsed time
  762. dwElapsed = GetTickCount() - dwTimeSent;
  764. pingresult = dwElapsed;
  766. if (pingresult != 0){
  767. int a123 = 0;
  768. }
  770. }
  772. nRet = closesocket(rawSocket);
  773. if (nRet == SOCKET_ERROR)
  774. {
  775. // Do nothing
  776. ReportError("closesocket()");
  777. }
  778. }
  781. // SendEchoRequest()
  782. // Fill in echo request header
  783. // and send to destination
  784. int CDlgStatistics::SendEchoRequest(SOCKET s,LPSOCKADDR_IN lpstToAddr) 
  785. {
  786. static ECHOREQUEST echoReq;
  787. static nId = 1;
  788. static nSeq = 1;
  789. int nRet;
  791. // Fill in echo request
  792. echoReq.icmpHdr.Type = ICMP_ECHOREQ;
  793. echoReq.icmpHdr.Code = 0;
  794. echoReq.icmpHdr.Checksum = 0;
  795. echoReq.icmpHdr.ID = nId++;
  796. echoReq.icmpHdr.Seq = nSeq++;
  798. // Fill in some data to send
  799. for (nRet = 0; nRet < REQ_DATASIZE; nRet++)
  800. echoReq.cData[nRet] = ' '+nRet;
  802. // Save tick count when sent
  803. echoReq.dwTime = GetTickCount();
  805. // Put data in packet and compute checksum
  806. echoReq.icmpHdr.Checksum = in_cksum((u_short *)&echoReq, sizeof(ECHOREQUEST));
  808. // Send the echo request     
  809. nRet = sendto(s, /* socket */
  810.  (LPSTR)&echoReq, /* buffer */
  811.  sizeof(ECHOREQUEST),
  812.  0, /* flags */
  813.  (LPSOCKADDR)lpstToAddr, /* destination */
  814.  sizeof(SOCKADDR_IN));   /* address length */
  816. if (nRet == SOCKET_ERROR){
  817. // Do nothing
  818. ReportError("sendto()");
  819. }
  821. return (nRet);
  823. }
  826. // RecvEchoReply()
  827. // Receive incoming data
  828. // and parse out fields
  829. DWORD CDlgStatistics::RecvEchoReply(SOCKET s, LPSOCKADDR_IN lpsaFrom, u_char *pTTL) 
  830. {
  831. ECHOREPLY echoReply;
  832. int nRet;
  833. int nAddrLen = sizeof(struct sockaddr_in);
  835. // Receive the echo reply
  836. nRet = recvfrom(s, // socket
  837. (LPSTR)&echoReply, // buffer
  838. sizeof(ECHOREPLY), // size of buffer
  839. 0, // flags
  840. (LPSOCKADDR)lpsaFrom, // From address
  841. &nAddrLen); // pointer to address len
  843. // Check return value
  845. if (nRet == SOCKET_ERROR){
  846. // Do Nothing
  847. ReportError("recvfrom()");
  848. }
  850. // return time sent and IP TTL
  851. *pTTL = echoReply.ipHdr.TTL;
  852. return(echoReply.echoRequest.dwTime);   
  853. }
  855. // What happened?
  856. void CDlgStatistics::ReportError(LPCSTR pWhere)
  857. {
  858. fprintf(stderr,"n%s error: %dn",
  859. WSAGetLastError());
  860. }
  863. // WaitForEchoReply()
  864. // Use select() to determine when
  865. // data is waiting to be read
  866. int CDlgStatistics::WaitForEchoReply(SOCKET s)
  867. {
  868. struct timeval Timeout;
  869. fd_set readfds;
  871. readfds.fd_count = 1;
  872. readfds.fd_array[0] = s;
  873. Timeout.tv_sec = 5;
  874.     Timeout.tv_usec = 0;
  876. return(select(1, &readfds, NULL, NULL, &Timeout));
  877. }
  880. //
  881. // Mike Muuss' in_cksum() function
  882. // and his comments from the original
  883. // ping program
  884. //
  885. // * Author -
  886. // * Mike Muuss
  887. // * U. S. Army Ballistic Research Laboratory
  888. // * December, 1983
  890. /*
  891.  * I N _ C K S U M
  892.  *
  893.  * Checksum routine for Internet Protocol family headers (C Version)
  894.  *
  895.  */
  896. u_short CDlgStatistics::in_cksum(u_short *addr, int len)
  897. {
  898. register int nleft = len;
  899. register u_short *w = addr;
  900. register u_short answer;
  901. register int sum = 0;
  903. /*
  904.  *  Our algorithm is simple, using a 32 bit accumulator (sum),
  905.  *  we add sequential 16 bit words to it, and at the end, fold
  906.  *  back all the carry bits from the top 16 bits into the lower
  907.  *  16 bits.
  908.  */
  909. while( nleft > 1 )  {
  910. sum += *w++;
  911. nleft -= 2;
  912. }
  914. /* mop up an odd byte, if necessary */
  915. if( nleft == 1 ) {
  916. u_short u = 0;
  918. *(u_char *)(&u) = *(u_char *)w ;
  919. sum += u;
  920. }
  922. /*
  923.  * add back carry outs from top 16 bits to low 16 bits
  924.  */
  925. sum = (sum >> 16) + (sum & 0xffff); /* add hi 16 to low 16 */
  926. sum += (sum >> 16); /* add carry */
  927. answer = ~sum; /* truncate to 16 bits */
  928. return (answer);
  929. }