1/* 2 * Copyright (c) 2000-2008 Apple Computer, Inc. All rights reserved. 3 * 4 * @APPLE_OSREFERENCE_LICENSE_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 License 10 * may not be used to create, or enable the creation or redistribution of, 11 * unlawful or unlicensed copies of an Apple operating system, or to 12 * circumvent, violate, or enable the circumvention or violation of, any 13 * terms of an Apple operating system software license agreement. 14 * 15 * Please obtain a copy of the License at 16 * http://www.opensource.apple.com/apsl/ and read it before using this file. 17 * 18 * The Original Code and all software distributed under the License are 19 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 20 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, 21 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, 22 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 23 * Please see the License for the specific language governing rights and 24 * limitations under the License. 25 * 26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ 27 */ 28/* 29 * Copyright (c) 1996 Apple Computer, Inc. 30 * 31 * Created April 25, 1996, by Justin C. Walker 32 * Modified, March 17, 1997 by Tuyen Nguyen for MacOSX. 33 * 34 * File: aurpd.c 35 */ 36 37/* 38 * Kernel process to implement the AURP daemon: 39 * manage tunnels to remote AURP servers across IP networks 40 */ 41#ifdef AURP_SUPPORT 42 43#include <sys/errno.h> 44#include <sys/types.h> 45#include <sys/param.h> 46#include <machine/spl.h> 47#include <sys/systm.h> 48#include <sys/kernel.h> 49#include <sys/proc.h> 50#include <sys/kauth.h> 51#include <sys/filedesc.h> 52#include <sys/fcntl.h> 53#include <sys/mbuf.h> 54#include <sys/socket.h> 55#include <sys/socketvar.h> 56#include <sys/protosw.h> 57#include <sys/malloc.h> 58#include <sys/proc.h> 59#include <sys/uio_internal.h> 60#include <kern/locks.h> 61#include <netinet/in.h> 62#include <net/if.h> 63 64#include <netat/sysglue.h> 65#include <netat/appletalk.h> 66#include <netat/at_pcb.h> 67#include <netat/at_var.h> 68#include <netat/routing_tables.h> 69#include <netat/at_pcb.h> 70#include <netat/aurp.h> 71#include <netat/debug.h> 72 73#define M_RCVBUF (64 * 1024) 74#define M_SNDBUF (64 * 1024) 75 76extern lck_mtx_t * atalk_mutex; 77 78static int ip_to_atalk(struct sockaddr_in *fp, register gbuf_t *p_mbuf); 79static int aurp_bindrp(struct socket *so); 80 81struct aurp_global_t aurp_global; 82 83/* 84 * Initialize the aurp pipe - 85 * -Create, initialize, and start the aurpd kernel process; we need 86 * a process to permit queueing between the socket and the stream, 87 * which is necessary for orderly access to the socket structure. 88 * -The user process (aurpd) is there to 'build' the AURP 89 * stream, act as a 'logging agent' (:-}), and hold open the stream 90 * during its use. 91 * -Data and AURP packets from the DDP stream will be fed into the 92 * UDP tunnel (AURPsend()) 93 * -Data and AURP packets from the UDP tunnel will be fed into the 94 * DDP stream (ip_to_atalk(), via the kernel process). 95 */ 96int 97aurpd_start() 98{ 99 register int error; 100 register struct socket *so; 101 struct mbuf *m; 102 int maxbuf; 103 struct sockopt sopt; 104 105 if (suser(kauth_cred_get(), 0) != 0 ) 106 return(EPERM); 107 108 /* 109 * Set up state prior to starting kernel process so we can back out 110 * (error return) if something goes wrong. 111 */ 112 bzero((char *)&aurp_global.tunnel, sizeof(aurp_global.tunnel)); 113 /*lock_alloc(&aurp_global.glock, LOCK_ALLOC_PIN, AURP_EVNT_LOCK, -1);*/ 114 ATEVENTINIT(aurp_global.event_anchor); 115 116 /* open udp socket */ 117 if (aurp_global.udp_port == 0) 118 aurp_global.udp_port = AURP_SOCKNUM; 119 error = socreate(AF_INET, &aurp_global.tunnel, SOCK_DGRAM, 120 IPPROTO_UDP); 121 if (error) 122 { dPrintf(D_M_AURP, D_L_FATAL, ("AURP: Can't get socket (%d)\n", 123 error)); 124 return(error); 125 } 126 127 so = aurp_global.tunnel; 128 129 if ((error = aurp_bindrp(so)) != 0) 130 { dPrintf(D_M_AURP, D_L_FATAL, 131 ("AURP: Can't bind to port %d (error %d)\n", 132 aurp_global.udp_port, error)); 133 soclose(so); 134 return(error); 135 } 136 137 sblock(&so->so_rcv, M_WAIT); 138 sblock(&so->so_snd, M_WAIT); 139 140 /* 141 * Set socket Receive buffer size 142 */ 143 m = m_get(M_WAIT, MT_SOOPTS); 144 if (m == NULL) { 145 error = ENOBUFS; 146 goto out; 147 } else { 148 maxbuf = M_RCVBUF; 149 sopt.sopt_val = CAST_USER_ADDR_T(&maxbuf); 150 sopt.sopt_valsize = sizeof(maxbuf); 151 sopt.sopt_level = SOL_SOCKET; 152 sopt.sopt_name = SO_RCVBUF; 153 sopt.sopt_dir = SOPT_SET; 154 sopt.sopt_p = kernproc; 155 if ((error = sosetopt(so, &sopt)) != 0) 156 goto out; 157 } 158 159 /* 160 * Set socket Send buffer size 161 */ 162 m = m_get(M_WAIT, MT_SOOPTS); 163 if (m == NULL) { 164 error = ENOBUFS; 165 goto out; 166 } else { 167 168 maxbuf = M_SNDBUF; 169 sopt.sopt_val = CAST_USER_ADDR_T(&maxbuf); 170 sopt.sopt_valsize = sizeof(maxbuf); 171 sopt.sopt_level = SOL_SOCKET; 172 sopt.sopt_name = SO_SNDBUF; 173 sopt.sopt_dir = SOPT_SET; 174 sopt.sopt_p = kernproc; 175 if ((error = sosetopt(so, &sopt)) != 0) 176 goto out; 177 } 178 179 so->so_upcall = aurp_wakeup; 180 so->so_upcallarg = (caddr_t)AE_UDPIP; /* Yuck */ 181 so->so_state |= SS_NBIO; 182 so->so_rcv.sb_flags |=(SB_SEL|SB_NOINTR); 183 so->so_snd.sb_flags |=(SB_SEL|SB_NOINTR); 184 185out: 186 sbunlock(&so->so_snd, 0); 187 sbunlock(&so->so_rcv, 0); 188 189 return(error); 190} 191 192int 193AURPgetmsg(err) 194 int *err; 195{ register struct socket *so; 196 register int events; 197 198 so = aurp_global.tunnel; 199 *err = 0; 200 201 for (;;) 202 { gbuf_t *from, *p_mbuf; 203 int flags = MSG_DONTWAIT; 204 uio_t auio; 205 char uio_buf[ UIO_SIZEOF(0) ]; 206 207 /* 208 * Wait for a package to arrive. This will be from the 209 * IP side - sowakeup() calls aurp_wakeup() 210 * when a packet arrives 211 */ 212 213 events = aurp_global.event; 214 if (((*err == 0) || (*err == EWOULDBLOCK)) && events == 0) 215 { 216 lck_mtx_assert(atalk_mutex, LCK_MTX_ASSERT_OWNED); 217 *err = msleep(&aurp_global.event_anchor, atalk_mutex, PSOCK | PCATCH, "AURPgetmsg", 0); 218 events = aurp_global.event; 219 aurp_global.event = 0; 220 } 221 222 /* 223 * Shut down if we have the AE_SHUTDOWN event or if we got 224 * a system error other than EWOULDBLOCK, such as EINTR. 225 */ 226 if (((*err != EWOULDBLOCK) && (*err != 0)) || events & AE_SHUTDOWN) 227 { 228 dPrintf(D_M_AURP, D_L_SHUTDN_INFO, 229 ("AURPgetmsg: AE_SHUTDOWN detected--starting shutdown sequence\n")); 230 aurp_global.shutdown = 1; 231 while (aurp_global.running) 232 ; 233 /*lock_free(&aurp_global.glock);*/ 234 aurp_global.tunnel = 0; 235 aurp_global.event = 0; 236 aurp_global.shutdown = 0; 237 soclose(so); 238 if (*err == 0) 239 *err = ESHUTDOWN; 240 dPrintf(D_M_AURP, D_L_SHUTDN_INFO, 241 ("AURPgetmsg: shutdown completed\n")); 242 return -1; 243 } 244 245 246 247 /* 248 * Set up the nominal uio structure - 249 * give it no iov's, point off to non-existant user space, 250 * but make sure the 'resid' count means somehting. 251 */ 252 auio = uio_createwithbuffer(0, 0, UIO_SYSSPACE, UIO_READ, 253 &uio_buf[0], sizeof(uio_buf)); 254 255 /* Keep up an even flow... */ 256 for (;;) 257 { 258/* 259 * This should be large enough to encompass a full DDP packet plus 260 * domain header. 261 */ 262#define A_LARGE_SIZE 700 263 264 flags = MSG_DONTWAIT; 265 uio_setresid(auio, A_LARGE_SIZE); 266 *err = soreceive(so, (struct sockaddr **)&from, auio, &p_mbuf, 0, &flags); 267 dPrintf(D_M_AURP, D_L_VERBOSE, 268 ("AURPgetmsg: soreceive returned %d, aurp_global.event==0x%x\n", *err, events)); 269 /* soreceive() sets *mp to zero! at start */ 270 if (p_mbuf) 271 ip_to_atalk((struct sockaddr_in *)from, p_mbuf); 272 if (*err || (p_mbuf == NULL)) { 273 /* 274 * An error occurred in soreceive(), 275 * so clear the data input event flag 276 * and break out of this inner loop. 277 * 278 * XXX Note that clearing AE_UDPIP here could 279 * cause us to lose an AE_UDPIP event that 280 * was posted in aurp_global.event between 281 * the soreceive() above and the code here. 282 * The protocol should recover from this 283 * lost event, though, since the next 284 * request (a tickle, for example) from 285 * the other end of the tunnel will cause 286 * another AE_UDPIP event to be posted, 287 * which will wake us from the sleep at 288 * the top of the outer loop. 289 */ 290 aurp_global.event &= ~AE_UDPIP; 291 dPrintf(D_M_AURP, D_L_WARNING, ("AURPgetmsg: spurious soreceive, err==%d, p_mbuf==0x%x\n", *err, (unsigned int) p_mbuf)); 292 break; 293 } 294 } 295 } 296 return -1; 297} 298 299/* 300 * Wakeup the sleeping giant - we've put a message on his queue(s). 301 * The arg indicates what queue has been updated. 302 * 303 * This conforms to the so_upcall function pointer member of struct sockbuf. 304 */ 305void aurp_wakeup(__unused struct socket *so, register caddr_t p, __unused int state) 306{ 307 register int bit; 308 309 bit = (int) p; 310 aurp_global.event |= bit; 311 312 dPrintf(D_M_AURP, D_L_STATE_CHG, 313 ("aurp_wakeup: bit 0x%x, aurp_global.event now 0x%x\n", 314 bit, aurp_global.event)); 315 316 wakeup(&aurp_global.event_anchor); 317} 318 319/* 320 * Try to bind to the specified reserved port. 321 * Sort of like sobind(), but no suser() check. 322 */ 323static int 324aurp_bindrp(struct socket *so) 325{ 326 struct sockaddr_in sin; 327 struct proc *p = current_proc(); 328 int error; 329 330 331 bzero(&sin, sizeof(sin)); 332 sin.sin_family = AF_INET; 333 sin.sin_addr.s_addr = htons(aurp_global.src_addr); 334 sin.sin_port = htons(aurp_global.udp_port); 335 sin.sin_len = sizeof(struct sockaddr_in); 336 337 sblock(&so->so_rcv, M_WAIT); 338 sblock(&so->so_snd, M_WAIT); 339 so->so_state |= SS_PRIV; 340 error = (*so->so_proto->pr_usrreqs->pru_bind)(so, (struct sockaddr *) &sin, p); 341 sbunlock(&so->so_snd, 0); 342 sbunlock(&so->so_rcv, 0); 343 344 return (error); 345} 346 347/* 348 * receive from UDP 349 * fp is the 'source address' mbuf; p_mbuf is the data mbuf. 350 * Use the source address to find the 'node number' (index of the address), 351 * and pass that to the next stage. 352 */ 353int ip_to_atalk(register struct sockaddr_in *rem_addr, register gbuf_t *p_mbuf) 354{ 355 register aurp_domain_t *domain; 356 unsigned char node; 357 358 359 /* determine the node where the packet came from */ 360 for (node=1; node <= dst_addr_cnt; node++) { 361 if (aurp_global.dst_addr[node] == *(long *)&rem_addr->sin_addr) 362 break; 363 } 364 if (node > dst_addr_cnt) { 365 dPrintf(D_M_AURP, D_L_WARNING, 366 ("AURPrecv: invalid node, %d.%lx\n", 367 rem_addr->sin_port, 368 rem_addr->sin_addr.s_addr)); 369 370 gbuf_freem(p_mbuf); 371 FREE(rem_addr, M_SONAME); 372 return -1; 373 } 374 375 /* validate the domain */ 376 domain = (aurp_domain_t *)gbuf_rptr(p_mbuf); 377 if ( (domain->dst_length != IP_LENGTH) || 378 (domain->dst_authority != IP_AUTHORITY) || 379 (domain->version != AUD_Version) || 380 ((domain->type != AUD_Atalk) && (domain->type != AUD_AURP)) ) { 381 dPrintf(D_M_AURP, D_L_WARNING, 382 ("AURPrecv: invalid domain, %d.%lx\n", 383 rem_addr->sin_port, 384 rem_addr->sin_addr.s_addr)); 385 386 gbuf_freem(p_mbuf); 387 FREE(rem_addr, M_SONAME); 388 return -1; 389 } 390 391 /* Remove domain header */ 392 p_mbuf->m_pkthdr.len -= IP_DOMAINSIZE; 393 gbuf_rinc(p_mbuf,IP_DOMAINSIZE); 394 gbuf_set_type(p_mbuf, MSG_DATA); 395 396 /* forward the packet to the local AppleTalk stack */ 397 398 at_insert(p_mbuf, domain->type, node); 399 FREE(rem_addr, M_SONAME); 400 return 0; 401} 402 403/* 404 * send to UDP 405 * The real work has been done already. Here, we just cobble together 406 * a sockaddr for the destination and call sosend(). 407 */ 408void 409atalk_to_ip(register gbuf_t *m) 410{ register aurp_domain_t *domain; 411 int error; 412 int flags = MSG_DONTWAIT; 413 struct sockaddr_in rem_addr; 414 415 m_mchtype(m, MT_HEADER); 416 m->m_pkthdr.len = gbuf_msgsize(m); 417 m->m_pkthdr.rcvif = 0; 418 419 bzero((char *) &rem_addr, sizeof(rem_addr)); 420 rem_addr.sin_family = PF_INET; 421 rem_addr.sin_port = aurp_global.udp_port; 422 rem_addr.sin_len = sizeof (struct sockaddr_in); 423 domain = (aurp_domain_t *)gbuf_rptr(m); 424 *(long *) &rem_addr.sin_addr = domain->dst_address; 425 426 aurp_global.running++; 427 if (aurp_global.shutdown) { 428 gbuf_freem(m); 429 aurp_global.running--; 430 dPrintf(D_M_AURP, D_L_SHUTDN_INFO, 431 ("atalk_to_ip: detected aurp_global.shutdown state\n")); 432 return; 433 } 434 dPrintf(D_M_AURP, D_L_VERBOSE, ("atalk_to_ip: calling sosend\n")); 435 error = sosend(aurp_global.tunnel, (struct sockaddr *) &rem_addr, NULL, m, NULL, flags); 436 if (error) 437 { /*log error*/ 438 dPrintf(D_M_AURP, D_L_ERROR, ("AURP: sosend error (%d)\n", 439 error)); 440 } 441 442 aurp_global.running--; 443 return; 444} 445 446#endif /* AURP_SUPPORT */ 447