SOCK_RAW, icmp, ping实现

// ICMP_study.cpp : 定义控制台应用程序的入口点。

//

#include "stdafx.h"

#include <winsock2.h>  

#include <WS2tcpip.h>  

#include <stdio.h>  

#include <stdlib.h>  

#define ICMP_ECHO 8  

#define ICMP_ECHOREPLY 0  

#define ICMP_MIN 8 //Minimum 8-byte ICMP packet (header)  

#define DEF_PACKET_SIZE 32  

#define MAX_PACKET 1024  

#define MAX_IP_HDR_SIZE 60  

#pragma comment(lib, "ws2_32.lib")

//IP header structure  

typedef struct _iphdr  

{  
unsigned int h_len:4;//Length of the header  
unsigned int version:4;//Version of IP  
unsigned char tos;//Type of service  
unsigned short total_len;//Total length of the packet  
unsigned short ident;//Unique identifier  
unsigned short frag_and_flags;//Flags  
unsigned char ttl;//Time to live  
unsigned char proto;//Protocol (TCP,UDP,etc.)  
unsigned short checksum;//IP checksum  

unsigned int sourceIP;  
unsigned int destIP;  

} IpHeader;  

//ICMP header structure  

typedef struct _icmphdr  

{  
BYTE i_type;  
BYTE i_code;//Type sub code  
USHORT i_cksum;  
USHORT i_id;  
USHORT i_seq;  

//This is not the standard header, but we reserve space for time  
ULONG timestamp;  

} IcmpHeader;  

//IP option header--use with socket option IP_OPTIONS  

typedef struct _ipoptionhdr  

{  
unsigned char code;//Option type  
unsigned char len;//Length of option hdr  
unsigned char ptr;//Offset into optons  
unsigned long addr[9];//List of IP addrs  

} IpOptionHeader;  

//Helper function to fill in various fields for our ICMP request  

void FillICMPData(char* icmp_data, int datasize)  

{  
//此结构体的填充是根据协议来的
IcmpHeader* icmp_hdr = (IcmpHeader*)icmp_data;  
icmp_hdr->i_type = ICMP_ECHO;//Request an ICMP echo  
icmp_hdr->i_code = 0;  
icmp_hdr->i_id = (USHORT)GetCurrentProcessId();  
icmp_hdr->i_cksum = 0;  
icmp_hdr->i_seq = 0;  

}  

//This function calculates the 16-bit one's complement sum  

//of the supplied buffer (ICMP) header  

USHORT checksum(USHORT* buffer, int size)  

{  
unsigned long cksum = 0;  

while (size > 1)  
{  
cksum += *buffer++;  
size -= sizeof(USHORT);  
}  

if (size)  
{  
cksum += *(UCHAR*)buffer;  
}  

cksum = (cksum>>16) + (cksum & 0xffff);  
cksum += (cksum>>16);  

return (USHORT)(~cksum);  

}  

//If the IP option header is present, find the IP options  

//within the IP header and print the record route option values  

void DecodeIPOptions(char* buf, int bytes)  

{  
IpOptionHeader* ipopt = (IpOptionHeader*)(buf + 20);  

printf("RR:    ");  
for (int i = 0; i < (ipopt->ptr / 4) - 1; i++)  
{  
IN_ADDR inaddr;  
inaddr.S_un.S_addr = ipopt->addr[i];  

if (i != 0)  
{  
printf("        ");  
}  

HOSTENT* host = gethostbyaddr((char*)&inaddr.S_un.S_addr,  
sizeof(inaddr.S_un.S_addr), AF_INET);  
if (host)  
{  
printf("(%-15s) %s\n", inet_ntoa(inaddr), host->h_name);  
}  
else  
{  
printf("(%-15s)\n", inet_ntoa(inaddr));  
}  
}  

return;  

}  

//The response is an IP packet. We must decode the IP header to  

//locate the ICMP data.  

void DecodeICMPHeader(char* buf, int bytes, struct sockaddr_in* from)  

