Document MAKEOBJDIRPREFIX.
[dragonfly.git] / sys / netproto / natm / natm.c
1 /*      $NetBSD: natm.c,v 1.5 1996/11/09 03:26:26 chuck Exp $   */
2 /* $FreeBSD: src/sys/netnatm/natm.c,v 1.12 2000/02/13 03:32:03 peter Exp $ */
3 /* $DragonFly: src/sys/netproto/natm/natm.c,v 1.20 2006/01/14 13:36:40 swildner Exp $ */
4
5 /*
6  *
7  * Copyright (c) 1996 Charles D. Cranor and Washington University.
8  * All rights reserved.
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  * 1. Redistributions of source code must retain the above copyright
14  *    notice, this list of conditions and the following disclaimer.
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in the
17  *    documentation and/or other materials provided with the distribution.
18  * 3. All advertising materials mentioning features or use of this software
19  *    must display the following acknowledgement:
20  *      This product includes software developed by Charles D. Cranor and
21  *      Washington University.
22  * 4. The name of the author may not be used to endorse or promote products
23  *    derived from this software without specific prior written permission.
24  *
25  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
26  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
27  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
28  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
29  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
30  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
31  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
32  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
33  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
34  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
35  */
36
37 /*
38  * natm.c: native mode ATM access (both aal0 and aal5).
39  */
40
41 #include <sys/param.h>
42 #include <sys/systm.h>
43 #include <sys/kernel.h>
44 #include <sys/proc.h>
45 #include <sys/sockio.h>
46 #include <sys/protosw.h>
47 #include <sys/malloc.h>
48 #include <sys/mbuf.h>
49 #include <sys/socket.h>
50 #include <sys/socketvar.h>
51
52 #include <sys/thread2.h>
53 #include <sys/msgport2.h>
54
55 #include <net/if.h>
56 #include <net/if_atm.h>
57 #include <net/netisr.h>
58
59 #include <netinet/in.h>
60
61 #include "natm.h"
62
63 static u_long natm5_sendspace = 16*1024;
64 static u_long natm5_recvspace = 16*1024;
65
66 static u_long natm0_sendspace = 16*1024;
67 static u_long natm0_recvspace = 16*1024;
68
69 /*
70  * user requests
71  */
72 #ifdef FREEBSD_USRREQS
73 /*
74  * FreeBSD new usrreqs supersedes pr_usrreq.
75  */
76 static int natm_usr_attach (struct socket *, int, struct pru_attach_info *);
77 static int natm_usr_detach (struct socket *);
78 static int natm_usr_connect (struct socket *, struct sockaddr *,
79                                  struct thread *);
80 static int natm_usr_disconnect (struct socket *);
81 static int natm_usr_shutdown (struct socket *);
82 static int natm_usr_send (struct socket *, int, struct mbuf *,
83                               struct sockaddr *, struct mbuf *, 
84                               struct thread *);
85 static int natm_usr_peeraddr (struct socket *, struct sockaddr **);
86 static int natm_usr_control (struct socket *, u_long, caddr_t,
87                                  struct ifnet *, struct thread *);
88 static int natm_usr_abort (struct socket *);
89 static int natm_usr_bind (struct socket *, struct sockaddr *, 
90                               struct thread *);
91 static int natm_usr_sockaddr (struct socket *, struct sockaddr **);
92
93 static int
94 natm_usr_attach(struct socket *so, int proto, struct pru_attach_info *ai)
95 {
96     struct natmpcb *npcb;
97     int error = 0;
98
99     crit_enter();
100     npcb = (struct natmpcb *) so->so_pcb;
101
102     if (npcb) {
103         error = EISCONN;
104         goto out;
105     }
106
107     if (so->so_snd.sb_hiwat == 0 || so->so_rcv.sb_hiwat == 0) {
108         if (proto == PROTO_NATMAAL5) 
109             error = soreserve(so, natm5_sendspace, natm5_recvspace,
110                               ai->sb_rlimit);
111         else
112             error = soreserve(so, natm0_sendspace, natm0_recvspace,
113                               ai->sb_rlimit);
114         if (error)
115           goto out;
116     }
117
118     so->so_pcb = (caddr_t) (npcb = npcb_alloc(M_WAITOK));
119     npcb->npcb_socket = so;
120  out:
121     crit_exit();
122     return (error);
123 }
124
125 static int
126 natm_usr_detach(struct socket *so)
127 {
128     struct natmpcb *npcb;
129     int error = 0;
130
131     crit_enter();
132     npcb = (struct natmpcb *) so->so_pcb;
133     if (npcb == NULL) {
134         error = EINVAL;
135         goto out;
136     }
137
138     /*
139      * we turn on 'drain' *before* we sofree.
140      */
141     npcb_free(npcb, NPCB_DESTROY);      /* drain */
142     so->so_pcb = NULL;
143     sofree(so);
144  out:
145     crit_exit();
146     return (error);
147 }
148
149 static int
150 natm_usr_connect(struct socket *so, struct sockaddr *nam, struct thread *td)
151 {
152     struct natmpcb *npcb;
153     struct sockaddr_natm *snatm;
154     struct atm_pseudoioctl api;
155     struct ifnet *ifp;
156     int error = 0;
157     int proto;
158
159     crit_enter();
160     proto = so->so_proto->pr_protocol;
161     npcb = (struct natmpcb *) so->so_pcb;
162     if (npcb == NULL) {
163         error = EINVAL;
164         goto out;
165     }
166
167     /*
168      * validate nam and npcb
169      */
170
171     snatm = (struct sockaddr_natm *)nam;
172     if (snatm->snatm_len != sizeof(*snatm) ||
173         (npcb->npcb_flags & NPCB_FREE) == 0) {
174         error = EINVAL;
175         goto out;
176     }
177     if (snatm->snatm_family != AF_NATM) {
178         error = EAFNOSUPPORT;
179         goto out;
180     }
181
182     snatm->snatm_if[IFNAMSIZ-1] = '\0';  /* XXX ensure null termination
183                                             since ifunit() uses strcmp */
184
185     /*
186      * convert interface string to ifp, validate.
187      */
188
189     ifp = ifunit(snatm->snatm_if);
190     if (ifp == NULL || (ifp->if_flags & IFF_RUNNING) == 0) {
191         error = ENXIO;
192         goto out;
193     }
194     if (ifp->if_output != atm_output) {
195         error = EAFNOSUPPORT;
196         goto out;
197     }
198
199     /*
200      * register us with the NATM PCB layer
201      */
202
203     if (npcb_add(npcb, ifp, snatm->snatm_vci, snatm->snatm_vpi) != npcb) {
204         error = EADDRINUSE;
205         goto out;
206     }
207
208     /*
209      * enable rx
210      */
211
212     ATM_PH_FLAGS(&api.aph) = (proto == PROTO_NATMAAL5) ? ATM_PH_AAL5 : 0;
213     ATM_PH_VPI(&api.aph) = npcb->npcb_vpi;
214     ATM_PH_SETVCI(&api.aph, npcb->npcb_vci);
215     api.rxhand = npcb;
216     lwkt_serialize_enter(ifp->if_serializer);
217     if (ifp->if_ioctl == NULL || 
218         ifp->if_ioctl(ifp, SIOCATMENA, (caddr_t) &api,
219                       td->td_proc->p_ucred) != 0) {
220         lwkt_serialize_exit(ifp->if_serializer);
221         npcb_free(npcb, NPCB_REMOVE);
222         error = EIO;
223         goto out;
224     }
225     lwkt_serialize_exit(ifp->if_serializer);
226
227     soisconnected(so);
228
229  out:
230     crit_exit();
231     return (error);
232 }
233
234 static int
235 natm_usr_disconnect(struct socket *so)
236 {
237     struct natmpcb *npcb;
238     struct atm_pseudoioctl api;
239     struct ifnet *ifp;
240     int error = 0;
241
242     crit_enter();
243     npcb = (struct natmpcb *) so->so_pcb;
244     if (npcb == NULL) {
245         error = EINVAL;
246         goto out;
247     }
248
249     if ((npcb->npcb_flags & NPCB_CONNECTED) == 0) {
250         printf("natm: disconnected check\n");
251         error = EIO;
252         goto out;
253     }
254     ifp = npcb->npcb_ifp;
255
256     /*
257      * disable rx
258      */
259
260     ATM_PH_FLAGS(&api.aph) = ATM_PH_AAL5;
261     ATM_PH_VPI(&api.aph) = npcb->npcb_vpi;
262     ATM_PH_SETVCI(&api.aph, npcb->npcb_vci);
263     api.rxhand = npcb;
264     if (ifp->if_ioctl != NULL) {
265         lwkt_serialize_enter(ifp->if_serializer);
266         ifp->if_ioctl(ifp, SIOCATMDIS, (caddr_t) &api, (struct ucred *)NULL);
267         lwkt_serialize_exit(ifp->if_serializer);
268     }
269
270     npcb_free(npcb, NPCB_REMOVE);
271     soisdisconnected(so);
272
273  out:
274     crit_exit();
275     return (error);
276 }
277
278 static int
279 natm_usr_shutdown(struct socket *so)
280 {
281     socantsendmore(so);
282     return 0;
283 }
284
285 static int
286 natm_usr_send(struct socket *so, int flags, struct mbuf *m, 
287               struct sockaddr *nam, struct mbuf *control, struct thread *td)
288 {
289     struct natmpcb *npcb;
290     struct atm_pseudohdr *aph;
291     int error = 0;
292     int proto = so->so_proto->pr_protocol;
293
294     crit_enter();
295
296     npcb = (struct natmpcb *) so->so_pcb;
297     if (npcb == NULL) {
298         error = EINVAL;
299         goto out;
300     }
301
302     if (control && control->m_len) {
303         m_freem(control);
304         m_freem(m);
305         error = EINVAL;
306         goto out;
307     }
308
309     /*
310      * send the data.   we must put an atm_pseudohdr on first
311      */
312
313     M_PREPEND(m, sizeof(*aph), M_WAITOK);
314     if (m == NULL) {
315         error = ENOBUFS;
316         goto out;
317     }
318     aph = mtod(m, struct atm_pseudohdr *);
319     ATM_PH_VPI(aph) = npcb->npcb_vpi;
320     ATM_PH_SETVCI(aph, npcb->npcb_vci);
321     ATM_PH_FLAGS(aph) = (proto == PROTO_NATMAAL5) ? ATM_PH_AAL5 : 0;
322
323     error = atm_output(npcb->npcb_ifp, m, NULL, NULL);
324
325  out:
326     crit_exit();
327     return (error);
328 }
329
330 static int
331 natm_usr_peeraddr(struct socket *so, struct sockaddr **nam)
332 {
333     struct natmpcb *npcb;
334     struct sockaddr_natm *snatm, ssnatm;
335     int error = 0;
336
337     crit_enter();
338     npcb = (struct natmpcb *) so->so_pcb;
339     if (npcb == NULL) {
340         error = EINVAL;
341         goto out;
342     }
343
344     snatm = &ssnatm;
345     bzero(snatm, sizeof(*snatm));
346     snatm->snatm_len = sizeof(*snatm);
347     snatm->snatm_family = AF_NATM;
348     strlcpy(snatm->snatm_if, npcb->npcb_ifp->if_xname,
349         sizeof(snatm->snatm_if));
350     snatm->snatm_vci = npcb->npcb_vci;
351     snatm->snatm_vpi = npcb->npcb_vpi;
352     *nam = dup_sockaddr((struct sockaddr *)snatm);
353
354  out:
355     crit_exit();
356     return (error);
357 }
358
359 static int
360 natm_usr_control(struct socket *so, u_long cmd, caddr_t arg,
361                  struct ifnet *ifp, struct thread *td)
362 {
363     struct natmpcb *npcb;
364     struct atm_rawioctl ario;
365     int error = 0;
366
367     npcb = (struct natmpcb *) so->so_pcb;
368     if (npcb == NULL) {
369         error = EINVAL;
370         goto out;
371     }
372
373     /*
374      * raw atm ioctl.   comes in as a SIOCRAWATM.   we convert it to
375      * SIOCXRAWATM and pass it to the driver.
376      */
377     if (cmd == SIOCRAWATM) {
378         if (npcb->npcb_ifp == NULL) {
379             error = ENOTCONN;
380             goto out;
381         }
382         ario.npcb = npcb;
383         ario.rawvalue = *((int *)arg);
384         lwkt_serialize_enter(ifp->if_serializer);
385         error = npcb->npcb_ifp->if_ioctl(npcb->npcb_ifp, 
386                                          SIOCXRAWATM, (caddr_t) &ario,
387                                          td->td_proc->p_ucred);
388         lwkt_serialize_exit(ifp->if_serializer);
389         if (!error) {
390             if (ario.rawvalue) 
391                 npcb->npcb_flags |= NPCB_RAW;
392             else
393                 npcb->npcb_flags &= ~(NPCB_RAW);
394         }
395     }
396     else
397         error = EOPNOTSUPP;
398  out:
399     return (error);
400 }
401
402 static int
403 natm_usr_abort(struct socket *so)
404 {
405     return natm_usr_shutdown(so);
406 }
407
408 static int
409 natm_usr_bind(struct socket *so, struct sockaddr *nam, struct thread *td)
410 {
411     return EOPNOTSUPP;
412 }
413
414 static int
415 natm_usr_sockaddr(struct socket *so, struct sockaddr **nam)
416 {
417     return EOPNOTSUPP;
418 }
419
420 /* xxx - should be const */
421 struct pr_usrreqs natm_usrreqs = {
422         natm_usr_abort, pru_accept_notsupp, natm_usr_attach, natm_usr_bind,
423         natm_usr_connect, pru_connect2_notsupp, natm_usr_control,
424         natm_usr_detach, natm_usr_disconnect, pru_listen_notsupp,
425         natm_usr_peeraddr, pru_rcvd_notsupp, pru_rcvoob_notsupp,
426         natm_usr_send, pru_sense_null, natm_usr_shutdown,
427         natm_usr_sockaddr, sosend, soreceive, sopoll
428 };
429
430 #else  /* !FREEBSD_USRREQS */
431
432 #if defined(__NetBSD__) || defined(__OpenBSD__)
433 int
434 natm_usrreq(struct socket *so, int req, struct mbuf *m, struct mbuf *nam,
435             struct mbuf *control, struct proc *p)
436 #elif defined(__DragonFly__)
437 int
438 natm_usrreq(struct socket *so, int req, struct mbuf *m, struct mbuf *nam,
439             struct mbuf *control)
440 #endif
441 {
442   int error = 0;
443   struct natmpcb *npcb;
444   struct sockaddr_natm *snatm;
445   struct atm_pseudoioctl api;
446   struct atm_pseudohdr *aph;
447   struct atm_rawioctl ario;
448   struct ifnet *ifp;
449   int proto = so->so_proto->pr_protocol;
450
451   crit_enter();
452
453   npcb = (struct natmpcb *) so->so_pcb;
454
455   if (npcb == NULL && req != PRU_ATTACH) {
456     error = EINVAL;
457     goto done;
458   }
459     
460
461   switch (req) {
462     case PRU_ATTACH:                    /* attach protocol to up */
463
464       if (npcb) {
465         error = EISCONN;
466         break;
467       }
468
469       if (so->so_snd.sb_hiwat == 0 || so->so_rcv.sb_hiwat == 0) {
470         if (proto == PROTO_NATMAAL5) 
471           error = soreserve(so, natm5_sendspace, natm5_recvspace);
472         else
473           error = soreserve(so, natm0_sendspace, natm0_recvspace);
474         if (error)
475           break;
476       }
477
478       so->so_pcb = (caddr_t) (npcb = npcb_alloc(M_WAITOK));
479       npcb->npcb_socket = so;
480
481       break;
482
483     case PRU_DETACH:                    /* detach protocol from up */
484
485       /*
486        * we turn on 'drain' *before* we sofree.
487        */
488
489       npcb_free(npcb, NPCB_DESTROY);    /* drain */
490       so->so_pcb = NULL;
491       sofree(so);
492
493       break;
494
495     case PRU_CONNECT:                   /* establish connection to peer */
496
497       /*
498        * validate nam and npcb
499        */
500
501       if (nam->m_len != sizeof(*snatm)) {
502         error = EINVAL;
503         break;
504       }
505       snatm = mtod(nam, struct sockaddr_natm *);
506       if (snatm->snatm_len != sizeof(*snatm) ||
507                 (npcb->npcb_flags & NPCB_FREE) == 0) {
508         error = EINVAL;
509         break;
510       }
511       if (snatm->snatm_family != AF_NATM) {
512         error = EAFNOSUPPORT;
513         break;
514       }
515
516       snatm->snatm_if[IFNAMSIZ-1] = '\0';  /* XXX ensure null termination
517                                                 since ifunit() uses strcmp */
518
519       /*
520        * convert interface string to ifp, validate.
521        */
522
523       ifp = ifunit(snatm->snatm_if);
524       if (ifp == NULL || (ifp->if_flags & IFF_RUNNING) == 0) {
525         error = ENXIO;
526         break;
527       }
528       if (ifp->if_output != atm_output) {
529         error = EAFNOSUPPORT;
530         break;
531       }
532
533
534       /*
535        * register us with the NATM PCB layer
536        */
537
538       if (npcb_add(npcb, ifp, snatm->snatm_vci, snatm->snatm_vpi) != npcb) {
539         error = EADDRINUSE;
540         break;
541       }
542
543       /*
544        * enable rx
545        */
546
547       ATM_PH_FLAGS(&api.aph) = (proto == PROTO_NATMAAL5) ? ATM_PH_AAL5 : 0;
548       ATM_PH_VPI(&api.aph) = npcb->npcb_vpi;
549       ATM_PH_SETVCI(&api.aph, npcb->npcb_vci);
550       api.rxhand = npcb;
551       lwkt_serialize_enter(ifp->if_serializer);
552       if (ifp->if_ioctl == NULL || 
553           ifp->if_ioctl(ifp, SIOCATMENA, (caddr_t) &api,
554                         (struct ucred *)NULL) != 0) {
555         lwkt_serialize_exit(ifp->if_serializer);
556         npcb_free(npcb, NPCB_REMOVE);
557         error = EIO;
558         break;
559       }
560       lwkt_serialize_exit(ifp->if_serializer);
561
562       soisconnected(so);
563
564       break;
565
566     case PRU_DISCONNECT:                /* disconnect from peer */
567
568       if ((npcb->npcb_flags & NPCB_CONNECTED) == 0) {
569         printf("natm: disconnected check\n");
570         error = EIO;
571         break;
572       }
573       ifp = npcb->npcb_ifp;
574
575       /*
576        * disable rx
577        */
578
579       ATM_PH_FLAGS(&api.aph) = ATM_PH_AAL5;
580       ATM_PH_VPI(&api.aph) = npcb->npcb_vpi;
581       ATM_PH_SETVCI(&api.aph, npcb->npcb_vci);
582       api.rxhand = npcb;
583       lwkt_serialize_enter(ifp->if_serializer);
584       if (ifp->if_ioctl != NULL)
585           ifp->if_ioctl(ifp, SIOCATMDIS, (caddr_t) &api, (struct ucred *)NULL);
586       lwkt_serialize_exit(ifp->if_serializer);
587
588       npcb_free(npcb, NPCB_REMOVE);
589       soisdisconnected(so);
590
591       break;
592
593     case PRU_SHUTDOWN:                  /* won't send any more data */
594       socantsendmore(so);
595       break;
596
597     case PRU_SEND:                      /* send this data */
598       if (control && control->m_len) {
599         m_freem(control);
600         m_freem(m);
601         error = EINVAL;
602         break;
603       }
604
605       /*
606        * send the data.   we must put an atm_pseudohdr on first
607        */
608
609       M_PREPEND(m, sizeof(*aph), M_WAITOK);
610       if (m == NULL) {
611         error = ENOBUFS;
612         break;
613       }
614       aph = mtod(m, struct atm_pseudohdr *);
615       ATM_PH_VPI(aph) = npcb->npcb_vpi;
616       ATM_PH_SETVCI(aph, npcb->npcb_vci);
617       ATM_PH_FLAGS(aph) = (proto == PROTO_NATMAAL5) ? ATM_PH_AAL5 : 0;
618
619       error = atm_output(npcb->npcb_ifp, m, NULL, NULL);
620
621       break;
622
623     case PRU_SENSE:                     /* return status into m */
624       /* return zero? */
625       break;
626
627     case PRU_PEERADDR:                  /* fetch peer's address */
628       snatm = mtod(nam, struct sockaddr_natm *);
629       bzero(snatm, sizeof(*snatm));
630       nam->m_len = snatm->snatm_len = sizeof(*snatm);
631       snatm->snatm_family = AF_NATM;
632 #if defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)
633       bcopy(npcb->npcb_ifp->if_xname, snatm->snatm_if, sizeof(snatm->snatm_if));
634 #elif defined(__DragonFly__)
635       snprintf(snatm->snatm_if, sizeof(snatm->snatm_if),
636         "%s%d", npcb->npcb_ifp->if_name, npcb->npcb_ifp->if_unit);
637 #endif
638       snatm->snatm_vci = npcb->npcb_vci;
639       snatm->snatm_vpi = npcb->npcb_vpi;
640       break;
641
642     case PRU_CONTROL:                   /* control operations on protocol */
643       /*
644        * raw atm ioctl.   comes in as a SIOCRAWATM.   we convert it to
645        * SIOCXRAWATM and pass it to the driver.
646        */
647       if ((u_long)m == SIOCRAWATM) {
648         if (npcb->npcb_ifp == NULL) {
649           error = ENOTCONN;
650           break;
651         }
652         ario.npcb = npcb;
653         ario.rawvalue = *((int *)nam);
654         lwkt_serialize_enter(npcb->npcb_ifp->if_serializer);
655         error = npcb->npcb_ifp->if_ioctl(npcb->npcb_ifp, SIOCXRAWATM,
656                                          (caddr_t) &ario, (struct ucred *)NULL);
657         lwkt_serialize_exit(npcb->npcb_ifp->if_serializer);
658         if (!error) {
659           if (ario.rawvalue) 
660             npcb->npcb_flags |= NPCB_RAW;
661           else
662             npcb->npcb_flags &= ~(NPCB_RAW);
663         }
664
665         break;
666       }
667
668       error = EOPNOTSUPP;
669       break;
670
671     case PRU_BIND:                      /* bind socket to address */
672     case PRU_LISTEN:                    /* listen for connection */
673     case PRU_ACCEPT:                    /* accept connection from peer */
674     case PRU_CONNECT2:                  /* connect two sockets */
675     case PRU_ABORT:                     /* abort (fast DISCONNECT, DETATCH) */
676                                         /* (only happens if LISTEN socket) */
677     case PRU_RCVD:                      /* have taken data; more room now */
678     case PRU_FASTTIMO:                  /* 200ms timeout */
679     case PRU_SLOWTIMO:                  /* 500ms timeout */
680     case PRU_RCVOOB:                    /* retrieve out of band data */
681     case PRU_SENDOOB:                   /* send out of band data */
682     case PRU_PROTORCV:                  /* receive from below */
683     case PRU_PROTOSEND:                 /* send to below */
684     case PRU_SOCKADDR:                  /* fetch socket's address */
685 #ifdef DIAGNOSTIC
686       printf("natm: PRU #%d unsupported\n", req);
687 #endif
688       error = EOPNOTSUPP;
689       break;
690    
691     default: panic("natm usrreq");
692   }
693
694 done:
695   crit_exit();
696   return(error);
697 }
698
699 #endif  /* !FREEBSD_USRREQS */
700
701 /* 
702  * natm0_sysctl: not used, but here in case we want to add something
703  * later...
704  */
705
706 int
707 natm0_sysctl(int *name, u_int namelen, void *oldp, size_t *oldlenp,
708              void *newp, size_t newlen)
709 {
710   /* All sysctl names at this level are terminal. */
711   if (namelen != 1)
712     return (ENOTDIR);
713   return (ENOPROTOOPT);
714 }
715
716 /* 
717  * natm5_sysctl: not used, but here in case we want to add something
718  * later...
719  */
720
721 int
722 natm5_sysctl(int *name, u_int namelen, void *oldp, size_t *oldlenp,
723              void *newp, size_t newlen)
724 {
725   /* All sysctl names at this level are terminal. */
726   if (namelen != 1)
727     return (ENOTDIR);
728   return (ENOPROTOOPT);
729 }
730
731 static int natmintr(struct netmsg *);
732
733 #if defined(__DragonFly__)
734 static void
735 netisr_natm_setup(void *dummy __unused)
736 {
737
738         netisr_register(NETISR_NATM, cpu0_portfn, natmintr);
739 }
740 SYSINIT(natm_setup, SI_SUB_CPU, SI_ORDER_ANY, netisr_natm_setup, NULL);
741 #endif
742
743 void
744 natm_init(void)
745 {
746   LIST_INIT(&natm_pcbs);
747
748   netisr_register(NETISR_NATM, cpu0_portfn, natmintr);
749 }
750
751 /*
752  * natmintr: software interrupt
753  *
754  * note: we expect a socket pointer in rcvif rather than an interface
755  * pointer.    we can get the interface pointer from the so's PCB if
756  * we really need it.
757  */
758 static int
759 natmintr(struct netmsg *msg)
760 {
761   struct mbuf *m = ((struct netmsg_packet *)msg)->nm_packet;
762   struct socket *so;
763   struct natmpcb *npcb;
764
765 #ifdef DIAGNOSTIC
766   if ((m->m_flags & M_PKTHDR) == 0)
767     panic("natmintr no HDR");
768 #endif
769
770   npcb = (struct natmpcb *) m->m_pkthdr.rcvif; /* XXX: overloaded */
771   so = npcb->npcb_socket;
772
773   crit_enter();
774   npcb->npcb_inq--;
775   crit_exit();
776
777   if (npcb->npcb_flags & NPCB_DRAIN) {
778     m_freem(m);
779     if (npcb->npcb_inq == 0)
780       FREE(npcb, M_PCB);                        /* done! */
781     goto out;
782   }
783
784   if (npcb->npcb_flags & NPCB_FREE) {
785     m_freem(m);                                 /* drop */
786     goto out;
787   }
788
789 #ifdef NEED_TO_RESTORE_IFP
790   m->m_pkthdr.rcvif = npcb->npcb_ifp;
791 #else
792 #ifdef DIAGNOSTIC
793 m->m_pkthdr.rcvif = NULL;       /* null it out to be safe */
794 #endif
795 #endif
796
797   if (sbspace(&so->so_rcv) > m->m_pkthdr.len ||
798      ((npcb->npcb_flags & NPCB_RAW) != 0 && so->so_rcv.sb_cc < NPCB_RAWCC) ) {
799 #ifdef NATM_STAT
800     natm_sookcnt++;
801     natm_sookbytes += m->m_pkthdr.len;
802 #endif
803     sbappendrecord(&so->so_rcv, m);
804     sorwakeup(so);
805   } else {
806 #ifdef NATM_STAT
807     natm_sodropcnt++;
808     natm_sodropbytes += m->m_pkthdr.len;
809 #endif
810     m_freem(m);
811   }
812 out:
813   lwkt_replymsg(&msg->nm_lmsg, 0);
814   return(EASYNC);
815 }
816