uipc_syscalls.c revision 1.30
1 /* $NetBSD: uipc_syscalls.c,v 1.30 1998/04/25 17:35:19 matt Exp $ */ 2 3 /* 4 * Copyright (c) 1982, 1986, 1989, 1990, 1993 5 * The Regents of the University of California. All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. All advertising materials mentioning features or use of this software 16 * must display the following acknowledgement: 17 * This product includes software developed by the University of 18 * California, Berkeley and its contributors. 19 * 4. Neither the name of the University nor the names of its contributors 20 * may be used to endorse or promote products derived from this software 21 * without specific prior written permission. 22 * 23 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 24 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 26 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 28 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 29 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 32 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 33 * SUCH DAMAGE. 34 * 35 * @(#)uipc_syscalls.c 8.6 (Berkeley) 2/14/95 36 */ 37 38 #include <sys/param.h> 39 #include <sys/systm.h> 40 #include <sys/filedesc.h> 41 #include <sys/proc.h> 42 #include <sys/file.h> 43 #include <sys/buf.h> 44 #include <sys/malloc.h> 45 #include <sys/mbuf.h> 46 #include <sys/protosw.h> 47 #include <sys/socket.h> 48 #include <sys/socketvar.h> 49 #include <sys/signalvar.h> 50 #include <sys/un.h> 51 #ifdef KTRACE 52 #include <sys/ktrace.h> 53 #endif 54 55 #include <sys/mount.h> 56 #include <sys/syscallargs.h> 57 58 /* 59 * System call interface to the socket abstraction. 60 */ 61 extern struct fileops socketops; 62 63 int 64 sys_socket(p, v, retval) 65 struct proc *p; 66 void *v; 67 register_t *retval; 68 { 69 register struct sys_socket_args /* { 70 syscallarg(int) domain; 71 syscallarg(int) type; 72 syscallarg(int) protocol; 73 } */ *uap = v; 74 struct filedesc *fdp = p->p_fd; 75 struct socket *so; 76 struct file *fp; 77 int fd, error; 78 79 if ((error = falloc(p, &fp, &fd)) != 0) 80 return (error); 81 fp->f_flag = FREAD|FWRITE; 82 fp->f_type = DTYPE_SOCKET; 83 fp->f_ops = &socketops; 84 error = socreate(SCARG(uap, domain), &so, SCARG(uap, type), 85 SCARG(uap, protocol)); 86 if (error) { 87 fdp->fd_ofiles[fd] = 0; 88 ffree(fp); 89 } else { 90 fp->f_data = (caddr_t)so; 91 *retval = fd; 92 } 93 return (error); 94 } 95 96 /* ARGSUSED */ 97 int 98 sys_bind(p, v, retval) 99 struct proc *p; 100 void *v; 101 register_t *retval; 102 { 103 register struct sys_bind_args /* { 104 syscallarg(int) s; 105 syscallarg(const struct sockaddr *) name; 106 syscallarg(int) namelen; 107 } */ *uap = v; 108 struct file *fp; 109 struct mbuf *nam; 110 int error; 111 112 if ((error = getsock(p->p_fd, SCARG(uap, s), &fp)) != 0) 113 return (error); 114 error = sockargs(&nam, SCARG(uap, name), SCARG(uap, namelen), 115 MT_SONAME); 116 if (error) 117 return (error); 118 error = sobind((struct socket *)fp->f_data, nam); 119 m_freem(nam); 120 return (error); 121 } 122 123 /* ARGSUSED */ 124 int 125 sys_listen(p, v, retval) 126 struct proc *p; 127 void *v; 128 register_t *retval; 129 { 130 register struct sys_listen_args /* { 131 syscallarg(int) s; 132 syscallarg(int) backlog; 133 } */ *uap = v; 134 struct file *fp; 135 int error; 136 137 if ((error = getsock(p->p_fd, SCARG(uap, s), &fp)) != 0) 138 return (error); 139 return (solisten((struct socket *)fp->f_data, SCARG(uap, backlog))); 140 } 141 142 int 143 sys_accept(p, v, retval) 144 struct proc *p; 145 void *v; 146 register_t *retval; 147 { 148 register struct sys_accept_args /* { 149 syscallarg(int) s; 150 syscallarg(struct sockaddr *) name; 151 syscallarg(int *) anamelen; 152 } */ *uap = v; 153 struct file *fp; 154 struct mbuf *nam; 155 int namelen, error, s, tmpfd; 156 register struct socket *so; 157 158 if (SCARG(uap, name) && (error = copyin((caddr_t)SCARG(uap, anamelen), 159 (caddr_t)&namelen, sizeof (namelen)))) 160 return (error); 161 if ((error = getsock(p->p_fd, SCARG(uap, s), &fp)) != 0) 162 return (error); 163 s = splsoftnet(); 164 so = (struct socket *)fp->f_data; 165 if ((so->so_options & SO_ACCEPTCONN) == 0) { 166 splx(s); 167 return (EINVAL); 168 } 169 if ((so->so_state & SS_NBIO) && so->so_qlen == 0) { 170 splx(s); 171 return (EWOULDBLOCK); 172 } 173 while (so->so_qlen == 0 && so->so_error == 0) { 174 if (so->so_state & SS_CANTRCVMORE) { 175 so->so_error = ECONNABORTED; 176 break; 177 } 178 error = tsleep((caddr_t)&so->so_timeo, PSOCK | PCATCH, 179 netcon, 0); 180 if (error) { 181 splx(s); 182 return (error); 183 } 184 } 185 if (so->so_error) { 186 error = so->so_error; 187 so->so_error = 0; 188 splx(s); 189 return (error); 190 } 191 if ((error = falloc(p, &fp, &tmpfd)) != 0) { 192 splx(s); 193 return (error); 194 } 195 *retval = tmpfd; 196 { struct socket *aso = so->so_q.tqh_first; 197 if (soqremque(aso, 1) == 0) 198 panic("accept"); 199 so = aso; 200 } 201 fp->f_type = DTYPE_SOCKET; 202 fp->f_flag = FREAD|FWRITE; 203 fp->f_ops = &socketops; 204 fp->f_data = (caddr_t)so; 205 nam = m_get(M_WAIT, MT_SONAME); 206 (void) soaccept(so, nam); 207 if (SCARG(uap, name)) { 208 if (namelen > nam->m_len) 209 namelen = nam->m_len; 210 /* SHOULD COPY OUT A CHAIN HERE */ 211 if ((error = copyout(mtod(nam, caddr_t), 212 (caddr_t)SCARG(uap, name), (u_int)namelen)) == 0) 213 error = copyout((caddr_t)&namelen, 214 (caddr_t)SCARG(uap, anamelen), 215 sizeof (*SCARG(uap, anamelen))); 216 } 217 m_freem(nam); 218 splx(s); 219 return (error); 220 } 221 222 /* ARGSUSED */ 223 int 224 sys_connect(p, v, retval) 225 struct proc *p; 226 void *v; 227 register_t *retval; 228 { 229 register struct sys_connect_args /* { 230 syscallarg(int) s; 231 syscallarg(const struct sockaddr *) name; 232 syscallarg(int) namelen; 233 } */ *uap = v; 234 struct file *fp; 235 register struct socket *so; 236 struct mbuf *nam; 237 int error, s; 238 239 if ((error = getsock(p->p_fd, SCARG(uap, s), &fp)) != 0) 240 return (error); 241 so = (struct socket *)fp->f_data; 242 if ((so->so_state & SS_NBIO) && (so->so_state & SS_ISCONNECTING)) 243 return (EALREADY); 244 error = sockargs(&nam, SCARG(uap, name), SCARG(uap, namelen), 245 MT_SONAME); 246 if (error) 247 return (error); 248 error = soconnect(so, nam); 249 if (error) 250 goto bad; 251 if ((so->so_state & SS_NBIO) && (so->so_state & SS_ISCONNECTING)) { 252 m_freem(nam); 253 return (EINPROGRESS); 254 } 255 s = splsoftnet(); 256 while ((so->so_state & SS_ISCONNECTING) && so->so_error == 0) { 257 error = tsleep((caddr_t)&so->so_timeo, PSOCK | PCATCH, 258 netcon, 0); 259 if (error) 260 break; 261 } 262 if (error == 0) { 263 error = so->so_error; 264 so->so_error = 0; 265 } 266 splx(s); 267 bad: 268 so->so_state &= ~SS_ISCONNECTING; 269 m_freem(nam); 270 if (error == ERESTART) 271 error = EINTR; 272 return (error); 273 } 274 275 int 276 sys_socketpair(p, v, retval) 277 struct proc *p; 278 void *v; 279 register_t *retval; 280 { 281 register struct sys_socketpair_args /* { 282 syscallarg(int) domain; 283 syscallarg(int) type; 284 syscallarg(int) protocol; 285 syscallarg(int *) rsv; 286 } */ *uap = v; 287 register struct filedesc *fdp = p->p_fd; 288 struct file *fp1, *fp2; 289 struct socket *so1, *so2; 290 int fd, error, sv[2]; 291 292 error = socreate(SCARG(uap, domain), &so1, SCARG(uap, type), 293 SCARG(uap, protocol)); 294 if (error) 295 return (error); 296 error = socreate(SCARG(uap, domain), &so2, SCARG(uap, type), 297 SCARG(uap, protocol)); 298 if (error) 299 goto free1; 300 if ((error = falloc(p, &fp1, &fd)) != 0) 301 goto free2; 302 sv[0] = fd; 303 fp1->f_flag = FREAD|FWRITE; 304 fp1->f_type = DTYPE_SOCKET; 305 fp1->f_ops = &socketops; 306 fp1->f_data = (caddr_t)so1; 307 if ((error = falloc(p, &fp2, &fd)) != 0) 308 goto free3; 309 fp2->f_flag = FREAD|FWRITE; 310 fp2->f_type = DTYPE_SOCKET; 311 fp2->f_ops = &socketops; 312 fp2->f_data = (caddr_t)so2; 313 sv[1] = fd; 314 if ((error = soconnect2(so1, so2)) != 0) 315 goto free4; 316 if (SCARG(uap, type) == SOCK_DGRAM) { 317 /* 318 * Datagram socket connection is asymmetric. 319 */ 320 if ((error = soconnect2(so2, so1)) != 0) 321 goto free4; 322 } 323 error = copyout((caddr_t)sv, (caddr_t)SCARG(uap, rsv), 324 2 * sizeof (int)); 325 return (error); 326 free4: 327 ffree(fp2); 328 fdp->fd_ofiles[sv[1]] = 0; 329 free3: 330 ffree(fp1); 331 fdp->fd_ofiles[sv[0]] = 0; 332 free2: 333 (void)soclose(so2); 334 free1: 335 (void)soclose(so1); 336 return (error); 337 } 338 339 int 340 sys_sendto(p, v, retval) 341 struct proc *p; 342 void *v; 343 register_t *retval; 344 { 345 register struct sys_sendto_args /* { 346 syscallarg(int) s; 347 syscallarg(const void *) buf; 348 syscallarg(size_t) len; 349 syscallarg(int) flags; 350 syscallarg(const struct sockaddr *) to; 351 syscallarg(int) tolen; 352 } */ *uap = v; 353 struct msghdr msg; 354 struct iovec aiov; 355 356 msg.msg_name = (caddr_t)SCARG(uap, to); /* XXX kills const */ 357 msg.msg_namelen = SCARG(uap, tolen); 358 msg.msg_iov = &aiov; 359 msg.msg_iovlen = 1; 360 msg.msg_control = 0; 361 #ifdef COMPAT_OLDSOCK 362 msg.msg_flags = 0; 363 #endif 364 aiov.iov_base = (char *)SCARG(uap, buf); /* XXX kills const */ 365 aiov.iov_len = SCARG(uap, len); 366 return (sendit(p, SCARG(uap, s), &msg, SCARG(uap, flags), retval)); 367 } 368 369 int 370 sys_sendmsg(p, v, retval) 371 struct proc *p; 372 void *v; 373 register_t *retval; 374 { 375 register struct sys_sendmsg_args /* { 376 syscallarg(int) s; 377 syscallarg(const struct msghdr *) msg; 378 syscallarg(int) flags; 379 } */ *uap = v; 380 struct msghdr msg; 381 struct iovec aiov[UIO_SMALLIOV], *iov; 382 int error; 383 384 error = copyin(SCARG(uap, msg), (caddr_t)&msg, sizeof (msg)); 385 if (error) 386 return (error); 387 if ((u_int)msg.msg_iovlen >= UIO_SMALLIOV) { 388 if ((u_int)msg.msg_iovlen >= UIO_MAXIOV) 389 return (EMSGSIZE); 390 MALLOC(iov, struct iovec *, 391 sizeof(struct iovec) * (u_int)msg.msg_iovlen, M_IOV, 392 M_WAITOK); 393 } else 394 iov = aiov; 395 if (msg.msg_iovlen && 396 (error = copyin((caddr_t)msg.msg_iov, (caddr_t)iov, 397 (unsigned)(msg.msg_iovlen * sizeof (struct iovec))))) 398 goto done; 399 msg.msg_iov = iov; 400 #ifdef COMPAT_OLDSOCK 401 msg.msg_flags = 0; 402 #endif 403 error = sendit(p, SCARG(uap, s), &msg, SCARG(uap, flags), retval); 404 done: 405 if (iov != aiov) 406 FREE(iov, M_IOV); 407 return (error); 408 } 409 410 int 411 sendit(p, s, mp, flags, retsize) 412 register struct proc *p; 413 int s; 414 register struct msghdr *mp; 415 int flags; 416 register_t *retsize; 417 { 418 struct file *fp; 419 struct uio auio; 420 register struct iovec *iov; 421 register int i; 422 struct mbuf *to, *control; 423 int len, error; 424 struct socket *so; 425 #ifdef KTRACE 426 struct iovec *ktriov = NULL; 427 #endif 428 429 if ((error = getsock(p->p_fd, s, &fp)) != 0) 430 return (error); 431 auio.uio_iov = mp->msg_iov; 432 auio.uio_iovcnt = mp->msg_iovlen; 433 auio.uio_segflg = UIO_USERSPACE; 434 auio.uio_rw = UIO_WRITE; 435 auio.uio_procp = p; 436 auio.uio_offset = 0; /* XXX */ 437 auio.uio_resid = 0; 438 iov = mp->msg_iov; 439 for (i = 0; i < mp->msg_iovlen; i++, iov++) { 440 #if 0 441 /* cannot happen; iov_len is unsigned */ 442 if (iov->iov_len < 0) 443 return (EINVAL); 444 #endif 445 if ((auio.uio_resid += iov->iov_len) < 0) 446 return (EINVAL); 447 } 448 if (mp->msg_name) { 449 error = sockargs(&to, mp->msg_name, mp->msg_namelen, 450 MT_SONAME); 451 if (error) 452 return (error); 453 } else 454 to = 0; 455 if (mp->msg_control) { 456 if (mp->msg_controllen < sizeof(struct cmsghdr) 457 #ifdef COMPAT_OLDSOCK 458 && mp->msg_flags != MSG_COMPAT 459 #endif 460 ) { 461 error = EINVAL; 462 goto bad; 463 } 464 error = sockargs(&control, mp->msg_control, 465 mp->msg_controllen, MT_CONTROL); 466 if (error) 467 goto bad; 468 #ifdef COMPAT_OLDSOCK 469 if (mp->msg_flags == MSG_COMPAT) { 470 register struct cmsghdr *cm; 471 472 M_PREPEND(control, sizeof(*cm), M_WAIT); 473 if (control == 0) { 474 error = ENOBUFS; 475 goto bad; 476 } else { 477 cm = mtod(control, struct cmsghdr *); 478 cm->cmsg_len = control->m_len; 479 cm->cmsg_level = SOL_SOCKET; 480 cm->cmsg_type = SCM_RIGHTS; 481 } 482 } 483 #endif 484 } else 485 control = 0; 486 #ifdef KTRACE 487 if (KTRPOINT(p, KTR_GENIO)) { 488 int iovlen = auio.uio_iovcnt * sizeof (struct iovec); 489 490 MALLOC(ktriov, struct iovec *, iovlen, M_TEMP, M_WAITOK); 491 bcopy((caddr_t)auio.uio_iov, (caddr_t)ktriov, iovlen); 492 } 493 #endif 494 len = auio.uio_resid; 495 so = (struct socket *)fp->f_data; 496 error = (*so->so_send)(so, to, &auio, NULL, control, flags); 497 if (error) { 498 if (auio.uio_resid != len && (error == ERESTART || 499 error == EINTR || error == EWOULDBLOCK)) 500 error = 0; 501 if (error == EPIPE) 502 psignal(p, SIGPIPE); 503 } 504 if (error == 0) 505 *retsize = len - auio.uio_resid; 506 #ifdef KTRACE 507 if (ktriov != NULL) { 508 if (error == 0) 509 ktrgenio(p->p_tracep, s, UIO_WRITE, 510 ktriov, *retsize, error); 511 FREE(ktriov, M_TEMP); 512 } 513 #endif 514 bad: 515 if (to) 516 m_freem(to); 517 return (error); 518 } 519 520 int 521 sys_recvfrom(p, v, retval) 522 struct proc *p; 523 void *v; 524 register_t *retval; 525 { 526 register struct sys_recvfrom_args /* { 527 syscallarg(int) s; 528 syscallarg(void *) buf; 529 syscallarg(size_t) len; 530 syscallarg(int) flags; 531 syscallarg(struct sockaddr *) from; 532 syscallarg(int *) fromlenaddr; 533 } */ *uap = v; 534 struct msghdr msg; 535 struct iovec aiov; 536 int error; 537 538 if (SCARG(uap, fromlenaddr)) { 539 error = copyin((caddr_t)SCARG(uap, fromlenaddr), 540 (caddr_t)&msg.msg_namelen, 541 sizeof (msg.msg_namelen)); 542 if (error) 543 return (error); 544 } else 545 msg.msg_namelen = 0; 546 msg.msg_name = (caddr_t)SCARG(uap, from); 547 msg.msg_iov = &aiov; 548 msg.msg_iovlen = 1; 549 aiov.iov_base = SCARG(uap, buf); 550 aiov.iov_len = SCARG(uap, len); 551 msg.msg_control = 0; 552 msg.msg_flags = SCARG(uap, flags); 553 return (recvit(p, SCARG(uap, s), &msg, 554 (caddr_t)SCARG(uap, fromlenaddr), retval)); 555 } 556 557 int 558 sys_recvmsg(p, v, retval) 559 struct proc *p; 560 void *v; 561 register_t *retval; 562 { 563 register struct sys_recvmsg_args /* { 564 syscallarg(int) s; 565 syscallarg(struct msghdr *) msg; 566 syscallarg(int) flags; 567 } */ *uap = v; 568 struct msghdr msg; 569 struct iovec aiov[UIO_SMALLIOV], *uiov, *iov; 570 register int error; 571 572 error = copyin((caddr_t)SCARG(uap, msg), (caddr_t)&msg, 573 sizeof (msg)); 574 if (error) 575 return (error); 576 if ((u_int)msg.msg_iovlen >= UIO_SMALLIOV) { 577 if ((u_int)msg.msg_iovlen >= UIO_MAXIOV) 578 return (EMSGSIZE); 579 MALLOC(iov, struct iovec *, 580 sizeof(struct iovec) * (u_int)msg.msg_iovlen, M_IOV, 581 M_WAITOK); 582 } else 583 iov = aiov; 584 #ifdef COMPAT_OLDSOCK 585 msg.msg_flags = SCARG(uap, flags) &~ MSG_COMPAT; 586 #else 587 msg.msg_flags = SCARG(uap, flags); 588 #endif 589 uiov = msg.msg_iov; 590 msg.msg_iov = iov; 591 error = copyin((caddr_t)uiov, (caddr_t)iov, 592 (unsigned)(msg.msg_iovlen * sizeof (struct iovec))); 593 if (error) 594 goto done; 595 if ((error = recvit(p, SCARG(uap, s), &msg, (caddr_t)0, retval)) == 0) { 596 msg.msg_iov = uiov; 597 error = copyout((caddr_t)&msg, (caddr_t)SCARG(uap, msg), 598 sizeof(msg)); 599 } 600 done: 601 if (iov != aiov) 602 FREE(iov, M_IOV); 603 return (error); 604 } 605 606 int 607 recvit(p, s, mp, namelenp, retsize) 608 register struct proc *p; 609 int s; 610 register struct msghdr *mp; 611 caddr_t namelenp; 612 register_t *retsize; 613 { 614 struct file *fp; 615 struct uio auio; 616 register struct iovec *iov; 617 register int i; 618 int len, error; 619 struct mbuf *from = 0, *control = 0; 620 struct socket *so; 621 #ifdef KTRACE 622 struct iovec *ktriov = NULL; 623 #endif 624 625 if ((error = getsock(p->p_fd, s, &fp)) != 0) 626 return (error); 627 auio.uio_iov = mp->msg_iov; 628 auio.uio_iovcnt = mp->msg_iovlen; 629 auio.uio_segflg = UIO_USERSPACE; 630 auio.uio_rw = UIO_READ; 631 auio.uio_procp = p; 632 auio.uio_offset = 0; /* XXX */ 633 auio.uio_resid = 0; 634 iov = mp->msg_iov; 635 for (i = 0; i < mp->msg_iovlen; i++, iov++) { 636 #if 0 637 /* cannot happen iov_len is unsigned */ 638 if (iov->iov_len < 0) 639 return (EINVAL); 640 #endif 641 if ((auio.uio_resid += iov->iov_len) < 0) 642 return (EINVAL); 643 } 644 #ifdef KTRACE 645 if (KTRPOINT(p, KTR_GENIO)) { 646 int iovlen = auio.uio_iovcnt * sizeof (struct iovec); 647 648 MALLOC(ktriov, struct iovec *, iovlen, M_TEMP, M_WAITOK); 649 bcopy((caddr_t)auio.uio_iov, (caddr_t)ktriov, iovlen); 650 } 651 #endif 652 len = auio.uio_resid; 653 so = (struct socket *)fp->f_data; 654 error = (*so->so_receive)(so, &from, &auio, NULL, 655 mp->msg_control ? &control : NULL, &mp->msg_flags); 656 if (error) { 657 if (auio.uio_resid != len && (error == ERESTART || 658 error == EINTR || error == EWOULDBLOCK)) 659 error = 0; 660 } 661 #ifdef KTRACE 662 if (ktriov != NULL) { 663 if (error == 0) 664 ktrgenio(p->p_tracep, s, UIO_READ, 665 ktriov, len - auio.uio_resid, error); 666 FREE(ktriov, M_TEMP); 667 } 668 #endif 669 if (error) 670 goto out; 671 *retsize = len - auio.uio_resid; 672 if (mp->msg_name) { 673 len = mp->msg_namelen; 674 if (len <= 0 || from == 0) 675 len = 0; 676 else { 677 #ifdef COMPAT_OLDSOCK 678 if (mp->msg_flags & MSG_COMPAT) 679 mtod(from, struct osockaddr *)->sa_family = 680 mtod(from, struct sockaddr *)->sa_family; 681 #endif 682 if (len > from->m_len) 683 len = from->m_len; 684 /* else if len < from->m_len ??? */ 685 error = copyout(mtod(from, caddr_t), 686 (caddr_t)mp->msg_name, (unsigned)len); 687 if (error) 688 goto out; 689 } 690 mp->msg_namelen = len; 691 if (namelenp && 692 (error = copyout((caddr_t)&len, namelenp, sizeof (int)))) { 693 #ifdef COMPAT_OLDSOCK 694 if (mp->msg_flags & MSG_COMPAT) 695 error = 0; /* old recvfrom didn't check */ 696 else 697 #endif 698 goto out; 699 } 700 } 701 if (mp->msg_control) { 702 #ifdef COMPAT_OLDSOCK 703 /* 704 * We assume that old recvmsg calls won't receive access 705 * rights and other control info, esp. as control info 706 * is always optional and those options didn't exist in 4.3. 707 * If we receive rights, trim the cmsghdr; anything else 708 * is tossed. 709 */ 710 if (control && mp->msg_flags & MSG_COMPAT) { 711 if (mtod(control, struct cmsghdr *)->cmsg_level != 712 SOL_SOCKET || 713 mtod(control, struct cmsghdr *)->cmsg_type != 714 SCM_RIGHTS) { 715 mp->msg_controllen = 0; 716 goto out; 717 } 718 control->m_len -= sizeof (struct cmsghdr); 719 control->m_data += sizeof (struct cmsghdr); 720 } 721 #endif 722 len = mp->msg_controllen; 723 if (len <= 0 || control == 0) 724 len = 0; 725 else { 726 struct mbuf *m = control; 727 caddr_t p = (caddr_t)mp->msg_control; 728 729 do { 730 i = m->m_len; 731 if (len < i) { 732 mp->msg_flags |= MSG_CTRUNC; 733 i = len; 734 } 735 error = copyout(mtod(m, caddr_t), p, 736 (unsigned)i); 737 if (m->m_next) 738 i = ALIGN(i); 739 p += i; 740 len -= i; 741 if (error != 0 || len <= 0) 742 break; 743 } while ((m = m->m_next) != NULL); 744 len = p - (caddr_t)mp->msg_control; 745 } 746 mp->msg_controllen = len; 747 } 748 out: 749 if (from) 750 m_freem(from); 751 if (control) 752 m_freem(control); 753 return (error); 754 } 755 756 /* ARGSUSED */ 757 int 758 sys_shutdown(p, v, retval) 759 struct proc *p; 760 void *v; 761 register_t *retval; 762 { 763 register struct sys_shutdown_args /* { 764 syscallarg(int) s; 765 syscallarg(int) how; 766 } */ *uap = v; 767 struct file *fp; 768 int error; 769 770 if ((error = getsock(p->p_fd, SCARG(uap, s), &fp)) != 0) 771 return (error); 772 return (soshutdown((struct socket *)fp->f_data, SCARG(uap, how))); 773 } 774 775 /* ARGSUSED */ 776 int 777 sys_setsockopt(p, v, retval) 778 struct proc *p; 779 void *v; 780 register_t *retval; 781 { 782 register struct sys_setsockopt_args /* { 783 syscallarg(int) s; 784 syscallarg(int) level; 785 syscallarg(int) name; 786 syscallarg(const void *) val; 787 syscallarg(int) valsize; 788 } */ *uap = v; 789 struct file *fp; 790 struct mbuf *m = NULL; 791 int error; 792 793 if ((error = getsock(p->p_fd, SCARG(uap, s), &fp)) != 0) 794 return (error); 795 if (SCARG(uap, valsize) > MLEN) 796 return (EINVAL); 797 if (SCARG(uap, val)) { 798 m = m_get(M_WAIT, MT_SOOPTS); 799 error = copyin(SCARG(uap, val), mtod(m, caddr_t), 800 (u_int)SCARG(uap, valsize)); 801 if (error) { 802 (void) m_free(m); 803 return (error); 804 } 805 m->m_len = SCARG(uap, valsize); 806 } 807 return (sosetopt((struct socket *)fp->f_data, SCARG(uap, level), 808 SCARG(uap, name), m)); 809 } 810 811 /* ARGSUSED */ 812 int 813 sys_getsockopt(p, v, retval) 814 struct proc *p; 815 void *v; 816 register_t *retval; 817 { 818 register struct sys_getsockopt_args /* { 819 syscallarg(int) s; 820 syscallarg(int) level; 821 syscallarg(int) name; 822 syscallarg(void *) val; 823 syscallarg(int *) avalsize; 824 } */ *uap = v; 825 struct file *fp; 826 struct mbuf *m = NULL; 827 int valsize, error; 828 829 if ((error = getsock(p->p_fd, SCARG(uap, s), &fp)) != 0) 830 return (error); 831 if (SCARG(uap, val)) { 832 error = copyin((caddr_t)SCARG(uap, avalsize), 833 (caddr_t)&valsize, sizeof (valsize)); 834 if (error) 835 return (error); 836 } else 837 valsize = 0; 838 if ((error = sogetopt((struct socket *)fp->f_data, SCARG(uap, level), 839 SCARG(uap, name), &m)) == 0 && SCARG(uap, val) && valsize && 840 m != NULL) { 841 if (valsize > m->m_len) 842 valsize = m->m_len; 843 error = copyout(mtod(m, caddr_t), SCARG(uap, val), 844 (u_int)valsize); 845 if (error == 0) 846 error = copyout((caddr_t)&valsize, 847 (caddr_t)SCARG(uap, avalsize), sizeof (valsize)); 848 } 849 if (m != NULL) 850 (void) m_free(m); 851 return (error); 852 } 853 854 /* ARGSUSED */ 855 int 856 sys_pipe(p, v, retval) 857 struct proc *p; 858 void *v; 859 register_t *retval; 860 { 861 register struct filedesc *fdp = p->p_fd; 862 struct file *rf, *wf; 863 struct socket *rso, *wso; 864 int fd, error; 865 866 if ((error = socreate(AF_UNIX, &rso, SOCK_STREAM, 0)) != 0) 867 return (error); 868 if ((error = socreate(AF_UNIX, &wso, SOCK_STREAM, 0)) != 0) 869 goto free1; 870 if ((error = falloc(p, &rf, &fd)) != 0) 871 goto free2; 872 retval[0] = fd; 873 rf->f_flag = FREAD; 874 rf->f_type = DTYPE_SOCKET; 875 rf->f_ops = &socketops; 876 rf->f_data = (caddr_t)rso; 877 if ((error = falloc(p, &wf, &fd)) != 0) 878 goto free3; 879 wf->f_flag = FWRITE; 880 wf->f_type = DTYPE_SOCKET; 881 wf->f_ops = &socketops; 882 wf->f_data = (caddr_t)wso; 883 retval[1] = fd; 884 if ((error = unp_connect2(wso, rso)) != 0) 885 goto free4; 886 return (0); 887 free4: 888 ffree(wf); 889 fdp->fd_ofiles[retval[1]] = 0; 890 free3: 891 ffree(rf); 892 fdp->fd_ofiles[retval[0]] = 0; 893 free2: 894 (void)soclose(wso); 895 free1: 896 (void)soclose(rso); 897 return (error); 898 } 899 900 /* 901 * Get socket name. 902 */ 903 /* ARGSUSED */ 904 int 905 sys_getsockname(p, v, retval) 906 struct proc *p; 907 void *v; 908 register_t *retval; 909 { 910 register struct sys_getsockname_args /* { 911 syscallarg(int) fdes; 912 syscallarg(struct sockaddr *) asa; 913 syscallarg(int *) alen; 914 } */ *uap = v; 915 struct file *fp; 916 register struct socket *so; 917 struct mbuf *m; 918 int len, error; 919 920 if ((error = getsock(p->p_fd, SCARG(uap, fdes), &fp)) != 0) 921 return (error); 922 error = copyin((caddr_t)SCARG(uap, alen), (caddr_t)&len, sizeof (len)); 923 if (error) 924 return (error); 925 so = (struct socket *)fp->f_data; 926 m = m_getclr(M_WAIT, MT_SONAME); 927 error = (*so->so_proto->pr_usrreq)(so, PRU_SOCKADDR, (struct mbuf *)0, 928 m, (struct mbuf *)0, (struct proc *)0); 929 if (error) 930 goto bad; 931 if (len > m->m_len) 932 len = m->m_len; 933 error = copyout(mtod(m, caddr_t), (caddr_t)SCARG(uap, asa), (u_int)len); 934 if (error == 0) 935 error = copyout((caddr_t)&len, (caddr_t)SCARG(uap, alen), 936 sizeof (len)); 937 bad: 938 m_freem(m); 939 return (error); 940 } 941 942 /* 943 * Get name of peer for connected socket. 944 */ 945 /* ARGSUSED */ 946 int 947 sys_getpeername(p, v, retval) 948 struct proc *p; 949 void *v; 950 register_t *retval; 951 { 952 register struct sys_getpeername_args /* { 953 syscallarg(int) fdes; 954 syscallarg(struct sockaddr *) asa; 955 syscallarg(int *) alen; 956 } */ *uap = v; 957 struct file *fp; 958 register struct socket *so; 959 struct mbuf *m; 960 int len, error; 961 962 if ((error = getsock(p->p_fd, SCARG(uap, fdes), &fp)) != 0) 963 return (error); 964 so = (struct socket *)fp->f_data; 965 if ((so->so_state & (SS_ISCONNECTED|SS_ISCONFIRMING)) == 0) 966 return (ENOTCONN); 967 error = copyin((caddr_t)SCARG(uap, alen), (caddr_t)&len, sizeof (len)); 968 if (error) 969 return (error); 970 m = m_getclr(M_WAIT, MT_SONAME); 971 error = (*so->so_proto->pr_usrreq)(so, PRU_PEERADDR, (struct mbuf *)0, 972 m, (struct mbuf *)0, (struct proc *)0); 973 if (error) 974 goto bad; 975 if (len > m->m_len) 976 len = m->m_len; 977 error = copyout(mtod(m, caddr_t), (caddr_t)SCARG(uap, asa), (u_int)len); 978 if (error) 979 goto bad; 980 error = copyout((caddr_t)&len, (caddr_t)SCARG(uap, alen), sizeof (len)); 981 bad: 982 m_freem(m); 983 return (error); 984 } 985 986 /* 987 * XXX In a perfect world, we wouldn't pass around socket control 988 * XXX arguments in mbufs, and this could go away. 989 */ 990 int 991 sockargs(mp, buf, buflen, type) 992 struct mbuf **mp; 993 const void *buf; 994 int buflen, type; 995 { 996 register struct sockaddr *sa; 997 register struct mbuf *m; 998 int error; 999 1000 /* 1001 * We can't allow socket names > UCHAR_MAX in length, since that 1002 * will overflow sa_len. 1003 */ 1004 if (type == MT_SONAME && (u_int)buflen > UCHAR_MAX) 1005 return (EINVAL); 1006 1007 /* Allocate an mbuf to hold the arguments. */ 1008 m = m_get(M_WAIT, type); 1009 if ((u_int)buflen > MLEN) { 1010 /* 1011 * Won't fit into a regular mbuf, so we allocate just 1012 * enough external storage to hold the argument. 1013 */ 1014 MEXTMALLOC(m, buflen, M_WAITOK); 1015 } 1016 m->m_len = buflen; 1017 error = copyin(buf, mtod(m, caddr_t), (u_int)buflen); 1018 if (error) { 1019 (void) m_free(m); 1020 return (error); 1021 } 1022 *mp = m; 1023 if (type == MT_SONAME) { 1024 sa = mtod(m, struct sockaddr *); 1025 1026 #if defined(COMPAT_OLDSOCK) && BYTE_ORDER != BIG_ENDIAN 1027 if (sa->sa_family == 0 && sa->sa_len < AF_MAX) 1028 sa->sa_family = sa->sa_len; 1029 #endif 1030 sa->sa_len = buflen; 1031 } 1032 return (0); 1033 } 1034 1035 int 1036 getsock(fdp, fdes, fpp) 1037 struct filedesc *fdp; 1038 int fdes; 1039 struct file **fpp; 1040 { 1041 register struct file *fp; 1042 1043 if ((unsigned)fdes >= fdp->fd_nfiles || 1044 (fp = fdp->fd_ofiles[fdes]) == NULL) 1045 return (EBADF); 1046 if (fp->f_type != DTYPE_SOCKET) 1047 return (ENOTSOCK); 1048 *fpp = fp; 1049 return (0); 1050 } 1051
Indexes created Fri Sep 26 20:09:58 GMT 2025