{  
static int icmpcount = 0;  
IpHeader* iphdr = (IpHeader*)buf;  

//Number of 32-bit words * 4 = bytes  
unsigned short iphdrlen = iphdr->h_len * 4;
//这是在分析ip包
DWORD tick = GetTickCount();  

if ((iphdrlen == MAX_IP_HDR_SIZE) && (!icmpcount))  
{  
DecodeIPOptions(buf, bytes);  
}  

if (bytes < iphdrlen + ICMP_MIN)  
{  
printf("Too few bytes from %s\n", inet_ntoa(from->sin_addr));  
}  

IcmpHeader* icmphdr = (IcmpHeader*)(buf + iphdrlen);  
if (icmphdr->i_type != ICMP_ECHOREPLY)  
{  
printf("nonecho type %d recvd\n", icmphdr->i_type);  
return;  
}  

//Make sure this is an ICMP reply to something we sent!  
if (icmphdr->i_id != (USHORT)GetCurrentProcessId())  
{  
printf("someone else's packet!\n");  
return;  
}  

//此处算出来的timestamp,是发送与接收之间的间隔
printf("%d bytes from %s:", bytes, inet_ntoa(from->sin_addr));  
printf("  icmp_seq = %d. ", icmphdr->i_seq);  
printf("  time:%d ms", tick - icmphdr->timestamp);  
printf("\n");  

icmpcount++;  
return;  

}  

BOOL fgInitSocket()

{
WSADATA wsaData;  
if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)  
{  
printf("WSAStartup() failed:%d\n", GetLastError());  
return FALSE;  
}  
return TRUE;

}

SOCKET sCreateRawSocket()

{
SOCKET sockRaw = WSASocket(AF_INET, SOCK_RAW, IPPROTO_ICMP, NULL, 0, WSA_FLAG_OVERLAPPED);  
if (sockRaw == INVALID_SOCKET)  
{  
printf("WSASocket() failed:%d\n", WSAGetLastError());  
return INVALID_SOCKET;  
}  

//Set the send/recv timeout values  
int timeout = 1000;  

int bread = setsockopt(sockRaw, SOL_SOCKET, SO_RCVTIMEO, (char*)&timeout, sizeof(timeout));  
if (bread == SOCKET_ERROR)  
{  
printf("setsockopt(SO_RCVTIMEO) failed:%d\n", WSAGetLastError());  
return INVALID_SOCKET;  
}  

timeout = 1000;  
bread = setsockopt(sockRaw, SOL_SOCKET, SO_SNDTIMEO, (char*)&timeout, sizeof(timeout));  
if (bread == SOCKET_ERROR)  
{  
printf("setsockopt(SO_SNDTIMEO) failed:%d\n", WSAGetLastError());  
return INVALID_SOCKET;  
} 
return sockRaw;

}

int _tmain(int argc, _TCHAR* argv[])

{
if (!fgInitSocket())
{
return -1;
}

SOCKET sockRaw = sCreateRawSocket();
if (sockRaw == INVALID_SOCKET)
{
return -1;
}

struct sockaddr_in from;  
int fromlen = sizeof(from);  

struct sockaddr_in dest;  
memset(&dest, 0, sizeof(dest));  
dest.sin_family = AF_INET;  
dest.sin_addr.s_addr = inet_addr("101.226.103.106");  

//Create the ICMP packet  
char icmp_data[MAX_PACKET] = {0};
memset(icmp_data, 0, MAX_PACKET);  
FillICMPData(icmp_data, sizeof(IcmpHeader));  

char recvbuf[MAX_PACKET] = {0};

//Start sending/receiving ICMP packets  
USHORT seq_no = 0;  
while (true)  
{  
static int nCount = 0;  
int bwrote;  

if (nCount++ == 4)  
{  
break;  
}  

((IcmpHeader*)icmp_data)->i_cksum = 0;  
((IcmpHeader*)icmp_data)->timestamp = GetTickCount();  
((IcmpHeader*)icmp_data)->i_seq = seq_no++;  
((IcmpHeader*)icmp_data)->i_cksum =  checksum((USHORT*)icmp_data, sizeof(IcmpHeader));  

bwrote = sendto(sockRaw, icmp_data, sizeof(IcmpHeader), 0, (struct sockaddr*)&dest, sizeof(dest));  
if (bwrote == SOCKET_ERROR)  
{  
if (WSAGetLastError() == WSAETIMEDOUT)  
{  
printf("timed out\n");  
continue;  
}  

printf("sendto() failed:%d\n", WSAGetLastError());  
return -1;  
}  

if (bwrote < sizeof(IcmpHeader))  
{  
printf("Wrote %d bytes\n", bwrote);  
}  

int bread = recvfrom(sockRaw, recvbuf, MAX_PACKET, 0,  (struct sockaddr*)&from, &fromlen);  
if (bread == SOCKET_ERROR)  
{  
int iErr = GetLastError();
if (iErr == WSAETIMEDOUT)  
{  
printf("timed out\n");  
continue;  
}  

printf("revefrom() failed:%d\n", iErr);  
return -1;  
}  

DecodeICMPHeader(recvbuf, bread, &from);  

Sleep(1000);  
}  

//Cleanup  
if (sockRaw != INVALID_SOCKET)  
{  
closesocket(sockRaw);  
}  

WSACleanup(); 
return 0;

}