C 如果事先没有ping，UDP数据包不会到达

我有一个代码将UDP数据包从linux设备（服务器）发送到另一个（客户端）。我有一个问题，什么时候做这件事

重新启动服务器

运行程序发送数据包，但客户端未收到该数据包

然后，如果我对客户端ip进行ping，并再次运行该程序，那么现在该数据包将被客户端接收

代码如下：

  int main (int argc, char **argv){
  int i, status, datalen, frame_length, sd, bytes;
  char *interface, *target, *src_ip, *dst_ip;
  struct ip6_hdr iphdr;
  struct udphdr udphdr;
  uint8_t *data, *src_mac, *dst_mac, *ether_frame;
  struct addrinfo hints, *res;
  struct sockaddr_in6 *ipv6;
  struct sockaddr_ll device;
  struct ifreq ifr;
  void *tmp;

  // Allocate memory for various arrays.
  src_mac = allocate_ustrmem (6);
  dst_mac = allocate_ustrmem (6);
  data = allocate_ustrmem (IP_MAXPACKET);
  ether_frame = allocate_ustrmem (IP_MAXPACKET);
  interface = allocate_strmem (INET6_ADDRSTRLEN);
  target = allocate_strmem (INET6_ADDRSTRLEN);
  src_ip = allocate_strmem (INET6_ADDRSTRLEN);
  dst_ip = allocate_strmem (INET6_ADDRSTRLEN);

  // Interface to send packet through.
  strcpy (interface, "usb0");

  // Submit request for a socket descriptor to look up interface.
  if ((sd = socket (PF_PACKET, SOCK_RAW, htons (ETH_P_ALL))) < 0) {
    perror ("socket() failed to get socket descriptor for using ioctl() ");
    exit (EXIT_FAILURE);
  }

  // Use ioctl() to look up interface name and get its MAC address.
  memset (&ifr, 0, sizeof (ifr));
  snprintf (ifr.ifr_name, sizeof (ifr.ifr_name), "%s", interface);
  if (ioctl (sd, SIOCGIFHWADDR, &ifr) < 0) {
    perror ("ioctl() failed to get source MAC address ");
    return (EXIT_FAILURE);
  }
  close (sd);

  // Copy source MAC address.
  memcpy (src_mac, ifr.ifr_hwaddr.sa_data, 6 * sizeof (uint8_t));

  // Report source MAC address to stdout.
  printf ("MAC address for interface %s is ", interface);
  for (i=0; i<5; i++) {
    printf ("%02x:", src_mac[i]);
  }
  printf ("%02x\n", src_mac[5]);

  // Find interface index from interface name and store index in
  // struct sockaddr_ll device, which will be used as an argument of sendto().
  memset (&device, 0, sizeof (device));
  if ((device.sll_ifindex = if_nametoindex (interface)) == 0) {
    perror ("if_nametoindex() failed to obtain interface index ");
    exit (EXIT_FAILURE);
  }
  printf ("Index for interface %s is %i\n", interface, device.sll_ifindex);

  // Set destination MAC address
  dst_mac[0] = 0x00;
  dst_mac[1] = 0x11;
  dst_mac[2] = 0x7d;
  dst_mac[3] = 0x30;
  dst_mac[4] = 0x7f;
  dst_mac[5] = 0xd0;

  // Source IPv6 address
  strcpy (src_ip, "fe80::11:7dff:fe30:8013");

  // Destination URL or IPv6 address
  strcpy (target, "fe80:0000:0000:0000:0211:7d00:0030:7fd0");

  // Fill out hints for getaddrinfo().
  memset (&hints, 0, sizeof (hints));
  hints.ai_family = AF_INET6;
  hints.ai_socktype = SOCK_STREAM;
  hints.ai_flags = hints.ai_flags | AI_CANONNAME;

  // Resolve target using getaddrinfo().
  if ((status = getaddrinfo (target, NULL, &hints, &res)) != 0) {
    fprintf (stderr, "getaddrinfo() failed: %s\n", gai_strerror (status));
    exit (EXIT_FAILURE);
  }
  ipv6 = (struct sockaddr_in6 *) res->ai_addr;
  tmp = &(ipv6->sin6_addr);
  if (inet_ntop (AF_INET6, tmp, dst_ip, INET6_ADDRSTRLEN) == NULL) {
    status = errno;
    fprintf (stderr, "inet_ntop() failed.\nError message: %s", strerror (status));
    exit (EXIT_FAILURE);
  }
  freeaddrinfo (res);

  // Fill out sockaddr_ll.
  device.sll_family = AF_PACKET;
  memcpy (device.sll_addr, src_mac, 6 * sizeof (uint8_t));
  device.sll_halen = 6;

  // UDP data
  datalen = 4;
  data[0] = 'T';
  data[1] = 'E';
  data[2] = 'S';
  data[3] = 'T';

  // IPv6 header

  // IPv6 version (4 bits), Traffic class (8 bits), Flow label (20 bits)
  iphdr.ip6_flow = htonl ((6 << 28) | (0 << 20) | 0);

  // Payload length (16 bits): UDP header + UDP data
  iphdr.ip6_plen = htons (UDP_HDRLEN + datalen);

  // Next header (8 bits): 17 for UDP
  iphdr.ip6_nxt = IPPROTO_UDP;

  // Hop limit (8 bits): default to maximum value
  iphdr.ip6_hops = 255;

  // Source IPv6 address (128 bits)
  if ((status = inet_pton (AF_INET6, src_ip, &(iphdr.ip6_src))) != 1) {
    fprintf (stderr, "inet_pton() failed.\nError message: %s", strerror (status));
    exit (EXIT_FAILURE);
  }

  // Destination IPv6 address (128 bits)
  if ((status = inet_pton (AF_INET6, dst_ip, &(iphdr.ip6_dst))) != 1) {
    fprintf (stderr, "inet_pton() failed.\nError message: %s", strerror (status));
    exit (EXIT_FAILURE);
  }

  // UDP header

  // Source port number (16 bits): pick a number
  udphdr.source = htons (61616);

  // Destination port number (16 bits): pick a number
  udphdr.dest = htons (61616);

  // Length of UDP datagram (16 bits): UDP header + UDP data
  udphdr.len = htons (UDP_HDRLEN + datalen);

  // UDP checksum (16 bits)
  udphdr.check = udp6_checksum (iphdr, udphdr, data, datalen);

  // Fill out ethernet frame header.

  // Ethernet frame length = ethernet header (MAC + MAC + ethernet type) + ethernet data (IP header + UDP header + UDP data)
  frame_length = 6 + 6 + 2 + IP6_HDRLEN + UDP_HDRLEN + datalen;

  // Destination and Source MAC addresses
  memcpy (ether_frame, dst_mac, 6 * sizeof (uint8_t));
  memcpy (ether_frame + 6, src_mac, 6 * sizeof (uint8_t));

  // Next is ethernet type code (ETH_P_IPV6 for IPv6).
  // http://www.iana.org/assignments/ethernet-numbers
  ether_frame[12] = ETH_P_IPV6 / 256;
  ether_frame[13] = ETH_P_IPV6 % 256;

  // Next is ethernet frame data (IPv6 header + UDP header + UDP data).

  // IPv6 header
  memcpy (ether_frame + ETH_HDRLEN, &iphdr, IP6_HDRLEN * sizeof (uint8_t));

  // UDP header
  memcpy (ether_frame + ETH_HDRLEN + IP6_HDRLEN, &udphdr, UDP_HDRLEN * sizeof (uint8_t));

  // UDP data
  memcpy (ether_frame + ETH_HDRLEN + IP6_HDRLEN + UDP_HDRLEN, data, datalen * sizeof (uint8_t));

  // Submit request for a raw socket descriptor.
  if ((sd = socket (PF_PACKET, SOCK_RAW, htons (ETH_P_ALL))) < 0) {
    perror ("socket() failed ");
    exit (EXIT_FAILURE);
  }

  // Send ethernet frame to socket.
  if ((bytes = sendto (sd, ether_frame, frame_length, 0, (struct sockaddr *) &device, sizeof (device))) <= 0) {
    perror ("sendto() failed");
    exit (EXIT_FAILURE);
  }

  // Close socket descriptor.
  close (sd);

  // Free allocated memory.
  free (src_mac);
  free (dst_mac);
  free (data);
  free (ether_frame);
  free (interface);
  free (target);
  free (src_ip);
  free (dst_ip);

  return (EXIT_SUCCESS);
}

