]> Git Repo - qemu.git/blob - slirp/udp.c
slirp: Factorizing address translation
[qemu.git] / slirp / udp.c
1 /*
2  * Copyright (c) 1982, 1986, 1988, 1990, 1993
3  *      The Regents of the University of California.  All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 3. Neither the name of the University nor the names of its contributors
14  *    may be used to endorse or promote products derived from this software
15  *    without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27  * SUCH DAMAGE.
28  *
29  *      @(#)udp_usrreq.c        8.4 (Berkeley) 1/21/94
30  * udp_usrreq.c,v 1.4 1994/10/02 17:48:45 phk Exp
31  */
32
33 /*
34  * Changes and additions relating to SLiRP
35  * Copyright (c) 1995 Danny Gasparovski.
36  *
37  * Please read the file COPYRIGHT for the
38  * terms and conditions of the copyright.
39  */
40
41 #include <slirp.h>
42 #include "ip_icmp.h"
43
44 static uint8_t udp_tos(struct socket *so);
45
46 void
47 udp_init(Slirp *slirp)
48 {
49     slirp->udb.so_next = slirp->udb.so_prev = &slirp->udb;
50     slirp->udp_last_so = &slirp->udb;
51 }
52
53 void udp_cleanup(Slirp *slirp)
54 {
55     while (slirp->udb.so_next != &slirp->udb) {
56         udp_detach(slirp->udb.so_next);
57     }
58 }
59
60 /* m->m_data  points at ip packet header
61  * m->m_len   length ip packet
62  * ip->ip_len length data (IPDU)
63  */
64 void
65 udp_input(register struct mbuf *m, int iphlen)
66 {
67         Slirp *slirp = m->slirp;
68         register struct ip *ip;
69         register struct udphdr *uh;
70         int len;
71         struct ip save_ip;
72         struct socket *so;
73
74         DEBUG_CALL("udp_input");
75         DEBUG_ARG("m = %p", m);
76         DEBUG_ARG("iphlen = %d", iphlen);
77
78         /*
79          * Strip IP options, if any; should skip this,
80          * make available to user, and use on returned packets,
81          * but we don't yet have a way to check the checksum
82          * with options still present.
83          */
84         if(iphlen > sizeof(struct ip)) {
85                 ip_stripoptions(m, (struct mbuf *)0);
86                 iphlen = sizeof(struct ip);
87         }
88
89         /*
90          * Get IP and UDP header together in first mbuf.
91          */
92         ip = mtod(m, struct ip *);
93         uh = (struct udphdr *)((caddr_t)ip + iphlen);
94
95         /*
96          * Make mbuf data length reflect UDP length.
97          * If not enough data to reflect UDP length, drop.
98          */
99         len = ntohs((uint16_t)uh->uh_ulen);
100
101         if (ip->ip_len != len) {
102                 if (len > ip->ip_len) {
103                         goto bad;
104                 }
105                 m_adj(m, len - ip->ip_len);
106                 ip->ip_len = len;
107         }
108
109         /*
110          * Save a copy of the IP header in case we want restore it
111          * for sending an ICMP error message in response.
112          */
113         save_ip = *ip;
114         save_ip.ip_len+= iphlen;         /* tcp_input subtracts this */
115
116         /*
117          * Checksum extended UDP header and data.
118          */
119         if (uh->uh_sum) {
120       memset(&((struct ipovly *)ip)->ih_mbuf, 0, sizeof(struct mbuf_ptr));
121           ((struct ipovly *)ip)->ih_x1 = 0;
122           ((struct ipovly *)ip)->ih_len = uh->uh_ulen;
123           if(cksum(m, len + sizeof(struct ip))) {
124             goto bad;
125           }
126         }
127
128         /*
129          *  handle DHCP/BOOTP
130          */
131         if (ntohs(uh->uh_dport) == BOOTP_SERVER &&
132             (ip->ip_dst.s_addr == slirp->vhost_addr.s_addr ||
133              ip->ip_dst.s_addr == 0xffffffff)) {
134                 bootp_input(m);
135                 goto bad;
136             }
137
138         /*
139          *  handle TFTP
140          */
141         if (ntohs(uh->uh_dport) == TFTP_SERVER &&
142             ip->ip_dst.s_addr == slirp->vhost_addr.s_addr) {
143             tftp_input(m);
144             goto bad;
145         }
146
147         if (slirp->restricted) {
148             goto bad;
149         }
150
151         /*
152          * Locate pcb for datagram.
153          */
154         so = slirp->udp_last_so;
155         if (so == &slirp->udb || so->so_lport != uh->uh_sport ||
156             so->so_laddr.s_addr != ip->ip_src.s_addr) {
157                 struct socket *tmp;
158
159                 for (tmp = slirp->udb.so_next; tmp != &slirp->udb;
160                      tmp = tmp->so_next) {
161                         if (tmp->so_lport == uh->uh_sport &&
162                             tmp->so_laddr.s_addr == ip->ip_src.s_addr) {
163                                 so = tmp;
164                                 break;
165                         }
166                 }
167                 if (tmp == &slirp->udb) {
168                   so = NULL;
169                 } else {
170                   slirp->udp_last_so = so;
171                 }
172         }
173
174         if (so == NULL) {
175           /*
176            * If there's no socket for this packet,
177            * create one
178            */
179           so = socreate(slirp);
180           if (!so) {
181               goto bad;
182           }
183           if(udp_attach(so) == -1) {
184             DEBUG_MISC((dfd," udp_attach errno = %d-%s\n",
185                         errno,strerror(errno)));
186             sofree(so);
187             goto bad;
188           }
189
190           /*
191            * Setup fields
192            */
193           so->so_lfamily = AF_INET;
194           so->so_laddr = ip->ip_src;
195           so->so_lport = uh->uh_sport;
196
197           if ((so->so_iptos = udp_tos(so)) == 0)
198             so->so_iptos = ip->ip_tos;
199
200           /*
201            * XXXXX Here, check if it's in udpexec_list,
202            * and if it is, do the fork_exec() etc.
203            */
204         }
205
206         so->so_ffamily = AF_INET;
207         so->so_faddr = ip->ip_dst; /* XXX */
208         so->so_fport = uh->uh_dport; /* XXX */
209
210         iphlen += sizeof(struct udphdr);
211         m->m_len -= iphlen;
212         m->m_data += iphlen;
213
214         /*
215          * Now we sendto() the packet.
216          */
217         if(sosendto(so,m) == -1) {
218           m->m_len += iphlen;
219           m->m_data -= iphlen;
220           *ip=save_ip;
221           DEBUG_MISC((dfd,"udp tx errno = %d-%s\n",errno,strerror(errno)));
222           icmp_error(m, ICMP_UNREACH,ICMP_UNREACH_NET, 0,strerror(errno));
223           goto bad;
224         }
225
226         m_free(so->so_m);   /* used for ICMP if error on sorecvfrom */
227
228         /* restore the orig mbuf packet */
229         m->m_len += iphlen;
230         m->m_data -= iphlen;
231         *ip=save_ip;
232         so->so_m=m;         /* ICMP backup */
233
234         return;
235 bad:
236         m_free(m);
237 }
238
239 int udp_output(struct socket *so, struct mbuf *m,
240                 struct sockaddr_in *saddr, struct sockaddr_in *daddr,
241                 int iptos)
242 {
243         register struct udpiphdr *ui;
244         int error = 0;
245
246         DEBUG_CALL("udp_output");
247         DEBUG_ARG("so = %p", so);
248         DEBUG_ARG("m = %p", m);
249         DEBUG_ARG("saddr = %lx", (long)saddr->sin_addr.s_addr);
250         DEBUG_ARG("daddr = %lx", (long)daddr->sin_addr.s_addr);
251
252         /*
253          * Adjust for header
254          */
255         m->m_data -= sizeof(struct udpiphdr);
256         m->m_len += sizeof(struct udpiphdr);
257
258         /*
259          * Fill in mbuf with extended UDP header
260          * and addresses and length put into network format.
261          */
262         ui = mtod(m, struct udpiphdr *);
263     memset(&ui->ui_i.ih_mbuf, 0 , sizeof(struct mbuf_ptr));
264         ui->ui_x1 = 0;
265         ui->ui_pr = IPPROTO_UDP;
266         ui->ui_len = htons(m->m_len - sizeof(struct ip));
267         /* XXXXX Check for from-one-location sockets, or from-any-location sockets */
268         ui->ui_src = saddr->sin_addr;
269         ui->ui_dst = daddr->sin_addr;
270         ui->ui_sport = saddr->sin_port;
271         ui->ui_dport = daddr->sin_port;
272         ui->ui_ulen = ui->ui_len;
273
274         /*
275          * Stuff checksum and output datagram.
276          */
277         ui->ui_sum = 0;
278         if ((ui->ui_sum = cksum(m, m->m_len)) == 0)
279                 ui->ui_sum = 0xffff;
280         ((struct ip *)ui)->ip_len = m->m_len;
281
282         ((struct ip *)ui)->ip_ttl = IPDEFTTL;
283         ((struct ip *)ui)->ip_tos = iptos;
284
285         error = ip_output(so, m);
286
287         return (error);
288 }
289
290 int
291 udp_attach(struct socket *so)
292 {
293   if((so->s = qemu_socket(AF_INET,SOCK_DGRAM,0)) != -1) {
294     so->so_expire = curtime + SO_EXPIRE;
295     insque(so, &so->slirp->udb);
296   }
297   return(so->s);
298 }
299
300 void
301 udp_detach(struct socket *so)
302 {
303         closesocket(so->s);
304         sofree(so);
305 }
306
307 static const struct tos_t udptos[] = {
308         {0, 53, IPTOS_LOWDELAY, 0},                     /* DNS */
309         {0, 0, 0, 0}
310 };
311
312 static uint8_t
313 udp_tos(struct socket *so)
314 {
315         int i = 0;
316
317         while(udptos[i].tos) {
318                 if ((udptos[i].fport && ntohs(so->so_fport) == udptos[i].fport) ||
319                     (udptos[i].lport && ntohs(so->so_lport) == udptos[i].lport)) {
320                         so->so_emu = udptos[i].emu;
321                         return udptos[i].tos;
322                 }
323                 i++;
324         }
325
326         return 0;
327 }
328
329 struct socket *
330 udp_listen(Slirp *slirp, uint32_t haddr, u_int hport, uint32_t laddr,
331            u_int lport, int flags)
332 {
333         struct sockaddr_in addr;
334         struct socket *so;
335         socklen_t addrlen = sizeof(struct sockaddr_in);
336
337         so = socreate(slirp);
338         if (!so) {
339             return NULL;
340         }
341         so->s = qemu_socket(AF_INET,SOCK_DGRAM,0);
342         so->so_expire = curtime + SO_EXPIRE;
343         insque(so, &slirp->udb);
344
345         addr.sin_family = AF_INET;
346         addr.sin_addr.s_addr = haddr;
347         addr.sin_port = hport;
348
349         if (bind(so->s,(struct sockaddr *)&addr, addrlen) < 0) {
350                 udp_detach(so);
351                 return NULL;
352         }
353         socket_set_fast_reuse(so->s);
354
355         getsockname(so->s,(struct sockaddr *)&addr,&addrlen);
356         so->fhost.sin = addr;
357         sotranslate_accept(so);
358         so->so_lfamily = AF_INET;
359         so->so_lport = lport;
360         so->so_laddr.s_addr = laddr;
361         if (flags != SS_FACCEPTONCE)
362            so->so_expire = 0;
363
364         so->so_state &= SS_PERSISTENT_MASK;
365         so->so_state |= SS_ISFCONNECTED | flags;
366
367         return so;
368 }
This page took 0.044526 seconds and 4 git commands to generate.