protocol.cpp

转上传一个

 307.    
 308.         case WSAENETDOWN:   
 309.             MessageBox(NULL,"In RecvIcmpPacket,WSAGetLastError() == WSAENETDOWN." \   
 310.                 , "warning", MB_OK);   
 311.             break;   
 312.    
 313.         case WSAEFAULT:   
 314.             MessageBox(NULL,"In RecvIcmpPacket,WSAGetLastError() == WSAEFAULT." \   
 315.                 , "warning", MB_OK);   
 316.             break;   
 317.    
 318.         case WSAEINTR:   
 319.             MessageBox(NULL,"In RecvIcmpPacket,WSAGetLastError() == WSAEINTR." \   
 320.                 , "warning", MB_OK);   
 321.             break;   
 322.            
 323.         case WSAEINVAL:   
 324.             MessageBox(NULL,"In RecvIcmpPacket,WSAGetLastError() == WSAEINVAL." \   
 325.                 , "warning", MB_OK);   
 326.             break;   
 327.    
 328.         case WSAETIMEDOUT:   
 329.             //MessageBox(NULL,"In RecvIcmpPacket,WSAGetLastError() == WSAETIMEDOUT." \   
 330.                 , "warning", MB_OK);   
 331.             break;   
 332.         case WSAEMSGSIZE:   
 333.             MessageBox(NULL,"In RecvIcmpPacket,WSAGetLastError() == WSAEMSGSIZE." \   
 334.                 , "warning", MB_OK);   
 335.             break;   
 336.    
 337.         default:   
 338.             MessageBox(NULL,"In RecvIcmpPacket,WSAGetLastError() == UNKWON." \   
 339.                 , "warning", MB_OK);   
 340.             break;   
 341.         }   
 342.    
 343.         return -1;   
 344.     }   
 345.    
 346.     //Parse icmp packet.   
 347.     nBytes = ParseIcmpPacket(pcDataBuffer, nBuffLen, nOption);   
 348.     if(-1 == nBytes)   
 349.     {   
 350.         MessageBox(NULL, "In RecvIcmpPacket, call ParseIcmpPacket failure.", "warning" \   
 351.             , MB_OK);   
 352.         return -1;   
 353.     }   
 354.    
 355.     return nBytes;   
 356. }   
 357.        
 358.    
 359.    
 360. ////////////////////////////////////////////////////////////////////////////////   
 361. //   
 362. //   
 363. //   
 364. //   
 365. //   
 366. //   
 367. //   
 368. //   
 369. ////////////////////////////////////////////////////////////////////////////////   
 370. BOOL Protocol::CreateIcmpPacket(char * pcDataBuffer, int nBuffLen, int nOption)   
 371. {      
 372.     BOOL bResult;   
 373.     int nMaxDataLen;   
 374.     ICMP_HEADER * pIcmpHeader = NULL;   
 375.     COMMAND_HEADER * pCommandHeader = NULL;   
 376.     unsigned short usCheckSum;   
 377.     char pcAuthCode[] = "@#$%&_+|=*";   
 378.        
 379.     //Check if arguments are valid.   
 380.     if(NULL == pcDataBuffer)   
 381.     {   
 382.         MessageBox(NULL, "In CreateIcmpPacket, pcDataBuffer == NULL", "warning", MB_OK);   
 383.         return FALSE;   
 384.     }   
 385.    
 386.     nMaxDataLen =  ICMP_PACKET_MAX_SIZE - sizeof(ICMP_HEADER) - sizeof(COMMAND_HEADER);   
 387.     if( (nBuffLen <= 0)||(nBuffLen > nMaxDataLen) )   
 388.     {   
 389.         MessageBox(NULL, "In CreateIcmpPacket, nBufferLen <= 0 or nBuffLen > nMaxDataLen" \   
 390.             , "waring", MB_OK);   
 391.         return FALSE;   
 392.     }   
 393.        
 394.     //Set icmp header.   
 395.     if(NULL == m_pucSendBuffer)   
 396.     {   
 397.         MessageBox(NULL, "In CreateIcmpPacket, m_pucSendBuffer == NULL.", "warning", MB_OK);   
 398.         return FALSE;   
 399.     }   
 400.    
 401.     pIcmpHeader = (ICMP_HEADER *)m_pucSendBuffer;   
 402.        
 403.    
 404.     if(ICMP_ECHO == nOption)   
 405.     {   
 406.         pIcmpHeader->ucType = ICMP_ECHO;   
 407.     }   
 408.     else if(ICMP_ECHOREPLY == nOption)   
 409.     {   
 410.         pIcmpHeader->ucType = ICMP_ECHOREPLY;   
 411.     }   
 412.     else   
 413.     {   
 414.         MessageBox(NULL, "In CreateIcmpPacket, nOption is not correct." \   
 415.             , "waring", MB_OK);   
 416.         return FALSE;   
 417.     }   
 418.     pIcmpHeader->ucCode = 0;   
 419.     pIcmpHeader->usCheckSum = 0;   
 420.     pIcmpHeader->usId = 0;   
 421.     pIcmpHeader->usSeq = 0;   
 422.        
 423.     //Set command header.   
 424.     pCommandHeader = (COMMAND_HEADER *)(m_pucSendBuffer + sizeof(ICMP_HEADER));   
 425.     pCommandHeader->ucVerHLen = 0;   
 426.     pCommandHeader->ucSign = 0;   
 427.     pCommandHeader->ucType = 0;   
 428.     pCommandHeader->ucCode = 0;   
 429.     pCommandHeader->ulSessionId = 0;   
 430.     strncpy(pCommandHeader->pcAuthCode, pcAuthCode, sizeof(pcAuthCode));     
 431.    
 432.    
 433.     //Copy user data.   
 434.     if(NULL == m_pucSendBuffer)   
 435.     {   
 436.         MessageBox(NULL, "In CreateIcmpPacket, m_pucSendBuffer == NULL." \   
 437.             , "waring", MB_OK);   
 438.         return FALSE;   
 439.     }   
 440.        
 441.     memcpy(m_pucSendBuffer + sizeof(ICMP_HEADER) + sizeof(COMMAND_HEADER) \   
 442.         , pcDataBuffer, nBuffLen);   
 443.    
 444.     //Calculate checksum.   
 445.     bResult = CalculateCheckSum((unsigned short *)m_pucSendBuffer \   
 446.         , sizeof(ICMP_HEADER) + sizeof(COMMAND_HEADER) + nBuffLen , &usCheckSum);   
 447.            
 448.     if(FALSE == bResult)   
 449.     {   
 450.         MessageBox(NULL, "In CreateIcmpPacket, call CalculateCheckSum failure.", "warning" \   
 451.             , MB_OK);   
 452.         return FALSE;   
 453.     }   
 454.        
 455.     pIcmpHeader->usCheckSum = usCheckSum;   
 456.    
 457.     return TRUE;   
 458. }   
 459.    
 460.    
 461.    
 462.    
 463. ////////////////////////////////////////////////////////////////////////////////   
 464. //   
 465. //   
 466. //   
 467. //   
 468. //   
 469. //   
 470. // Not handle nOption.   
 471. //   
 472. ////////////////////////////////////////////////////////////////////////////////   
 473. int Protocol::ParseIcmpPacket(char * pcDataBuffer, int nBuffLen, int nOption)   
 474. {   
 475.     int nBytes , nDataBytes;   
 476.     IP_HEADER * pIpHeader = NULL;   
 477.     ICMP_HEADER * pIcmpHeader = NULL;   
 478.     COMMAND_HEADER * pCommandHeader = NULL;   
 479.     char * pcDataPart = NULL;//Point to data part.   
 480.     char pcAuthCode[] = "@#$%&_+|=*";   
 481.    
 482.     //Check if arguments are valid.   
 483.     if(NULL == pcDataBuffer)   
 484.     {   
 485.         MessageBox(NULL, "In ParseIcmpPacket, pcDataBuffer == NULL.", "warning", MB_OK);   
 486.         return -1;   
 487.     }   
 488.     if(nBuffLen <= 0)   
 489.     {   
 490.         MessageBox(NULL, "In ParseIcmpPacket, nBuffLen <= 0.", "warning", MB_OK);   
 491.         return -1;   
 492.     }   
 493.    
 494.     //Parse icmp packet.   
 495.     pIpHeader = (IP_HEADER *)m_pucRecvBuffer;   
 496.     nDataBytes = ntohs(pIpHeader->usTotalLen) - sizeof(IP_HEADER) \   
 497.         - sizeof(ICMP_HEADER) - sizeof(COMMAND_HEADER);   
 498.    
 499.     nBytes = nDataBytes < nBuffLen ? nDataBytes : nBuffLen;   
 500.     if(nBytes < 0)   
 501.     {   
 502.         return -1;   
 503.     }   
 504.    
 505.     //Check if Command header is valid.   
 506.     pCommandHeader = (COMMAND_HEADER *)(m_pucRecvBuffer + sizeof(IP_HEADER) \   
 507.         + sizeof(ICMP_HEADER));   
 508.     if(strcmp(pCommandHeader->pcAuthCode, pcAuthCode) != 0)   
 509.     {   
 510.         return -1;   
 511.     }   
 512.        
 513.     //Get user data.   
 514.     pcDataPart = m_pucRecvBuffer + sizeof(IP_HEADER) + sizeof(ICMP_HEADER) \   
 515.         + sizeof(COMMAND_HEADER);   
 516.            
 517.    
 518.     memcpy(pcDataBuffer, pcDataPart, nBytes);   
 519.    
 520.     return nBytes;   
 521. }   
 522.    
 523.    
 524.    
 525.    
 526. ////////////////////////////////////////////////////////////////////////////////   
 527. //   
 528. //   
 529. //   
 530. //   
 531. //   
 532. //   
 533. //   
 534. //   
 535. ////////////////////////////////////////////////////////////////////////////////   
 536. BOOL Protocol::CalculateCheckSum(unsigned short * pusDataBuffer, int nBuffLen \   
 537.         , unsigned short * pusCheckSum)   
 538. {   
 539.     unsigned long ulSum;   
 540.     unsigned short usCheckSum;   
 541.    
 542.     //Check if arguments are valid.   
 543.     if(NULL == pusDataBuffer)   
 544.     {   
 545.         MessageBox(NULL, "In CalculateCheckSum, pusDataBuffer == NULL.", "warning", MB_OK);   
 546.         return FALSE;   
 547.     }   
 548.     if(nBuffLen < 0)   
 549.     {   
 550.         MessageBox(NULL, "In CalculateCheckSum, nBuffLen < 0.", "warning", MB_OK);   
 551.         return FALSE;   
 552.     }   
 553.     if(NULL == pusCheckSum)   
 554.     {   
 555.         MessageBox(NULL, "In CalculateCheckSum, pusCheckSum == NULL.", "warning", MB_OK);   
 556.         return FALSE;   
 557.     }   
 558.    
 559.     //Calculate checksum.   
 560.     ulSum = 0;   
 561.     while(nBuffLen > 1)   
 562.     {   
 563.         ulSum = ulSum + *pusDataBuffer;   
 564.         pusDataBuffer = pusDataBuffer + 1;   
 565.         nBuffLen = nBuffLen - 2;   
 566.     }   
 567.    
 568.     if(1 == nBuffLen)   
 569.     {   
 570.         ulSum = ulSum + (unsigned short)*(unsigned char *)pusDataBuffer;   
 571.     }   
 572.    
 573.     while(ulSum >> 16)   
 574.     {   
 575.         ulSum = (ulSum >> 16) + (ulSum&0xffff);   
 576.     }   
 577.       
 578.     usCheckSum = (unsigned short)ulSum;   
 579.    
 580.     usCheckSum =  usCheckSum == 0xffff ? 0xffff : ~usCheckSum;   
 581.        
 582.     //Store usCheckSum.   
 583.     *pusCheckSum = usCheckSum;   
 584.    
 585.     return TRUE;   
 586. }   
 587.    
 588.    
 589.    
 590. ///////////////////////////////////////////////////////////////////////////////   
 591. //   
 592. //   
 593. //   
 594. //   
 595. //   
 596. //   
 597. //   
 598. //   
 599. ///////////////////////////////////////////////////////////////////////////////   
 600. void Protocol::RecordPacket(int nBytes)   
 601. {   
 602.     FILE * pFile = fopen("log.log", "w+");   
 603.     fwrite(m_pucSendBuffer, nBytes, 1, pFile);   
 604.     fclose(pFile);   
 605. }   
 606.    
 607. void Protocol::RecordChar(int nValue)   
 608. {   
 609.     FILE * pFile = fopen("log.str", "w+");   
 610.     fwrite(&nValue, sizeof(int), 1, pFile);   
 611.     fclose(pFile);   
 612. }