int main（int argc，char**argv）{
int i，状态，数据长度，帧长度，sd，字节；
字符*接口、*目标、*src_ip、*dst_ip；
结构ip6_hdr iphdr；
结构udphdr udphdr；
uint8_t*数据、*src_mac、*dst_mac、*以太帧；
结构addrinfo提示，*res；
6*ipv6中的结构sockaddr_；
结构sockaddr\u ll设备；
结构ifreq-ifr；
无效*tmp；
//为各种阵列分配内存。
src_mac=allocate_ustrem（6）；
dst_mac=分配（6）；
数据=分配USTMEM（IP最大数据包）；
以太帧=分配USTMEM（IP最大数据包）；
接口=分配\u strem（INET6\u ADDRSTRLEN）；
目标=分配\u strem（INET6\u ADDRSTRLEN）；
src\u ip=分配\u strem（INET6\u ADDRSTRLEN）；
dst_ip=allocate_strem（INET6_ADDRSTRLEN）；
//用于发送数据包的接口。
strcpy（接口，“usb0”）；
//提交套接字描述符的请求以查找接口。
如果（（sd=套接字（PF_数据包、SOCK_原始、htons（ETH_P_全部）））<0）{
perror（“socket（）无法获取用于使用ioctl（）的套接字描述符”）；
退出（退出失败）；
}
//使用ioctl（）查找接口名称并获取其MAC地址。
memset（&ifr，0，sizeof（ifr））；
snprintf（ifr.ifr\u名称，sizeof（ifr.ifr\u名称），“%s”，接口）；
如果（ioctl（sd、SIOCGIFHWADDR和ifr）<0）{
perror（“ioctl（）无法获取源MAC地址”）；
返回（退出失败）；
}
关闭（sd）；
//复制源MAC地址。
memcpy（src_mac，ifr.ifr_hwaddr.sa_数据，6*sizeof（uint8_t））；
//向标准输出报告源MAC地址。
printf（“接口%s的MAC地址为”，接口）；
对于（i=0；iai_addr；
tmp=&（ipv6->sin6地址）；
if（inet_ntop（AF_INET6、tmp、dst_ip、INET6_ADDRSTRLEN）==NULL）{
状态=错误号；
fprintf（stderr，“inet_ntop（）失败。\n错误消息：%s”，strerror（status））；
退出（退出失败）；
}
freeaddrinfo（res）；
//填写sockaddr\u ll。
device.sll_family=AF_数据包；
memcpy（device.sll_addr，src_mac，6*sizeof（uint8_t））；
device.sll_halen=6；
//UDP数据
datalen=4；
数据[0]=“T”；
数据[1]=“E”；
数据[2]=“S”；
数据[3]＝‘T’；
//IPv6报头
//IPv6版本（4位）、流量类别（8位）、流量标签（20位）
iphdr.ip6_flow=htonl（（6如果
dst mac
不在
ARP
表中，您选择发送
UDP
数据包的方法似乎会失败。不知何故，这样做会导致
dst mac
的内核不
ARP
（可能是因为您已手动将其插入数据包）-但是-数据包传输仍然失败，因为它不存在于
ARP
表中。
ping
导致
ARP
表被填充，然后它开始工作

这只是一个理论。我们必须看看内核路径来证实这一点

你可以尝试几个实验来证实这个理论

不要
ping
。运行该程序几次，看看它在后续运行中是否有效
首先
ping
，然后尝试该程序（应该可以运行），然后刷新
ARP
表，再次尝试该程序（应该失败）。使用
sudo ip-s-s neigh flush all
刷新
ARP
表
是否有任何理由不使用
SOCK_DGRAM
，这是执行
UDP
的标准方法

编辑

正如评论中所指出的，我忽略了OP正在使用IPV6的事实。将所有提到的ARP替换为邻居（以及同等的）.
如果你多次运行程序，没有ping或任何其他网络通信，会发生什么？如果你在运行程序之前只等待五分钟会发生什么？实际上，IPv6没有ARP-它使用NDP。没错。我没有注意到。但是理论仍然适用。是的，它有，这就是为什么我投+1票。我只是想是的您可能想更正IPv6的答案。谢谢。添加了一些词。NDP是ARP的一大改进，因为ARP广播并中断每台主机，但NDP基于IPv6地址的最后24位多播到特定组，可能只命中它试图解析第2层地址的一台主机。