My fork of the HTTPServer (working)
Embed:
(wiki syntax)
Show/hide line numbers
udp.c
Go to the documentation of this file.
00001 /** 00002 * @file 00003 * User Datagram Protocol module 00004 * 00005 */ 00006 00007 /* 00008 * Copyright (c) 2001-2004 Swedish Institute of Computer Science. 00009 * All rights reserved. 00010 * 00011 * Redistribution and use in source and binary forms, with or without modification, 00012 * are permitted provided that the following conditions are met: 00013 * 00014 * 1. Redistributions of source code must retain the above copyright notice, 00015 * this list of conditions and the following disclaimer. 00016 * 2. Redistributions in binary form must reproduce the above copyright notice, 00017 * this list of conditions and the following disclaimer in the documentation 00018 * and/or other materials provided with the distribution. 00019 * 3. The name of the author may not be used to endorse or promote products 00020 * derived from this software without specific prior written permission. 00021 * 00022 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED 00023 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 00024 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT 00025 * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 00026 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 00027 * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 00028 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 00029 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 00030 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY 00031 * OF SUCH DAMAGE. 00032 * 00033 * This file is part of the lwIP TCP/IP stack. 00034 * 00035 * Author: Adam Dunkels <adam@sics.se> 00036 * 00037 */ 00038 00039 00040 /* udp.c 00041 * 00042 * The code for the User Datagram Protocol UDP & UDPLite (RFC 3828). 00043 * 00044 */ 00045 00046 /* @todo Check the use of '(struct udp_pcb).chksum_len_rx'! 00047 */ 00048 00049 #include "lwip/opt.h" 00050 00051 #if LWIP_UDP /* don't build if not configured for use in lwipopts.h */ 00052 00053 #include "lwip/udp.h" 00054 #include "lwip/def.h" 00055 #include "lwip/memp.h" 00056 #include "lwip/inet.h" 00057 #include "lwip/inet_chksum.h" 00058 #include "lwip/ip_addr.h" 00059 #include "lwip/netif.h" 00060 #include "lwip/icmp.h" 00061 #include "lwip/stats.h" 00062 #include "lwip/snmp.h" 00063 #include "arch/perf.h" 00064 #include "lwip/dhcp.h " 00065 00066 #include <string.h> 00067 00068 /* The list of UDP PCBs */ 00069 /* exported in udp.h (was static) */ 00070 struct udp_pcb *udp_pcbs; 00071 00072 /** 00073 * Process an incoming UDP datagram. 00074 * 00075 * Given an incoming UDP datagram (as a chain of pbufs) this function 00076 * finds a corresponding UDP PCB and hands over the pbuf to the pcbs 00077 * recv function. If no pcb is found or the datagram is incorrect, the 00078 * pbuf is freed. 00079 * 00080 * @param p pbuf to be demultiplexed to a UDP PCB. 00081 * @param inp network interface on which the datagram was received. 00082 * 00083 */ 00084 void 00085 udp_input(struct pbuf *p, struct netif *inp) 00086 { 00087 struct udp_hdr *udphdr; 00088 struct udp_pcb *pcb, *prev; 00089 struct udp_pcb *uncon_pcb; 00090 struct ip_hdr *iphdr; 00091 u16_t src, dest; 00092 u8_t local_match; 00093 00094 PERF_START; 00095 00096 UDP_STATS_INC(udp.recv); 00097 00098 iphdr = (struct ip_hdr *)(p->payload); 00099 00100 /* Check minimum length (IP header + UDP header) 00101 * and move payload pointer to UDP header */ 00102 if (p->tot_len < (IPH_HL(iphdr) * 4 + UDP_HLEN) || pbuf_header(p, -(s16_t)(IPH_HL(iphdr) * 4))) { 00103 /* drop short packets */ 00104 LWIP_DEBUGF(UDP_DEBUG, 00105 ("udp_input: short UDP datagram (%"U16_F" bytes) discarded\n", p->tot_len)); 00106 UDP_STATS_INC(udp.lenerr); 00107 UDP_STATS_INC(udp.drop); 00108 snmp_inc_udpinerrors(); 00109 pbuf_free(p); 00110 goto end; 00111 } 00112 00113 udphdr = (struct udp_hdr *)p->payload; 00114 00115 LWIP_DEBUGF(UDP_DEBUG, ("udp_input: received datagram of length %"U16_F"\n", p->tot_len)); 00116 00117 /* convert src and dest ports to host byte order */ 00118 src = ntohs(udphdr->src); 00119 dest = ntohs(udphdr->dest); 00120 00121 udp_debug_print(udphdr); 00122 00123 /* print the UDP source and destination */ 00124 LWIP_DEBUGF(UDP_DEBUG, 00125 ("udp (%"U16_F".%"U16_F".%"U16_F".%"U16_F", %"U16_F") <-- " 00126 "(%"U16_F".%"U16_F".%"U16_F".%"U16_F", %"U16_F")\n", 00127 ip4_addr1(&iphdr->dest), ip4_addr2(&iphdr->dest), 00128 ip4_addr3(&iphdr->dest), ip4_addr4(&iphdr->dest), ntohs(udphdr->dest), 00129 ip4_addr1(&iphdr->src), ip4_addr2(&iphdr->src), 00130 ip4_addr3(&iphdr->src), ip4_addr4(&iphdr->src), ntohs(udphdr->src))); 00131 00132 #if LWIP_DHCP 00133 pcb = NULL; 00134 /* when LWIP_DHCP is active, packets to DHCP_CLIENT_PORT may only be processed by 00135 the dhcp module, no other UDP pcb may use the local UDP port DHCP_CLIENT_PORT */ 00136 if (dest == DHCP_CLIENT_PORT) { 00137 /* all packets for DHCP_CLIENT_PORT not coming from DHCP_SERVER_PORT are dropped! */ 00138 if (src == DHCP_SERVER_PORT) { 00139 if ((inp->dhcp != NULL) && (inp->dhcp->pcb != NULL)) { 00140 /* accept the packe if 00141 (- broadcast or directed to us) -> DHCP is link-layer-addressed, local ip is always ANY! 00142 - inp->dhcp->pcb->remote == ANY or iphdr->src */ 00143 if ((ip_addr_isany(&inp->dhcp->pcb->remote_ip) || 00144 ip_addr_cmp(&(inp->dhcp->pcb->remote_ip), &(iphdr->src)))) { 00145 pcb = inp->dhcp->pcb; 00146 } 00147 } 00148 } 00149 } else 00150 #endif /* LWIP_DHCP */ 00151 { 00152 prev = NULL; 00153 local_match = 0; 00154 uncon_pcb = NULL; 00155 /* Iterate through the UDP pcb list for a matching pcb. 00156 * 'Perfect match' pcbs (connected to the remote port & ip address) are 00157 * preferred. If no perfect match is found, the first unconnected pcb that 00158 * matches the local port and ip address gets the datagram. */ 00159 for (pcb = udp_pcbs; pcb != NULL; pcb = pcb->next) { 00160 local_match = 0; 00161 /* print the PCB local and remote address */ 00162 LWIP_DEBUGF(UDP_DEBUG, 00163 ("pcb (%"U16_F".%"U16_F".%"U16_F".%"U16_F", %"U16_F") --- " 00164 "(%"U16_F".%"U16_F".%"U16_F".%"U16_F", %"U16_F")\n", 00165 ip4_addr1(&pcb->local_ip), ip4_addr2(&pcb->local_ip), 00166 ip4_addr3(&pcb->local_ip), ip4_addr4(&pcb->local_ip), pcb->local_port, 00167 ip4_addr1(&pcb->remote_ip), ip4_addr2(&pcb->remote_ip), 00168 ip4_addr3(&pcb->remote_ip), ip4_addr4(&pcb->remote_ip), pcb->remote_port)); 00169 00170 /* compare PCB local addr+port to UDP destination addr+port */ 00171 if ((pcb->local_port == dest) && 00172 (ip_addr_isany(&pcb->local_ip) || 00173 ip_addr_cmp(&(pcb->local_ip), &(iphdr->dest)) || 00174 #if LWIP_IGMP 00175 ip_addr_ismulticast(&(iphdr->dest)) || 00176 #endif /* LWIP_IGMP */ 00177 ip_addr_isbroadcast(&(iphdr->dest), inp))) { 00178 local_match = 1; 00179 if ((uncon_pcb == NULL) && 00180 ((pcb->flags & UDP_FLAGS_CONNECTED) == 0)) { 00181 /* the first unconnected matching PCB */ 00182 uncon_pcb = pcb; 00183 } 00184 } 00185 /* compare PCB remote addr+port to UDP source addr+port */ 00186 if ((local_match != 0) && 00187 (pcb->remote_port == src) && 00188 (ip_addr_isany(&pcb->remote_ip) || 00189 ip_addr_cmp(&(pcb->remote_ip), &(iphdr->src)))) { 00190 /* the first fully matching PCB */ 00191 if (prev != NULL) { 00192 /* move the pcb to the front of udp_pcbs so that is 00193 found faster next time */ 00194 prev->next = pcb->next; 00195 pcb->next = udp_pcbs; 00196 udp_pcbs = pcb; 00197 } else { 00198 UDP_STATS_INC(udp.cachehit); 00199 } 00200 break; 00201 } 00202 prev = pcb; 00203 } 00204 /* no fully matching pcb found? then look for an unconnected pcb */ 00205 if (pcb == NULL) { 00206 pcb = uncon_pcb; 00207 } 00208 } 00209 00210 /* Check checksum if this is a match or if it was directed at us. */ 00211 if (pcb != NULL || ip_addr_cmp(&inp->ip_addr, &iphdr->dest)) { 00212 LWIP_DEBUGF(UDP_DEBUG | LWIP_DBG_TRACE, ("udp_input: calculating checksum\n")); 00213 #if LWIP_UDPLITE 00214 if (IPH_PROTO(iphdr) == IP_PROTO_UDPLITE) { 00215 /* Do the UDP Lite checksum */ 00216 #if CHECKSUM_CHECK_UDP 00217 u16_t chklen = ntohs(udphdr->len); 00218 if (chklen < sizeof(struct udp_hdr)) { 00219 if (chklen == 0) { 00220 /* For UDP-Lite, checksum length of 0 means checksum 00221 over the complete packet (See RFC 3828 chap. 3.1) */ 00222 chklen = p->tot_len; 00223 } else { 00224 /* At least the UDP-Lite header must be covered by the 00225 checksum! (Again, see RFC 3828 chap. 3.1) */ 00226 UDP_STATS_INC(udp.chkerr); 00227 UDP_STATS_INC(udp.drop); 00228 snmp_inc_udpinerrors(); 00229 pbuf_free(p); 00230 goto end; 00231 } 00232 } 00233 if (inet_chksum_pseudo_partial(p, (struct ip_addr *)&(iphdr->src), 00234 (struct ip_addr *)&(iphdr->dest), 00235 IP_PROTO_UDPLITE, p->tot_len, chklen) != 0) { 00236 LWIP_DEBUGF(UDP_DEBUG | 2, 00237 ("udp_input: UDP Lite datagram discarded due to failing checksum\n")); 00238 UDP_STATS_INC(udp.chkerr); 00239 UDP_STATS_INC(udp.drop); 00240 snmp_inc_udpinerrors(); 00241 pbuf_free(p); 00242 goto end; 00243 } 00244 #endif /* CHECKSUM_CHECK_UDP */ 00245 } else 00246 #endif /* LWIP_UDPLITE */ 00247 { 00248 #if CHECKSUM_CHECK_UDP 00249 if (udphdr->chksum != 0) { 00250 if (inet_chksum_pseudo(p, (struct ip_addr *)&(iphdr->src), 00251 (struct ip_addr *)&(iphdr->dest), 00252 IP_PROTO_UDP, p->tot_len) != 0) { 00253 LWIP_DEBUGF(UDP_DEBUG | 2, 00254 ("udp_input: UDP datagram discarded due to failing checksum\n")); 00255 UDP_STATS_INC(udp.chkerr); 00256 UDP_STATS_INC(udp.drop); 00257 snmp_inc_udpinerrors(); 00258 pbuf_free(p); 00259 goto end; 00260 } 00261 } 00262 #endif /* CHECKSUM_CHECK_UDP */ 00263 } 00264 if(pbuf_header(p, -UDP_HLEN)) { 00265 /* Can we cope with this failing? Just assert for now */ 00266 LWIP_ASSERT("pbuf_header failed\n", 0); 00267 UDP_STATS_INC(udp.drop); 00268 snmp_inc_udpinerrors(); 00269 pbuf_free(p); 00270 goto end; 00271 } 00272 if (pcb != NULL) { 00273 snmp_inc_udpindatagrams(); 00274 /* callback */ 00275 if (pcb->recv != NULL) { 00276 /* now the recv function is responsible for freeing p */ 00277 struct ip_addr iphdrsrc; // __packed hack 00278 iphdrsrc.addr = iphdr->src.addr; 00279 pcb->recv(pcb->recv_arg, pcb, p, &iphdrsrc, src); 00280 } else { 00281 /* no recv function registered? then we have to free the pbuf! */ 00282 pbuf_free(p); 00283 goto end; 00284 } 00285 } else { 00286 LWIP_DEBUGF(UDP_DEBUG | LWIP_DBG_TRACE, ("udp_input: not for us.\n")); 00287 00288 #if LWIP_ICMP 00289 /* No match was found, send ICMP destination port unreachable unless 00290 destination address was broadcast/multicast. */ 00291 if (!ip_addr_isbroadcast(&(iphdr->dest), inp) && 00292 !ip_addr_ismulticast(&iphdr->dest)) { 00293 /* move payload pointer back to ip header */ 00294 pbuf_header(p, (IPH_HL(iphdr) * 4) + UDP_HLEN); 00295 LWIP_ASSERT("p->payload == iphdr", (p->payload == iphdr)); 00296 icmp_dest_unreach(p, ICMP_DUR_PORT); 00297 } 00298 #endif /* LWIP_ICMP */ 00299 UDP_STATS_INC(udp.proterr); 00300 UDP_STATS_INC(udp.drop); 00301 snmp_inc_udpnoports(); 00302 pbuf_free(p); 00303 } 00304 } else { 00305 pbuf_free(p); 00306 } 00307 end: 00308 PERF_STOP("udp_input"); 00309 } 00310 00311 /** 00312 * Send data using UDP. 00313 * 00314 * @param pcb UDP PCB used to send the data. 00315 * @param p chain of pbuf's to be sent. 00316 * 00317 * The datagram will be sent to the current remote_ip & remote_port 00318 * stored in pcb. If the pcb is not bound to a port, it will 00319 * automatically be bound to a random port. 00320 * 00321 * @return lwIP error code. 00322 * - ERR_OK. Successful. No error occured. 00323 * - ERR_MEM. Out of memory. 00324 * - ERR_RTE. Could not find route to destination address. 00325 * - More errors could be returned by lower protocol layers. 00326 * 00327 * @see udp_disconnect() udp_sendto() 00328 */ 00329 err_t 00330 udp_send(struct udp_pcb *pcb, struct pbuf *p) 00331 { 00332 /* send to the packet using remote ip and port stored in the pcb */ 00333 return udp_sendto(pcb, p, &pcb->remote_ip, pcb->remote_port); 00334 } 00335 00336 /** 00337 * Send data to a specified address using UDP. 00338 * 00339 * @param pcb UDP PCB used to send the data. 00340 * @param p chain of pbuf's to be sent. 00341 * @param dst_ip Destination IP address. 00342 * @param dst_port Destination UDP port. 00343 * 00344 * dst_ip & dst_port are expected to be in the same byte order as in the pcb. 00345 * 00346 * If the PCB already has a remote address association, it will 00347 * be restored after the data is sent. 00348 * 00349 * @return lwIP error code (@see udp_send for possible error codes) 00350 * 00351 * @see udp_disconnect() udp_send() 00352 */ 00353 err_t 00354 udp_sendto(struct udp_pcb *pcb, struct pbuf *p, 00355 struct ip_addr *dst_ip, u16_t dst_port) 00356 { 00357 struct netif *netif; 00358 00359 LWIP_DEBUGF(UDP_DEBUG | LWIP_DBG_TRACE | 3, ("udp_send\n")); 00360 00361 /* find the outgoing network interface for this packet */ 00362 #if LWIP_IGMP 00363 netif = ip_route((ip_addr_ismulticast(dst_ip))?(&(pcb->multicast_ip)):(dst_ip)); 00364 #else 00365 netif = ip_route(dst_ip); 00366 #endif /* LWIP_IGMP */ 00367 00368 /* no outgoing network interface could be found? */ 00369 if (netif == NULL) { 00370 LWIP_DEBUGF(UDP_DEBUG | 1, ("udp_send: No route to 0x%"X32_F"\n", dst_ip->addr)); 00371 UDP_STATS_INC(udp.rterr); 00372 return ERR_RTE; 00373 } 00374 return udp_sendto_if(pcb, p, dst_ip, dst_port, netif); 00375 } 00376 00377 /** 00378 * Send data to a specified address using UDP. 00379 * The netif used for sending can be specified. 00380 * 00381 * This function exists mainly for DHCP, to be able to send UDP packets 00382 * on a netif that is still down. 00383 * 00384 * @param pcb UDP PCB used to send the data. 00385 * @param p chain of pbuf's to be sent. 00386 * @param dst_ip Destination IP address. 00387 * @param dst_port Destination UDP port. 00388 * @param netif the netif used for sending. 00389 * 00390 * dst_ip & dst_port are expected to be in the same byte order as in the pcb. 00391 * 00392 * @return lwIP error code (@see udp_send for possible error codes) 00393 * 00394 * @see udp_disconnect() udp_send() 00395 */ 00396 err_t 00397 udp_sendto_if(struct udp_pcb *pcb, struct pbuf *p, 00398 struct ip_addr *dst_ip, u16_t dst_port, struct netif *netif) 00399 { 00400 struct udp_hdr *udphdr; 00401 struct ip_addr *src_ip; 00402 err_t err; 00403 struct pbuf *q; /* q will be sent down the stack */ 00404 00405 /* if the PCB is not yet bound to a port, bind it here */ 00406 if (pcb->local_port == 0) { 00407 LWIP_DEBUGF(UDP_DEBUG | LWIP_DBG_TRACE | 2, ("udp_send: not yet bound to a port, binding now\n")); 00408 err = udp_bind(pcb, &pcb->local_ip, pcb->local_port); 00409 if (err != ERR_OK) { 00410 LWIP_DEBUGF(UDP_DEBUG | LWIP_DBG_TRACE | 2, ("udp_send: forced port bind failed\n")); 00411 return err; 00412 } 00413 } 00414 00415 /* not enough space to add an UDP header to first pbuf in given p chain? */ 00416 if (pbuf_header(p, UDP_HLEN)) { 00417 /* allocate header in a separate new pbuf */ 00418 q = pbuf_alloc(PBUF_IP, UDP_HLEN, PBUF_RAM); 00419 /* new header pbuf could not be allocated? */ 00420 if (q == NULL) { 00421 LWIP_DEBUGF(UDP_DEBUG | LWIP_DBG_TRACE | 2, ("udp_send: could not allocate header\n")); 00422 return ERR_MEM; 00423 } 00424 /* chain header q in front of given pbuf p */ 00425 pbuf_chain(q, p); 00426 /* first pbuf q points to header pbuf */ 00427 LWIP_DEBUGF(UDP_DEBUG, 00428 ("udp_send: added header pbuf %p before given pbuf %p\n", (void *)q, (void *)p)); 00429 } else { 00430 /* adding space for header within p succeeded */ 00431 /* first pbuf q equals given pbuf */ 00432 q = p; 00433 LWIP_DEBUGF(UDP_DEBUG, ("udp_send: added header in given pbuf %p\n", (void *)p)); 00434 } 00435 LWIP_ASSERT("check that first pbuf can hold struct udp_hdr", 00436 (q->len >= sizeof(struct udp_hdr))); 00437 /* q now represents the packet to be sent */ 00438 udphdr = (struct udp_hdr *)(q->payload); 00439 udphdr->src = htons(pcb->local_port); 00440 udphdr->dest = htons(dst_port); 00441 /* in UDP, 0 checksum means 'no checksum' */ 00442 udphdr->chksum = 0x0000; 00443 00444 /* PCB local address is IP_ANY_ADDR? */ 00445 if (ip_addr_isany(&pcb->local_ip)) { 00446 /* use outgoing network interface IP address as source address */ 00447 src_ip = &(netif->ip_addr); 00448 } else { 00449 /* check if UDP PCB local IP address is correct 00450 * this could be an old address if netif->ip_addr has changed */ 00451 if (!ip_addr_cmp(&(pcb->local_ip), &(netif->ip_addr))) { 00452 /* local_ip doesn't match, drop the packet */ 00453 if (q != p) { 00454 /* free the header pbuf */ 00455 pbuf_free(q); 00456 q = NULL; 00457 /* p is still referenced by the caller, and will live on */ 00458 } 00459 return ERR_VAL; 00460 } 00461 /* use UDP PCB local IP address as source address */ 00462 src_ip = &(pcb->local_ip); 00463 } 00464 00465 LWIP_DEBUGF(UDP_DEBUG, ("udp_send: sending datagram of length %"U16_F"\n", q->tot_len)); 00466 00467 #if LWIP_UDPLITE 00468 /* UDP Lite protocol? */ 00469 if (pcb->flags & UDP_FLAGS_UDPLITE) { 00470 u16_t chklen, chklen_hdr; 00471 LWIP_DEBUGF(UDP_DEBUG, ("udp_send: UDP LITE packet length %"U16_F"\n", q->tot_len)); 00472 /* set UDP message length in UDP header */ 00473 chklen_hdr = chklen = pcb->chksum_len_tx; 00474 if ((chklen < sizeof(struct udp_hdr)) || (chklen > q->tot_len)) { 00475 if (chklen != 0) { 00476 LWIP_DEBUGF(UDP_DEBUG, ("udp_send: UDP LITE pcb->chksum_len is illegal: %"U16_F"\n", chklen)); 00477 } 00478 /* For UDP-Lite, checksum length of 0 means checksum 00479 over the complete packet. (See RFC 3828 chap. 3.1) 00480 At least the UDP-Lite header must be covered by the 00481 checksum, therefore, if chksum_len has an illegal 00482 value, we generate the checksum over the complete 00483 packet to be safe. */ 00484 chklen_hdr = 0; 00485 chklen = q->tot_len; 00486 } 00487 udphdr->len = htons(chklen_hdr); 00488 /* calculate checksum */ 00489 #if CHECKSUM_GEN_UDP 00490 udphdr->chksum = inet_chksum_pseudo_partial(q, src_ip, dst_ip, 00491 IP_PROTO_UDPLITE, q->tot_len, chklen); 00492 /* chksum zero must become 0xffff, as zero means 'no checksum' */ 00493 if (udphdr->chksum == 0x0000) 00494 udphdr->chksum = 0xffff; 00495 #endif /* CHECKSUM_CHECK_UDP */ 00496 /* output to IP */ 00497 LWIP_DEBUGF(UDP_DEBUG, ("udp_send: ip_output_if (,,,,IP_PROTO_UDPLITE,)\n")); 00498 #if LWIP_NETIF_HWADDRHINT 00499 netif->addr_hint = &(pcb->addr_hint); 00500 #endif /* LWIP_NETIF_HWADDRHINT*/ 00501 err = ip_output_if(q, src_ip, dst_ip, pcb->ttl, pcb->tos, IP_PROTO_UDPLITE, netif); 00502 #if LWIP_NETIF_HWADDRHINT 00503 netif->addr_hint = NULL; 00504 #endif /* LWIP_NETIF_HWADDRHINT*/ 00505 } else 00506 #endif /* LWIP_UDPLITE */ 00507 { /* UDP */ 00508 LWIP_DEBUGF(UDP_DEBUG, ("udp_send: UDP packet length %"U16_F"\n", q->tot_len)); 00509 udphdr->len = htons(q->tot_len); 00510 /* calculate checksum */ 00511 #if CHECKSUM_GEN_UDP 00512 if ((pcb->flags & UDP_FLAGS_NOCHKSUM) == 0) { 00513 udphdr->chksum = inet_chksum_pseudo(q, src_ip, dst_ip, IP_PROTO_UDP, q->tot_len); 00514 /* chksum zero must become 0xffff, as zero means 'no checksum' */ 00515 if (udphdr->chksum == 0x0000) udphdr->chksum = 0xffff; 00516 } 00517 #endif /* CHECKSUM_CHECK_UDP */ 00518 LWIP_DEBUGF(UDP_DEBUG, ("udp_send: UDP checksum 0x%04"X16_F"\n", udphdr->chksum)); 00519 LWIP_DEBUGF(UDP_DEBUG, ("udp_send: ip_output_if (,,,,IP_PROTO_UDP,)\n")); 00520 /* output to IP */ 00521 #if LWIP_NETIF_HWADDRHINT 00522 netif->addr_hint = &(pcb->addr_hint); 00523 #endif /* LWIP_NETIF_HWADDRHINT*/ 00524 err = ip_output_if(q, src_ip, dst_ip, pcb->ttl, pcb->tos, IP_PROTO_UDP, netif); 00525 #if LWIP_NETIF_HWADDRHINT 00526 netif->addr_hint = NULL; 00527 #endif /* LWIP_NETIF_HWADDRHINT*/ 00528 } 00529 /* TODO: must this be increased even if error occured? */ 00530 snmp_inc_udpoutdatagrams(); 00531 00532 /* did we chain a separate header pbuf earlier? */ 00533 if (q != p) { 00534 /* free the header pbuf */ 00535 pbuf_free(q); 00536 q = NULL; 00537 /* p is still referenced by the caller, and will live on */ 00538 } 00539 00540 UDP_STATS_INC(udp.xmit); 00541 return err; 00542 } 00543 00544 /** 00545 * Bind an UDP PCB. 00546 * 00547 * @param pcb UDP PCB to be bound with a local address ipaddr and port. 00548 * @param ipaddr local IP address to bind with. Use IP_ADDR_ANY to 00549 * bind to all local interfaces. 00550 * @param port local UDP port to bind with. Use 0 to automatically bind 00551 * to a random port between UDP_LOCAL_PORT_RANGE_START and 00552 * UDP_LOCAL_PORT_RANGE_END. 00553 * 00554 * ipaddr & port are expected to be in the same byte order as in the pcb. 00555 * 00556 * @return lwIP error code. 00557 * - ERR_OK. Successful. No error occured. 00558 * - ERR_USE. The specified ipaddr and port are already bound to by 00559 * another UDP PCB. 00560 * 00561 * @see udp_disconnect() 00562 */ 00563 err_t 00564 udp_bind(struct udp_pcb *pcb, struct ip_addr *ipaddr, u16_t port) 00565 { 00566 struct udp_pcb *ipcb; 00567 u8_t rebind; 00568 00569 LWIP_DEBUGF(UDP_DEBUG | LWIP_DBG_TRACE | 3, ("udp_bind(ipaddr = ")); 00570 ip_addr_debug_print(UDP_DEBUG, ipaddr); 00571 LWIP_DEBUGF(UDP_DEBUG | LWIP_DBG_TRACE | 3, (", port = %"U16_F")\n", port)); 00572 00573 rebind = 0; 00574 /* Check for double bind and rebind of the same pcb */ 00575 for (ipcb = udp_pcbs; ipcb != NULL; ipcb = ipcb->next) { 00576 /* is this UDP PCB already on active list? */ 00577 if (pcb == ipcb) { 00578 /* pcb may occur at most once in active list */ 00579 LWIP_ASSERT("rebind == 0", rebind == 0); 00580 /* pcb already in list, just rebind */ 00581 rebind = 1; 00582 } 00583 00584 /* this code does not allow upper layer to share a UDP port for 00585 listening to broadcast or multicast traffic (See SO_REUSE_ADDR and 00586 SO_REUSE_PORT under *BSD). TODO: See where it fits instead, OR 00587 combine with implementation of UDP PCB flags. Leon Woestenberg. */ 00588 #ifdef LWIP_UDP_TODO 00589 /* port matches that of PCB in list? */ 00590 else 00591 if ((ipcb->local_port == port) && 00592 /* IP address matches, or one is IP_ADDR_ANY? */ 00593 (ip_addr_isany(&(ipcb->local_ip)) || 00594 ip_addr_isany(ipaddr) || 00595 ip_addr_cmp(&(ipcb->local_ip), ipaddr))) { 00596 /* other PCB already binds to this local IP and port */ 00597 LWIP_DEBUGF(UDP_DEBUG, 00598 ("udp_bind: local port %"U16_F" already bound by another pcb\n", port)); 00599 return ERR_USE; 00600 } 00601 #endif 00602 } 00603 00604 ip_addr_set(&pcb->local_ip, ipaddr); 00605 00606 /* no port specified? */ 00607 if (port == 0) { 00608 #ifndef UDP_LOCAL_PORT_RANGE_START 00609 #define UDP_LOCAL_PORT_RANGE_START 4096 00610 #define UDP_LOCAL_PORT_RANGE_END 0x7fff 00611 #endif 00612 port = UDP_LOCAL_PORT_RANGE_START; 00613 ipcb = udp_pcbs; 00614 while ((ipcb != NULL) && (port != UDP_LOCAL_PORT_RANGE_END)) { 00615 if (ipcb->local_port == port) { 00616 /* port is already used by another udp_pcb */ 00617 port++; 00618 /* restart scanning all udp pcbs */ 00619 ipcb = udp_pcbs; 00620 } else 00621 /* go on with next udp pcb */ 00622 ipcb = ipcb->next; 00623 } 00624 if (ipcb != NULL) { 00625 /* no more ports available in local range */ 00626 LWIP_DEBUGF(UDP_DEBUG, ("udp_bind: out of free UDP ports\n")); 00627 return ERR_USE; 00628 } 00629 } 00630 pcb->local_port = port; 00631 snmp_insert_udpidx_tree(pcb); 00632 /* pcb not active yet? */ 00633 if (rebind == 0) { 00634 /* place the PCB on the active list if not already there */ 00635 pcb->next = udp_pcbs; 00636 udp_pcbs = pcb; 00637 } 00638 LWIP_DEBUGF(UDP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, 00639 ("udp_bind: bound to %"U16_F".%"U16_F".%"U16_F".%"U16_F", port %"U16_F"\n", 00640 (u16_t)((ntohl(pcb->local_ip.addr) >> 24) & 0xff), 00641 (u16_t)((ntohl(pcb->local_ip.addr) >> 16) & 0xff), 00642 (u16_t)((ntohl(pcb->local_ip.addr) >> 8) & 0xff), 00643 (u16_t)(ntohl(pcb->local_ip.addr) & 0xff), pcb->local_port)); 00644 return ERR_OK; 00645 } 00646 /** 00647 * Connect an UDP PCB. 00648 * 00649 * This will associate the UDP PCB with the remote address. 00650 * 00651 * @param pcb UDP PCB to be connected with remote address ipaddr and port. 00652 * @param ipaddr remote IP address to connect with. 00653 * @param port remote UDP port to connect with. 00654 * 00655 * @return lwIP error code 00656 * 00657 * ipaddr & port are expected to be in the same byte order as in the pcb. 00658 * 00659 * The udp pcb is bound to a random local port if not already bound. 00660 * 00661 * @see udp_disconnect() 00662 */ 00663 err_t 00664 udp_connect(struct udp_pcb *pcb, struct ip_addr *ipaddr, u16_t port) 00665 { 00666 struct udp_pcb *ipcb; 00667 00668 if (pcb->local_port == 0) { 00669 err_t err = udp_bind(pcb, &pcb->local_ip, pcb->local_port); 00670 if (err != ERR_OK) 00671 return err; 00672 } 00673 00674 ip_addr_set(&pcb->remote_ip, ipaddr); 00675 pcb->remote_port = port; 00676 pcb->flags |= UDP_FLAGS_CONNECTED; 00677 /** TODO: this functionality belongs in upper layers */ 00678 #ifdef LWIP_UDP_TODO 00679 /* Nail down local IP for netconn_addr()/getsockname() */ 00680 if (ip_addr_isany(&pcb->local_ip) && !ip_addr_isany(&pcb->remote_ip)) { 00681 struct netif *netif; 00682 00683 if ((netif = ip_route(&(pcb->remote_ip))) == NULL) { 00684 LWIP_DEBUGF(UDP_DEBUG, ("udp_connect: No route to 0x%lx\n", pcb->remote_ip.addr)); 00685 UDP_STATS_INC(udp.rterr); 00686 return ERR_RTE; 00687 } 00688 /** TODO: this will bind the udp pcb locally, to the interface which 00689 is used to route output packets to the remote address. However, we 00690 might want to accept incoming packets on any interface! */ 00691 pcb->local_ip = netif->ip_addr; 00692 } else if (ip_addr_isany(&pcb->remote_ip)) { 00693 pcb->local_ip.addr = 0; 00694 } 00695 #endif 00696 LWIP_DEBUGF(UDP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, 00697 ("udp_connect: connected to %"U16_F".%"U16_F".%"U16_F".%"U16_F",port %"U16_F"\n", 00698 (u16_t)((ntohl(pcb->remote_ip.addr) >> 24) & 0xff), 00699 (u16_t)((ntohl(pcb->remote_ip.addr) >> 16) & 0xff), 00700 (u16_t)((ntohl(pcb->remote_ip.addr) >> 8) & 0xff), 00701 (u16_t)(ntohl(pcb->remote_ip.addr) & 0xff), pcb->remote_port)); 00702 00703 /* Insert UDP PCB into the list of active UDP PCBs. */ 00704 for (ipcb = udp_pcbs; ipcb != NULL; ipcb = ipcb->next) { 00705 if (pcb == ipcb) { 00706 /* already on the list, just return */ 00707 return ERR_OK; 00708 } 00709 } 00710 /* PCB not yet on the list, add PCB now */ 00711 pcb->next = udp_pcbs; 00712 udp_pcbs = pcb; 00713 return ERR_OK; 00714 } 00715 00716 /** 00717 * Disconnect a UDP PCB 00718 * 00719 * @param pcb the udp pcb to disconnect. 00720 */ 00721 void 00722 udp_disconnect(struct udp_pcb *pcb) 00723 { 00724 /* reset remote address association */ 00725 ip_addr_set(&pcb->remote_ip, IP_ADDR_ANY); 00726 pcb->remote_port = 0; 00727 /* mark PCB as unconnected */ 00728 pcb->flags &= ~UDP_FLAGS_CONNECTED; 00729 } 00730 00731 /** 00732 * Set a receive callback for a UDP PCB 00733 * 00734 * This callback will be called when receiving a datagram for the pcb. 00735 * 00736 * @param pcb the pcb for wich to set the recv callback 00737 * @param recv function pointer of the callback function 00738 * @param recv_arg additional argument to pass to the callback function 00739 */ 00740 void 00741 udp_recv(struct udp_pcb *pcb, 00742 void (* recv)(void *arg, struct udp_pcb *upcb, struct pbuf *p, 00743 struct ip_addr *addr, u16_t port), 00744 void *recv_arg) 00745 { 00746 /* remember recv() callback and user data */ 00747 pcb->recv = recv; 00748 pcb->recv_arg = recv_arg; 00749 } 00750 00751 /** 00752 * Remove an UDP PCB. 00753 * 00754 * @param pcb UDP PCB to be removed. The PCB is removed from the list of 00755 * UDP PCB's and the data structure is freed from memory. 00756 * 00757 * @see udp_new() 00758 */ 00759 void 00760 udp_remove(struct udp_pcb *pcb) 00761 { 00762 struct udp_pcb *pcb2; 00763 00764 snmp_delete_udpidx_tree(pcb); 00765 /* pcb to be removed is first in list? */ 00766 if (udp_pcbs == pcb) { 00767 /* make list start at 2nd pcb */ 00768 udp_pcbs = udp_pcbs->next; 00769 /* pcb not 1st in list */ 00770 } else 00771 for (pcb2 = udp_pcbs; pcb2 != NULL; pcb2 = pcb2->next) { 00772 /* find pcb in udp_pcbs list */ 00773 if (pcb2->next != NULL && pcb2->next == pcb) { 00774 /* remove pcb from list */ 00775 pcb2->next = pcb->next; 00776 } 00777 } 00778 memp_free(MEMP_UDP_PCB, pcb); 00779 } 00780 00781 /** 00782 * Create a UDP PCB. 00783 * 00784 * @return The UDP PCB which was created. NULL if the PCB data structure 00785 * could not be allocated. 00786 * 00787 * @see udp_remove() 00788 */ 00789 struct udp_pcb * 00790 udp_new(void) 00791 { 00792 struct udp_pcb *pcb; 00793 pcb = (struct udp_pcb *)(memp_malloc(MEMP_UDP_PCB)); 00794 /* could allocate UDP PCB? */ 00795 if (pcb != NULL) { 00796 /* UDP Lite: by initializing to all zeroes, chksum_len is set to 0 00797 * which means checksum is generated over the whole datagram per default 00798 * (recommended as default by RFC 3828). */ 00799 /* initialize PCB to all zeroes */ 00800 memset(pcb, 0, sizeof(struct udp_pcb)); 00801 pcb->ttl = UDP_TTL; 00802 } 00803 return pcb; 00804 } 00805 00806 #if UDP_DEBUG 00807 /** 00808 * Print UDP header information for debug purposes. 00809 * 00810 * @param udphdr pointer to the udp header in memory. 00811 */ 00812 void 00813 udp_debug_print(struct udp_hdr *udphdr) 00814 { 00815 LWIP_DEBUGF(UDP_DEBUG, ("UDP header:\n")); 00816 LWIP_DEBUGF(UDP_DEBUG, ("+-------------------------------+\n")); 00817 LWIP_DEBUGF(UDP_DEBUG, ("| %5"U16_F" | %5"U16_F" | (src port, dest port)\n", 00818 ntohs(udphdr->src), ntohs(udphdr->dest))); 00819 LWIP_DEBUGF(UDP_DEBUG, ("+-------------------------------+\n")); 00820 LWIP_DEBUGF(UDP_DEBUG, ("| %5"U16_F" | 0x%04"X16_F" | (len, chksum)\n", 00821 ntohs(udphdr->len), ntohs(udphdr->chksum))); 00822 LWIP_DEBUGF(UDP_DEBUG, ("+-------------------------------+\n")); 00823 } 00824 #endif /* UDP_DEBUG */ 00825 00826 #endif /* LWIP_UDP */
Generated on Tue Jul 12 2022 19:24:06 by 1.7.2