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