ANSIfication. No functional changes.
[dragonfly.git] / sys / netproto / ns / ns_pcb.c
1 /*
2  * Copyright (c) 1984, 1985, 1986, 1987, 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. All advertising materials mentioning features or use of this software
14  *    must display the following acknowledgement:
15  *      This product includes software developed by the University of
16  *      California, Berkeley and its contributors.
17  * 4. Neither the name of the University nor the names of its contributors
18  *    may be used to endorse or promote products derived from this software
19  *    without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31  * SUCH DAMAGE.
32  *
33  *      @(#)ns_pcb.c    8.1 (Berkeley) 6/10/93
34  * $FreeBSD: src/sys/netns/ns_pcb.c,v 1.9 1999/08/28 00:49:51 peter Exp $
35  * $DragonFly: src/sys/netproto/ns/ns_pcb.c,v 1.9 2004/06/04 01:46:49 dillon Exp $
36  */
37
38 #include <sys/param.h>
39 #include <sys/systm.h>
40 #include <sys/mbuf.h>
41 #include <sys/errno.h>
42 #include <sys/socket.h>
43 #include <sys/socketvar.h>
44 #include <sys/protosw.h>
45
46 #include <net/if.h>
47 #include <net/route.h>
48
49 #include "ns.h"
50 #include "ns_if.h"
51 #include "ns_pcb.h"
52
53 struct  ns_addr zerons_addr;
54 struct nspcb nspcb;             /* head of list */
55
56 int
57 ns_pcballoc(struct socket *so, struct nspcb *head)
58 {
59         struct mbuf *m;
60         struct nspcb *nsp;
61
62         m = m_getclr(MB_DONTWAIT, MT_CONTROL); /*protocol private PCB */
63         if (m == NULL)
64                 return (ENOBUFS);
65         nsp = mtod(m, struct nspcb *);
66         nsp->nsp_socket = so;
67         insque(nsp, head);
68         so->so_pcb = (caddr_t)nsp;
69         return (0);
70 }
71
72 int
73 ns_pcbbind(struct nspcb *nsp, struct mbuf *nam)
74 {
75         struct sockaddr_ns *sns;
76         u_short lport = 0;
77
78         if (nsp->nsp_lport || !ns_nullhost(nsp->nsp_laddr))
79                 return (EINVAL);
80         if (nam == 0)
81                 goto noname;
82         sns = mtod(nam, struct sockaddr_ns *);
83         if (nam->m_len != sizeof (*sns))
84                 return (EINVAL);
85         if (!ns_nullhost(sns->sns_addr)) {
86                 int tport = sns->sns_port;
87
88                 sns->sns_port = 0;              /* yech... */
89                 if (ifa_ifwithaddr((struct sockaddr *)sns) == 0)
90                         return (EADDRNOTAVAIL);
91                 sns->sns_port = tport;
92         }
93         lport = sns->sns_port;
94         if (lport) {
95 #ifdef  NS_PRIV_SOCKETS
96                 u_short aport = ntohs(lport);
97
98                 if (aport < NSPORT_RESERVED &&
99                     (nsp->nsp_socket->so_state & SS_PRIV) == 0)
100                         return (EACCES);
101 #endif  /* NS_PRIV_SOCKETS */
102
103                 if (ns_pcblookup(&zerons_addr, lport, 0))
104                         return (EADDRINUSE);
105         }
106         nsp->nsp_laddr = sns->sns_addr;
107 noname:
108         if (lport == 0)
109                 do {
110                         if (nspcb.nsp_lport++ < NSPORT_RESERVED)
111                                 nspcb.nsp_lport = NSPORT_RESERVED;
112                         lport = htons(nspcb.nsp_lport);
113                 } while (ns_pcblookup(&zerons_addr, lport, 0));
114         nsp->nsp_lport = lport;
115         return (0);
116 }
117
118 /*
119  * Connect from a socket to a specified address.
120  * Both address and port must be specified in argument sns.
121  * If don't have a local address for this socket yet,
122  * then pick one.
123  */
124 int
125 ns_pcbconnect(struct nspcb *nsp, struct mbuf *nam)
126 {
127         struct ns_ifaddr *ia;
128         struct sockaddr_ns *sns = mtod(nam, struct sockaddr_ns *);
129         struct ns_addr *dst;
130         struct route *ro;
131         struct ifnet *ifp;
132
133         if (nam->m_len != sizeof (*sns))
134                 return (EINVAL);
135         if (sns->sns_family != AF_NS)
136                 return (EAFNOSUPPORT);
137         if (sns->sns_port==0 || ns_nullhost(sns->sns_addr))
138                 return (EADDRNOTAVAIL);
139         /*
140          * If we haven't bound which network number to use as ours,
141          * we will use the number of the outgoing interface.
142          * This depends on having done a routing lookup, which
143          * we will probably have to do anyway, so we might
144          * as well do it now.  On the other hand if we are
145          * sending to multiple destinations we may have already
146          * done the lookup, so see if we can use the route
147          * from before.  In any case, we only
148          * chose a port number once, even if sending to multiple
149          * destinations.
150          */
151         ro = &nsp->nsp_route;
152         dst = &satons_addr(ro->ro_dst);
153         if (nsp->nsp_socket->so_options & SO_DONTROUTE)
154                 goto flush;
155         if (!ns_neteq(nsp->nsp_lastdst, sns->sns_addr))
156                 goto flush;
157         if (!ns_hosteq(nsp->nsp_lastdst, sns->sns_addr)) {
158                 if (ro->ro_rt && ! (ro->ro_rt->rt_flags & RTF_HOST)) {
159                         /* can patch route to avoid rtalloc */
160                         *dst = sns->sns_addr;
161                 } else {
162         flush:
163                         if (ro->ro_rt)
164                                 RTFREE(ro->ro_rt);
165                         ro->ro_rt = (struct rtentry *)0;
166                         nsp->nsp_laddr.x_net = ns_zeronet;
167                 }
168         }/* else cached route is ok; do nothing */
169         nsp->nsp_lastdst = sns->sns_addr;
170         if ((nsp->nsp_socket->so_options & SO_DONTROUTE) == 0 && /*XXX*/
171             (ro->ro_rt == (struct rtentry *)0 ||
172              ro->ro_rt->rt_ifp == (struct ifnet *)0)) {
173                     /* No route yet, so try to acquire one */
174                     ro->ro_dst.sa_family = AF_NS;
175                     ro->ro_dst.sa_len = sizeof(ro->ro_dst);
176                     *dst = sns->sns_addr;
177                     dst->x_port = 0;
178                     rtalloc(ro);
179         }
180         if (ns_neteqnn(nsp->nsp_laddr.x_net, ns_zeronet)) {
181                 /*
182                  * If route is known or can be allocated now,
183                  * our src addr is taken from the i/f, else punt.
184                  */
185
186                 ia = (struct ns_ifaddr *)0;
187                 /*
188                  * If we found a route, use the address
189                  * corresponding to the outgoing interface
190                  */
191                 if (ro->ro_rt && (ifp = ro->ro_rt->rt_ifp))
192                         for (ia = ns_ifaddr; ia; ia = ia->ia_next)
193                                 if (ia->ia_ifp == ifp)
194                                         break;
195                 if (ia == 0) {
196                         u_short fport = sns->sns_addr.x_port;
197                         sns->sns_addr.x_port = 0;
198                         ia = (struct ns_ifaddr *)
199                                 ifa_ifwithdstaddr((struct sockaddr *)sns);
200                         sns->sns_addr.x_port = fport;
201                         if (ia == 0)
202                                 ia = ns_iaonnetof(&sns->sns_addr);
203                         if (ia == 0)
204                                 ia = ns_ifaddr;
205                         if (ia == 0)
206                                 return (EADDRNOTAVAIL);
207                 }
208                 nsp->nsp_laddr.x_net = satons_addr(ia->ia_addr).x_net;
209         }
210         if (ns_pcblookup(&sns->sns_addr, nsp->nsp_lport, 0))
211                 return (EADDRINUSE);
212         if (ns_nullhost(nsp->nsp_laddr)) {
213                 if (nsp->nsp_lport == 0)
214                         (void) ns_pcbbind(nsp, (struct mbuf *)0);
215                 nsp->nsp_laddr.x_host = ns_thishost;
216         }
217         nsp->nsp_faddr = sns->sns_addr;
218         /* Includes nsp->nsp_fport = sns->sns_port; */
219         return (0);
220 }
221
222 void
223 ns_pcbdisconnect(struct nspcb *nsp)
224 {
225         nsp->nsp_faddr = zerons_addr;
226         if (nsp->nsp_socket->so_state & SS_NOFDREF)
227                 ns_pcbdetach(nsp);
228 }
229
230 void
231 ns_pcbdetach(struct nspcb *nsp)
232 {
233         struct socket *so = nsp->nsp_socket;
234
235         so->so_pcb = 0;
236         sofree(so);
237         if (nsp->nsp_route.ro_rt)
238                 rtfree(nsp->nsp_route.ro_rt);
239         remque(nsp);
240         (void) m_free(dtom(nsp));
241 }
242
243 void
244 ns_setsockaddr(struct nspcb *nsp, struct mbuf *nam)
245 {
246         struct sockaddr_ns *sns = mtod(nam, struct sockaddr_ns *);
247
248         nam->m_len = sizeof (*sns);
249         sns = mtod(nam, struct sockaddr_ns *);
250         bzero((caddr_t)sns, sizeof (*sns));
251         sns->sns_len = sizeof(*sns);
252         sns->sns_family = AF_NS;
253         sns->sns_addr = nsp->nsp_laddr;
254 }
255
256 void
257 ns_setpeeraddr(struct nspcb *nsp, struct mbuf *nam)
258 {
259         struct sockaddr_ns *sns = mtod(nam, struct sockaddr_ns *);
260
261         nam->m_len = sizeof (*sns);
262         sns = mtod(nam, struct sockaddr_ns *);
263         bzero((caddr_t)sns, sizeof (*sns));
264         sns->sns_len = sizeof(*sns);
265         sns->sns_family = AF_NS;
266         sns->sns_addr  = nsp->nsp_faddr;
267 }
268
269 /*
270  * Pass some notification to all connections of a protocol
271  * associated with address dst.  Call the
272  * protocol specific routine to handle each connection.
273  * Also pass an extra paramter via the nspcb. (which may in fact
274  * be a parameter list!)
275  */
276 void
277 ns_pcbnotify(struct ns_addr *dst, int errno,
278             void (*notify)(struct nspcb *), long param)
279 {
280         struct nspcb *nsp, *oinp;
281         int s = splimp();
282
283         for (nsp = (&nspcb)->nsp_next; nsp != (&nspcb);) {
284                 if (!ns_hosteq(*dst,nsp->nsp_faddr)) {
285         next:
286                         nsp = nsp->nsp_next;
287                         continue;
288                 }
289                 if (nsp->nsp_socket == 0)
290                         goto next;
291                 if (errno)
292                         nsp->nsp_socket->so_error = errno;
293                 oinp = nsp;
294                 nsp = nsp->nsp_next;
295                 oinp->nsp_notify_param = param;
296                 (*notify)(oinp);
297         }
298         splx(s);
299 }
300
301 #ifdef notdef
302 /*
303  * After a routing change, flush old routing
304  * and allocate a (hopefully) better one.
305  */
306 ns_rtchange(struct nspcb *nsp)
307 {
308         if (nsp->nsp_route.ro_rt) {
309                 rtfree(nsp->nsp_route.ro_rt);
310                 nsp->nsp_route.ro_rt = 0;
311                 /*
312                  * A new route can be allocated the next time
313                  * output is attempted.
314                  */
315         }
316         /* SHOULD NOTIFY HIGHER-LEVEL PROTOCOLS */
317 }
318 #endif
319
320 struct nspcb *
321 ns_pcblookup(struct ns_addr *faddr, u_short lport, int wildp)
322 {
323         struct nspcb *nsp, *match = 0;
324         int matchwild = 3, wildcard;
325         u_short fport;
326
327         fport = faddr->x_port;
328         for (nsp = (&nspcb)->nsp_next; nsp != (&nspcb); nsp = nsp->nsp_next) {
329                 if (nsp->nsp_lport != lport)
330                         continue;
331                 wildcard = 0;
332                 if (ns_nullhost(nsp->nsp_faddr)) {
333                         if (!ns_nullhost(*faddr))
334                                 wildcard++;
335                 } else {
336                         if (ns_nullhost(*faddr))
337                                 wildcard++;
338                         else {
339                                 if (!ns_hosteq(nsp->nsp_faddr, *faddr))
340                                         continue;
341                                 if (nsp->nsp_fport != fport) {
342                                         if (nsp->nsp_fport != 0)
343                                                 continue;
344                                         else
345                                                 wildcard++;
346                                 }
347                         }
348                 }
349                 if (wildcard && wildp==0)
350                         continue;
351                 if (wildcard < matchwild) {
352                         match = nsp;
353                         matchwild = wildcard;
354                         if (wildcard == 0)
355                                 break;
356                 }
357         }
358         return (match);
359 }