linux_socketcall.c revision 1.7
1 /* $NetBSD: linux_socketcall.c,v 1.7 1995/05/28 10:20:46 mycroft Exp $ */ 2 3 /* 4 * Copyright (c) 1995 Frank van der Linden 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. All advertising materials mentioning features or use of this software 16 * must display the following acknowledgement: 17 * This product includes software developed for the NetBSD Project 18 * by Frank van der Linden 19 * 4. The name of the author may not be used to endorse or promote products 20 * derived from this software without specific prior written permission 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 23 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 24 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 25 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 26 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 27 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 31 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 32 */ 33 34 #include <sys/param.h> 35 #include <sys/kernel.h> 36 #include <sys/systm.h> 37 #include <sys/buf.h> 38 #include <sys/malloc.h> 39 #include <sys/ioctl.h> 40 #include <sys/tty.h> 41 #include <sys/file.h> 42 #include <sys/filedesc.h> 43 #include <sys/select.h> 44 #include <sys/socket.h> 45 #include <sys/socketvar.h> 46 #include <net/if.h> 47 #include <netinet/in.h> 48 #include <netinet/tcp.h> 49 #include <sys/mount.h> 50 #include <sys/proc.h> 51 #include <sys/vnode.h> 52 #include <sys/device.h> 53 54 #include <sys/syscallargs.h> 55 56 #include <compat/linux/linux_types.h> 57 #include <compat/linux/linux_util.h> 58 #include <compat/linux/linux_syscallargs.h> 59 #include <compat/linux/linux_ioctl.h> 60 #include <compat/linux/linux_socket.h> 61 #include <compat/linux/linux_socketcall.h> 62 #include <compat/linux/linux_sockio.h> 63 64 /* 65 * All the calls in this file are entered via one common system 66 * call in Linux, represented here by linux_socketcall() 67 * Arguments for the various calls are on the user stack. A pointer 68 * to them is the only thing that is passed. It is up to the various 69 * calls to copy them in themselves. To make it look better, they 70 * are copied to structures. 71 */ 72 73 /* 74 * Convert between Linux and BSD socket domain values 75 */ 76 int 77 linux_to_bsd_domain(ldom) 78 int ldom; 79 { 80 switch (ldom) { 81 case LINUX_AF_UNSPEC: 82 return AF_UNSPEC; 83 case LINUX_AF_UNIX: 84 return AF_LOCAL; 85 case LINUX_AF_INET: 86 return AF_INET; 87 case LINUX_AF_AX25: 88 return AF_CCITT; 89 case LINUX_AF_IPX: 90 return AF_IPX; 91 case LINUX_AF_APPLETALK: 92 return AF_APPLETALK; 93 default: 94 return -1; 95 } 96 } 97 98 int 99 linux_socket(p, args, retval) 100 struct proc *p; 101 struct linux_socket_args /* { 102 syscallarg(int) domain; 103 syscallarg(int) type; 104 syscallarg(int) protocol; 105 } */ *args; 106 register_t *retval; 107 { 108 struct linux_socket_args lsa; 109 struct socket_args bsa; 110 int error; 111 112 if ((error = copyin((caddr_t) args, (caddr_t) &lsa, sizeof lsa))) 113 return error; 114 115 SCARG(&bsa, protocol) = lsa.protocol; 116 SCARG(&bsa, type) = lsa.type; 117 SCARG(&bsa, domain) = linux_to_bsd_domain(lsa.domain); 118 if (SCARG(&bsa, domain) == -1) 119 return EINVAL; 120 return socket(p, &bsa, retval); 121 } 122 123 int 124 linux_bind(p, args, retval) 125 struct proc *p; 126 struct linux_bind_args /* { 127 syscallarg(int) s; 128 syscallarg(struct sockaddr *) name; 129 syscallarg(int) namelen; 130 } */ *args; 131 register_t *retval; 132 { 133 struct linux_bind_args lba; 134 struct bind_args bba; 135 int error; 136 137 if ((error = copyin((caddr_t) args, (caddr_t) &lba, sizeof lba))) 138 return error; 139 140 SCARG(&bba, s) = lba.s; 141 SCARG(&bba, name) = (caddr_t) lba.name; 142 SCARG(&bba, namelen) = lba.namelen; 143 144 return bind(p, &bba, retval); 145 } 146 147 int 148 linux_connect(p, args, retval) 149 struct proc *p; 150 struct linux_connect_args /* { 151 syscallarg(int) s; 152 syscallarg(struct sockaddr *) name; 153 syscallarg(int) namelen; 154 } */ *args; 155 register_t *retval; 156 { 157 struct linux_connect_args lca; 158 struct connect_args bca; 159 int error; 160 161 if ((error = copyin((caddr_t) args, (caddr_t) &lca, sizeof lca))) 162 return error; 163 164 SCARG(&bca, s) = lca.s; 165 SCARG(&bca, name) = (caddr_t) lca.name; 166 SCARG(&bca, namelen) = lca.namelen; 167 168 return connect(p, &bca, retval); 169 } 170 171 int 172 linux_listen(p, args, retval) 173 struct proc *p; 174 struct linux_listen_args /* { 175 syscallarg(int) s; 176 syscallarg(int) backlog; 177 } */ *args; 178 register *retval; 179 { 180 struct linux_listen_args lla; 181 struct listen_args bla; 182 int error; 183 184 if ((error = copyin((caddr_t) args, (caddr_t) &lla, sizeof lla))) 185 return error; 186 187 SCARG(&bla, s) = lla.s; 188 SCARG(&bla, backlog) = lla.backlog; 189 190 return listen(p, &bla, retval); 191 } 192 193 int 194 linux_accept(p, args, retval) 195 struct proc *p; 196 struct linux_accept_args /* { 197 syscallarg(int) s; 198 syscallarg(struct sockaddr *) addr; 199 syscallarg(int *) namelen; 200 } */ *args; 201 register_t *retval; 202 { 203 struct linux_accept_args laa; 204 struct compat_43_accept_args baa; 205 int error; 206 207 if ((error = copyin((caddr_t) args, (caddr_t) &laa, sizeof laa))) 208 return error; 209 210 SCARG(&baa, s) = laa.s; 211 SCARG(&baa, name) = (caddr_t) laa.addr; 212 SCARG(&baa, anamelen) = laa.namelen; 213 214 return compat_43_accept(p, &baa, retval); 215 } 216 217 int 218 linux_getsockname(p, args, retval) 219 struct proc *p; 220 struct linux_getsockname_args /* { 221 syscallarg(int) s; 222 syscallarg(struct sockaddr *) addr; 223 syscallarg(int *) namelen; 224 } */ *args; 225 register_t *retval; 226 { 227 struct linux_getsockname_args lga; 228 struct compat_43_getsockname_args bga; 229 int error; 230 231 if ((error = copyin((caddr_t) args, (caddr_t) &lga, sizeof lga))) 232 return error; 233 234 SCARG(&bga, fdec) = lga.s; 235 SCARG(&bga, asa) = (caddr_t) lga.addr; 236 SCARG(&bga, alen) = lga.namelen; 237 238 return compat_43_getsockname(p, &bga, retval); 239 } 240 241 int 242 linux_getpeername(p, args, retval) 243 struct proc *p; 244 struct linux_getpeername_args /* { 245 syscallarg(int) s; 246 syscallarg(struct sockaddr *) addr; 247 syscallarg(int *) namelen; 248 } */ *args; 249 register_t *retval; 250 { 251 struct linux_getpeername_args lga; 252 struct compat_43_getpeername_args bga; 253 int error; 254 255 if ((error = copyin((caddr_t) args, (caddr_t) &lga, sizeof lga))) 256 return error; 257 258 SCARG(&bga, fdes) = lga.s; 259 SCARG(&bga, asa) = (caddr_t) lga.addr; 260 SCARG(&bga, alen) = lga.namelen; 261 262 return compat_43_getpeername(p, &bga, retval); 263 } 264 265 int 266 linux_socketpair(p, args, retval) 267 struct proc *p; 268 struct linux_socketpair_args /* { 269 syscallarg(int) domain; 270 syscallarg(int) type; 271 syscallarg(int) protocol; 272 syscallarg(int *) rsv; 273 } */ *args; 274 register_t *retval; 275 { 276 struct linux_socketpair_args lsa; 277 struct socketpair_args bsa; 278 int error; 279 280 if ((error = copyin((caddr_t) args, &lsa, sizeof lsa))) 281 return error; 282 283 SCARG(&bsa, domain) = linux_to_bsd_domain(lsa.domain); 284 if (SCARG(&bsa, domain) == -1) 285 return EINVAL; 286 SCARG(&bsa, type) = lsa.type; 287 SCARG(&bsa, protocol) = lsa.protocol; 288 SCARG(&bsa, rsv) = lsa.rsv; 289 290 return socketpair(p, &bsa, retval); 291 } 292 293 int 294 linux_send(p, args, retval) 295 struct proc *p; 296 struct linux_send_args /* { 297 syscallarg(int) s; 298 syscallarg(void *) msg; 299 syscallarg(int) len; 300 syscallarg(int) flags; 301 } */ *args; 302 register_t *retval; 303 { 304 struct linux_send_args lsa; 305 struct compat_43_send_args bsa; 306 int error; 307 308 if ((error = copyin((caddr_t) args, (caddr_t) &lsa, sizeof lsa))) 309 return error; 310 311 SCARG(&bsa, s) = lsa.s; 312 SCARG(&bsa, buf) = lsa.msg; 313 SCARG(&bsa, len) = lsa.len; 314 SCARG(&bsa, flags) = lsa.flags; 315 316 return compat_43_send(p, &bsa, retval); 317 } 318 319 int 320 linux_recv(p, args, retval) 321 struct proc *p; 322 struct linux_recv_args *args; 323 register_t *retval; 324 { 325 struct linux_recv_args lra; 326 struct compat_43_recv_args bra; 327 int error; 328 329 if ((error = copyin((caddr_t) args, (caddr_t) &lra, sizeof lra))) 330 return error; 331 332 SCARG(&bra, s) = lra.s; 333 SCARG(&bra, buf) = lra.msg; 334 SCARG(&bra, len) = lra.len; 335 SCARG(&bra, flags) = lra.flags; 336 337 return compat_43_recv(p, &bra, retval); 338 } 339 340 int 341 linux_sendto(p, args, retval) 342 struct proc *p; 343 struct linux_sendto_args /* { 344 syscallarg(int) s; 345 syscallarg(void *) msg; 346 syscallarg(int) len; 347 syscallarg(int) flags; 348 syscallarg(sockaddr *) to; 349 syscallarg(int) tolen; 350 } */ *args; 351 register_t *retval; 352 { 353 struct linux_sendto_args lsa; 354 struct sendto_args bsa; 355 int error; 356 357 if ((error = copyin((caddr_t) args, (caddr_t) &lsa, sizeof lsa))) 358 return error; 359 360 SCARG(&bsa, s) = lsa.s; 361 SCARG(&bsa, buf) = lsa.msg; 362 SCARG(&bsa, len) = lsa.len; 363 SCARG(&bsa, flags) = lsa.flags; 364 SCARG(&bsa, to) = (caddr_t) lsa.to; 365 SCARG(&bsa, tolen) = lsa.tolen; 366 367 return sendto(p, &bsa, retval); 368 } 369 370 int 371 linux_recvfrom(p, args, retval) 372 struct proc *p; 373 struct linux_recvfrom_args /* { 374 syscallarg(int) s; 375 syscallarg(void *) buf; 376 syscallarg(int) len; 377 syscallarg(int) flags; 378 syscallarg(struct sockaddr *) from; 379 syscallarg(int *) fromlen; 380 } */ *args; 381 { 382 struct linux_recvfrom_args lra; 383 struct compat_43_recvfrom_args bra; 384 int error; 385 386 if ((error = copyin((caddr_t) args, (caddr_t) &lra, sizeof lra))) 387 return error; 388 389 SCARG(&bra, s) = lra.s; 390 SCARG(&bra, buf) = lra.buf; 391 SCARG(&bra, len) = lra.len; 392 SCARG(&bra, flags) = lra.flags; 393 SCARG(&bra, from) = (caddr_t) lra.from; 394 SCARG(&bra, fromlenaddr) = lra.fromlen; 395 396 return compat_43_recvfrom(p, &bra, retval); 397 } 398 399 int 400 linux_shutdown(p, args, retval) 401 struct proc *p; 402 struct linux_shutdown_args /* { 403 syscallarg(int) s; 404 syscallarg(int) how; 405 } */ *args; 406 register_t *retval; 407 { 408 struct linux_shutdown_args lsa; 409 struct shutdown_args bsa; 410 int error; 411 412 if ((error = copyin((caddr_t) args, (caddr_t) &lsa, sizeof lsa))) 413 return error; 414 415 SCARG(&bsa, s) = lsa.s; 416 SCARG(&bsa, how) = lsa.how; 417 418 return shutdown(p, &bsa, retval); 419 } 420 421 /* 422 * Convert socket option level from Linux to NetBSD value. Only SOL_SOCKET 423 * is different, the rest matches IPPROTO_* on both systems. 424 */ 425 int 426 linux_to_bsd_sopt_level(llevel) 427 int llevel; 428 { 429 switch (llevel) { 430 case LINUX_SOL_SOCKET: 431 return SOL_SOCKET; 432 case LINUX_SOL_IP: 433 return IPPROTO_IP; 434 case LINUX_SOL_TCP: 435 return IPPROTO_TCP; 436 case LINUX_SOL_UDP: 437 return IPPROTO_UDP; 438 default: 439 return -1; 440 } 441 } 442 443 /* 444 * Convert Linux socket level socket option numbers to NetBSD values. 445 */ 446 int 447 linux_to_bsd_so_sockopt(lopt) 448 int lopt; 449 { 450 switch (lopt) { 451 case LINUX_SO_DEBUG: 452 return SO_DEBUG; 453 case LINUX_SO_REUSEADDR: 454 return SO_REUSEADDR; 455 case LINUX_SO_TYPE: 456 return SO_TYPE; 457 case LINUX_SO_ERROR: 458 return SO_ERROR; 459 case LINUX_SO_DONTROUTE: 460 return SO_DONTROUTE; 461 case LINUX_SO_BROADCAST: 462 return SO_BROADCAST; 463 case LINUX_SO_SNDBUF: 464 return SO_SNDBUF; 465 case LINUX_SO_RCVBUF: 466 return SO_RCVBUF; 467 case LINUX_SO_KEEPALIVE: 468 return SO_KEEPALIVE; 469 case LINUX_SO_OOBINLINE: 470 return SO_OOBINLINE; 471 case LINUX_SO_LINGER: 472 return SO_LINGER; 473 case LINUX_SO_PRIORITY: 474 case LINUX_SO_NO_CHECK: 475 default: 476 return -1; 477 } 478 } 479 480 /* 481 * Convert Linux IP level socket option number to NetBSD values. 482 */ 483 int 484 linux_to_bsd_ip_sockopt(lopt) 485 int lopt; 486 { 487 switch (lopt) { 488 case LINUX_IP_TOS: 489 return IP_TOS; 490 case LINUX_IP_TTL: 491 return IP_TTL; 492 case LINUX_IP_MULTICAST_TTL: 493 return IP_MULTICAST_TTL; 494 case LINUX_IP_MULTICAST_LOOP: 495 return IP_MULTICAST_LOOP; 496 case LINUX_IP_MULTICAST_IF: 497 return IP_MULTICAST_IF; 498 case LINUX_IP_ADD_MEMBERSHIP: 499 return IP_ADD_MEMBERSHIP; 500 case LINUX_IP_DROP_MEMBERSHIP: 501 return IP_DROP_MEMBERSHIP; 502 default: 503 return -1; 504 } 505 } 506 507 /* 508 * Convert Linux TCP level socket option number to NetBSD values. 509 */ 510 int 511 linux_to_bsd_tcp_sockopt(lopt) 512 int lopt; 513 { 514 switch (lopt) { 515 case LINUX_TCP_NODELAY: 516 return TCP_NODELAY; 517 case LINUX_TCP_MAXSEG: 518 return TCP_MAXSEG; 519 default: 520 return -1; 521 } 522 } 523 524 /* 525 * Convert Linux UDP level socket option number to NetBSD values. 526 */ 527 int 528 linux_to_bsd_udp_sockopt(lopt) 529 int lopt; 530 { 531 switch (lopt) { 532 default: 533 return -1; 534 } 535 } 536 537 /* 538 * Another reasonably straightforward function: setsockopt(2). 539 * The level and option numbers are converted; the values passed 540 * are not (yet) converted, the ones currently implemented don't 541 * need conversion, as they are the same on both systems. 542 */ 543 int 544 linux_setsockopt(p, args, retval) 545 struct proc *p; 546 struct linux_setsockopt_args /* { 547 syscallarg(int) s; 548 syscallarg(int) level; 549 syscallarg(int) optname; 550 syscallarg(void *) optval; 551 syscallarg(int) optlen; 552 } */ *args; 553 register_t *retval; 554 { 555 struct linux_setsockopt_args lsa; 556 struct setsockopt_args bsa; 557 int error, name; 558 559 if ((error = copyin((caddr_t) args, (caddr_t) &lsa, sizeof lsa))) 560 return error; 561 562 SCARG(&bsa, s) = lsa.s; 563 SCARG(&bsa, level) = linux_to_bsd_sopt_level(lsa.level); 564 SCARG(&bsa, val) = lsa.optval; 565 SCARG(&bsa, valsize) = lsa.optlen; 566 567 switch (SCARG(&bsa, level)) { 568 case SOL_SOCKET: 569 name = linux_to_bsd_so_sockopt(lsa.optname); 570 break; 571 case IPPROTO_IP: 572 name = linux_to_bsd_ip_sockopt(lsa.optname); 573 break; 574 case IPPROTO_TCP: 575 name = linux_to_bsd_tcp_sockopt(lsa.optname); 576 break; 577 case IPPROTO_UDP: 578 name = linux_to_bsd_udp_sockopt(lsa.optname); 579 break; 580 default: 581 return EINVAL; 582 } 583 584 if (name == -1) 585 return EINVAL; 586 SCARG(&bsa, name) = name; 587 588 return setsockopt(p, &bsa, retval); 589 } 590 591 /* 592 * getsockopt(2) is very much the same as setsockopt(2) (see above) 593 */ 594 int 595 linux_getsockopt(p, args, retval) 596 struct proc *p; 597 struct linux_getsockopt_args /* { 598 syscallarg(int) s; 599 syscallarg(int) level; 600 syscallarg(int) optname; 601 syscallarg(void *) optval; 602 syscallarg(int) *optlen; 603 } */ *args; 604 register_t *retval; 605 { 606 struct linux_getsockopt_args lga; 607 struct getsockopt_args bga; 608 int error, name; 609 610 if ((error = copyin((caddr_t) args, (caddr_t) &lga, sizeof lga))) 611 return error; 612 613 SCARG(&bga, s) = lga.s; 614 SCARG(&bga, level) = linux_to_bsd_sopt_level(lga.level); 615 SCARG(&bga, val) = lga.optval; 616 SCARG(&bga, avalsize) = lga.optlen; 617 618 switch (SCARG(&bga, level)) { 619 case SOL_SOCKET: 620 name = linux_to_bsd_so_sockopt(lga.optname); 621 break; 622 case IPPROTO_IP: 623 name = linux_to_bsd_ip_sockopt(lga.optname); 624 break; 625 case IPPROTO_TCP: 626 name = linux_to_bsd_tcp_sockopt(lga.optname); 627 break; 628 case IPPROTO_UDP: 629 name = linux_to_bsd_udp_sockopt(lga.optname); 630 break; 631 default: 632 return EINVAL; 633 } 634 635 if (name == -1) 636 return EINVAL; 637 SCARG(&bga, name) = name; 638 639 return getsockopt(p, &bga, retval); 640 } 641 642 /* 643 * Entry point to all Linux socket calls. Just check which call to 644 * make and take appropriate action. 645 */ 646 int 647 linux_socketcall(p, uap, retval) 648 struct proc *p; 649 struct linux_socketcall_args /* { 650 syscallarg(int) what; 651 syscallarg(void *) args; 652 } */ *uap; 653 register_t *retval; 654 { 655 switch (SCARG(uap, what)) { 656 case LINUX_SYS_socket: 657 return linux_socket(p, SCARG(uap, args), retval); 658 case LINUX_SYS_bind: 659 return linux_bind(p, SCARG(uap, args), retval); 660 case LINUX_SYS_connect: 661 return linux_connect(p, SCARG(uap, args), retval); 662 case LINUX_SYS_listen: 663 return linux_listen(p, SCARG(uap, args), retval); 664 case LINUX_SYS_accept: 665 return linux_accept(p, SCARG(uap, args), retval); 666 case LINUX_SYS_getsockname: 667 return linux_getsockname(p, SCARG(uap, args), retval); 668 case LINUX_SYS_getpeername: 669 return linux_getpeername(p, SCARG(uap, args), retval); 670 case LINUX_SYS_socketpair: 671 return linux_socketpair(p, SCARG(uap, args), retval); 672 case LINUX_SYS_send: 673 return linux_send(p, SCARG(uap, args), retval); 674 case LINUX_SYS_recv: 675 return linux_recv(p, SCARG(uap, args), retval); 676 case LINUX_SYS_sendto: 677 return linux_sendto(p, SCARG(uap, args), retval); 678 case LINUX_SYS_recvfrom: 679 return linux_recvfrom(p, SCARG(uap, args), retval); 680 case LINUX_SYS_shutdown: 681 return linux_shutdown(p, SCARG(uap, args), retval); 682 case LINUX_SYS_setsockopt: 683 return linux_setsockopt(p, SCARG(uap, args), retval); 684 case LINUX_SYS_getsockopt: 685 return linux_getsockopt(p, SCARG(uap, args), retval); 686 default: 687 return ENOSYS; 688 } 689 } 690
Indexes created Wed Sep 24 05:09:52 GMT 2025