1

int socket(int domain, int type, int protocol);

1
2

sd = socket(PF_INET, SOCK_STREAM, 0);
sd = socket(PF_INET, SOCK_DGRAM, 0);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

/* 由自己填充 TCP 头 */
s = socket(AF_INET, SOCK_RAW, IPPROTO_TCP);

/* 由自己填充 UDP 头 */
s = socket(AF_INET, SOCK_RAW, IPPROTO_UDP);

/* 由自己填充 ICMP 头 */
s = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP);

/* 由自己填充任何协议头 */
s = socket(AF_INET, SOCK_RAW, IPPROTO_RAW);

1
2
3
4
5

int on = 1;
if ((setsockopt(s, IPPROTO_IP, IP_HDRINCL, &on, sizeof(on))) == -1)
{
    LOG_D(TAG, "[setsockopt] IP_HDRINCL errno: %d", errno);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

/*
 * Structure of an icmp header.
 */
struct icmp {
	uint8_t  icmp_type;		/* type of message */
	uint8_t  icmp_code;		/* type sub code */
	uint16_t icmp_cksum;		/* ones complement cksum of struct */
	union {
		uint8_t   ih_pptr;		/* ICMP_PARAMPROB */
		struct in_addr ih_gwaddr;	/* ICMP_REDIRECT */
		struct ih_idseq {
			  uint16_t  icd_id;
			  uint16_t  icd_seq;
		} ih_idseq;
		int32_t   ih_void;

		/* ICMP_UNREACH_NEEDFRAG -- Path MTU Discovery (RFC1191) */
		struct ih_pmtu {
			  uint16_t  ipm_void;
			  uint16_t  ipm_nextmtu;
		} ih_pmtu;

		struct ih_rtradv {
			uint8_t   irt_num_addrs;
			uint8_t   irt_wpa;
			uint16_t  irt_lifetime;
		} ih_rtradv;
	} icmp_hun;
// 定义了一些结构体区域内的宏, 方便调用
// 比如 sturct icmp *pk = new icmp();
// 要设置 sequence number, 则需要设置 pk->icmp_hun.ih_idseq.icd_seq = 0;
// 可以利用宏 icmp_seq, 等效简写为 pk->icmp_seq = 0;
#define	icmp_pptr	  icmp_hun.ih_pptr
#define	icmp_gwaddr	  icmp_hun.ih_gwaddr
#define	icmp_id		  icmp_hun.ih_idseq.icd_id
#define	icmp_seq	  icmp_hun.ih_idseq.icd_seq
#define	icmp_void	  icmp_hun.ih_void
#define	icmp_pmvoid	  icmp_hun.ih_pmtu.ipm_void
#define	icmp_nextmtu	  icmp_hun.ih_pmtu.ipm_nextmtu
#define	icmp_num_addrs	  icmp_hun.ih_rtradv.irt_num_addrs
#define	icmp_wpa	  icmp_hun.ih_rtradv.irt_wpa
#define	icmp_lifetime	  icmp_hun.ih_rtradv.irt_lifetime
	union {
		struct id_ts {
			  uint32_t  its_otime;
			  uint32_t  its_rtime;
			  uint32_t  its_ttime;
		} id_ts;
		struct id_ip  {
			  struct ip idi_ip;
			  /* options and then 64 bits of data */
		} id_ip;
		uint32_t  id_mask;
		int8_t	  id_data[1];
	} icmp_dun;
#define	icmp_otime	  icmp_dun.id_ts.its_otime
#define	icmp_rtime	  icmp_dun.id_ts.its_rtime
#define	icmp_ttime	  icmp_dun.id_ts.its_ttime
#define	icmp_ip		  icmp_dun.id_ip.idi_ip
#define	icmp_mask	  icmp_dun.id_mask
#define	icmp_data	  icmp_dun.id_data
};

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

#include "log.h"
#include <errno.h>
#include <memory>
#include <sys/socket.h>
#include <unistd.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <netinet/ip_icmp.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <signal.h>
#include <sys/time.h>
#include "checksum.cpp"

namespace NetUtility
{

#define TAG "NetUtility"
#define BUFFER_SIZE 1500

void doping(int signal);

int s;
struct sockaddr_in serveraddr;
int step, max = 0;
char *hostname, *ipadrr;

void ping(const char *host, int maxstep)
{
    max = maxstep;
    struct timeval tval;
    struct itimerval timer;
    struct sigaction act;

    /* Setting the handler for the SIGALRM and SIGINI signals */
    memset(&act, 0, sizeof(act));
    act.sa_handler = &doping;
    sigaction(SIGALRM, &act, NULL);
    sigaction(SIGINT, &act, NULL);

    // Host resolve domain name service
    hostent *h = gethostbyname(host);
    hostname = h->h_name;
    ipadrr = inet_ntoa(*(struct in_addr *)(h->h_addr));

    s = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP);
    int n = 1;

    if (s == -1)
    {
        LOG_D(TAG, "create socket fd failed. errno: %d", errno);
        if (errno == EPERM)
        {
            LOG_D(TAG, "Operation not permitted");
        }
        if (errno == EACCES)
        {
            LOG_D(TAG,
                  "Permission to create a socket of the specified type and/or protocol is denied");
        }
        exit(errno);
    }

    setuid(getuid());

    // Set broadcast
    int on = 1;
    if ((setsockopt(s, SOL_SOCKET, SO_BROADCAST, &on, sizeof(on))) == -1)
    {
        LOG_D(TAG, "[setsockopt] SO_BROADCAST errno: %d", errno);
    }
    // Set buffer
    int size = 60 * 1024;
    if ((setsockopt(s, SOL_SOCKET, SO_RCVBUF, &size, sizeof(size))) == -1)
    {
        LOG_D(TAG, "[setsockopt] SO_RCVBUF errno: %d", errno);
    }

    /* Starting a timer to send the SIGALRM signal */
    timer.it_value.tv_sec = 0;
    timer.it_value.tv_usec = 1;
    /* Timer first every second */
    timer.it_interval.tv_sec = 1;
    timer.it_interval.tv_usec = 0;
    /* Starting the real-time timer */
    setitimer(ITIMER_REAL, &timer, NULL);

    bzero(&serveraddr, sizeof(serveraddr));
    serveraddr.sin_family = AF_INET;
    serveraddr.sin_addr = *((struct in_addr *)h->h_addr);

    // Receive from
    int bytes = 0;
    struct sockaddr_in from;
    socklen_t from_len = sizeof(from);
    char buffer[BUFFER_SIZE];

    while (1)
    {
        bytes = recvfrom(s,
                         buffer,
                         sizeof(buffer),
                         0,
                         (struct sockaddr *)&from,
                         &from_len);
        if (bytes < 0)
        {
            if (errno == EINTR)
            {
                continue;
            }
            LOG_D(TAG, "recvfrom() failed");
            continue;
        }
        gettimeofday(&tval, NULL);
        LOG_D(TAG, "%d bytes from %s", bytes, ipadrr);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

void doping(int signal)
{
    if (signal != SIGALRM || step >= max)
    {
        exit(1);
    }
    int icmplen;
    struct icmp *icmp;
    char sendbuf[BUFFER_SIZE];
    icmp = reinterpret_cast<struct icmp *>(sendbuf);
    /* Fill all filed of the ICMP message */
    icmp->icmp_type = ICMP_ECHO;
    icmp->icmp_code = 0;
    icmp->icmp_id = getpid();
    icmp->icmp_seq = step;
    gettimeofday((struct timeval *)icmp->icmp_data, NULL);

    icmplen = 8 + 56;
    icmp->icmp_cksum = 0;
    icmp->icmp_cksum = checksum(reinterpret_cast<unsigned short *>(icmp), icmplen);

    if (sendto(
            s,
            sendbuf,
            icmplen,
            0,
            reinterpret_cast<sockaddr *>(&serveraddr),
            sizeof(sockaddr)) < 0)
    {
        LOG_D(TAG, "[send to] error: %d", errno);
    }

    if (step == 0)
    {
        LOG_D(TAG, "PING %s (%s): %d data bytes", hostname, ipadrr, icmplen);
    }
    step++;
}

}; // namespace NetUtility

1
2
3
4
5

int main()
{
    NetUtility::ping("jiyang.site", 6);
    return 0;
}

1
2
3
4
5
6
7
8
9

val sd = Os.socket(OsConstants.AF_INET, OsConstants.SOCK_RAW, OsConstants.IPPROTO_ICMP)
val address = InetAddress.getByName("10.184.20.144")
val date = ByteArray(4)
date[0] = 8     //type
date[1] = 0     //code
date[2] = 100   //checksum
date[3] = 1     // identifier
date[4] = 0     //seq
val send = Os.sendto(sd, date, 0, date.size, 0, address, 0)