svr4_stream.c revision 281436
1/*- 2 * Copyright (c) 1998 Mark Newton. All rights reserved. 3 * Copyright (c) 1994, 1996 Christos Zoulas. All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 3. All advertising materials mentioning features or use of this software 14 * must display the following acknowledgement: 15 * This product includes software developed by Christos Zoulas. 16 * 4. The name of the author may not be used to endorse or promote products 17 * derived from this software without specific prior written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 20 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 21 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 22 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 24 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 28 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 */ 30 31/* 32 * Pretend that we have streams... 33 * Yes, this is gross. 34 * 35 * ToDo: The state machine for getmsg needs re-thinking 36 */ 37 38#include <sys/cdefs.h> 39__FBSDID("$FreeBSD: head/sys/compat/svr4/svr4_stream.c 281436 2015-04-11 15:40:28Z mjg $"); 40 41#include "opt_compat.h" 42#include "opt_ktrace.h" 43 44#include <sys/param.h> 45#include <sys/systm.h> 46#include <sys/capsicum.h> 47#include <sys/fcntl.h> 48#include <sys/filedesc.h> 49#include <sys/filio.h> 50#include <sys/lock.h> 51#include <sys/malloc.h> 52#include <sys/file.h> /* Must come after sys/malloc.h */ 53#include <sys/mbuf.h> 54#include <sys/mutex.h> 55#include <sys/proc.h> 56#include <sys/protosw.h> 57#include <sys/signal.h> 58#include <sys/signalvar.h> 59#include <sys/socket.h> 60#include <sys/socketvar.h> 61#include <sys/stat.h> 62#include <sys/syscallsubr.h> 63#include <sys/sysproto.h> 64#include <sys/uio.h> 65#include <sys/ktrace.h> /* Must come after sys/uio.h */ 66#include <sys/un.h> 67 68#include <netinet/in.h> 69 70#include <compat/svr4/svr4.h> 71#include <compat/svr4/svr4_types.h> 72#include <compat/svr4/svr4_util.h> 73#include <compat/svr4/svr4_signal.h> 74#include <compat/svr4/svr4_proto.h> 75#include <compat/svr4/svr4_stropts.h> 76#include <compat/svr4/svr4_timod.h> 77#include <compat/svr4/svr4_sockmod.h> 78#include <compat/svr4/svr4_ioctl.h> 79#include <compat/svr4/svr4_socket.h> 80 81/* Utils */ 82static int clean_pipe(struct thread *, char *); 83static void getparm(struct file *, struct svr4_si_sockparms *); 84static int svr4_do_putmsg(struct thread *, struct svr4_sys_putmsg_args *, 85 struct file *); 86static int svr4_do_getmsg(struct thread *, struct svr4_sys_getmsg_args *, 87 struct file *); 88 89/* Address Conversions */ 90static void sockaddr_to_netaddr_in(struct svr4_strmcmd *, 91 const struct sockaddr_in *); 92static void sockaddr_to_netaddr_un(struct svr4_strmcmd *, 93 const struct sockaddr_un *); 94static void netaddr_to_sockaddr_in(struct sockaddr_in *, 95 const struct svr4_strmcmd *); 96static void netaddr_to_sockaddr_un(struct sockaddr_un *, 97 const struct svr4_strmcmd *); 98 99/* stream ioctls */ 100static int i_nread(struct file *, struct thread *, register_t *, int, 101 u_long, caddr_t); 102static int i_fdinsert(struct file *, struct thread *, register_t *, int, 103 u_long, caddr_t); 104static int i_str(struct file *, struct thread *, register_t *, int, 105 u_long, caddr_t); 106static int i_setsig(struct file *, struct thread *, register_t *, int, 107 u_long, caddr_t); 108static int i_getsig(struct file *, struct thread *, register_t *, int, 109 u_long, caddr_t); 110static int _i_bind_rsvd(struct file *, struct thread *, register_t *, int, 111 u_long, caddr_t); 112static int _i_rele_rsvd(struct file *, struct thread *, register_t *, int, 113 u_long, caddr_t); 114 115/* i_str sockmod calls */ 116static int sockmod(struct file *, int, struct svr4_strioctl *, 117 struct thread *); 118static int si_listen(struct file *, int, struct svr4_strioctl *, 119 struct thread *); 120static int si_ogetudata(struct file *, int, struct svr4_strioctl *, 121 struct thread *); 122static int si_sockparams(struct file *, int, struct svr4_strioctl *, 123 struct thread *); 124static int si_shutdown (struct file *, int, struct svr4_strioctl *, 125 struct thread *); 126static int si_getudata(struct file *, int, struct svr4_strioctl *, 127 struct thread *); 128 129/* i_str timod calls */ 130static int timod(struct file *, int, struct svr4_strioctl *, struct thread *); 131static int ti_getinfo(struct file *, int, struct svr4_strioctl *, 132 struct thread *); 133static int ti_bind(struct file *, int, struct svr4_strioctl *, struct thread *); 134 135#ifdef DEBUG_SVR4 136static void bufprint(u_char *, size_t); 137static int show_ioc(const char *, struct svr4_strioctl *); 138static int show_strbuf(struct svr4_strbuf *); 139static void show_msg(const char *, int, struct svr4_strbuf *, 140 struct svr4_strbuf *, int); 141 142static void 143bufprint(buf, len) 144 u_char *buf; 145 size_t len; 146{ 147 size_t i; 148 149 uprintf("\n\t"); 150 for (i = 0; i < len; i++) { 151 uprintf("%x ", buf[i]); 152 if (i && (i % 16) == 0) 153 uprintf("\n\t"); 154 } 155} 156 157static int 158show_ioc(str, ioc) 159 const char *str; 160 struct svr4_strioctl *ioc; 161{ 162 u_char *ptr = NULL; 163 int len; 164 int error; 165 166 len = ioc->len; 167 if (len > 1024) 168 len = 1024; 169 170 if (len > 0) { 171 ptr = (u_char *) malloc(len, M_TEMP, M_WAITOK); 172 if ((error = copyin(ioc->buf, ptr, len)) != 0) { 173 free((char *) ptr, M_TEMP); 174 return error; 175 } 176 } 177 178 uprintf("%s cmd = %ld, timeout = %d, len = %d, buf = %p { ", 179 str, ioc->cmd, ioc->timeout, ioc->len, ioc->buf); 180 181 if (ptr != NULL) 182 bufprint(ptr, len); 183 184 uprintf("}\n"); 185 186 if (ptr != NULL) 187 free((char *) ptr, M_TEMP); 188 return 0; 189} 190 191 192static int 193show_strbuf(str) 194 struct svr4_strbuf *str; 195{ 196 int error; 197 u_char *ptr = NULL; 198 int maxlen = str->maxlen; 199 int len = str->len; 200 201 if (maxlen > 8192) 202 maxlen = 8192; 203 204 if (maxlen < 0) 205 maxlen = 0; 206 207 if (len >= maxlen) 208 len = maxlen; 209 210 if (len > 0) { 211 ptr = (u_char *) malloc(len, M_TEMP, M_WAITOK); 212 213 if ((error = copyin(str->buf, ptr, len)) != 0) { 214 free((char *) ptr, M_TEMP); 215 return error; 216 } 217 } 218 219 uprintf(", { %d, %d, %p=[ ", str->maxlen, str->len, str->buf); 220 221 if (ptr) 222 bufprint(ptr, len); 223 224 uprintf("]}"); 225 226 if (ptr) 227 free((char *) ptr, M_TEMP); 228 229 return 0; 230} 231 232 233static void 234show_msg(str, fd, ctl, dat, flags) 235 const char *str; 236 int fd; 237 struct svr4_strbuf *ctl; 238 struct svr4_strbuf *dat; 239 int flags; 240{ 241 struct svr4_strbuf buf; 242 int error; 243 244 uprintf("%s(%d", str, fd); 245 if (ctl != NULL) { 246 if ((error = copyin(ctl, &buf, sizeof(buf))) != 0) 247 return; 248 show_strbuf(&buf); 249 } 250 else 251 uprintf(", NULL"); 252 253 if (dat != NULL) { 254 if ((error = copyin(dat, &buf, sizeof(buf))) != 0) 255 return; 256 show_strbuf(&buf); 257 } 258 else 259 uprintf(", NULL"); 260 261 uprintf(", %x);\n", flags); 262} 263 264#endif /* DEBUG_SVR4 */ 265 266/* 267 * We are faced with an interesting situation. On svr4 unix sockets 268 * are really pipes. But we really have sockets, and we might as 269 * well use them. At the point where svr4 calls TI_BIND, it has 270 * already created a named pipe for the socket using mknod(2). 271 * We need to create a socket with the same name when we bind, 272 * so we need to remove the pipe before, otherwise we'll get address 273 * already in use. So we *carefully* remove the pipe, to avoid 274 * using this as a random file removal tool. We use system calls 275 * to avoid code duplication. 276 */ 277static int 278clean_pipe(td, path) 279 struct thread *td; 280 char *path; 281{ 282 struct stat st; 283 int error; 284 285 error = kern_statat(td, AT_SYMLINK_NOFOLLOW, AT_FDCWD, path, 286 UIO_SYSSPACE, &st, NULL); 287 288 /* 289 * Make sure we are dealing with a mode 0 named pipe. 290 */ 291 if ((st.st_mode & S_IFMT) != S_IFIFO) 292 return (0); 293 294 if ((st.st_mode & ALLPERMS) != 0) 295 return (0); 296 297 error = kern_unlinkat(td, AT_FDCWD, path, UIO_SYSSPACE, 0); 298 if (error) 299 DPRINTF(("clean_pipe: unlink failed %d\n", error)); 300 return (error); 301} 302 303 304static void 305sockaddr_to_netaddr_in(sc, sain) 306 struct svr4_strmcmd *sc; 307 const struct sockaddr_in *sain; 308{ 309 struct svr4_netaddr_in *na; 310 na = SVR4_ADDROF(sc); 311 312 na->family = sain->sin_family; 313 na->port = sain->sin_port; 314 na->addr = sain->sin_addr.s_addr; 315 DPRINTF(("sockaddr_in -> netaddr %d %d %lx\n", na->family, na->port, 316 na->addr)); 317} 318 319 320static void 321sockaddr_to_netaddr_un(sc, saun) 322 struct svr4_strmcmd *sc; 323 const struct sockaddr_un *saun; 324{ 325 struct svr4_netaddr_un *na; 326 char *dst, *edst = ((char *) sc) + sc->offs + sizeof(na->family) + 1 - 327 sizeof(*sc); 328 const char *src; 329 330 na = SVR4_ADDROF(sc); 331 na->family = saun->sun_family; 332 for (src = saun->sun_path, dst = na->path; (*dst++ = *src++) != '\0'; ) 333 if (dst == edst) 334 break; 335 DPRINTF(("sockaddr_un -> netaddr %d %s\n", na->family, na->path)); 336} 337 338 339static void 340netaddr_to_sockaddr_in(sain, sc) 341 struct sockaddr_in *sain; 342 const struct svr4_strmcmd *sc; 343{ 344 const struct svr4_netaddr_in *na; 345 346 347 na = SVR4_C_ADDROF(sc); 348 memset(sain, 0, sizeof(*sain)); 349 sain->sin_len = sizeof(*sain); 350 sain->sin_family = na->family; 351 sain->sin_port = na->port; 352 sain->sin_addr.s_addr = na->addr; 353 DPRINTF(("netaddr -> sockaddr_in %d %d %x\n", sain->sin_family, 354 sain->sin_port, sain->sin_addr.s_addr)); 355} 356 357 358static void 359netaddr_to_sockaddr_un(saun, sc) 360 struct sockaddr_un *saun; 361 const struct svr4_strmcmd *sc; 362{ 363 const struct svr4_netaddr_un *na; 364 char *dst, *edst = &saun->sun_path[sizeof(saun->sun_path) - 1]; 365 const char *src; 366 367 na = SVR4_C_ADDROF(sc); 368 memset(saun, 0, sizeof(*saun)); 369 saun->sun_family = na->family; 370 for (src = na->path, dst = saun->sun_path; (*dst++ = *src++) != '\0'; ) 371 if (dst == edst) 372 break; 373 saun->sun_len = dst - saun->sun_path; 374 DPRINTF(("netaddr -> sockaddr_un %d %s\n", saun->sun_family, 375 saun->sun_path)); 376} 377 378 379static void 380getparm(fp, pa) 381 struct file *fp; 382 struct svr4_si_sockparms *pa; 383{ 384 struct svr4_strm *st; 385 struct socket *so; 386 387 st = svr4_stream_get(fp); 388 if (st == NULL) 389 return; 390 391 so = fp->f_data; 392 393 pa->family = st->s_family; 394 395 switch (so->so_type) { 396 case SOCK_DGRAM: 397 pa->type = SVR4_T_CLTS; 398 pa->protocol = IPPROTO_UDP; 399 DPRINTF(("getparm(dgram)\n")); 400 return; 401 402 case SOCK_STREAM: 403 pa->type = SVR4_T_COTS; /* What about T_COTS_ORD? XXX */ 404 pa->protocol = IPPROTO_IP; 405 DPRINTF(("getparm(stream)\n")); 406 return; 407 408 case SOCK_RAW: 409 pa->type = SVR4_T_CLTS; 410 pa->protocol = IPPROTO_RAW; 411 DPRINTF(("getparm(raw)\n")); 412 return; 413 414 default: 415 pa->type = 0; 416 pa->protocol = 0; 417 DPRINTF(("getparm(type %d?)\n", so->so_type)); 418 return; 419 } 420} 421 422 423static int 424si_ogetudata(fp, fd, ioc, td) 425 struct file *fp; 426 int fd; 427 struct svr4_strioctl *ioc; 428 struct thread *td; 429{ 430 int error; 431 struct svr4_si_oudata ud; 432 struct svr4_si_sockparms pa; 433 434 if (ioc->len != sizeof(ud) && ioc->len != sizeof(ud) - sizeof(int)) { 435 DPRINTF(("SI_OGETUDATA: Wrong size %d != %d\n", 436 sizeof(ud), ioc->len)); 437 return EINVAL; 438 } 439 440 if ((error = copyin(ioc->buf, &ud, sizeof(ud))) != 0) 441 return error; 442 443 getparm(fp, &pa); 444 445 switch (pa.family) { 446 case AF_INET: 447 ud.tidusize = 16384; 448 ud.addrsize = sizeof(struct svr4_sockaddr_in); 449 if (pa.type == SVR4_SOCK_STREAM) 450 ud.etsdusize = 1; 451 else 452 ud.etsdusize = 0; 453 break; 454 455 case AF_LOCAL: 456 ud.tidusize = 65536; 457 ud.addrsize = 128; 458 ud.etsdusize = 128; 459 break; 460 461 default: 462 DPRINTF(("SI_OGETUDATA: Unsupported address family %d\n", 463 pa.family)); 464 return ENOSYS; 465 } 466 467 /* I have no idea what these should be! */ 468 ud.optsize = 128; 469 ud.tsdusize = 128; 470 471 ud.servtype = pa.type; 472 473 /* XXX: Fixme */ 474 ud.so_state = 0; 475 ud.so_options = 0; 476 return copyout(&ud, ioc->buf, ioc->len); 477} 478 479 480static int 481si_sockparams(fp, fd, ioc, td) 482 struct file *fp; 483 int fd; 484 struct svr4_strioctl *ioc; 485 struct thread *td; 486{ 487 struct svr4_si_sockparms pa; 488 489 getparm(fp, &pa); 490 return copyout(&pa, ioc->buf, sizeof(pa)); 491} 492 493 494static int 495si_listen(fp, fd, ioc, td) 496 struct file *fp; 497 int fd; 498 struct svr4_strioctl *ioc; 499 struct thread *td; 500{ 501 int error; 502 struct svr4_strm *st = svr4_stream_get(fp); 503 struct svr4_strmcmd lst; 504 struct listen_args la; 505 506 if (st == NULL) 507 return EINVAL; 508 509 if (ioc->len < 0 || ioc->len > sizeof(lst)) 510 return EINVAL; 511 512 if ((error = copyin(ioc->buf, &lst, ioc->len)) != 0) 513 return error; 514 515 if (lst.cmd != SVR4_TI_OLD_BIND_REQUEST) { 516 DPRINTF(("si_listen: bad request %ld\n", lst.cmd)); 517 return EINVAL; 518 } 519 520 /* 521 * We are making assumptions again... 522 */ 523 la.s = fd; 524 DPRINTF(("SI_LISTEN: fileno %d backlog = %d\n", fd, 5)); 525 la.backlog = 5; 526 527 if ((error = sys_listen(td, &la)) != 0) { 528 DPRINTF(("SI_LISTEN: listen failed %d\n", error)); 529 return error; 530 } 531 532 st->s_cmd = SVR4_TI__ACCEPT_WAIT; 533 lst.cmd = SVR4_TI_BIND_REPLY; 534 535 switch (st->s_family) { 536 case AF_INET: 537 /* XXX: Fill the length here */ 538 break; 539 540 case AF_LOCAL: 541 lst.len = 140; 542 lst.pad[28] = 0x00000000; /* magic again */ 543 lst.pad[29] = 0x00000800; /* magic again */ 544 lst.pad[30] = 0x80001400; /* magic again */ 545 break; 546 547 default: 548 DPRINTF(("SI_LISTEN: Unsupported address family %d\n", 549 st->s_family)); 550 return ENOSYS; 551 } 552 553 554 if ((error = copyout(&lst, ioc->buf, ioc->len)) != 0) 555 return error; 556 557 return 0; 558} 559 560 561static int 562si_getudata(fp, fd, ioc, td) 563 struct file *fp; 564 int fd; 565 struct svr4_strioctl *ioc; 566 struct thread *td; 567{ 568 int error; 569 struct svr4_si_udata ud; 570 571 if (sizeof(ud) != ioc->len) { 572 DPRINTF(("SI_GETUDATA: Wrong size %d != %d\n", 573 sizeof(ud), ioc->len)); 574 return EINVAL; 575 } 576 577 if ((error = copyin(ioc->buf, &ud, sizeof(ud))) != 0) 578 return error; 579 580 getparm(fp, &ud.sockparms); 581 582 switch (ud.sockparms.family) { 583 case AF_INET: 584 DPRINTF(("getudata_inet\n")); 585 ud.tidusize = 16384; 586 ud.tsdusize = 16384; 587 ud.addrsize = sizeof(struct svr4_sockaddr_in); 588 if (ud.sockparms.type == SVR4_SOCK_STREAM) 589 ud.etsdusize = 1; 590 else 591 ud.etsdusize = 0; 592 ud.optsize = 0; 593 break; 594 595 case AF_LOCAL: 596 DPRINTF(("getudata_local\n")); 597 ud.tidusize = 65536; 598 ud.tsdusize = 128; 599 ud.addrsize = 128; 600 ud.etsdusize = 128; 601 ud.optsize = 128; 602 break; 603 604 default: 605 DPRINTF(("SI_GETUDATA: Unsupported address family %d\n", 606 ud.sockparms.family)); 607 return ENOSYS; 608 } 609 610 611 ud.servtype = ud.sockparms.type; 612 DPRINTF(("ud.servtype = %d\n", ud.servtype)); 613 /* XXX: Fixme */ 614 ud.so_state = 0; 615 ud.so_options = 0; 616 return copyout(&ud, ioc->buf, sizeof(ud)); 617} 618 619 620static int 621si_shutdown(fp, fd, ioc, td) 622 struct file *fp; 623 int fd; 624 struct svr4_strioctl *ioc; 625 struct thread *td; 626{ 627 int error; 628 struct shutdown_args ap; 629 630 if (ioc->len != sizeof(ap.how)) { 631 DPRINTF(("SI_SHUTDOWN: Wrong size %d != %d\n", 632 sizeof(ap.how), ioc->len)); 633 return EINVAL; 634 } 635 636 if ((error = copyin(ioc->buf, &ap.how, ioc->len)) != 0) 637 return error; 638 639 ap.s = fd; 640 641 return sys_shutdown(td, &ap); 642} 643 644 645static int 646sockmod(fp, fd, ioc, td) 647 struct file *fp; 648 int fd; 649 struct svr4_strioctl *ioc; 650 struct thread *td; 651{ 652 switch (ioc->cmd) { 653 case SVR4_SI_OGETUDATA: 654 DPRINTF(("SI_OGETUDATA\n")); 655 return si_ogetudata(fp, fd, ioc, td); 656 657 case SVR4_SI_SHUTDOWN: 658 DPRINTF(("SI_SHUTDOWN\n")); 659 return si_shutdown(fp, fd, ioc, td); 660 661 case SVR4_SI_LISTEN: 662 DPRINTF(("SI_LISTEN\n")); 663 return si_listen(fp, fd, ioc, td); 664 665 case SVR4_SI_SETMYNAME: 666 DPRINTF(("SI_SETMYNAME\n")); 667 return 0; 668 669 case SVR4_SI_SETPEERNAME: 670 DPRINTF(("SI_SETPEERNAME\n")); 671 return 0; 672 673 case SVR4_SI_GETINTRANSIT: 674 DPRINTF(("SI_GETINTRANSIT\n")); 675 return 0; 676 677 case SVR4_SI_TCL_LINK: 678 DPRINTF(("SI_TCL_LINK\n")); 679 return 0; 680 681 case SVR4_SI_TCL_UNLINK: 682 DPRINTF(("SI_TCL_UNLINK\n")); 683 return 0; 684 685 case SVR4_SI_SOCKPARAMS: 686 DPRINTF(("SI_SOCKPARAMS\n")); 687 return si_sockparams(fp, fd, ioc, td); 688 689 case SVR4_SI_GETUDATA: 690 DPRINTF(("SI_GETUDATA\n")); 691 return si_getudata(fp, fd, ioc, td); 692 693 default: 694 DPRINTF(("Unknown sockmod ioctl %lx\n", ioc->cmd)); 695 return 0; 696 697 } 698} 699 700 701static int 702ti_getinfo(fp, fd, ioc, td) 703 struct file *fp; 704 int fd; 705 struct svr4_strioctl *ioc; 706 struct thread *td; 707{ 708 int error; 709 struct svr4_infocmd info; 710 711 memset(&info, 0, sizeof(info)); 712 713 if (ioc->len < 0 || ioc->len > sizeof(info)) 714 return EINVAL; 715 716 if ((error = copyin(ioc->buf, &info, ioc->len)) != 0) 717 return error; 718 719 if (info.cmd != SVR4_TI_INFO_REQUEST) 720 return EINVAL; 721 722 info.cmd = SVR4_TI_INFO_REPLY; 723 info.tsdu = 0; 724 info.etsdu = 1; 725 info.cdata = -2; 726 info.ddata = -2; 727 info.addr = 16; 728 info.opt = -1; 729 info.tidu = 16384; 730 info.serv = 2; 731 info.current = 0; 732 info.provider = 2; 733 734 ioc->len = sizeof(info); 735 if ((error = copyout(&info, ioc->buf, ioc->len)) != 0) 736 return error; 737 738 return 0; 739} 740 741 742static int 743ti_bind(fp, fd, ioc, td) 744 struct file *fp; 745 int fd; 746 struct svr4_strioctl *ioc; 747 struct thread *td; 748{ 749 int error; 750 struct svr4_strm *st = svr4_stream_get(fp); 751 struct sockaddr_in sain; 752 struct sockaddr_un saun; 753 struct sockaddr *skp; 754 int sasize; 755 struct svr4_strmcmd bnd; 756 757 if (st == NULL) { 758 DPRINTF(("ti_bind: bad file descriptor\n")); 759 return EINVAL; 760 } 761 762 if (ioc->len < 0 || ioc->len > sizeof(bnd)) 763 return EINVAL; 764 765 if ((error = copyin(ioc->buf, &bnd, ioc->len)) != 0) 766 return error; 767 768 if (bnd.cmd != SVR4_TI_OLD_BIND_REQUEST) { 769 DPRINTF(("ti_bind: bad request %ld\n", bnd.cmd)); 770 return EINVAL; 771 } 772 773 switch (st->s_family) { 774 case AF_INET: 775 skp = (struct sockaddr *)&sain; 776 sasize = sizeof(sain); 777 778 if (bnd.offs == 0) 779 goto error; 780 781 netaddr_to_sockaddr_in(&sain, &bnd); 782 783 DPRINTF(("TI_BIND: fam %d, port %d, addr %x\n", 784 sain.sin_family, sain.sin_port, 785 sain.sin_addr.s_addr)); 786 break; 787 788 case AF_LOCAL: 789 skp = (struct sockaddr *)&saun; 790 sasize = sizeof(saun); 791 if (bnd.offs == 0) 792 goto error; 793 794 netaddr_to_sockaddr_un(&saun, &bnd); 795 796 if (saun.sun_path[0] == '\0') 797 goto error; 798 799 DPRINTF(("TI_BIND: fam %d, path %s\n", 800 saun.sun_family, saun.sun_path)); 801 802 if ((error = clean_pipe(td, saun.sun_path)) != 0) 803 return error; 804 805 bnd.pad[28] = 0x00001000; /* magic again */ 806 break; 807 808 default: 809 DPRINTF(("TI_BIND: Unsupported address family %d\n", 810 st->s_family)); 811 return ENOSYS; 812 } 813 814 DPRINTF(("TI_BIND: fileno %d\n", fd)); 815 816 if ((error = kern_bindat(td, AT_FDCWD, fd, skp)) != 0) { 817 DPRINTF(("TI_BIND: bind failed %d\n", error)); 818 return error; 819 } 820 goto reply; 821 822error: 823 memset(&bnd, 0, sizeof(bnd)); 824 bnd.len = sasize + 4; 825 bnd.offs = 0x10; /* XXX */ 826 827reply: 828 bnd.cmd = SVR4_TI_BIND_REPLY; 829 830 if ((error = copyout(&bnd, ioc->buf, ioc->len)) != 0) 831 return error; 832 833 return 0; 834} 835 836 837static int 838timod(fp, fd, ioc, td) 839 struct file *fp; 840 int fd; 841 struct svr4_strioctl *ioc; 842 struct thread *td; 843{ 844 switch (ioc->cmd) { 845 case SVR4_TI_GETINFO: 846 DPRINTF(("TI_GETINFO\n")); 847 return ti_getinfo(fp, fd, ioc, td); 848 849 case SVR4_TI_OPTMGMT: 850 DPRINTF(("TI_OPTMGMT\n")); 851 return 0; 852 853 case SVR4_TI_BIND: 854 DPRINTF(("TI_BIND\n")); 855 return ti_bind(fp, fd, ioc, td); 856 857 case SVR4_TI_UNBIND: 858 DPRINTF(("TI_UNBIND\n")); 859 return 0; 860 861 default: 862 DPRINTF(("Unknown timod ioctl %lx\n", ioc->cmd)); 863 return 0; 864 } 865} 866 867 868int 869svr4_stream_ti_ioctl(fp, td, retval, fd, cmd, dat) 870 struct file *fp; 871 struct thread *td; 872 register_t *retval; 873 int fd; 874 u_long cmd; 875 caddr_t dat; 876{ 877 struct svr4_strbuf skb, *sub = (struct svr4_strbuf *) dat; 878 struct svr4_strm *st = svr4_stream_get(fp); 879 int error; 880 struct sockaddr *sa; 881 socklen_t sasize, oldsasize; 882 struct svr4_strmcmd sc; 883 884 DPRINTF(("svr4_stream_ti_ioctl\n")); 885 886 if (st == NULL) 887 return EINVAL; 888 889 sc.offs = 0x10; 890 891 if ((error = copyin(sub, &skb, sizeof(skb))) != 0) { 892 DPRINTF(("ti_ioctl: error copying in strbuf\n")); 893 return error; 894 } 895 896 switch (st->s_family) { 897 case AF_INET: 898 sasize = sizeof(struct sockaddr_in); 899 break; 900 901 case AF_LOCAL: 902 sasize = sizeof(struct sockaddr_un); 903 break; 904 905 default: 906 DPRINTF(("ti_ioctl: Unsupported address family %d\n", 907 st->s_family)); 908 return ENOSYS; 909 } 910 oldsasize = sasize; 911 912 switch (cmd) { 913 case SVR4_TI_GETMYNAME: 914 DPRINTF(("TI_GETMYNAME\n")); 915 { 916 error = kern_getsockname(td, fd, &sa, &sasize); 917 if (error) { 918 DPRINTF(("ti_ioctl: getsockname error\n")); 919 return error; 920 } 921 } 922 break; 923 924 case SVR4_TI_GETPEERNAME: 925 DPRINTF(("TI_GETPEERNAME\n")); 926 { 927 error = kern_getpeername(td, fd, &sa, &sasize); 928 if (error) { 929 DPRINTF(("ti_ioctl: getpeername error\n")); 930 return error; 931 } 932 } 933 break; 934 935 case SVR4_TI_SETMYNAME: 936 DPRINTF(("TI_SETMYNAME\n")); 937 return 0; 938 939 case SVR4_TI_SETPEERNAME: 940 DPRINTF(("TI_SETPEERNAME\n")); 941 return 0; 942 default: 943 DPRINTF(("ti_ioctl: Unknown ioctl %lx\n", cmd)); 944 return ENOSYS; 945 } 946 947 if (sasize < 0 || sasize > oldsasize) { 948 free(sa, M_SONAME); 949 return EINVAL; 950 } 951 952 switch (st->s_family) { 953 case AF_INET: 954 sockaddr_to_netaddr_in(&sc, (struct sockaddr_in *)sa); 955 skb.len = sasize; 956 break; 957 958 case AF_LOCAL: 959 sockaddr_to_netaddr_un(&sc, (struct sockaddr_un *)sa); 960 skb.len = sasize + 4; 961 break; 962 963 default: 964 free(sa, M_SONAME); 965 return ENOSYS; 966 } 967 free(sa, M_SONAME); 968 969 if ((error = copyout(SVR4_ADDROF(&sc), skb.buf, sasize)) != 0) { 970 DPRINTF(("ti_ioctl: error copying out socket data\n")); 971 return error; 972 } 973 974 975 if ((error = copyout(&skb, sub, sizeof(skb))) != 0) { 976 DPRINTF(("ti_ioctl: error copying out strbuf\n")); 977 return error; 978 } 979 980 return error; 981} 982 983 984 985 986static int 987i_nread(fp, td, retval, fd, cmd, dat) 988 struct file *fp; 989 struct thread *td; 990 register_t *retval; 991 int fd; 992 u_long cmd; 993 caddr_t dat; 994{ 995 int error; 996 int nread = 0; 997 998 /* 999 * We are supposed to return the message length in nread, and the 1000 * number of messages in retval. We don't have the notion of number 1001 * of stream messages, so we just find out if we have any bytes waiting 1002 * for us, and if we do, then we assume that we have at least one 1003 * message waiting for us. 1004 */ 1005 if ((error = fo_ioctl(fp, FIONREAD, (caddr_t) &nread, td->td_ucred, 1006 td)) != 0) 1007 return error; 1008 1009 if (nread != 0) 1010 *retval = 1; 1011 else 1012 *retval = 0; 1013 1014 return copyout(&nread, dat, sizeof(nread)); 1015} 1016 1017static int 1018i_fdinsert(fp, td, retval, fd, cmd, dat) 1019 struct file *fp; 1020 struct thread *td; 1021 register_t *retval; 1022 int fd; 1023 u_long cmd; 1024 caddr_t dat; 1025{ 1026 /* 1027 * Major hack again here. We assume that we are using this to 1028 * implement accept(2). If that is the case, we have already 1029 * called accept, and we have stored the file descriptor in 1030 * afd. We find the file descriptor that the code wants to use 1031 * in fd insert, and then we dup2() our accepted file descriptor 1032 * to it. 1033 */ 1034 int error; 1035 struct svr4_strm *st = svr4_stream_get(fp); 1036 struct svr4_strfdinsert fdi; 1037 struct dup2_args d2p; 1038 1039 if (st == NULL) { 1040 DPRINTF(("fdinsert: bad file type\n")); 1041 return EINVAL; 1042 } 1043 1044 mtx_lock(&Giant); 1045 if (st->s_afd == -1) { 1046 DPRINTF(("fdinsert: accept fd not found\n")); 1047 mtx_unlock(&Giant); 1048 return ENOENT; 1049 } 1050 1051 if ((error = copyin(dat, &fdi, sizeof(fdi))) != 0) { 1052 DPRINTF(("fdinsert: copyin failed %d\n", error)); 1053 mtx_unlock(&Giant); 1054 return error; 1055 } 1056 1057 d2p.from = st->s_afd; 1058 d2p.to = fdi.fd; 1059 1060 if ((error = sys_dup2(td, &d2p)) != 0) { 1061 DPRINTF(("fdinsert: dup2(%d, %d) failed %d\n", 1062 st->s_afd, fdi.fd, error)); 1063 mtx_unlock(&Giant); 1064 return error; 1065 } 1066 1067 if ((error = kern_close(td, st->s_afd)) != 0) { 1068 DPRINTF(("fdinsert: close(%d) failed %d\n", 1069 st->s_afd, error)); 1070 mtx_unlock(&Giant); 1071 return error; 1072 } 1073 1074 st->s_afd = -1; 1075 mtx_unlock(&Giant); 1076 1077 *retval = 0; 1078 return 0; 1079} 1080 1081 1082static int 1083_i_bind_rsvd(fp, td, retval, fd, cmd, dat) 1084 struct file *fp; 1085 struct thread *td; 1086 register_t *retval; 1087 int fd; 1088 u_long cmd; 1089 caddr_t dat; 1090{ 1091 struct mkfifo_args ap; 1092 1093 /* 1094 * This is a supposed to be a kernel and library only ioctl. 1095 * It gets called before ti_bind, when we have a unix 1096 * socket, to physically create the socket transport and 1097 * ``reserve'' it. I don't know how this get reserved inside 1098 * the kernel, but we are going to create it nevertheless. 1099 */ 1100 ap.path = dat; 1101 ap.mode = S_IFIFO; 1102 1103 return sys_mkfifo(td, &ap); 1104} 1105 1106static int 1107_i_rele_rsvd(fp, td, retval, fd, cmd, dat) 1108 struct file *fp; 1109 struct thread *td; 1110 register_t *retval; 1111 int fd; 1112 u_long cmd; 1113 caddr_t dat; 1114{ 1115 struct unlink_args ap; 1116 1117 /* 1118 * This is a supposed to be a kernel and library only ioctl. 1119 * I guess it is supposed to release the socket. 1120 */ 1121 ap.path = dat; 1122 1123 return sys_unlink(td, &ap); 1124} 1125 1126static int 1127i_str(fp, td, retval, fd, cmd, dat) 1128 struct file *fp; 1129 struct thread *td; 1130 register_t *retval; 1131 int fd; 1132 u_long cmd; 1133 caddr_t dat; 1134{ 1135 int error; 1136 struct svr4_strioctl ioc; 1137 1138 if ((error = copyin(dat, &ioc, sizeof(ioc))) != 0) 1139 return error; 1140 1141#ifdef DEBUG_SVR4 1142 if ((error = show_ioc(">", &ioc)) != 0) 1143 return error; 1144#endif /* DEBUG_SVR4 */ 1145 1146 switch (ioc.cmd & 0xff00) { 1147 case SVR4_SIMOD: 1148 if ((error = sockmod(fp, fd, &ioc, td)) != 0) 1149 return error; 1150 break; 1151 1152 case SVR4_TIMOD: 1153 if ((error = timod(fp, fd, &ioc, td)) != 0) 1154 return error; 1155 break; 1156 1157 default: 1158 DPRINTF(("Unimplemented module %c %ld\n", 1159 (char) (cmd >> 8), cmd & 0xff)); 1160 return 0; 1161 } 1162 1163#ifdef DEBUG_SVR4 1164 if ((error = show_ioc("<", &ioc)) != 0) 1165 return error; 1166#endif /* DEBUG_SVR4 */ 1167 return copyout(&ioc, dat, sizeof(ioc)); 1168} 1169 1170static int 1171i_setsig(fp, td, retval, fd, cmd, dat) 1172 struct file *fp; 1173 struct thread *td; 1174 register_t *retval; 1175 int fd; 1176 u_long cmd; 1177 caddr_t dat; 1178{ 1179 /* 1180 * This is the best we can do for now; we cannot generate 1181 * signals only for specific events so the signal mask gets 1182 * ignored; we save it just to pass it to a possible I_GETSIG... 1183 * 1184 * We alse have to fix the O_ASYNC fcntl bit, so the 1185 * process will get SIGPOLLs. 1186 */ 1187 int error; 1188 register_t oflags, flags; 1189 struct svr4_strm *st = svr4_stream_get(fp); 1190 1191 if (st == NULL) { 1192 DPRINTF(("i_setsig: bad file descriptor\n")); 1193 return EINVAL; 1194 } 1195 /* get old status flags */ 1196 error = kern_fcntl(td, fd, F_GETFL, 0); 1197 if (error) 1198 return (error); 1199 1200 oflags = td->td_retval[0]; 1201 1202 /* update the flags */ 1203 mtx_lock(&Giant); 1204 if (dat != NULL) { 1205 int mask; 1206 1207 flags = oflags | O_ASYNC; 1208 if ((error = copyin(dat, &mask, sizeof(mask))) != 0) { 1209 DPRINTF(("i_setsig: bad eventmask pointer\n")); 1210 return error; 1211 } 1212 if (mask & SVR4_S_ALLMASK) { 1213 DPRINTF(("i_setsig: bad eventmask data %x\n", mask)); 1214 return EINVAL; 1215 } 1216 st->s_eventmask = mask; 1217 } 1218 else { 1219 flags = oflags & ~O_ASYNC; 1220 st->s_eventmask = 0; 1221 } 1222 mtx_unlock(&Giant); 1223 1224 /* set the new flags, if changed */ 1225 if (flags != oflags) { 1226 error = kern_fcntl(td, fd, F_SETFL, flags); 1227 if (error) 1228 return (error); 1229 flags = td->td_retval[0]; 1230 } 1231 1232 /* set up SIGIO receiver if needed */ 1233 if (dat != NULL) 1234 return (kern_fcntl(td, fd, F_SETOWN, td->td_proc->p_pid)); 1235 return 0; 1236} 1237 1238static int 1239i_getsig(fp, td, retval, fd, cmd, dat) 1240 struct file *fp; 1241 struct thread *td; 1242 register_t *retval; 1243 int fd; 1244 u_long cmd; 1245 caddr_t dat; 1246{ 1247 int error, eventmask; 1248 1249 if (dat != NULL) { 1250 struct svr4_strm *st = svr4_stream_get(fp); 1251 1252 if (st == NULL) { 1253 DPRINTF(("i_getsig: bad file descriptor\n")); 1254 return EINVAL; 1255 } 1256 mtx_lock(&Giant); 1257 eventmask = st->s_eventmask; 1258 mtx_unlock(&Giant); 1259 if ((error = copyout(&eventmask, dat, 1260 sizeof(eventmask))) != 0) { 1261 DPRINTF(("i_getsig: bad eventmask pointer\n")); 1262 return error; 1263 } 1264 } 1265 return 0; 1266} 1267 1268int 1269svr4_stream_ioctl(fp, td, retval, fd, cmd, dat) 1270 struct file *fp; 1271 struct thread *td; 1272 register_t *retval; 1273 int fd; 1274 u_long cmd; 1275 caddr_t dat; 1276{ 1277 *retval = 0; 1278 1279 /* 1280 * All the following stuff assumes "sockmod" is pushed... 1281 */ 1282 switch (cmd) { 1283 case SVR4_I_NREAD: 1284 DPRINTF(("I_NREAD\n")); 1285 return i_nread(fp, td, retval, fd, cmd, dat); 1286 1287 case SVR4_I_PUSH: 1288 DPRINTF(("I_PUSH %p\n", dat)); 1289#if defined(DEBUG_SVR4) 1290 show_strbuf((struct svr4_strbuf *)dat); 1291#endif 1292 return 0; 1293 1294 case SVR4_I_POP: 1295 DPRINTF(("I_POP\n")); 1296 return 0; 1297 1298 case SVR4_I_LOOK: 1299 DPRINTF(("I_LOOK\n")); 1300 return 0; 1301 1302 case SVR4_I_FLUSH: 1303 DPRINTF(("I_FLUSH\n")); 1304 return 0; 1305 1306 case SVR4_I_SRDOPT: 1307 DPRINTF(("I_SRDOPT\n")); 1308 return 0; 1309 1310 case SVR4_I_GRDOPT: 1311 DPRINTF(("I_GRDOPT\n")); 1312 return 0; 1313 1314 case SVR4_I_STR: 1315 DPRINTF(("I_STR\n")); 1316 return i_str(fp, td, retval, fd, cmd, dat); 1317 1318 case SVR4_I_SETSIG: 1319 DPRINTF(("I_SETSIG\n")); 1320 return i_setsig(fp, td, retval, fd, cmd, dat); 1321 1322 case SVR4_I_GETSIG: 1323 DPRINTF(("I_GETSIG\n")); 1324 return i_getsig(fp, td, retval, fd, cmd, dat); 1325 1326 case SVR4_I_FIND: 1327 DPRINTF(("I_FIND\n")); 1328 /* 1329 * Here we are not pushing modules really, we just 1330 * pretend all are present 1331 */ 1332 *retval = 0; 1333 return 0; 1334 1335 case SVR4_I_LINK: 1336 DPRINTF(("I_LINK\n")); 1337 return 0; 1338 1339 case SVR4_I_UNLINK: 1340 DPRINTF(("I_UNLINK\n")); 1341 return 0; 1342 1343 case SVR4_I_ERECVFD: 1344 DPRINTF(("I_ERECVFD\n")); 1345 return 0; 1346 1347 case SVR4_I_PEEK: 1348 DPRINTF(("I_PEEK\n")); 1349 return 0; 1350 1351 case SVR4_I_FDINSERT: 1352 DPRINTF(("I_FDINSERT\n")); 1353 return i_fdinsert(fp, td, retval, fd, cmd, dat); 1354 1355 case SVR4_I_SENDFD: 1356 DPRINTF(("I_SENDFD\n")); 1357 return 0; 1358 1359 case SVR4_I_RECVFD: 1360 DPRINTF(("I_RECVFD\n")); 1361 return 0; 1362 1363 case SVR4_I_SWROPT: 1364 DPRINTF(("I_SWROPT\n")); 1365 return 0; 1366 1367 case SVR4_I_GWROPT: 1368 DPRINTF(("I_GWROPT\n")); 1369 return 0; 1370 1371 case SVR4_I_LIST: 1372 DPRINTF(("I_LIST\n")); 1373 return 0; 1374 1375 case SVR4_I_PLINK: 1376 DPRINTF(("I_PLINK\n")); 1377 return 0; 1378 1379 case SVR4_I_PUNLINK: 1380 DPRINTF(("I_PUNLINK\n")); 1381 return 0; 1382 1383 case SVR4_I_SETEV: 1384 DPRINTF(("I_SETEV\n")); 1385 return 0; 1386 1387 case SVR4_I_GETEV: 1388 DPRINTF(("I_GETEV\n")); 1389 return 0; 1390 1391 case SVR4_I_STREV: 1392 DPRINTF(("I_STREV\n")); 1393 return 0; 1394 1395 case SVR4_I_UNSTREV: 1396 DPRINTF(("I_UNSTREV\n")); 1397 return 0; 1398 1399 case SVR4_I_FLUSHBAND: 1400 DPRINTF(("I_FLUSHBAND\n")); 1401 return 0; 1402 1403 case SVR4_I_CKBAND: 1404 DPRINTF(("I_CKBAND\n")); 1405 return 0; 1406 1407 case SVR4_I_GETBAND: 1408 DPRINTF(("I_GETBANK\n")); 1409 return 0; 1410 1411 case SVR4_I_ATMARK: 1412 DPRINTF(("I_ATMARK\n")); 1413 return 0; 1414 1415 case SVR4_I_SETCLTIME: 1416 DPRINTF(("I_SETCLTIME\n")); 1417 return 0; 1418 1419 case SVR4_I_GETCLTIME: 1420 DPRINTF(("I_GETCLTIME\n")); 1421 return 0; 1422 1423 case SVR4_I_CANPUT: 1424 DPRINTF(("I_CANPUT\n")); 1425 return 0; 1426 1427 case SVR4__I_BIND_RSVD: 1428 DPRINTF(("_I_BIND_RSVD\n")); 1429 return _i_bind_rsvd(fp, td, retval, fd, cmd, dat); 1430 1431 case SVR4__I_RELE_RSVD: 1432 DPRINTF(("_I_RELE_RSVD\n")); 1433 return _i_rele_rsvd(fp, td, retval, fd, cmd, dat); 1434 1435 default: 1436 DPRINTF(("unimpl cmd = %lx\n", cmd)); 1437 break; 1438 } 1439 1440 return 0; 1441} 1442 1443 1444 1445int 1446svr4_sys_putmsg(td, uap) 1447 struct thread *td; 1448 struct svr4_sys_putmsg_args *uap; 1449{ 1450 cap_rights_t rights; 1451 struct file *fp; 1452 int error; 1453 1454 error = fget(td, uap->fd, cap_rights_init(&rights, CAP_SEND), &fp); 1455 if (error != 0) { 1456#ifdef DEBUG_SVR4 1457 uprintf("putmsg: bad fp\n"); 1458#endif 1459 return EBADF; 1460 } 1461 error = svr4_do_putmsg(td, uap, fp); 1462 fdrop(fp, td); 1463 return (error); 1464} 1465 1466static int 1467svr4_do_putmsg(td, uap, fp) 1468 struct thread *td; 1469 struct svr4_sys_putmsg_args *uap; 1470 struct file *fp; 1471{ 1472 struct svr4_strbuf dat, ctl; 1473 struct svr4_strmcmd sc; 1474 struct sockaddr_in sain; 1475 struct sockaddr_un saun; 1476 struct sockaddr *sa; 1477 int sasize, *retval; 1478 struct svr4_strm *st; 1479 int error; 1480 1481 retval = td->td_retval; 1482 1483#ifdef DEBUG_SVR4 1484 show_msg(">putmsg", uap->fd, uap->ctl, 1485 uap->dat, uap->flags); 1486#endif /* DEBUG_SVR4 */ 1487 1488 if (uap->ctl != NULL) { 1489 if ((error = copyin(uap->ctl, &ctl, sizeof(ctl))) != 0) { 1490#ifdef DEBUG_SVR4 1491 uprintf("putmsg: copyin(): %d\n", error); 1492#endif 1493 return error; 1494 } 1495 } 1496 else 1497 ctl.len = -1; 1498 1499 if (uap->dat != NULL) { 1500 if ((error = copyin(uap->dat, &dat, sizeof(dat))) != 0) { 1501#ifdef DEBUG_SVR4 1502 uprintf("putmsg: copyin(): %d (2)\n", error); 1503#endif 1504 return error; 1505 } 1506 } 1507 else 1508 dat.len = -1; 1509 1510 /* 1511 * Only for sockets for now. 1512 */ 1513 if ((st = svr4_stream_get(fp)) == NULL) { 1514 DPRINTF(("putmsg: bad file type\n")); 1515 return EINVAL; 1516 } 1517 1518 if (ctl.len < 0 || ctl.len > sizeof(sc)) { 1519 DPRINTF(("putmsg: Bad control size %d != %d\n", ctl.len, 1520 sizeof(struct svr4_strmcmd))); 1521 return EINVAL; 1522 } 1523 1524 if ((error = copyin(ctl.buf, &sc, ctl.len)) != 0) 1525 return error; 1526 1527 switch (st->s_family) { 1528 case AF_INET: 1529 if (sc.len != sizeof(sain)) { 1530 if (sc.cmd == SVR4_TI_DATA_REQUEST) { 1531 struct write_args wa; 1532 1533 /* Solaris seems to use sc.cmd = 3 to 1534 * send "expedited" data. telnet uses 1535 * this for options processing, sending EOF, 1536 * etc. I'm sure other things use it too. 1537 * I don't have any documentation 1538 * on it, so I'm making a guess that this 1539 * is how it works. newton@atdot.dotat.org XXX 1540 */ 1541 DPRINTF(("sending expedited data ??\n")); 1542 wa.fd = uap->fd; 1543 wa.buf = dat.buf; 1544 wa.nbyte = dat.len; 1545 return sys_write(td, &wa); 1546 } 1547 DPRINTF(("putmsg: Invalid inet length %ld\n", sc.len)); 1548 return EINVAL; 1549 } 1550 netaddr_to_sockaddr_in(&sain, &sc); 1551 sa = (struct sockaddr *)&sain; 1552 sasize = sizeof(sain); 1553 if (sain.sin_family != st->s_family) 1554 error = EINVAL; 1555 break; 1556 1557 case AF_LOCAL: 1558 if (ctl.len == 8) { 1559 /* We are doing an accept; succeed */ 1560 DPRINTF(("putmsg: Do nothing\n")); 1561 *retval = 0; 1562 return 0; 1563 } 1564 else { 1565 /* Maybe we've been given a device/inode pair */ 1566 dev_t *dev = SVR4_ADDROF(&sc); 1567 ino_t *ino = (ino_t *) &dev[1]; 1568 if (svr4_find_socket(td, fp, *dev, *ino, &saun) != 0) { 1569 /* I guess we have it by name */ 1570 netaddr_to_sockaddr_un(&saun, &sc); 1571 } 1572 sa = (struct sockaddr *)&saun; 1573 sasize = sizeof(saun); 1574 } 1575 break; 1576 1577 default: 1578 DPRINTF(("putmsg: Unsupported address family %d\n", 1579 st->s_family)); 1580 return ENOSYS; 1581 } 1582 1583 mtx_lock(&Giant); 1584 st->s_cmd = sc.cmd; 1585 mtx_unlock(&Giant); 1586 switch (sc.cmd) { 1587 case SVR4_TI_CONNECT_REQUEST: /* connect */ 1588 { 1589 1590 return (kern_connectat(td, AT_FDCWD, uap->fd, sa)); 1591 } 1592 1593 case SVR4_TI_SENDTO_REQUEST: /* sendto */ 1594 { 1595 struct msghdr msg; 1596 struct iovec aiov; 1597 1598 msg.msg_name = sa; 1599 msg.msg_namelen = sasize; 1600 msg.msg_iov = &aiov; 1601 msg.msg_iovlen = 1; 1602 msg.msg_control = 0; 1603 msg.msg_flags = 0; 1604 aiov.iov_base = dat.buf; 1605 aiov.iov_len = dat.len; 1606 error = kern_sendit(td, uap->fd, &msg, uap->flags, 1607 NULL, UIO_USERSPACE); 1608 DPRINTF(("sendto_request error: %d\n", error)); 1609 *retval = 0; 1610 return error; 1611 } 1612 1613 default: 1614 DPRINTF(("putmsg: Unimplemented command %lx\n", sc.cmd)); 1615 return ENOSYS; 1616 } 1617} 1618 1619int 1620svr4_sys_getmsg(td, uap) 1621 struct thread *td; 1622 struct svr4_sys_getmsg_args *uap; 1623{ 1624 cap_rights_t rights; 1625 struct file *fp; 1626 int error; 1627 1628 error = fget(td, uap->fd, cap_rights_init(&rights, CAP_RECV), &fp); 1629 if (error != 0) { 1630#ifdef DEBUG_SVR4 1631 uprintf("getmsg: bad fp\n"); 1632#endif 1633 return EBADF; 1634 } 1635 error = svr4_do_getmsg(td, uap, fp); 1636 fdrop(fp, td); 1637 return (error); 1638} 1639 1640int 1641svr4_do_getmsg(td, uap, fp) 1642 struct thread *td; 1643 struct svr4_sys_getmsg_args *uap; 1644 struct file *fp; 1645{ 1646 struct svr4_strbuf dat, ctl; 1647 struct svr4_strmcmd sc; 1648 int error, *retval; 1649 struct msghdr msg; 1650 struct iovec aiov; 1651 struct sockaddr_in sain; 1652 struct sockaddr_un saun; 1653 struct sockaddr *sa; 1654 socklen_t sasize; 1655 struct svr4_strm *st; 1656 struct file *afp; 1657 int fl; 1658 1659 retval = td->td_retval; 1660 error = 0; 1661 afp = NULL; 1662 1663 memset(&sc, 0, sizeof(sc)); 1664 1665#ifdef DEBUG_SVR4 1666 show_msg(">getmsg", uap->fd, uap->ctl, 1667 uap->dat, 0); 1668#endif /* DEBUG_SVR4 */ 1669 1670 if (uap->ctl != NULL) { 1671 if ((error = copyin(uap->ctl, &ctl, sizeof(ctl))) != 0) 1672 return error; 1673 if (ctl.len < 0) 1674 return EINVAL; 1675 } 1676 else { 1677 ctl.len = -1; 1678 ctl.maxlen = 0; 1679 } 1680 1681 if (uap->dat != NULL) { 1682 if ((error = copyin(uap->dat, &dat, sizeof(dat))) != 0) 1683 return error; 1684 } 1685 else { 1686 dat.len = -1; 1687 dat.maxlen = 0; 1688 } 1689 1690 /* 1691 * Only for sockets for now. 1692 */ 1693 if ((st = svr4_stream_get(fp)) == NULL) { 1694 DPRINTF(("getmsg: bad file type\n")); 1695 return EINVAL; 1696 } 1697 1698 if (ctl.maxlen == -1 || dat.maxlen == -1) { 1699 DPRINTF(("getmsg: Cannot handle -1 maxlen (yet)\n")); 1700 return ENOSYS; 1701 } 1702 1703 switch (st->s_family) { 1704 case AF_INET: 1705 sasize = sizeof(sain); 1706 break; 1707 1708 case AF_LOCAL: 1709 sasize = sizeof(saun); 1710 break; 1711 1712 default: 1713 DPRINTF(("getmsg: Unsupported address family %d\n", 1714 st->s_family)); 1715 return ENOSYS; 1716 } 1717 1718 mtx_lock(&Giant); 1719 switch (st->s_cmd) { 1720 case SVR4_TI_CONNECT_REQUEST: 1721 DPRINTF(("getmsg: TI_CONNECT_REQUEST\n")); 1722 /* 1723 * We do the connect in one step, so the putmsg should 1724 * have gotten the error. 1725 */ 1726 sc.cmd = SVR4_TI_OK_REPLY; 1727 sc.len = 0; 1728 1729 ctl.len = 8; 1730 dat.len = -1; 1731 fl = 1; 1732 st->s_cmd = sc.cmd; 1733 break; 1734 1735 case SVR4_TI_OK_REPLY: 1736 DPRINTF(("getmsg: TI_OK_REPLY\n")); 1737 /* 1738 * We are immediately after a connect reply, so we send 1739 * a connect verification. 1740 */ 1741 1742 error = kern_getpeername(td, uap->fd, &sa, &sasize); 1743 if (error) { 1744 mtx_unlock(&Giant); 1745 DPRINTF(("getmsg: getpeername failed %d\n", error)); 1746 return error; 1747 } 1748 1749 sc.cmd = SVR4_TI_CONNECT_REPLY; 1750 sc.pad[0] = 0x4; 1751 sc.offs = 0x18; 1752 sc.pad[1] = 0x14; 1753 sc.pad[2] = 0x04000402; 1754 1755 switch (st->s_family) { 1756 case AF_INET: 1757 sc.len = sasize; 1758 sockaddr_to_netaddr_in(&sc, (struct sockaddr_in *)sa); 1759 break; 1760 1761 case AF_LOCAL: 1762 sc.len = sasize + 4; 1763 sockaddr_to_netaddr_un(&sc, (struct sockaddr_un *)sa); 1764 break; 1765 1766 default: 1767 mtx_unlock(&Giant); 1768 free(sa, M_SONAME); 1769 return ENOSYS; 1770 } 1771 free(sa, M_SONAME); 1772 1773 ctl.len = 40; 1774 dat.len = -1; 1775 fl = 0; 1776 st->s_cmd = sc.cmd; 1777 break; 1778 1779 case SVR4_TI__ACCEPT_OK: 1780 DPRINTF(("getmsg: TI__ACCEPT_OK\n")); 1781 /* 1782 * We do the connect in one step, so the putmsg should 1783 * have gotten the error. 1784 */ 1785 sc.cmd = SVR4_TI_OK_REPLY; 1786 sc.len = 1; 1787 1788 ctl.len = 8; 1789 dat.len = -1; 1790 fl = 1; 1791 st->s_cmd = SVR4_TI__ACCEPT_WAIT; 1792 break; 1793 1794 case SVR4_TI__ACCEPT_WAIT: 1795 DPRINTF(("getmsg: TI__ACCEPT_WAIT\n")); 1796 /* 1797 * We are after a listen, so we try to accept... 1798 */ 1799 1800 error = kern_accept(td, uap->fd, &sa, &sasize, &afp); 1801 if (error) { 1802 mtx_unlock(&Giant); 1803 DPRINTF(("getmsg: accept failed %d\n", error)); 1804 return error; 1805 } 1806 1807 st->s_afd = *retval; 1808 1809 DPRINTF(("getmsg: Accept fd = %d\n", st->s_afd)); 1810 1811 sc.cmd = SVR4_TI_ACCEPT_REPLY; 1812 sc.offs = 0x18; 1813 sc.pad[0] = 0x0; 1814 1815 switch (st->s_family) { 1816 case AF_INET: 1817 sc.pad[1] = 0x28; 1818 sockaddr_to_netaddr_in(&sc, (struct sockaddr_in *)&sa); 1819 ctl.len = 40; 1820 sc.len = sasize; 1821 break; 1822 1823 case AF_LOCAL: 1824 sc.pad[1] = 0x00010000; 1825 sc.pad[2] = 0xf6bcdaa0; /* I don't know what that is */ 1826 sc.pad[3] = 0x00010000; 1827 ctl.len = 134; 1828 sc.len = sasize + 4; 1829 break; 1830 1831 default: 1832 fdclose(td, afp, st->s_afd); 1833 fdrop(afp, td); 1834 st->s_afd = -1; 1835 mtx_unlock(&Giant); 1836 free(sa, M_SONAME); 1837 return ENOSYS; 1838 } 1839 free(sa, M_SONAME); 1840 1841 dat.len = -1; 1842 fl = 0; 1843 st->s_cmd = SVR4_TI__ACCEPT_OK; 1844 break; 1845 1846 case SVR4_TI_SENDTO_REQUEST: 1847 DPRINTF(("getmsg: TI_SENDTO_REQUEST\n")); 1848 if (ctl.maxlen > 36 && ctl.len < 36) 1849 ctl.len = 36; 1850 1851 if (ctl.len > sizeof(sc)) 1852 ctl.len = sizeof(sc); 1853 1854 if ((error = copyin(ctl.buf, &sc, ctl.len)) != 0) { 1855 mtx_unlock(&Giant); 1856 return error; 1857 } 1858 1859 switch (st->s_family) { 1860 case AF_INET: 1861 sa = (struct sockaddr *)&sain; 1862 sockaddr_to_netaddr_in(&sc, &sain); 1863 break; 1864 1865 case AF_LOCAL: 1866 sa = (struct sockaddr *)&saun; 1867 sockaddr_to_netaddr_un(&sc, &saun); 1868 break; 1869 1870 default: 1871 mtx_unlock(&Giant); 1872 return ENOSYS; 1873 } 1874 1875 msg.msg_name = sa; 1876 msg.msg_namelen = sasize; 1877 msg.msg_iov = &aiov; 1878 msg.msg_iovlen = 1; 1879 msg.msg_control = 0; 1880 aiov.iov_base = dat.buf; 1881 aiov.iov_len = dat.maxlen; 1882 msg.msg_flags = 0; 1883 1884 error = kern_recvit(td, uap->fd, &msg, UIO_SYSSPACE, NULL); 1885 1886 if (error) { 1887 mtx_unlock(&Giant); 1888 DPRINTF(("getmsg: recvit failed %d\n", error)); 1889 return error; 1890 } 1891 1892 sc.cmd = SVR4_TI_RECVFROM_IND; 1893 1894 switch (st->s_family) { 1895 case AF_INET: 1896 sc.len = sasize; 1897 sockaddr_to_netaddr_in(&sc, &sain); 1898 break; 1899 1900 case AF_LOCAL: 1901 sc.len = sasize + 4; 1902 sockaddr_to_netaddr_un(&sc, &saun); 1903 break; 1904 1905 default: 1906 mtx_unlock(&Giant); 1907 return ENOSYS; 1908 } 1909 1910 dat.len = *retval; 1911 fl = 0; 1912 st->s_cmd = sc.cmd; 1913 break; 1914 1915 default: 1916 st->s_cmd = sc.cmd; 1917 if (st->s_cmd == SVR4_TI_CONNECT_REQUEST) { 1918 struct read_args ra; 1919 1920 /* More weirdness: Again, I can't find documentation 1921 * to back this up, but when a process does a generic 1922 * "getmsg()" call it seems that the command field is 1923 * zero and the length of the data area is zero. I 1924 * think processes expect getmsg() to fill in dat.len 1925 * after reading at most dat.maxlen octets from the 1926 * stream. Since we're using sockets I can let 1927 * read() look after it and frob return values 1928 * appropriately (or inappropriately :-) 1929 * -- newton@atdot.dotat.org XXX 1930 */ 1931 ra.fd = uap->fd; 1932 ra.buf = dat.buf; 1933 ra.nbyte = dat.maxlen; 1934 if ((error = sys_read(td, &ra)) != 0) { 1935 mtx_unlock(&Giant); 1936 return error; 1937 } 1938 dat.len = *retval; 1939 *retval = 0; 1940 st->s_cmd = SVR4_TI_SENDTO_REQUEST; 1941 break; 1942 } 1943 mtx_unlock(&Giant); 1944 DPRINTF(("getmsg: Unknown state %x\n", st->s_cmd)); 1945 return EINVAL; 1946 } 1947 1948 if (uap->ctl) { 1949 if (ctl.len > sizeof(sc)) 1950 ctl.len = sizeof(sc); 1951 if (ctl.len != -1) 1952 error = copyout(&sc, ctl.buf, ctl.len); 1953 1954 if (error == 0) 1955 error = copyout(&ctl, uap->ctl, sizeof(ctl)); 1956 } 1957 1958 if (uap->dat) { 1959 if (error == 0) 1960 error = copyout(&dat, uap->dat, sizeof(dat)); 1961 } 1962 1963 if (uap->flags) { /* XXX: Need translation */ 1964 if (error == 0) 1965 error = copyout(&fl, uap->flags, sizeof(fl)); 1966 } 1967 1968 if (error) { 1969 if (afp) { 1970 fdclose(td, afp, st->s_afd); 1971 fdrop(afp, td); 1972 st->s_afd = -1; 1973 } 1974 mtx_unlock(&Giant); 1975 return (error); 1976 } 1977 mtx_unlock(&Giant); 1978 if (afp) 1979 fdrop(afp, td); 1980 1981 *retval = 0; 1982 1983#ifdef DEBUG_SVR4 1984 show_msg("<getmsg", uap->fd, uap->ctl, 1985 uap->dat, fl); 1986#endif /* DEBUG_SVR4 */ 1987 return error; 1988} 1989 1990int svr4_sys_send(td, uap) 1991 struct thread *td; 1992 struct svr4_sys_send_args *uap; 1993{ 1994 struct sendto_args sta; 1995 1996 sta.s = uap->s; 1997 sta.buf = uap->buf; 1998 sta.len = uap->len; 1999 sta.flags = uap->flags; 2000 sta.to = NULL; 2001 sta.tolen = 0; 2002 2003 return (sys_sendto(td, &sta)); 2004} 2005 2006int svr4_sys_recv(td, uap) 2007 struct thread *td; 2008 struct svr4_sys_recv_args *uap; 2009{ 2010 struct recvfrom_args rfa; 2011 2012 rfa.s = uap->s; 2013 rfa.buf = uap->buf; 2014 rfa.len = uap->len; 2015 rfa.flags = uap->flags; 2016 rfa.from = NULL; 2017 rfa.fromlenaddr = NULL; 2018 2019 return (sys_recvfrom(td, &rfa)); 2020} 2021 2022/* 2023 * XXX This isn't necessary, but it's handy for inserting debug code into 2024 * sendto(). Let's leave it here for now... 2025 */ 2026int 2027svr4_sys_sendto(td, uap) 2028 struct thread *td; 2029 struct svr4_sys_sendto_args *uap; 2030{ 2031 struct sendto_args sa; 2032 2033 sa.s = uap->s; 2034 sa.buf = uap->buf; 2035 sa.len = uap->len; 2036 sa.flags = uap->flags; 2037 sa.to = (caddr_t)uap->to; 2038 sa.tolen = uap->tolen; 2039 2040 DPRINTF(("calling sendto()\n")); 2041 return sys_sendto(td, &sa); 2042} 2043 2044