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