开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 查看源码
udp.c
资源名称：LWIP+GTM900+LPC2104.rar　[点击查看]
上传用户：yyhongfa
上传日期：2013-01-18
资源大小：267k
文件大小：27k
源码类别：

嵌入式/单片机编程

开发平台：

C/C++

udp.c：源码内容
  1. /**
  2.  * @file
  3.  * User Datagram Protocol module
  4.  *
  5.  */
  6. /*
  7.  * Copyright (c) 2001-2004 Swedish Institute of Computer Science.
  8.  * All rights reserved.
  9.  *
  10.  * Redistribution and use in source and binary forms, with or without modification,
  11.  * are permitted provided that the following conditions are met:
  12.  *
  13.  * 1. Redistributions of source code must retain the above copyright notice,
  14.  *    this list of conditions and the following disclaimer.
  15.  * 2. Redistributions in binary form must reproduce the above copyright notice,
  16.  *    this list of conditions and the following disclaimer in the documentation
  17.  *    and/or other materials provided with the distribution.
  18.  * 3. The name of the author may not be used to endorse or promote products
  19.  *    derived from this software without specific prior written permission.
  20.  *
  21.  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
  22.  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  23.  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
  24.  * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  25.  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
  26.  * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  27.  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  28.  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  29.  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  30.  * OF SUCH DAMAGE.
  31.  *
  32.  * This file is part of the lwIP TCP/IP stack.
  33.  *
  34.  * Author: Adam Dunkels <adam@sics.se>
  35.  *
  36.  */
  39. /* udp.c
  40.  *
  41.  * The code for the User Datagram Protocol UDP.
  42.  *
  43.  */
  45. #include <string.h>
  47. #include "lwip/opt.h"
  49. #include "lwip/def.h"
  50. #include "lwip/memp.h"
  51. #include "lwip/inet.h"
  52. #include "lwip/ip_addr.h"
  53. #include "lwip/netif.h"
  54. #include "lwip/udp.h"
  55. #include "lwip/icmp.h"
  57. #include "lwip/stats.h"
  59. #include "arch/perf.h"
  60. #include "lwip/snmp.h"
  62. #include "uart.h"
  64. /* The list of UDP PCBs */
  65. #if LWIP_UDP
  66. /* was static, but we may want to access this from a socket layer */
  67. struct udp_pcb *udp_pcbs = NULL;
  69. static struct udp_pcb *pcb_cache = NULL;
  72. void
  73. udp_init(void)
  74. {
  75.   udp_pcbs = pcb_cache = NULL;
  76. }
  78. /**
  79.  * Process an incoming UDP datagram.
  80.  *
  81.  * Given an incoming UDP datagram (as a chain of pbufs) this function
  82.  * finds a corresponding UDP PCB and
  83.  *
  84.  * @param pbuf pbuf to be demultiplexed to a UDP PCB.
  85.  * @param netif network interface on which the datagram was received.
  86.  *
  87.  */
  88. void
  89. udp_input(struct pbuf *p, struct netif *inp)
  90. {
  91.   struct udp_hdr *udphdr;
  92.   struct udp_pcb *pcb;
  93.   struct ip_hdr *iphdr;
  94.   u16_t src, dest;
  96. #if SO_REUSE
  97.   struct udp_pcb *pcb_temp;
  98.   int reuse = 0;
  99.   int reuse_port_1 = 0;
  100.   int reuse_port_2 = 0;
  101. #endif /* SO_REUSE */
  102.   
  103.   PERF_START;
  105.   DEBUG_FUNCTION("udp_input()");
  107.   UDP_STATS_INC(udp.recv);
  109.   iphdr = p->payload;
  111.   if (pbuf_header(p, -((s16_t)(UDP_HLEN + IPH_HL(iphdr) * 4)))) {
  112.     /* drop short packets */
  113.     LWIP_DEBUGF(UDP_DEBUG, ("udp_input: short UDP datagram (%u bytes) discardedn", p->tot_len));
  114.     UDP_STATS_INC(udp.lenerr);
  115.     UDP_STATS_INC(udp.drop);
  116.     snmp_inc_udpinerrors();
  117.     pbuf_free(p);
  118.     goto end;
  119.   }
  121.   udphdr = (struct udp_hdr *)((u8_t *)p->payload - UDP_HLEN);
  123.   LWIP_DEBUGF(UDP_DEBUG, ("udp_input: received datagram of length %un", p->tot_len));
  125.   src = ntohs(udphdr->src);
  126.   dest = ntohs(udphdr->dest);
  128.   udp_debug_print(udphdr);
  130.   /* print the UDP source and destination */
  131.   LWIP_DEBUGF(UDP_DEBUG, ("udp (%u.%u.%u.%u, %u) <-- (%u.%u.%u.%u, %u)n",
  132.     ip4_addr1(&iphdr->dest), ip4_addr2(&iphdr->dest),
  133.     ip4_addr3(&iphdr->dest), ip4_addr4(&iphdr->dest), ntohs(udphdr->dest),
  134.     ip4_addr1(&iphdr->src), ip4_addr2(&iphdr->src),
  135.     ip4_addr3(&iphdr->src), ip4_addr4(&iphdr->src), ntohs(udphdr->src)));
  137. #if SO_REUSE
  138.   pcb_temp = udp_pcbs;
  139.   
  140.  again_1:
  141.   
  142.   /* Iterate through the UDP pcb list for a fully matching pcb */
  143.   for (pcb = pcb_temp; pcb != NULL; pcb = pcb->next) {
  144. #else  /* SO_REUSE */ 
  145.   /* Iterate through the UDP pcb list for a fully matching pcb */
  146.   for (pcb = udp_pcbs; pcb != NULL; pcb = pcb->next) {
  147. #endif  /* SO_REUSE */ 
  148.     /* print the PCB local and remote address */
  149.     LWIP_DEBUGF(UDP_DEBUG, ("pcb (%u.%u.%u.%u, %u) --- (%u.%u.%u.%u, %u)n",
  150.       ip4_addr1(&pcb->local_ip), ip4_addr2(&pcb->local_ip),
  151.       ip4_addr3(&pcb->local_ip), ip4_addr4(&pcb->local_ip), pcb->local_port,
  152.       ip4_addr1(&pcb->remote_ip), ip4_addr2(&pcb->remote_ip),
  153.       ip4_addr3(&pcb->remote_ip), ip4_addr4(&pcb->remote_ip), pcb->remote_port));
  155.        /* PCB remote port matches UDP source port? */
  156.     if ((pcb->remote_port == src) &&
  157.        /* PCB local port matches UDP destination port? */
  158.        (pcb->local_port == dest) &&
  159.        /* accepting from any remote (source) IP address? or... */
  160.        (ip_addr_isany(&pcb->remote_ip) ||
  161.        /* PCB remote IP address matches UDP source IP address? */
  162.         ip_addr_cmp(&(pcb->remote_ip), &(iphdr->src))) &&
  163.        /* accepting on any local (netif) IP address? or... */
  164.        (ip_addr_isany(&pcb->local_ip) ||
  165.        /* PCB local IP address matches UDP destination IP address? */
  166.         ip_addr_cmp(&(pcb->local_ip), &(iphdr->dest)))) {
  167. #if SO_REUSE
  168.       if (pcb->so_options & SOF_REUSEPORT) {
  169.         if(reuse) {
  170.           /* We processed one PCB already */
  171.           LWIP_DEBUGF(UDP_DEBUG, ("udp_input: second or later PCB and SOF_REUSEPORT set.n"));
  172.         } else {
  173.           /* First PCB with this address */
  174.           LWIP_DEBUGF(UDP_DEBUG, ("udp_input: first PCB and SOF_REUSEPORT set.n"));
  175.           reuse = 1;
  176.         }
  177.         
  178.         reuse_port_1 = 1; 
  179.         p->ref++;
  180.         LWIP_DEBUGF(UDP_DEBUG, ("udp_input: reference counter on PBUF set to %in", p->ref));
  181.       } else {
  182.         if (reuse) {
  183.           /* We processed one PCB already */
  184.           LWIP_DEBUGF(UDP_DEBUG, ("udp_input: second or later PCB but SOF_REUSEPORT not set !n"));
  185.         }
  186.       }
  187. #endif /* SO_REUSE */
  188.       break;
  189.     }
  190.   }
  191.   /* no fully matching pcb found? then look for an unconnected pcb */
  192.   if (pcb == NULL) {
  193.     /* Iterate through the UDP PCB list for a pcb that matches
  194.        the local address. */
  196. #if SO_REUSE
  197.     pcb_temp = udp_pcbs;
  198.     
  199.   again_2:
  201.     for (pcb = pcb_temp; pcb != NULL; pcb = pcb->next) {
  202. #else  /* SO_REUSE */ 
  203.     for (pcb = udp_pcbs; pcb != NULL; pcb = pcb->next) {
  204. #endif  /* SO_REUSE */ 
  205.       LWIP_DEBUGF(UDP_DEBUG, ("pcb (%u.%u.%u.%u, %u) --- (%u.%u.%u.%u, %u)n",
  206.         ip4_addr1(&pcb->local_ip), ip4_addr2(&pcb->local_ip),
  207.         ip4_addr3(&pcb->local_ip), ip4_addr4(&pcb->local_ip), pcb->local_port,
  208.         ip4_addr1(&pcb->remote_ip), ip4_addr2(&pcb->remote_ip),
  209.         ip4_addr3(&pcb->remote_ip), ip4_addr4(&pcb->remote_ip), pcb->remote_port));
  210.       /* unconnected? */
  211.       if (((pcb->flags & UDP_FLAGS_CONNECTED) == 0) &&
  212.          /* destination port matches? */
  213.         (pcb->local_port == dest) &&
  214.         /* not bound to a specific (local) interface address? or... */
  215.         (ip_addr_isany(&pcb->local_ip) ||
  216.         /* ...matching interface address? */
  217.         ip_addr_cmp(&(pcb->local_ip), &(iphdr->dest)))) {
  218. #if SO_REUSE
  219.         if (pcb->so_options & SOF_REUSEPORT) {
  220.           if (reuse) {
  221.             /* We processed one PCB already */
  222.             LWIP_DEBUGF(UDP_DEBUG, ("udp_input: second or later PCB and SOF_REUSEPORT set.n"));
  223.           } else {
  224.             /* First PCB with this address */
  225.             LWIP_DEBUGF(UDP_DEBUG, ("udp_input: first PCB and SOF_REUSEPORT set.n"));
  226.             reuse = 1;
  227.           }
  228.           
  229.           reuse_port_2 = 1; 
  230.           p->ref++;
  231.           LWIP_DEBUGF(UDP_DEBUG, ("udp_input: reference counter on PBUF set to %in", p->ref));
  232.         } else {
  233.           if (reuse) {
  234.             /* We processed one PCB already */
  235.             LWIP_DEBUGF(UDP_DEBUG, ("udp_input: second or later PCB but SOF_REUSEPORT not set !n"));
  236.           }
  237.         }
  238. #endif /* SO_REUSE */
  239.         break;
  240.       }
  241.     }
  242.   }
  244.   /* Check checksum if this is a match or if it was directed at us. */
  245.   if (pcb != NULL  || ip_addr_cmp(&inp->ip_addr, &iphdr->dest))
  246.     {
  247.     LWIP_DEBUGF(UDP_DEBUG | DBG_TRACE, ("udp_input: calculating checksumn"));
  248.     pbuf_header(p, UDP_HLEN);
  249. #ifdef IPv6
  250.     if (iphdr->nexthdr == IP_PROTO_UDPLITE) {
  251. #else
  252.     if (IPH_PROTO(iphdr) == IP_PROTO_UDPLITE) {
  253. #endif /* IPv4 */
  254.       /* Do the UDP Lite checksum */
  255. #if CHECKSUM_CHECK_UDP
  256.       if (inet_chksum_pseudo(p, (struct ip_addr *)&(iphdr->src),
  257.          (struct ip_addr *)&(iphdr->dest),
  258.          IP_PROTO_UDPLITE, ntohs(udphdr->len)) != 0) {
  259.   LWIP_DEBUGF(UDP_DEBUG | 2, ("udp_input: UDP Lite datagram discarded due to failing checksumn"));
  260.   UDP_STATS_INC(udp.chkerr);
  261.   UDP_STATS_INC(udp.drop);
  262.   snmp_inc_udpinerrors();
  263.   pbuf_free(p);
  264.   goto end;
  265.       }
  266. #endif
  267.     } else {
  268. #if CHECKSUM_CHECK_UDP
  269.       if (udphdr->chksum != 0) {
  270.   if (inet_chksum_pseudo(p, (struct ip_addr *)&(iphdr->src),
  271.        (struct ip_addr *)&(iphdr->dest),
  272.         IP_PROTO_UDP, p->tot_len) != 0) {
  273.     LWIP_DEBUGF(UDP_DEBUG | 2, ("udp_input: UDP datagram discarded due to failing checksumn"));
  275.     UDP_STATS_INC(udp.chkerr);
  276.     UDP_STATS_INC(udp.drop);
  277.     snmp_inc_udpinerrors();
  278.     pbuf_free(p);
  279.     goto end;
  280.   }
  281.       }
  282. #endif
  283.     }
  284.     pbuf_header(p, -UDP_HLEN);
  285.     if (pcb != NULL) {
  286.       snmp_inc_udpindatagrams();
  287.   
  288.    /*
  289.     *modified by skier 2006.01.30
  290.     */
  291.       //pcb->recv(pcb->recv_arg, pcb, p, &(iphdr->src), src);
  292.          DEBUG_EVENT("Send reveived packet to udp function")
  293.   pcb->recv(p);
  294.          pbuf_free(p);
  295.    //end
  296. #if SO_REUSE
  297.       /* First socket should receive now */
  298.       if(reuse_port_1 || reuse_port_2) {
  299.         /* We want to search on next socket after receiving */
  300.         pcb_temp = pcb->next;
  301.         
  302.         if(reuse_port_1) {
  303.           /* We are searching connected sockets */
  304.           reuse_port_1 = 0;
  305.           reuse_port_2 = 0;
  306.           goto again_1;
  307.         } else {
  308.           /* We are searching unconnected sockets */
  309.           reuse_port_1 = 0;
  310.           reuse_port_2 = 0;
  311.           goto again_2;
  312.         }
  313.       }
  314. #endif /* SO_REUSE */ 
  315.     } else {
  316. #if SO_REUSE
  317.       if(reuse) {
  318.         LWIP_DEBUGF(UDP_DEBUG, ("udp_input: freeing PBUF with reference counter set to %in", p->ref));
  319.         pbuf_free(p);
  320.         goto end;
  321.       }
  322. #endif /* SO_REUSE */
  323.       LWIP_DEBUGF(UDP_DEBUG | DBG_TRACE, ("udp_input: not for us.n"));
  325.       /* No match was found, send ICMP destination port unreachable unless
  326.       destination address was broadcast/multicast. */
  328.       if (!ip_addr_isbroadcast(&iphdr->dest, inp) &&
  329.           !ip_addr_ismulticast(&iphdr->dest)) {
  331.   /* adjust pbuf pointer */
  332.   p->payload = iphdr;
  333.   icmp_dest_unreach(p, ICMP_DUR_PORT);
  334.       }
  335.       UDP_STATS_INC(udp.proterr);
  336.       UDP_STATS_INC(udp.drop);
  337.     snmp_inc_udpnoports();
  338.       pbuf_free(p);
  339.     }
  340.   } else {
  341.     pbuf_free(p);
  342.   }
  343.   end:
  344.    return;
  346.   //PERF_STOP("udp_input");
  347. }
  349. /**
  350.  * Send data to a specified address using UDP.
  351.  *
  352.  * @param pcb UDP PCB used to send the data.
  353.  * @param pbuf chain of pbuf's to be sent.
  354.  * @param dst_ip Destination IP address.
  355.  * @param dst_port Destination UDP port.
  356.  *
  357.  * If the PCB already has a remote address association, it will
  358.  * be restored after the data is sent.
  359.  * 
  360.  * @return lwIP error code.
  361.  * - ERR_OK. Successful. No error occured.
  362.  * - ERR_MEM. Out of memory.
  363.  * - ERR_RTE. Could not find route to destination address.
  364.  *
  365.  * @see udp_disconnect() udp_send()
  366.  */
  367. err_t
  368. udp_sendto(struct udp_pcb *pcb, struct pbuf *p,
  369.   struct ip_addr *dst_ip, u16_t dst_port)
  370. {
  371.   err_t err;
  372.   /* temporary space for current PCB remote address */
  373.   struct ip_addr pcb_remote_ip;
  374.   u16_t pcb_remote_port;
  375.   /* remember current remote peer address of PCB */
  376.   pcb_remote_ip.addr = pcb->remote_ip.addr;
  377.   pcb_remote_port = pcb->remote_port;
  378.   /* copy packet destination address to PCB remote peer address */
  379.   pcb->remote_ip.addr = dst_ip->addr;
  380.   pcb->remote_port = dst_port;
  381.   /* send to the packet destination address */
  382.   err = udp_send(pcb, p);
  383.   /* restore PCB remote peer address */
  384.   pcb->remote_ip.addr = pcb_remote_ip.addr;
  385.   pcb->remote_port = pcb_remote_port;
  386.   return err;
  387. }
  389. /*
  390. *write some data to UDP peer 
  391. *create by skier 2006.01.30
  392. */
  393. err_t udp_write(u8_t *data, u16_t len)
  394. {
  395.        struct pbuf *p;
  396.  err_t  err;
  398. p = pbuf_alloc(PBUF_RAW , len, PBUF_RAM);
  400. if(p == NULL)
  401. {
  402.               DEBUG_EVENT("write some data to UDP Peer, but pbuf malloc failed!");
  403. return ERR_BUF;
  404. }
  406. memcpy((u8_t*)p->payload,data, len);
  408.  /*
  409.  *because only 1 UDP PCB here
  410.  *so I user udp_pcbs directely
  411.  */
  412. err =  udp_send(udp_pcbs, p);
  414. pbuf_free(p);
  416. return err;
  417. }
  420. /**
  421.  * Send data using UDP.
  422.  *
  423.  * @param pcb UDP PCB used to send the data.
  424.  * @param pbuf chain of pbuf's to be sent.
  425.  *
  426.  * @return lwIP error code.
  427.  * - ERR_OK. Successful. No error occured.
  428.  * - ERR_MEM. Out of memory.
  429.  * - ERR_RTE. Could not find route to destination address.
  430.  *
  431.  * @see udp_disconnect() udp_sendto()
  432.  */
  433. err_t
  434. udp_send(struct udp_pcb *pcb, struct pbuf *p)
  435. {
  436.   struct udp_hdr *udphdr;
  437.   struct netif *netif;
  438.   struct ip_addr *src_ip;
  439.   err_t err;
  440.   struct pbuf *q; /* q will be sent down the stack */
  442.   LWIP_DEBUGF(UDP_DEBUG | DBG_TRACE | 3, ("udp_sendn"));
  444.   /* if the PCB is not yet bound to a port, bind it here */
  445.   if (pcb->local_port == 0) {
  446.     LWIP_DEBUGF(UDP_DEBUG | DBG_TRACE | 2, ("udp_send: not yet bound to a port, binding nown"));
  447.     err = udp_bind(pcb, &pcb->local_ip, pcb->local_port);
  448.     if (err != ERR_OK) {
  449.       LWIP_DEBUGF(UDP_DEBUG | DBG_TRACE | 2, ("udp_send: forced port bind failedn"));
  450.       return err;
  451.     }
  452.   }
  454.   /* not enough space to add an UDP header to first pbuf in given p chain? */
  455.   if (pbuf_header(p, UDP_HLEN)) {
  456.     /* allocate header in a seperate new pbuf */
  457.     q = pbuf_alloc(PBUF_IP, UDP_HLEN, PBUF_RAM);
  458.     /* new header pbuf could not be allocated? */
  459.     if (q == NULL) {
  460.       LWIP_DEBUGF(UDP_DEBUG | DBG_TRACE | 2, ("udp_send: could not allocate headern"));
  461.       return ERR_MEM;
  462.     }
  463.     /* chain header q in front of given pbuf p */
  464.     pbuf_chain(q, p);
  465.     /* { first pbuf q points to header pbuf } */
  466.     LWIP_DEBUGF(UDP_DEBUG, ("udp_send: added header pbuf %p before given pbuf %pn", (void *)q, (void *)p));
  467.   /* adding a header within p succeeded */
  468.   } else {
  469.     /* first pbuf q equals given pbuf */
  470.     q = p;
  471.     LWIP_DEBUGF(UDP_DEBUG, ("udp_send: added header in given pbuf %pn", (void *)p));
  472.   }
  473.   /* { q now represents the packet to be sent } */
  474.   udphdr = q->payload;
  475.   udphdr->src = htons(pcb->local_port);
  476.   udphdr->dest = htons(pcb->remote_port);
  477.   /* in UDP, 0 checksum means 'no checksum' */
  478.   udphdr->chksum = 0x0000; 
  480.   /* find the outgoing network interface for this packet */
  481.   netif = ip_route(&(pcb->remote_ip));
  482.   /* no outgoing network interface could be found? */
  483.   if (netif == NULL) {
  484.     LWIP_DEBUGF(UDP_DEBUG | 1, ("udp_send: No route to 0x%lxn", pcb->remote_ip.addr));
  485.     UDP_STATS_INC(udp.rterr);
  486.     return ERR_RTE;
  487.   }
  488.   /* PCB local address is IP_ANY_ADDR? */
  489.   if (ip_addr_isany(&pcb->local_ip)) {
  490.     /* use outgoing network interface IP address as source address */
  491.     src_ip = &(netif->ip_addr);
  492.   } else {
  493.     /* use UDP PCB local IP address as source address */
  494.     src_ip = &(pcb->local_ip);
  495.   }
  497.   LWIP_DEBUGF(UDP_DEBUG, ("udp_send: sending datagram of length %un", q->tot_len));
  499.   /* UDP Lite protocol? */
  500.   if (pcb->flags & UDP_FLAGS_UDPLITE) {
  501.     LWIP_DEBUGF(UDP_DEBUG, ("udp_send: UDP LITE packet length %un", q->tot_len));
  502.     /* set UDP message length in UDP header */
  503.     udphdr->len = htons(pcb->chksum_len);
  504.     /* calculate checksum */
  505. #if CHECKSUM_GEN_UDP
  506.     udphdr->chksum = inet_chksum_pseudo(q, src_ip, &(pcb->remote_ip),
  507.           IP_PROTO_UDP, pcb->chksum_len);
  508.     /* chksum zero must become 0xffff, as zero means 'no checksum' */
  509.     if (udphdr->chksum == 0x0000) udphdr->chksum = 0xffff;
  510. #else
  511.     udphdr->chksum = 0x0000;
  512. #endif
  513.     /* output to IP */
  514.     LWIP_DEBUGF(UDP_DEBUG, ("udp_send: ip_output_if (,,,,IP_PROTO_UDPLITE,)n"));
  515.     err = ip_output_if (q, src_ip, &pcb->remote_ip, pcb->ttl, pcb->tos, IP_PROTO_UDPLITE, netif);    
  516.   /* UDP */
  517.   } else {
  518.     LWIP_DEBUGF(UDP_DEBUG, ("udp_send: UDP packet length %un", q->tot_len));
  519.     udphdr->len = htons(q->tot_len);
  520.     /* calculate checksum */
  521. #if CHECKSUM_GEN_UDP
  522.     if ((pcb->flags & UDP_FLAGS_NOCHKSUM) == 0) {
  523.       udphdr->chksum = inet_chksum_pseudo(q, src_ip, &pcb->remote_ip, IP_PROTO_UDP, q->tot_len);
  524.       /* chksum zero must become 0xffff, as zero means 'no checksum' */
  525.       if (udphdr->chksum == 0x0000) udphdr->chksum = 0xffff;
  526.     }
  527. #else
  528.     udphdr->chksum = 0x0000;
  529. #endif
  530.     LWIP_DEBUGF(UDP_DEBUG, ("udp_send: UDP checksum 0x%04xn", udphdr->chksum));
  531.     LWIP_DEBUGF(UDP_DEBUG, ("udp_send: ip_output_if (,,,,IP_PROTO_UDP,)n"));
  532.     /* output to IP */
  533.     err = ip_output_if(q, src_ip, &pcb->remote_ip, pcb->ttl, pcb->tos, IP_PROTO_UDP, netif);    
  534.   }
  535.   /* TODO: must this be increased even if error occured? */
  536.   snmp_inc_udpoutdatagrams();
  538.   /* did we chain a seperate header pbuf earlier? */
  539.   if (q != p) {
  540.     /* free the header pbuf */
  541.     pbuf_free(q); q = NULL;
  542.     /* { p is still referenced by the caller, and will live on } */
  543.   }
  545.   UDP_STATS_INC(udp.xmit);
  546.   return err;
  547. }
  549. /**
  550.  * Bind an UDP PCB.
  551.  *
  552.  * @param pcb UDP PCB to be bound with a local address ipaddr and port.
  553.  * @param ipaddr local IP address to bind with. Use IP_ADDR_ANY to
  554.  * bind to all local interfaces.
  555.  * @param port local UDP port to bind with.
  556.  *
  557.  * @return lwIP error code.
  558.  * - ERR_OK. Successful. No error occured.
  559.  * - ERR_USE. The specified ipaddr and port are already bound to by
  560.  * another UDP PCB.
  561.  *
  562.  * @see udp_disconnect()
  563.  */
  564. err_t
  565. udp_bind(struct udp_pcb *pcb, struct ip_addr *ipaddr, u16_t port)
  566. {
  567.   struct udp_pcb *ipcb;
  568.   u8_t rebind;
  569. #if SO_REUSE
  570.   int reuse_port_all_set = 1;
  571. #endif /* SO_REUSE */
  572.   LWIP_DEBUGF(UDP_DEBUG | DBG_TRACE | 3, ("udp_bind(ipaddr = "));
  573.   ip_addr_debug_print(UDP_DEBUG, ipaddr);
  574.   LWIP_DEBUGF(UDP_DEBUG | DBG_TRACE | 3, (", port = %u)n", port));
  576.   rebind = 0;
  577.   /* Check for double bind and rebind of the same pcb */
  578.   for (ipcb = udp_pcbs; ipcb != NULL; ipcb = ipcb->next) {
  579.     /* is this UDP PCB already on active list? */
  580.     if (pcb == ipcb) {
  581.       /* pcb may occur at most once in active list */
  582.       LWIP_ASSERT("rebind == 0", rebind == 0);
  583.       /* pcb already in list, just rebind */
  584.       rebind = 1;
  585.     }
  587. #if SO_REUSE == 0
  588. /* this code does not allow upper layer to share a UDP port for
  589.    listening to broadcast or multicast traffic (See SO_REUSE_ADDR and
  590.    SO_REUSE_PORT under *BSD). TODO: See where it fits instead, OR
  591.    combine with implementation of UDP PCB flags. Leon Woestenberg. */
  592. #ifdef LWIP_UDP_TODO
  593.     /* port matches that of PCB in list? */
  594.     else if ((ipcb->local_port == port) &&
  595.        /* IP address matches, or one is IP_ADDR_ANY? */
  596.        (ip_addr_isany(&(ipcb->local_ip)) ||
  597.        ip_addr_isany(ipaddr) ||
  598.        ip_addr_cmp(&(ipcb->local_ip), ipaddr))) {
  599.       /* other PCB already binds to this local IP and port */
  600.       LWIP_DEBUGF(UDP_DEBUG, ("udp_bind: local port %u already bound by another pcbn", port));
  601.       return ERR_USE;
  602.     }
  603. #endif
  605. #else /* SO_REUSE */
  606.       /* Search through list of PCB's. 
  607.          
  608.       If there is a PCB bound to specified port and IP_ADDR_ANY another PCB can be bound to the interface IP
  609.       or to the loopback address on the same port if SOF_REUSEADDR is set. Any combination of PCB's bound to 
  610.       the same local port, but to one address out of {IP_ADDR_ANY, 127.0.0.1, interface IP} at a time is valid.
  611.       But no two PCB's bound to same local port and same local address is valid.
  612.       
  613.       If SOF_REUSEPORT is set several PCB's can be bound to same local port and same local address also. But then 
  614.       all PCB's must have the SOF_REUSEPORT option set.
  615.       
  616.       When the two options aren't set and specified port is already bound, ERR_USE is returned saying that 
  617.       address is already in use. */
  618.     else if (ipcb->local_port == port) {
  619.       if(ip_addr_cmp(&(ipcb->local_ip), ipaddr)) {
  620.         if(pcb->so_options & SOF_REUSEPORT) {
  621.           LWIP_DEBUGF(UDP_DEBUG, ("udp_bind: in UDP PCB's SO_REUSEPORT set and same address.n"));
  622.           reuse_port_all_set = (reuse_port_all_set && (ipcb->so_options & SOF_REUSEPORT));
  623.         }
  624.         else {
  625.           LWIP_DEBUGF(UDP_DEBUG, ("udp_bind: in UDP PCB's SO_REUSEPORT not set and same address.n"));
  626.           return ERR_USE;
  627.         }
  628.       }
  629.       else if((ip_addr_isany(ipaddr) && !ip_addr_isany(&(ipcb->local_ip))) ||
  630.               (!ip_addr_isany(ipaddr) && ip_addr_isany(&(ipcb->local_ip)))) {
  631.         if(!(pcb->so_options & SOF_REUSEADDR) && !(pcb->so_options & SOF_REUSEPORT)) {
  632.           LWIP_DEBUGF(UDP_DEBUG, ("udp_bind: in UDP PCB's SO_REUSEPORT or SO_REUSEADDR not set and not the same address.n"));
  633.           return ERR_USE;
  634.         }           
  635.       }
  636.     }
  637. #endif /* SO_REUSE */
  639.   }
  641. #if SO_REUSE
  642.   /* If SOF_REUSEPORT isn't set in all PCB's bound to specified port and local address specified then 
  643.      {IP, port} can't be reused. */
  644.   if(!reuse_port_all_set) {
  645.     LWIP_DEBUGF(UDP_DEBUG, ("udp_bind: not all sockets have SO_REUSEPORT set.n"));
  646.     return ERR_USE;
  647.   }
  648. #endif /* SO_REUSE */
  650.   ip_addr_set(&pcb->local_ip, ipaddr);
  651.   /* no port specified? */
  652.   if (port == 0) {
  653. #ifndef UDP_LOCAL_PORT_RANGE_START
  654. #define UDP_LOCAL_PORT_RANGE_START 4096
  655. #define UDP_LOCAL_PORT_RANGE_END   0x7fff
  656. #endif
  657.     port = UDP_LOCAL_PORT_RANGE_START;
  658.     ipcb = udp_pcbs;
  659.     while ((ipcb != NULL) && (port != UDP_LOCAL_PORT_RANGE_END)) {
  660.       if (ipcb->local_port == port) {
  661.         port++;
  662.         ipcb = udp_pcbs;
  663.       } else
  664.         ipcb = ipcb->next;
  665.     }
  666.     if (ipcb != NULL) {
  667.       /* no more ports available in local range */
  668.       LWIP_DEBUGF(UDP_DEBUG, ("udp_bind: out of free UDP portsn"));
  669.       return ERR_USE;
  670.     }
  671.   }
  672.   pcb->local_port = port;
  673.   /* pcb not active yet? */
  674.   if (rebind == 0) {
  675.     /* place the PCB on the active list if not already there */
  676.     pcb->next = udp_pcbs;
  677.     udp_pcbs = pcb;
  678.   }
  679.   LWIP_DEBUGF(UDP_DEBUG | DBG_TRACE | DBG_STATE, ("udp_bind: bound to %u.%u.%u.%u, port %un",
  680.    (unsigned int)(ntohl(pcb->local_ip.addr) >> 24 & 0xff),
  681.    (unsigned int)(ntohl(pcb->local_ip.addr) >> 16 & 0xff),
  682.    (unsigned int)(ntohl(pcb->local_ip.addr) >> 8 & 0xff),
  683.    (unsigned int)(ntohl(pcb->local_ip.addr) & 0xff), pcb->local_port));
  684.   return ERR_OK;
  685. }
  686. /**
  687.  * Connect an UDP PCB.
  688.  *
  689.  * This will associate the UDP PCB with the remote address.
  690.  *
  691.  * @param pcb UDP PCB to be connected with remote address ipaddr and port.
  692.  * @param ipaddr remote IP address to connect with.
  693.  * @param port remote UDP port to connect with.
  694.  *
  695.  * @return lwIP error code
  696.  *
  697.  * @see udp_disconnect()
  698.  */
  699. err_t
  700. udp_connect(struct udp_pcb *pcb, struct ip_addr *ipaddr, u16_t port)
  701. {
  702.   struct udp_pcb *ipcb;
  704.   if (pcb->local_port == 0) {
  705.     err_t err = udp_bind(pcb, &pcb->local_ip, pcb->local_port);
  706.     if (err != ERR_OK)
  707.       return err;
  708.   }
  710.   ip_addr_set(&pcb->remote_ip, ipaddr);
  711.   pcb->remote_port = port;
  712.   pcb->flags |= UDP_FLAGS_CONNECTED;
  713. /** TODO: this functionality belongs in upper layers */
  714. #ifdef LWIP_UDP_TODO
  715.   /* Nail down local IP for netconn_addr()/getsockname() */
  716.   if (ip_addr_isany(&pcb->local_ip) && !ip_addr_isany(&pcb->remote_ip)) {
  717.     struct netif *netif;
  719.     if ((netif = ip_route(&(pcb->remote_ip))) == NULL) {
  720.       LWIP_DEBUGF(UDP_DEBUG, ("udp_connect: No route to 0x%lxn", pcb->remote_ip.addr));
  721.         UDP_STATS_INC(udp.rterr);
  722.       return ERR_RTE;
  723.     }
  724.     /** TODO: this will bind the udp pcb locally, to the interface which
  725.         is used to route output packets to the remote address. However, we
  726.         might want to accept incoming packets on any interface! */
  727.     pcb->local_ip = netif->ip_addr;
  728.   } else if (ip_addr_isany(&pcb->remote_ip)) {
  729.     pcb->local_ip.addr = 0;
  730.   }
  731. #endif
  732.   LWIP_DEBUGF(UDP_DEBUG | DBG_TRACE | DBG_STATE, ("udp_connect: connected to %u.%u.%u.%u, port %un",
  733.    (unsigned int)(ntohl(pcb->remote_ip.addr) >> 24 & 0xff),
  734.    (unsigned int)(ntohl(pcb->remote_ip.addr) >> 16 & 0xff),
  735.    (unsigned int)(ntohl(pcb->remote_ip.addr) >> 8 & 0xff),
  736.    (unsigned int)(ntohl(pcb->remote_ip.addr) & 0xff), pcb->remote_port));
  738.   /* Insert UDP PCB into the list of active UDP PCBs. */
  739.   for(ipcb = udp_pcbs; ipcb != NULL; ipcb = ipcb->next) {
  740.     if (pcb == ipcb) {
  741.       /* already on the list, just return */
  742.       return ERR_OK;
  743.     }
  744.   }
  745.   /* PCB not yet on the list, add PCB now */
  746.   pcb->next = udp_pcbs;
  747.   udp_pcbs = pcb;
  748.   return ERR_OK;
  749. }
  751. void
  752. udp_disconnect(struct udp_pcb *pcb)
  753. {
  754.   /* reset remote address association */
  755.   ip_addr_set(&pcb->remote_ip, IP_ADDR_ANY);
  756.   pcb->remote_port = 0;
  757.   /* mark PCB as unconnected */
  758.   pcb->flags &= ~UDP_FLAGS_CONNECTED;
  759. }
  761. //delete by skier 2005.01.30
  762. #if 0
  763. void
  764. udp_recv(struct udp_pcb *pcb,
  765.    void (* recv)(void *arg, struct udp_pcb *upcb, struct pbuf *p,
  766.            struct ip_addr *addr, u16_t port),
  767.    void *recv_arg)
  768. {
  769.   /* remember recv() callback and user data */
  770.   pcb->recv = recv;
  771.   pcb->recv_arg = recv_arg;
  772. }
  773. #endif
  774. /**
  775.  * Remove an UDP PCB.
  776.  *
  777.  * @param pcb UDP PCB to be removed. The PCB is removed from the list of
  778.  * UDP PCB's and the data structure is freed from memory.
  779.  *
  780.  * @see udp_new()
  781.  */
  782. void
  783. udp_remove(struct udp_pcb *pcb)
  784. {
  785.   struct udp_pcb *pcb2;
  786.   /* pcb to be removed is first in list? */
  787.   if (udp_pcbs == pcb) {
  788.     /* make list start at 2nd pcb */
  789.     udp_pcbs = udp_pcbs->next;
  790.   /* pcb not 1st in list */
  791.   } else for(pcb2 = udp_pcbs; pcb2 != NULL; pcb2 = pcb2->next) {
  792.     /* find pcb in udp_pcbs list */
  793.     if (pcb2->next != NULL && pcb2->next == pcb) {
  794.       /* remove pcb from list */
  795.       pcb2->next = pcb->next;
  796.     }
  797.   }
  798.   memp_free(MEMP_UDP_PCB, pcb);
  799. }
  801. /*
  802. *this fun will be called when a valid UDP Packet received
  803. *created by skier 2006.01.30
  804. */
  805. extern void udp_data_ind(u8_t *buf, u16_t len);
  806. void recv_udp(struct pbuf *p)
  807. {
  808.     struct pbuf *temp = p;
  810.     DEBUG_EVENT("recv_udp()")
  812.     while(temp != NULL)
  813.     {
  814.         udp_data_ind((u8_t *)temp->payload, temp->len);
  815.  temp = temp->next;
  816.     }
  817. }
  819. /**
  820.  * Create a UDP PCB.
  821.  *
  822.  * @return The UDP PCB which was created. NULL if the PCB data structure
  823.  * could not be allocated.
  824.  *
  825.  * @see udp_remove()
  826.  */
  827. struct udp_pcb *
  828. udp_new(void) {
  829.   struct udp_pcb *pcb;
  830.   pcb = memp_malloc(MEMP_UDP_PCB);
  831.   /* could allocate UDP PCB? */
  832.   if (pcb != NULL) {
  833.     /* initialize PCB to all zeroes */
  834.     memset(pcb, 0, sizeof(struct udp_pcb));
  835.     pcb->ttl = UDP_TTL;
  837.     pcb->recv = recv_udp;/*new added by skier 2006.01.30*/
  838.   }
  839.   
  840.   
  841.   return pcb;
  842. }
  846. #if UDP_DEBUG
  847. int
  848. udp_debug_print(struct udp_hdr *udphdr)
  849. {
  850.   LWIP_DEBUGF(UDP_DEBUG, ("UDP header:n"));
  851.   LWIP_DEBUGF(UDP_DEBUG, ("+-------------------------------+n"));
  852.   LWIP_DEBUGF(UDP_DEBUG, ("|     %5u     |     %5u     | (src port, dest port)n",
  853.          ntohs(udphdr->src), ntohs(udphdr->dest)));
  854.   LWIP_DEBUGF(UDP_DEBUG, ("+-------------------------------+n"));
  855.   LWIP_DEBUGF(UDP_DEBUG, ("|     %5u     |     0x%04x    | (len, chksum)n",
  856.          ntohs(udphdr->len), ntohs(udphdr->chksum)));
  857.   LWIP_DEBUGF(UDP_DEBUG, ("+-------------------------------+n"));
  858.   return 0;
  859. }
  860. #endif /* UDP_DEBUG */
  862. #endif /* LWIP_UDP */