/** * @file * User Datagram Protocol module * *//* * Copyright (c) 2001-2004 Swedish Institute of Computer Science. * All rights reserved. * * Redistribution and use in source and binary forms, with or without modification, * are permitted provided that the following conditions are met: * * 1. Redistributions of source code must retain the above copyright notice, *    this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright notice, *    this list of conditions and the following disclaimer in the documentation *    and/or other materials provided with the distribution. * 3. The name of the author may not be used to endorse or promote products *    derived from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY * OF SUCH DAMAGE. * * This file is part of the lwIP TCP/IP stack. * * Author: Adam Dunkels <adam@sics.se> * *//* udp.c * * The code for the User Datagram Protocol UDP. * */#include <string.h>#include "lwip/opt.h"#include "lwip/def.h"#include "lwip/memp.h"#include "lwip/inet.h"#include "lwip/ip_addr.h"#include "lwip/netif.h"#include "lwip/udp.h"#include "lwip/icmp.h"#include "lwip/stats.h"#include "arch/perf.h"#include "lwip/snmp.h"/* The list of UDP PCBs */#if LWIP_UDP/* was static, but we may want to access this from a socket layer */struct udp_pcb *udp_pcbs = NULL;static struct udp_pcb *pcb_cache = NULL;voidudp_init(void){  udp_pcbs = pcb_cache = NULL;}/** * Process an incoming UDP datagram. * * Given an incoming UDP datagram (as a chain of pbufs) this function * finds a corresponding UDP PCB and * * @param pbuf pbuf to be demultiplexed to a UDP PCB. * @param netif network interface on which the datagram was received. * */voidudp_input(struct pbuf *p, struct netif *inp){  struct udp_hdr *udphdr;  struct udp_pcb *pcb;  struct ip_hdr *iphdr;  u16_t src, dest;#if SO_REUSE  struct udp_pcb *pcb_temp;  int reuse = 0;  int reuse_port_1 = 0;  int reuse_port_2 = 0;#endif /* SO_REUSE */    PERF_START;  UDP_STATS_INC(udp.recv);  iphdr = p->payload;  if (pbuf_header(p, -((s16_t)(UDP_HLEN + IPH_HL(iphdr) * 4)))) {    /* drop short packets */    LWIP_DEBUGF(UDP_DEBUG, ("udp_input: short UDP datagram (%u bytes) discarded\n", p->tot_len));    UDP_STATS_INC(udp.lenerr);    UDP_STATS_INC(udp.drop);    snmp_inc_udpinerrors();    pbuf_free(p);    goto end;  }  udphdr = (struct udp_hdr *)((u8_t *)p->payload - UDP_HLEN);  LWIP_DEBUGF(UDP_DEBUG, ("udp_input: received datagram of length %u\n", p->tot_len));  src = ntohs(udphdr->src);  dest = ntohs(udphdr->dest);  udp_debug_print(udphdr);  /* print the UDP source and destination */  LWIP_DEBUGF(UDP_DEBUG, ("udp (%u.%u.%u.%u, %u) <-- (%u.%u.%u.%u, %u)\n",    ip4_addr1(&iphdr->dest), ip4_addr2(&iphdr->dest),    ip4_addr3(&iphdr->dest), ip4_addr4(&iphdr->dest), ntohs(udphdr->dest),    ip4_addr1(&iphdr->src), ip4_addr2(&iphdr->src),    ip4_addr3(&iphdr->src), ip4_addr4(&iphdr->src), ntohs(udphdr->src)));#if SO_REUSE  pcb_temp = udp_pcbs;   again_1:    /* Iterate through the UDP pcb list for a fully matching pcb */  for (pcb = pcb_temp; pcb != NULL; pcb = pcb->next) {#else  /* SO_REUSE */   /* Iterate through the UDP pcb list for a fully matching pcb */  for (pcb = udp_pcbs; pcb != NULL; pcb = pcb->next) {#endif  /* SO_REUSE */     /* print the PCB local and remote address */    LWIP_DEBUGF(UDP_DEBUG, ("pcb (%u.%u.%u.%u, %u) --- (%u.%u.%u.%u, %u)\n",      ip4_addr1(&pcb->local_ip), ip4_addr2(&pcb->local_ip),      ip4_addr3(&pcb->local_ip), ip4_addr4(&pcb->local_ip), pcb->local_port,      ip4_addr1(&pcb->remote_ip), ip4_addr2(&pcb->remote_ip),      ip4_addr3(&pcb->remote_ip), ip4_addr4(&pcb->remote_ip), pcb->remote_port));       /* PCB remote port matches UDP source port? */    if ((pcb->remote_port == src) &&       /* PCB local port matches UDP destination port? */       (pcb->local_port == dest) &&       /* accepting from any remote (source) IP address? or... */       (ip_addr_isany(&pcb->remote_ip) ||       /* PCB remote IP address matches UDP source IP address? */        ip_addr_cmp(&(pcb->remote_ip), &(iphdr->src))) &&       /* accepting on any local (netif) IP address? or... */       (ip_addr_isany(&pcb->local_ip) ||       /* PCB local IP address matches UDP destination IP address? */        ip_addr_cmp(&(pcb->local_ip), &(iphdr->dest)))) {#if SO_REUSE      if (pcb->so_options & SOF_REUSEPORT) {        if(reuse) {          /* We processed one PCB already */          LWIP_DEBUGF(UDP_DEBUG, ("udp_input: second or later PCB and SOF_REUSEPORT set.\n"));        } else {          /* First PCB with this address */          LWIP_DEBUGF(UDP_DEBUG, ("udp_input: first PCB and SOF_REUSEPORT set.\n"));          reuse = 1;        }                reuse_port_1 = 1;         p->ref++;        LWIP_DEBUGF(UDP_DEBUG, ("udp_input: reference counter on PBUF set to %i\n", p->ref));      } else {        if (reuse) {          /* We processed one PCB already */          LWIP_DEBUGF(UDP_DEBUG, ("udp_input: second or later PCB but SOF_REUSEPORT not set !\n"));        }      }#endif /* SO_REUSE */      break;    }  }  /* no fully matching pcb found? then look for an unconnected pcb */  if (pcb == NULL) {    /* Iterate through the UDP PCB list for a pcb that matches       the local address. */#if SO_REUSE    pcb_temp = udp_pcbs;      again_2:    for (pcb = pcb_temp; pcb != NULL; pcb = pcb->next) {#else  /* SO_REUSE */     for (pcb = udp_pcbs; pcb != NULL; pcb = pcb->next) {#endif  /* SO_REUSE */       LWIP_DEBUGF(UDP_DEBUG, ("pcb (%u.%u.%u.%u, %u) --- (%u.%u.%u.%u, %u)\n",        ip4_addr1(&pcb->local_ip), ip4_addr2(&pcb->local_ip),        ip4_addr3(&pcb->local_ip), ip4_addr4(&pcb->local_ip), pcb->local_port,        ip4_addr1(&pcb->remote_ip), ip4_addr2(&pcb->remote_ip),        ip4_addr3(&pcb->remote_ip), ip4_addr4(&pcb->remote_ip), pcb->remote_port));      /* unconnected? */      if (((pcb->flags & UDP_FLAGS_CONNECTED) == 0) &&         /* destination port matches? */        (pcb->local_port == dest) &&        /* not bound to a specific (local) interface address? or... */        (ip_addr_isany(&pcb->local_ip) ||        /* ...matching interface address? */        ip_addr_cmp(&(pcb->local_ip), &(iphdr->dest)))) {#if SO_REUSE        if (pcb->so_options & SOF_REUSEPORT) {          if (reuse) {            /* We processed one PCB already */            LWIP_DEBUGF(UDP_DEBUG, ("udp_input: second or later PCB and SOF_REUSEPORT set.\n"));          } else {            /* First PCB with this address */            LWIP_DEBUGF(UDP_DEBUG, ("udp_input: first PCB and SOF_REUSEPORT set.\n"));            reuse = 1;          }                    reuse_port_2 = 1;           p->ref++;          LWIP_DEBUGF(UDP_DEBUG, ("udp_input: reference counter on PBUF set to %i\n", p->ref));        } else {          if (reuse) {            /* We processed one PCB already */            LWIP_DEBUGF(UDP_DEBUG, ("udp_input: second or later PCB but SOF_REUSEPORT not set !\n"));          }        }#endif /* SO_REUSE */        break;      }    }  }  /* Check checksum if this is a match or if it was directed at us. */  if (pcb != NULL  || ip_addr_cmp(&inp->ip_addr, &iphdr->dest))    {    LWIP_DEBUGF(UDP_DEBUG | DBG_TRACE, ("udp_input: calculating checksum\n"));    pbuf_header(p, UDP_HLEN);#ifdef IPv6    if (iphdr->nexthdr == IP_PROTO_UDPLITE) {#else    if (IPH_PROTO(iphdr) == IP_PROTO_UDPLITE) {#endif /* IPv4 */      /* Do the UDP Lite checksum */#if CHECKSUM_CHECK_UDP      if (inet_chksum_pseudo(p, (struct ip_addr *)&(iphdr->src),         (struct ip_addr *)&(iphdr->dest),         IP_PROTO_UDPLITE, ntohs(udphdr->len)) != 0) {  LWIP_DEBUGF(UDP_DEBUG | 2, ("udp_input: UDP Lite datagram discarded due to failing checksum\n"));  UDP_STATS_INC(udp.chkerr);  UDP_STATS_INC(udp.drop);  snmp_inc_udpinerrors();  pbuf_free(p);  goto end;      }#endif    } else {#if CHECKSUM_CHECK_UDP      if (udphdr->chksum != 0) {  if (inet_chksum_pseudo(p, (struct ip_addr *)&(iphdr->src),       (struct ip_addr *)&(iphdr->dest),        IP_PROTO_UDP, p->tot_len) != 0) {    LWIP_DEBUGF(UDP_DEBUG | 2, ("udp_input: UDP datagram discarded due to failing checksum\n"));    UDP_STATS_INC(udp.chkerr);    UDP_STATS_INC(udp.drop);    snmp_inc_udpinerrors();    pbuf_free(p);    goto end;  }      }#endif    }    pbuf_header(p, -UDP_HLEN);    if (pcb != NULL) {      snmp_inc_udpindatagrams();      pcb->recv(pcb->recv_arg, pcb, p, &(iphdr->src), src);#if SO_REUSE      /* First socket should receive now */      if(reuse_port_1 || reuse_port_2) {        /* We want to search on next socket after receiving */        pcb_temp = pcb->next;                if(reuse_port_1) {          /* We are searching connected sockets */          reuse_port_1 = 0;          reuse_port_2 = 0;          goto again_1;        } else {          /* We are searching unconnected sockets */          reuse_port_1 = 0;          reuse_port_2 = 0;          goto again_2;        }      }#endif /* SO_REUSE */     } else {#if SO_REUSE      if(reuse) {        LWIP_DEBUGF(UDP_DEBUG, ("udp_input: freeing PBUF with reference counter set to %i\n", p->ref));        pbuf_free(p);        goto end;      }#endif /* SO_REUSE */      LWIP_DEBUGF(UDP_DEBUG | DBG_TRACE, ("udp_input: not for us.\n"));      /* No match was found, send ICMP destination port unreachable unless      destination address was broadcast/multicast. */      if (!ip_addr_isbroadcast(&iphdr->dest, inp) &&          !ip_addr_ismulticast(&iphdr->dest)) {  /* adjust pbuf pointer */  p->payload = iphdr;  icmp_dest_unreach(p, ICMP_DUR_PORT);      }      UDP_STATS_INC(udp.proterr);      UDP_STATS_INC(udp.drop);    snmp_inc_udpnoports();      pbuf_free(p);    }  } else {    pbuf_free(p);  }  end:  PERF_STOP("udp_input");}/** * Send data to a specified address using UDP. * * @param pcb UDP PCB used to send the data. * @param pbuf chain of pbuf's to be sent. * @param dst_ip Destination IP address. * @param dst_port Destination UDP port. * * If the PCB already has a remote address association, it will * be restored after the data is sent. *  * @return lwIP error code. * - ERR_OK. Successful. No error occured. * - ERR_MEM. Out of memory. * - ERR_RTE. Could not find route to destination address. * * @see udp_disconnect() udp_send() */err_tudp_sendto(struct udp_pcb *pcb, struct pbuf *p,  struct ip_addr *dst_ip, u16_t dst_port){  err_t err;  /* temporary space for current PCB remote address */  struct ip_addr pcb_remote_ip;  u16_t pcb_remote_port;  /* remember current remote peer address of PCB */  pcb_remote_ip.addr = pcb->remote_ip.addr;  pcb_remote_port = pcb->remote_port;  /* copy packet destination address to PCB remote peer address */  pcb->remote_ip.addr = dst_ip->addr;  pcb->remote_port = dst_port;  /* send to the packet destination address */  err = udp_send(pcb, p);  /* restore PCB remote peer address */  pcb->remote_ip.addr = pcb_remote_ip.addr;  pcb->remote_port = pcb_remote_port;  return err;}/** * Send data using UDP. * * @param pcb UDP PCB used to send the data. * @param pbuf chain of pbuf's to be sent. * * @return lwIP error code. * - ERR_OK. Successful. No error occured. * - ERR_MEM. Out of memory. * - ERR_RTE. Could not find route to destination address. * * @see udp_disconnect() udp_sendto() */err_tudp_send(struct udp_pcb *pcb, struct pbuf *p){  struct udp_hdr *udphdr;  struct netif *netif;  struct ip_addr *src_ip;  err_t err;  struct pbuf *q; /* q will be sent down the stack */  LWIP_DEBUGF(UDP_DEBUG | DBG_TRACE | 3, ("udp_send\n"));  /* if the PCB is not yet bound to a port, bind it here */  if (pcb->local_port == 0) {