bsd/netat/at_pcb.c

   1 /*
   2  * Copyright (c) 2006 Apple Computer, Inc. All Rights Reserved.
   3  *
   4  * @APPLE_LICENSE_OSREFERENCE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License.  The rights granted to you under the
  10  * License may not be used to create, or enable the creation or
  11  * redistribution of, unlawful or unlicensed copies of an Apple operating
  12  * system, or to circumvent, violate, or enable the circumvention or
  13  * violation of, any terms of an Apple operating system software license
  14  * agreement.
  15  *
  16  * Please obtain a copy of the License at
  17  * http://www.opensource.apple.com/apsl/ and read it before using this
  18  * file.
  19  *
  20  * The Original Code and all software distributed under the License are
  21  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  22  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  23  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  24  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  25  * Please see the License for the specific language governing rights and
  26  * limitations under the License.
  27  *
  28  * @APPLE_LICENSE_OSREFERENCE_HEADER_END@
  29  */
  30
  31 /*
  32  *      Copyright (c) 1997-1999 Apple Computer, Inc.
  33  *      All Rights Reserved.
  34  */
  35 /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
  36 /*
  37  * Copyright (c) 1982, 1986, 1991, 1993
  38  *      The Regents of the University of California.  All rights reserved.
  39  *
  40  * Redistribution and use in source and binary forms, with or without
  41  * modification, are permitted provided that the following conditions
  42  * are met:
  43  * 1. Redistributions of source code must retain the above copyright
  44  *    notice, this list of conditions and the following disclaimer.
  45  * 2. Redistributions in binary form must reproduce the above copyright
  46  *    notice, this list of conditions and the following disclaimer in the
  47  *    documentation and/or other materials provided with the distribution.
  48  * 3. All advertising materials mentioning features or use of this software
  49  *    must display the following acknowledgement:
  50  *      This product includes software developed by the University of
  51  *      California, Berkeley and its contributors.
  52  * 4. Neither the name of the University nor the names of its contributors
  53  *    may be used to endorse or promote products derived from this software
  54  *    without specific prior written permission.
  55  *
  56  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  57  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  58  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  59  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  60  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  61  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  62  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  63  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  64  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  65  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  66  * SUCH DAMAGE.
  67  *
  68  *      @(#)at_pcb.c    8.2 (Berkeley) 1/4/94
  69  */
  70
  71 #include <sys/param.h>
  72 #include <sys/systm.h>
  73 #include <sys/malloc.h>
  74 #include <sys/mbuf.h>
  75 #include <sys/protosw.h>
  76 #include <sys/socket.h>
  77 #include <sys/socketvar.h>
  78 #include <sys/ioctl.h>
  79 #include <sys/errno.h>
  80 #include <sys/time.h>
  81 #include <sys/proc.h>
  82 #include <kern/kern_types.h>
  83 #include <kern/zalloc.h>
  84 #include <kern/queue.h>
  85
  86 #include <net/if.h>
  87
  88 #include <netat/sysglue.h>
  89 #include <netat/appletalk.h>
  90 #include <netat/ddp.h>
  91 #include <netat/at_pcb.h>
  92 #include <netat/debug.h>
  93 #include <netat/at_var.h>
  94 #include <netat/adsp.h>
  95 #include <netat/adsp_internal.h>
  96
  97 extern struct atpcb ddp_head;
  98 extern struct atpcb *atp_inputQ[];
  99 extern CCB *adsp_inputQ[];
 100 extern at_ifaddr_t *ifID_home;
 101 extern struct {
 102   void (*func)();
 103   } ddp_handler[];
 104
 105 int DDP_chksum_on = FALSE;
 106 int DDP_slfsnd_on = FALSE;
 107
 108 zone_t atpcb_zone;
 109
 110 void at_memzone_init()
 111 {
 112         vm_size_t str_size;
 113
 114         str_size = (vm_size_t)sizeof(struct atpcb);
 115         atpcb_zone = (zone_t)zinit(str_size, 1000*str_size, 8192, "atpcb zone");
 116 }
 117
 118 int at_pcballoc(so, head)
 119         struct socket *so;
 120         struct atpcb *head;
 121 {
 122         register struct atpcb *pcb;
 123
 124         pcb = (struct atpcb *)zalloc(atpcb_zone);
 125         if (pcb == NULL)
 126                 return (ENOBUFS);
 127         bzero((caddr_t)pcb, sizeof(*pcb));
 128
 129         /* set the flags to the system defaults */
 130         if (DDP_chksum_on)
 131                 pcb->ddp_flags |= DDPFLG_CHKSUM;
 132         else
 133                 pcb->ddp_flags &= ~DDPFLG_CHKSUM;
 134         if (DDP_slfsnd_on)
 135                 pcb->ddp_flags |= DDPFLG_SLFSND;
 136         else
 137                 pcb->ddp_flags &= ~DDPFLG_SLFSND;
 138
 139         pcb->atpcb_head = head;
 140         pcb->atpcb_socket = so;
 141         atalk_lock();   /* makes sure the list is locked while inserting atpcb */
 142         if (head)
 143             insque((queue_t)pcb, (queue_t)head);
 144         so->so_pcb = (caddr_t)pcb;
 145         atalk_unlock();
 146
 147         return (0);
 148 }
 149
 150 int at_pcbdetach(pcb)
 151         struct atpcb *pcb;
 152 {
 153         struct socket *so = pcb->atpcb_socket;
 154
 155         /* Notify NBP that we are closing this DDP socket */
 156         if (pcb->lport) {
 157                 ddp_notify_nbp(pcb->lport, pcb->pid, pcb->ddptype);
 158                 pcb->lport = 0;
 159         }
 160
 161         so->so_pcb = 0;
 162         so->so_flags |= SOF_PCBCLEARING;
 163         if ((pcb->atpcb_next) && (pcb->atpcb_prev))
 164             remque((queue_t)pcb);
 165         zfree(atpcb_zone, pcb);
 166         sofree(so);
 167         return(0);
 168 }
 169
 170 int ddp_socket_inuse(ddpsock, proto)
 171           u_char ddpsock, proto;
 172 {
 173           struct atpcb *pcb;
 174
 175           if ((!proto || (proto == DDP_ATP)) && atp_inputQ[ddpsock])
 176                 return TRUE;
 177           if ((!proto || (proto == DDP_ADSP)) && adsp_inputQ[ddpsock])
 178                 return TRUE;
 179           if (ddp_handler[ddpsock].func)
 180                 return TRUE;
 181           for (pcb = ddp_head.atpcb_next; pcb != &ddp_head;
 182                pcb = pcb->atpcb_next) {
 183                 if (pcb->lport == ddpsock &&
 184                     (!pcb->ddptype || !proto || (pcb->ddptype == proto)))
 185                         return TRUE;
 186           }
 187           return FALSE;
 188 }
 189
 190 int at_pcbbind(pcb, nam)
 191         register struct atpcb *pcb;
 192         struct sockaddr *nam;
 193 {
 194         register struct socket *so = pcb->atpcb_socket;
 195         register struct sockaddr_at *local = (struct sockaddr_at *) nam;
 196         u_char ddpsock = local->sat_port;
 197
 198         if ((!ifID_home) || (local->sat_family != AF_APPLETALK))
 199                 return(EADDRNOTAVAIL);
 200
 201         if (pcb->lport != ATADDR_ANYPORT ||
 202             pcb->laddr.s_node != ATADDR_ANYNODE ||
 203             pcb->laddr.s_net != ATADDR_ANYNET)
 204                 return(EINVAL);
 205
 206         /* Request for dynamic socket? */
 207         if (ddpsock == 0) {
 208                 /* Search table for free one */
 209                 /* *** borrow IP algorithm, instead? *** */
 210                 for (ddpsock = DDP_SOCKET_LAST;
 211                      ddpsock >= (DDP_SOCKET_1st_DYNAMIC + 1);
 212                                                 /* sip has 1st */
 213                      ddpsock--) {
 214                         if (! ddp_socket_inuse(ddpsock, pcb->ddptype))
 215                                 break;
 216                 }
 217                 if (ddpsock < (DDP_SOCKET_1st_DYNAMIC + 1))
 218                         return(EADDRNOTAVAIL);  /* Error if no free sockets */
 219         } else {
 220                 /* Asking to open a socket by its number.
 221                    Check if its legal & free. */
 222                 if (ddpsock > DDP_SOCKET_LAST)
 223                         return(EINVAL);
 224                 if (ddp_socket_inuse(ddpsock, pcb->ddptype))
 225                         return(EADDRNOTAVAIL);
 226         }
 227
 228         pcb->lport = ddpsock;
 229         /* if address is specified, make sure address matches one of the
 230            interfaces configured for AppleTalk */
 231         if (local->sat_addr.s_net || local->sat_addr.s_node) {
 232             if (MULTIHOME_MODE) {
 233                 at_ifaddr_t *ifID;
 234                 TAILQ_FOREACH(ifID, &at_ifQueueHd, aa_link) {
 235                         if (ifID->ifThisNode.s_net == local->sat_addr.s_net &&
 236                             ifID->ifThisNode.s_node == local->sat_addr.s_node) {
 237                                 pcb->laddr = local->sat_addr;
 238                                 return(0);
 239                         }
 240                 }
 241                 return(EINVAL);
 242             } else {
 243               /* for single-port and router modes if the local address is
 244                  specified, it must match the default interface, which is
 245                  what will be put into packets' source address anyway */
 246                 if (ifID_home->ifThisNode.s_net == local->sat_addr.s_net &&
 247                     ifID_home->ifThisNode.s_node == local->sat_addr.s_node) {
 248                         pcb->laddr = local->sat_addr;
 249                         return(0);
 250                 }
 251                 return(EINVAL);
 252
 253             }
 254         }
 255         return(0);
 256 }