/** * @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 udp_pcb *uncon_pcb;  struct ip_hdr *iphdr;  u16_t src, dest;  u8_t local_match;  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 (%"U16_F" 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 %"U16_F"\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 (%"U16_F".%"U16_F".%"U16_F".%"U16_F", %"U16_F") <-- (%"U16_F".%"U16_F".%"U16_F".%"U16_F", %"U16_F")\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)));  local_match = 0;  uncon_pcb = NULL;  /* Iterate through the UDP pcb list for a matching pcb */  for (pcb = udp_pcbs; pcb != NULL; pcb = pcb->next) {    /* print the PCB local and remote address */    LWIP_DEBUGF(UDP_DEBUG, ("pcb (%"U16_F".%"U16_F".%"U16_F".%"U16_F", %"U16_F") --- (%"U16_F".%"U16_F".%"U16_F".%"U16_F", %"U16_F")\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));    /* compare PCB local addr+port to UDP destination addr+port */    if ((pcb->local_port == dest) &&       (ip_addr_isany(&pcb->local_ip) ||        ip_addr_cmp(&(pcb->local_ip), &(iphdr->dest)))) {       local_match = 1;       if ((uncon_pcb == NULL) &&            ((pcb->flags & UDP_FLAGS_CONNECTED) == 0)) {         /* the first unconnected matching PCB */              uncon_pcb = pcb;       }    }    /* compare PCB remote addr+port to UDP source addr+port */    if ((local_match != 0) &&       (pcb->remote_port == src) &&       (ip_addr_isany(&pcb->remote_ip) ||       ip_addr_cmp(&(pcb->remote_ip), &(iphdr->src)))) {       /* the first fully matching PCB */      break;    }  }  /* no fully matching pcb found? then look for an unconnected pcb */  if (pcb == NULL) {    pcb = uncon_pcb;  }  /* 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();      /* callback */      if (pcb->recv != NULL)      {        pcb->recv(pcb->recv_arg, pcb, p, &(iphdr->src), src);      }        } else {      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) {    LWIP_DEBUGF(UDP_DEBUG | DBG_TRACE | 2, ("udp_send: not yet bound to a port, binding now\n"));    err = udp_bind(pcb, &pcb->local_ip, pcb->local_port);    if (err != ERR_OK) {      LWIP_DEBUGF(UDP_DEBUG | DBG_TRACE | 2, ("udp_send: forced port bind failed\n"));      return err;    }  }  /* find the outgoing network interface for this packet */  netif = ip_route(&(pcb->remote_ip));  /* no outgoing network interface could be found? */  if (netif == NULL) {    LWIP_DEBUGF(UDP_DEBUG | 1, ("udp_send: No route to 0x%"X32_F"\n", pcb->remote_ip.addr));    UDP_STATS_INC(udp.rterr);    return ERR_RTE;  }  /* not enough space to add an UDP header to first pbuf in given p chain? */  if (pbuf_header(p, UDP_HLEN)) {    /* allocate header in a seperate new pbuf */    q = pbuf_alloc(PBUF_IP, UDP_HLEN, PBUF_RAM);    /* new header pbuf could not be allocated? */    if (q == NULL) {      LWIP_DEBUGF(UDP_DEBUG | DBG_TRACE | 2, ("udp_send: could not allocate header\n"));      return ERR_MEM;    }    /* chain header q in front of given pbuf p */