uipc_syscalls.c revision 1.27
1 /* $NetBSD: uipc_syscalls.c,v 1.27 1998/01/07 23:47:10 thorpej 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.4 (Berkeley) 2/21/94 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 #ifdef KTRACE 425 struct iovec *ktriov = NULL; 426 #endif 427 428 if ((error = getsock(p->p_fd, s, &fp)) != 0) 429 return (error); 430 auio.uio_iov = mp->msg_iov; 431 auio.uio_iovcnt = mp->msg_iovlen; 432 auio.uio_segflg = UIO_USERSPACE; 433 auio.uio_rw = UIO_WRITE; 434 auio.uio_procp = p; 435 auio.uio_offset = 0; /* XXX */ 436 auio.uio_resid = 0; 437 iov = mp->msg_iov; 438 for (i = 0; i < mp->msg_iovlen; i++, iov++) { 439 #if 0 440 /* cannot happen; iov_len is unsigned */ 441 if (iov->iov_len < 0) 442 return (EINVAL); 443 #endif 444 if ((auio.uio_resid += iov->iov_len) < 0) 445 return (EINVAL); 446 } 447 if (mp->msg_name) { 448 error = sockargs(&to, mp->msg_name, mp->msg_namelen, 449 MT_SONAME); 450 if (error) 451 return (error); 452 } else 453 to = 0; 454 if (mp->msg_control) { 455 if (mp->msg_controllen < sizeof(struct cmsghdr) 456 #ifdef COMPAT_OLDSOCK 457 && mp->msg_flags != MSG_COMPAT 458 #endif 459 ) { 460 error = EINVAL; 461 goto bad; 462 } 463 error = sockargs(&control, mp->msg_control, 464 mp->msg_controllen, MT_CONTROL); 465 if (error) 466 goto bad; 467 #ifdef COMPAT_OLDSOCK 468 if (mp->msg_flags == MSG_COMPAT) { 469 register struct cmsghdr *cm; 470 471 M_PREPEND(control, sizeof(*cm), M_WAIT); 472 if (control == 0) { 473 error = ENOBUFS; 474 goto bad; 475 } else { 476 cm = mtod(control, struct cmsghdr *); 477 cm->cmsg_len = control->m_len; 478 cm->cmsg_level = SOL_SOCKET; 479 cm->cmsg_type = SCM_RIGHTS; 480 } 481 } 482 #endif 483 } else 484 control = 0; 485 #ifdef KTRACE 486 if (KTRPOINT(p, KTR_GENIO)) { 487 int iovlen = auio.uio_iovcnt * sizeof (struct iovec); 488 489 MALLOC(ktriov, struct iovec *, iovlen, M_TEMP, M_WAITOK); 490 bcopy((caddr_t)auio.uio_iov, (caddr_t)ktriov, iovlen); 491 } 492 #endif 493 len = auio.uio_resid; 494 error = sosend((struct socket *)fp->f_data, to, &auio, 495 NULL, control, flags); 496 if (error) { 497 if (auio.uio_resid != len && (error == ERESTART || 498 error == EINTR || error == EWOULDBLOCK)) 499 error = 0; 500 if (error == EPIPE) 501 psignal(p, SIGPIPE); 502 } 503 if (error == 0) 504 *retsize = len - auio.uio_resid; 505 #ifdef KTRACE 506 if (ktriov != NULL) { 507 if (error == 0) 508 ktrgenio(p->p_tracep, s, UIO_WRITE, 509 ktriov, *retsize, error); 510 FREE(ktriov, M_TEMP); 511 } 512 #endif 513 bad: 514 if (to) 515 m_freem(to); 516 return (error); 517 } 518 519 int 520 sys_recvfrom(p, v, retval) 521 struct proc *p; 522 void *v; 523 register_t *retval; 524 { 525 register struct sys_recvfrom_args /* { 526 syscallarg(int) s; 527 syscallarg(void *) buf; 528 syscallarg(size_t) len; 529 syscallarg(int) flags; 530 syscallarg(struct sockaddr *) from; 531 syscallarg(int *) fromlenaddr; 532 } */ *uap = v; 533 struct msghdr msg; 534 struct iovec aiov; 535 int error; 536 537 if (SCARG(uap, fromlenaddr)) { 538 error = copyin((caddr_t)SCARG(uap, fromlenaddr), 539 (caddr_t)&msg.msg_namelen, 540 sizeof (msg.msg_namelen)); 541 if (error) 542 return (error); 543 } else 544 msg.msg_namelen = 0; 545 msg.msg_name = (caddr_t)SCARG(uap, from); 546 msg.msg_iov = &aiov; 547 msg.msg_iovlen = 1; 548 aiov.iov_base = SCARG(uap, buf); 549 aiov.iov_len = SCARG(uap, len); 550 msg.msg_control = 0; 551 msg.msg_flags = SCARG(uap, flags); 552 return (recvit(p, SCARG(uap, s), &msg, 553 (caddr_t)SCARG(uap, fromlenaddr), retval)); 554 } 555 556 int 557 sys_recvmsg(p, v, retval) 558 struct proc *p; 559 void *v; 560 register_t *retval; 561 { 562 register struct sys_recvmsg_args /* { 563 syscallarg(int) s; 564 syscallarg(struct msghdr *) msg; 565 syscallarg(int) flags; 566 } */ *uap = v; 567 struct msghdr msg; 568 struct iovec aiov[UIO_SMALLIOV], *uiov, *iov; 569 register int error; 570 571 error = copyin((caddr_t)SCARG(uap, msg), (caddr_t)&msg, 572 sizeof (msg)); 573 if (error) 574 return (error); 575 if ((u_int)msg.msg_iovlen >= UIO_SMALLIOV) { 576 if ((u_int)msg.msg_iovlen >= UIO_MAXIOV) 577 return (EMSGSIZE); 578 MALLOC(iov, struct iovec *, 579 sizeof(struct iovec) * (u_int)msg.msg_iovlen, M_IOV, 580 M_WAITOK); 581 } else 582 iov = aiov; 583 #ifdef COMPAT_OLDSOCK 584 msg.msg_flags = SCARG(uap, flags) &~ MSG_COMPAT; 585 #else 586 msg.msg_flags = SCARG(uap, flags); 587 #endif 588 uiov = msg.msg_iov; 589 msg.msg_iov = iov; 590 error = copyin((caddr_t)uiov, (caddr_t)iov, 591 (unsigned)(msg.msg_iovlen * sizeof (struct iovec))); 592 if (error) 593 goto done; 594 if ((error = recvit(p, SCARG(uap, s), &msg, (caddr_t)0, retval)) == 0) { 595 msg.msg_iov = uiov; 596 error = copyout((caddr_t)&msg, (caddr_t)SCARG(uap, msg), 597 sizeof(msg)); 598 } 599 done: 600 if (iov != aiov) 601 FREE(iov, M_IOV); 602 return (error); 603 } 604 605 int 606 recvit(p, s, mp, namelenp, retsize) 607 register struct proc *p; 608 int s; 609 register struct msghdr *mp; 610 caddr_t namelenp; 611 register_t *retsize; 612 { 613 struct file *fp; 614 struct uio auio; 615 register struct iovec *iov; 616 register int i; 617 int len, error; 618 struct mbuf *from = 0, *control = 0; 619 #ifdef KTRACE 620 struct iovec *ktriov = NULL; 621 #endif 622 623 if ((error = getsock(p->p_fd, s, &fp)) != 0) 624 return (error); 625 auio.uio_iov = mp->msg_iov; 626 auio.uio_iovcnt = mp->msg_iovlen; 627 auio.uio_segflg = UIO_USERSPACE; 628 auio.uio_rw = UIO_READ; 629 auio.uio_procp = p; 630 auio.uio_offset = 0; /* XXX */ 631 auio.uio_resid = 0; 632 iov = mp->msg_iov; 633 for (i = 0; i < mp->msg_iovlen; i++, iov++) { 634 #if 0 635 /* cannot happen iov_len is unsigned */ 636 if (iov->iov_len < 0) 637 return (EINVAL); 638 #endif 639 if ((auio.uio_resid += iov->iov_len) < 0) 640 return (EINVAL); 641 } 642 #ifdef KTRACE 643 if (KTRPOINT(p, KTR_GENIO)) { 644 int iovlen = auio.uio_iovcnt * sizeof (struct iovec); 645 646 MALLOC(ktriov, struct iovec *, iovlen, M_TEMP, M_WAITOK); 647 bcopy((caddr_t)auio.uio_iov, (caddr_t)ktriov, iovlen); 648 } 649 #endif 650 len = auio.uio_resid; 651 error = soreceive((struct socket *)fp->f_data, &from, &auio, 652 NULL, mp->msg_control ? &control : NULL, 653 &mp->msg_flags); 654 if (error) { 655 if (auio.uio_resid != len && (error == ERESTART || 656 error == EINTR || error == EWOULDBLOCK)) 657 error = 0; 658 } 659 #ifdef KTRACE 660 if (ktriov != NULL) { 661 if (error == 0) 662 ktrgenio(p->p_tracep, s, UIO_READ, 663 ktriov, len - auio.uio_resid, error); 664 FREE(ktriov, M_TEMP); 665 } 666 #endif 667 if (error) 668 goto out; 669 *retsize = len - auio.uio_resid; 670 if (mp->msg_name) { 671 len = mp->msg_namelen; 672 if (len <= 0 || from == 0) 673 len = 0; 674 else { 675 #ifdef COMPAT_OLDSOCK 676 if (mp->msg_flags & MSG_COMPAT) 677 mtod(from, struct osockaddr *)->sa_family = 678 mtod(from, struct sockaddr *)->sa_family; 679 #endif 680 if (len > from->m_len) 681 len = from->m_len; 682 /* else if len < from->m_len ??? */ 683 error = copyout(mtod(from, caddr_t), 684 (caddr_t)mp->msg_name, (unsigned)len); 685 if (error) 686 goto out; 687 } 688 mp->msg_namelen = len; 689 if (namelenp && 690 (error = copyout((caddr_t)&len, namelenp, sizeof (int)))) { 691 #ifdef COMPAT_OLDSOCK 692 if (mp->msg_flags & MSG_COMPAT) 693 error = 0; /* old recvfrom didn't check */ 694 else 695 #endif 696 goto out; 697 } 698 } 699 if (mp->msg_control) { 700 #ifdef COMPAT_OLDSOCK 701 /* 702 * We assume that old recvmsg calls won't receive access 703 * rights and other control info, esp. as control info 704 * is always optional and those options didn't exist in 4.3. 705 * If we receive rights, trim the cmsghdr; anything else 706 * is tossed. 707 */ 708 if (control && mp->msg_flags & MSG_COMPAT) { 709 if (mtod(control, struct cmsghdr *)->cmsg_level != 710 SOL_SOCKET || 711 mtod(control, struct cmsghdr *)->cmsg_type != 712 SCM_RIGHTS) { 713 mp->msg_controllen = 0; 714 goto out; 715 } 716 control->m_len -= sizeof (struct cmsghdr); 717 control->m_data += sizeof (struct cmsghdr); 718 } 719 #endif 720 len = mp->msg_controllen; 721 if (len <= 0 || control == 0) 722 len = 0; 723 else { 724 struct mbuf *m = control; 725 caddr_t p = (caddr_t)mp->msg_control; 726 727 while (m) { 728 i = m->m_len; 729 if (len < i) { 730 mp->msg_flags |= MSG_CTRUNC; 731 i = len; 732 } 733 error = copyout(mtod(m, caddr_t), p, 734 (unsigned)i); 735 p += i; 736 len -= i; 737 if (error != 0 || len <= 0) 738 break; 739 m = m->m_next; 740 } 741 len = p - (caddr_t)mp->msg_control; 742 } 743 mp->msg_controllen = len; 744 } 745 out: 746 if (from) 747 m_freem(from); 748 if (control) 749 m_freem(control); 750 return (error); 751 } 752 753 /* ARGSUSED */ 754 int 755 sys_shutdown(p, v, retval) 756 struct proc *p; 757 void *v; 758 register_t *retval; 759 { 760 register struct sys_shutdown_args /* { 761 syscallarg(int) s; 762 syscallarg(int) how; 763 } */ *uap = v; 764 struct file *fp; 765 int error; 766 767 if ((error = getsock(p->p_fd, SCARG(uap, s), &fp)) != 0) 768 return (error); 769 return (soshutdown((struct socket *)fp->f_data, SCARG(uap, how))); 770 } 771 772 /* ARGSUSED */ 773 int 774 sys_setsockopt(p, v, retval) 775 struct proc *p; 776 void *v; 777 register_t *retval; 778 { 779 register struct sys_setsockopt_args /* { 780 syscallarg(int) s; 781 syscallarg(int) level; 782 syscallarg(int) name; 783 syscallarg(const void *) val; 784 syscallarg(int) valsize; 785 } */ *uap = v; 786 struct file *fp; 787 struct mbuf *m = NULL; 788 int error; 789 790 if ((error = getsock(p->p_fd, SCARG(uap, s), &fp)) != 0) 791 return (error); 792 if (SCARG(uap, valsize) > MLEN) 793 return (EINVAL); 794 if (SCARG(uap, val)) { 795 m = m_get(M_WAIT, MT_SOOPTS); 796 error = copyin(SCARG(uap, val), mtod(m, caddr_t), 797 (u_int)SCARG(uap, valsize)); 798 if (error) { 799 (void) m_free(m); 800 return (error); 801 } 802 m->m_len = SCARG(uap, valsize); 803 } 804 return (sosetopt((struct socket *)fp->f_data, SCARG(uap, level), 805 SCARG(uap, name), m)); 806 } 807 808 /* ARGSUSED */ 809 int 810 sys_getsockopt(p, v, retval) 811 struct proc *p; 812 void *v; 813 register_t *retval; 814 { 815 register struct sys_getsockopt_args /* { 816 syscallarg(int) s; 817 syscallarg(int) level; 818 syscallarg(int) name; 819 syscallarg(void *) val; 820 syscallarg(int *) avalsize; 821 } */ *uap = v; 822 struct file *fp; 823 struct mbuf *m = NULL; 824 int valsize, error; 825 826 if ((error = getsock(p->p_fd, SCARG(uap, s), &fp)) != 0) 827 return (error); 828 if (SCARG(uap, val)) { 829 error = copyin((caddr_t)SCARG(uap, avalsize), 830 (caddr_t)&valsize, sizeof (valsize)); 831 if (error) 832 return (error); 833 } else 834 valsize = 0; 835 if ((error = sogetopt((struct socket *)fp->f_data, SCARG(uap, level), 836 SCARG(uap, name), &m)) == 0 && SCARG(uap, val) && valsize && 837 m != NULL) { 838 if (valsize > m->m_len) 839 valsize = m->m_len; 840 error = copyout(mtod(m, caddr_t), SCARG(uap, val), 841 (u_int)valsize); 842 if (error == 0) 843 error = copyout((caddr_t)&valsize, 844 (caddr_t)SCARG(uap, avalsize), sizeof (valsize)); 845 } 846 if (m != NULL) 847 (void) m_free(m); 848 return (error); 849 } 850 851 /* ARGSUSED */ 852 int 853 sys_pipe(p, v, retval) 854 struct proc *p; 855 void *v; 856 register_t *retval; 857 { 858 register struct filedesc *fdp = p->p_fd; 859 struct file *rf, *wf; 860 struct socket *rso, *wso; 861 int fd, error; 862 863 if ((error = socreate(AF_UNIX, &rso, SOCK_STREAM, 0)) != 0) 864 return (error); 865 if ((error = socreate(AF_UNIX, &wso, SOCK_STREAM, 0)) != 0) 866 goto free1; 867 if ((error = falloc(p, &rf, &fd)) != 0) 868 goto free2; 869 retval[0] = fd; 870 rf->f_flag = FREAD; 871 rf->f_type = DTYPE_SOCKET; 872 rf->f_ops = &socketops; 873 rf->f_data = (caddr_t)rso; 874 if ((error = falloc(p, &wf, &fd)) != 0) 875 goto free3; 876 wf->f_flag = FWRITE; 877 wf->f_type = DTYPE_SOCKET; 878 wf->f_ops = &socketops; 879 wf->f_data = (caddr_t)wso; 880 retval[1] = fd; 881 if ((error = unp_connect2(wso, rso)) != 0) 882 goto free4; 883 return (0); 884 free4: 885 ffree(wf); 886 fdp->fd_ofiles[retval[1]] = 0; 887 free3: 888 ffree(rf); 889 fdp->fd_ofiles[retval[0]] = 0; 890 free2: 891 (void)soclose(wso); 892 free1: 893 (void)soclose(rso); 894 return (error); 895 } 896 897 /* 898 * Get socket name. 899 */ 900 /* ARGSUSED */ 901 int 902 sys_getsockname(p, v, retval) 903 struct proc *p; 904 void *v; 905 register_t *retval; 906 { 907 register struct sys_getsockname_args /* { 908 syscallarg(int) fdes; 909 syscallarg(struct sockaddr *) asa; 910 syscallarg(int *) alen; 911 } */ *uap = v; 912 struct file *fp; 913 register struct socket *so; 914 struct mbuf *m; 915 int len, error; 916 917 if ((error = getsock(p->p_fd, SCARG(uap, fdes), &fp)) != 0) 918 return (error); 919 error = copyin((caddr_t)SCARG(uap, alen), (caddr_t)&len, sizeof (len)); 920 if (error) 921 return (error); 922 so = (struct socket *)fp->f_data; 923 m = m_getclr(M_WAIT, MT_SONAME); 924 error = (*so->so_proto->pr_usrreq)(so, PRU_SOCKADDR, (struct mbuf *)0, 925 m, (struct mbuf *)0, (struct proc *)0); 926 if (error) 927 goto bad; 928 if (len > m->m_len) 929 len = m->m_len; 930 error = copyout(mtod(m, caddr_t), (caddr_t)SCARG(uap, asa), (u_int)len); 931 if (error == 0) 932 error = copyout((caddr_t)&len, (caddr_t)SCARG(uap, alen), 933 sizeof (len)); 934 bad: 935 m_freem(m); 936 return (error); 937 } 938 939 /* 940 * Get name of peer for connected socket. 941 */ 942 /* ARGSUSED */ 943 int 944 sys_getpeername(p, v, retval) 945 struct proc *p; 946 void *v; 947 register_t *retval; 948 { 949 register struct sys_getpeername_args /* { 950 syscallarg(int) fdes; 951 syscallarg(struct sockaddr *) asa; 952 syscallarg(int *) alen; 953 } */ *uap = v; 954 struct file *fp; 955 register struct socket *so; 956 struct mbuf *m; 957 int len, error; 958 959 if ((error = getsock(p->p_fd, SCARG(uap, fdes), &fp)) != 0) 960 return (error); 961 so = (struct socket *)fp->f_data; 962 if ((so->so_state & (SS_ISCONNECTED|SS_ISCONFIRMING)) == 0) 963 return (ENOTCONN); 964 error = copyin((caddr_t)SCARG(uap, alen), (caddr_t)&len, sizeof (len)); 965 if (error) 966 return (error); 967 m = m_getclr(M_WAIT, MT_SONAME); 968 error = (*so->so_proto->pr_usrreq)(so, PRU_PEERADDR, (struct mbuf *)0, 969 m, (struct mbuf *)0, (struct proc *)0); 970 if (error) 971 goto bad; 972 if (len > m->m_len) 973 len = m->m_len; 974 error = copyout(mtod(m, caddr_t), (caddr_t)SCARG(uap, asa), (u_int)len); 975 if (error) 976 goto bad; 977 error = copyout((caddr_t)&len, (caddr_t)SCARG(uap, alen), sizeof (len)); 978 bad: 979 m_freem(m); 980 return (error); 981 } 982 983 /* 984 * XXX In a perfect world, we wouldn't pass around socket control 985 * XXX arguments in mbufs, and this could go away. 986 */ 987 int 988 sockargs(mp, buf, buflen, type) 989 struct mbuf **mp; 990 const void *buf; 991 int buflen, type; 992 { 993 register struct sockaddr *sa; 994 register struct mbuf *m; 995 int error; 996 997 /* 998 * We can't allow socket names > UCHAR_MAX in length, since that 999 * will overflow sa_len. 1000 */ 1001 if (type == MT_SONAME && (u_int)buflen > UCHAR_MAX) 1002 return (EINVAL); 1003 1004 /* Allocate an mbuf to hold the arguments. */ 1005 m = m_get(M_WAIT, type); 1006 if ((u_int)buflen > MLEN) { 1007 /* 1008 * Won't fit into a regular mbuf, so we allocate just 1009 * enough external storage to hold the argument. 1010 */ 1011 MEXTMALLOC(m, buflen, M_WAITOK); 1012 } 1013 m->m_len = buflen; 1014 error = copyin(buf, mtod(m, caddr_t), (u_int)buflen); 1015 if (error) { 1016 (void) m_free(m); 1017 return (error); 1018 } 1019 *mp = m; 1020 if (type == MT_SONAME) { 1021 sa = mtod(m, struct sockaddr *); 1022 1023 #if defined(COMPAT_OLDSOCK) && BYTE_ORDER != BIG_ENDIAN 1024 if (sa->sa_family == 0 && sa->sa_len < AF_MAX) 1025 sa->sa_family = sa->sa_len; 1026 #endif 1027 sa->sa_len = buflen; 1028 } 1029 return (0); 1030 } 1031 1032 int 1033 getsock(fdp, fdes, fpp) 1034 struct filedesc *fdp; 1035 int fdes; 1036 struct file **fpp; 1037 { 1038 register struct file *fp; 1039 1040 if ((unsigned)fdes >= fdp->fd_nfiles || 1041 (fp = fdp->fd_ofiles[fdes]) == NULL) 1042 return (EBADF); 1043 if (fp->f_type != DTYPE_SOCKET) 1044 return (ENOTSOCK); 1045 *fpp = fp; 1046 return (0); 1047 } 1048
Indexes created Thu Sep 25 16:09:42 GMT 2025