net.c revision bce0cc6a2d103e1da4c15a4c5396fdc5676294f7
1/* 2 * Copyright (c) 1991, 1992 Paul Kranenburg <pk@cs.few.eur.nl> 3 * Copyright (c) 1993 Branko Lankester <branko@hacktic.nl> 4 * Copyright (c) 1993, 1994, 1995, 1996 Rick Sladkey <jrs@world.std.com> 5 * Copyright (c) 1996-2000 Wichert Akkerman <wichert@cistron.nl> 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 3. 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#include "defs.h" 32#include <sys/stat.h> 33#include <sys/socket.h> 34#include <sys/un.h> 35#if defined(HAVE_SIN6_SCOPE_ID_LINUX) 36# define in6_addr in6_addr_libc 37# define ipv6_mreq ipv6_mreq_libc 38# define sockaddr_in6 sockaddr_in6_libc 39#endif 40#include <netinet/in.h> 41#ifdef HAVE_NETINET_TCP_H 42# include <netinet/tcp.h> 43#endif 44#ifdef HAVE_NETINET_UDP_H 45# include <netinet/udp.h> 46#endif 47#ifdef HAVE_NETINET_SCTP_H 48# include <netinet/sctp.h> 49#endif 50#include <arpa/inet.h> 51#include <net/if.h> 52#include <asm/types.h> 53#if defined(__GLIBC__) 54# include <netipx/ipx.h> 55#else 56# include <linux/ipx.h> 57#endif 58 59#if defined(__GLIBC__) && defined(HAVE_SIN6_SCOPE_ID_LINUX) 60# if defined(HAVE_LINUX_IN6_H) 61# if defined(HAVE_SIN6_SCOPE_ID_LINUX) 62# undef in6_addr 63# undef ipv6_mreq 64# undef sockaddr_in6 65# define in6_addr in6_addr_kernel 66# define ipv6_mreq ipv6_mreq_kernel 67# define sockaddr_in6 sockaddr_in6_kernel 68# endif 69# include <linux/in6.h> 70# if defined(HAVE_SIN6_SCOPE_ID_LINUX) 71# undef in6_addr 72# undef ipv6_mreq 73# undef sockaddr_in6 74# define in6_addr in6_addr_libc 75# define ipv6_mreq ipv6_mreq_libc 76# define sockaddr_in6 sockaddr_in6_kernel 77# endif 78# endif 79#endif 80 81#if defined(HAVE_SYS_UIO_H) 82# include <sys/uio.h> 83#endif 84#if defined(HAVE_LINUX_NETLINK_H) 85# include <linux/netlink.h> 86#endif 87#if defined(HAVE_LINUX_IF_PACKET_H) 88# include <linux/if_packet.h> 89#endif 90#if defined(HAVE_LINUX_ICMP_H) 91# include <linux/icmp.h> 92#endif 93#ifndef PF_UNSPEC 94# define PF_UNSPEC AF_UNSPEC 95#endif 96 97static const struct xlat domains[] = { 98#ifdef PF_UNSPEC 99 XLAT(PF_UNSPEC), 100#endif 101#ifdef PF_LOCAL 102 XLAT(PF_LOCAL), 103#endif 104#ifdef PF_UNIX 105 XLAT(PF_UNIX), 106#endif 107#ifdef PF_INET 108 XLAT(PF_INET), 109#endif 110#ifdef PF_AX25 111 XLAT(PF_AX25), 112#endif 113#ifdef PF_IPX 114 XLAT(PF_IPX), 115#endif 116#ifdef PF_APPLETALK 117 XLAT(PF_APPLETALK), 118#endif 119#ifdef PF_NETROM 120 XLAT(PF_NETROM), 121#endif 122#ifdef PF_BRIDGE 123 XLAT(PF_BRIDGE), 124#endif 125#ifdef PF_ATMPVC 126 XLAT(PF_ATMPVC), 127#endif 128#ifdef PF_X25 129 XLAT(PF_X25), 130#endif 131#ifdef PF_INET6 132 XLAT(PF_INET6), 133#endif 134#ifdef PF_ROSE 135 XLAT(PF_ROSE), 136#endif 137#ifdef PF_DECnet 138 XLAT(PF_DECnet), 139#endif 140#ifdef PF_NETBEUI 141 XLAT(PF_NETBEUI), 142#endif 143#ifdef PF_SECURITY 144 XLAT(PF_SECURITY), 145#endif 146#ifdef PF_KEY 147 XLAT(PF_KEY), 148#endif 149#ifdef PF_NETLINK 150 XLAT(PF_NETLINK), 151#endif 152#ifdef PF_ROUTE 153 XLAT(PF_ROUTE), 154#endif 155#ifdef PF_PACKET 156 XLAT(PF_PACKET), 157#endif 158#ifdef PF_ASH 159 XLAT(PF_ASH), 160#endif 161#ifdef PF_ECONET 162 XLAT(PF_ECONET), 163#endif 164#ifdef PF_ATMSVC 165 XLAT(PF_ATMSVC), 166#endif 167#ifdef PF_RDS 168 XLAT(PF_RDS), 169#endif 170#ifdef PF_SNA 171 XLAT(PF_SNA), 172#endif 173#ifdef PF_IRDA 174 XLAT(PF_IRDA), 175#endif 176#ifdef PF_PPPOX 177 XLAT(PF_PPPOX), 178#endif 179#ifdef PF_WANPIPE 180 XLAT(PF_WANPIPE), 181#endif 182#ifdef PF_LLC 183 XLAT(PF_LLC), 184#endif 185#ifdef PF_CAN 186 XLAT(PF_CAN), 187#endif 188#ifdef PF_TIPC 189 XLAT(PF_TIPC), 190#endif 191#ifdef PF_BLUETOOTH 192 XLAT(PF_BLUETOOTH), 193#endif 194#ifdef PF_IUCV 195 XLAT(PF_IUCV), 196#endif 197#ifdef PF_RXRPC 198 XLAT(PF_RXRPC), 199#endif 200#ifdef PF_ISDN 201 XLAT(PF_ISDN), 202#endif 203#ifdef PF_PHONET 204 XLAT(PF_PHONET), 205#endif 206#ifdef PF_IEEE802154 207 XLAT(PF_IEEE802154), 208#endif 209#ifdef PF_CAIF 210 XLAT(PF_CAIF), 211#endif 212#ifdef PF_ALG 213 XLAT(PF_ALG), 214#endif 215#ifdef PF_NFC 216 XLAT(PF_NFC), 217#endif 218#ifdef PF_VSOCK 219 XLAT(PF_VSOCK), 220#endif 221 { 0, NULL }, 222}; 223const struct xlat addrfams[] = { 224#ifdef AF_UNSPEC 225 XLAT(AF_UNSPEC), 226#endif 227#ifdef AF_LOCAL 228 XLAT(AF_LOCAL), 229#endif 230#ifdef AF_UNIX 231 XLAT(AF_UNIX), 232#endif 233#ifdef AF_INET 234 XLAT(AF_INET), 235#endif 236#ifdef AF_AX25 237 XLAT(AF_AX25), 238#endif 239#ifdef AF_IPX 240 XLAT(AF_IPX), 241#endif 242#ifdef AF_APPLETALK 243 XLAT(AF_APPLETALK), 244#endif 245#ifdef AF_NETROM 246 XLAT(AF_NETROM), 247#endif 248#ifdef AF_BRIDGE 249 XLAT(AF_BRIDGE), 250#endif 251#ifdef AF_ATMPVC 252 XLAT(AF_ATMPVC), 253#endif 254#ifdef AF_X25 255 XLAT(AF_X25), 256#endif 257#ifdef AF_INET6 258 XLAT(AF_INET6), 259#endif 260#ifdef AF_ROSE 261 XLAT(AF_ROSE), 262#endif 263#ifdef AF_DECnet 264 XLAT(AF_DECnet), 265#endif 266#ifdef AF_NETBEUI 267 XLAT(AF_NETBEUI), 268#endif 269#ifdef AF_SECURITY 270 XLAT(AF_SECURITY), 271#endif 272#ifdef AF_KEY 273 XLAT(AF_KEY), 274#endif 275#ifdef AF_NETLINK 276 XLAT(AF_NETLINK), 277#endif 278#ifdef AF_ROUTE 279 XLAT(AF_ROUTE), 280#endif 281#ifdef AF_PACKET 282 XLAT(AF_PACKET), 283#endif 284#ifdef AF_ASH 285 XLAT(AF_ASH), 286#endif 287#ifdef AF_ECONET 288 XLAT(AF_ECONET), 289#endif 290#ifdef AF_ATMSVC 291 XLAT(AF_ATMSVC), 292#endif 293#ifdef AF_RDS 294 XLAT(AF_RDS), 295#endif 296#ifdef AF_SNA 297 XLAT(AF_SNA), 298#endif 299#ifdef AF_IRDA 300 XLAT(AF_IRDA), 301#endif 302#ifdef AF_PPPOX 303 XLAT(AF_PPPOX), 304#endif 305#ifdef AF_WANPIPE 306 XLAT(AF_WANPIPE), 307#endif 308#ifdef AF_LLC 309 XLAT(AF_LLC), 310#endif 311#ifdef AF_CAN 312 XLAT(AF_CAN), 313#endif 314#ifdef AF_TIPC 315 XLAT(AF_TIPC), 316#endif 317#ifdef AF_BLUETOOTH 318 XLAT(AF_BLUETOOTH), 319#endif 320#ifdef AF_IUCV 321 XLAT(AF_IUCV), 322#endif 323#ifdef AF_RXRPC 324 XLAT(AF_RXRPC), 325#endif 326#ifdef AF_ISDN 327 XLAT(AF_ISDN), 328#endif 329#ifdef AF_PHONET 330 XLAT(AF_PHONET), 331#endif 332#ifdef AF_IEEE802154 333 XLAT(AF_IEEE802154), 334#endif 335#ifdef AF_CAIF 336 XLAT(AF_CAIF), 337#endif 338#ifdef AF_ALG 339 XLAT(AF_ALG), 340#endif 341#ifdef AF_NFC 342 XLAT(AF_NFC), 343#endif 344#ifdef AF_VSOCK 345 XLAT(AF_VSOCK), 346#endif 347 { 0, NULL }, 348}; 349static const struct xlat socktypes[] = { 350 XLAT(SOCK_STREAM), 351 XLAT(SOCK_DGRAM), 352#ifdef SOCK_RAW 353 XLAT(SOCK_RAW), 354#endif 355#ifdef SOCK_RDM 356 XLAT(SOCK_RDM), 357#endif 358#ifdef SOCK_SEQPACKET 359 XLAT(SOCK_SEQPACKET), 360#endif 361#ifdef SOCK_DCCP 362 XLAT(SOCK_DCCP), 363#endif 364#ifdef SOCK_PACKET 365 XLAT(SOCK_PACKET), 366#endif 367 { 0, NULL }, 368}; 369static const struct xlat sock_type_flags[] = { 370#ifdef SOCK_CLOEXEC 371 XLAT(SOCK_CLOEXEC), 372#endif 373#ifdef SOCK_NONBLOCK 374 XLAT(SOCK_NONBLOCK), 375#endif 376 { 0, NULL }, 377}; 378#ifndef SOCK_TYPE_MASK 379# define SOCK_TYPE_MASK 0xf 380#endif 381static const struct xlat socketlayers[] = { 382#if defined(SOL_IP) 383 XLAT(SOL_IP), 384#endif 385#if defined(SOL_ICMP) 386 XLAT(SOL_ICMP), 387#endif 388#if defined(SOL_TCP) 389 XLAT(SOL_TCP), 390#endif 391#if defined(SOL_UDP) 392 XLAT(SOL_UDP), 393#endif 394#if defined(SOL_IPV6) 395 XLAT(SOL_IPV6), 396#endif 397#if defined(SOL_ICMPV6) 398 XLAT(SOL_ICMPV6), 399#endif 400#if defined(SOL_SCTP) 401 XLAT(SOL_SCTP), 402#endif 403#if defined(SOL_UDPLITE) 404 XLAT(SOL_UDPLITE), 405#endif 406#if defined(SOL_RAW) 407 XLAT(SOL_RAW), 408#endif 409#if defined(SOL_IPX) 410 XLAT(SOL_IPX), 411#endif 412#if defined(SOL_AX25) 413 XLAT(SOL_AX25), 414#endif 415#if defined(SOL_ATALK) 416 XLAT(SOL_ATALK), 417#endif 418#if defined(SOL_NETROM) 419 XLAT(SOL_NETROM), 420#endif 421#if defined(SOL_ROSE) 422 XLAT(SOL_ROSE), 423#endif 424#if defined(SOL_DECNET) 425 XLAT(SOL_DECNET), 426#endif 427#if defined(SOL_X25) 428 XLAT(SOL_X25), 429#endif 430#if defined(SOL_PACKET) 431 XLAT(SOL_PACKET), 432#endif 433#if defined(SOL_ATM) 434 XLAT(SOL_ATM), 435#endif 436#if defined(SOL_AAL) 437 XLAT(SOL_AAL), 438#endif 439#if defined(SOL_IRDA) 440 XLAT(SOL_IRDA), 441#endif 442#if defined(SOL_NETBEUI) 443 XLAT(SOL_NETBEUI), 444#endif 445#if defined(SOL_LLC) 446 XLAT(SOL_LLC), 447#endif 448#if defined(SOL_DCCP) 449 XLAT(SOL_DCCP), 450#endif 451#if defined(SOL_NETLINK) 452 XLAT(SOL_NETLINK), 453#endif 454#if defined(SOL_TIPC) 455 XLAT(SOL_TIPC), 456#endif 457#if defined(SOL_RXRPC) 458 XLAT(SOL_RXRPC), 459#endif 460#if defined(SOL_PPPOL2TP) 461 XLAT(SOL_PPPOL2TP), 462#endif 463#if defined(SOL_BLUETOOTH) 464 XLAT(SOL_BLUETOOTH), 465#endif 466#if defined(SOL_PNPIPE) 467 XLAT(SOL_PNPIPE), 468#endif 469#if defined(SOL_RDS) 470 XLAT(SOL_RDS), 471#endif 472#if defined(SOL_IUVC) 473 XLAT(SOL_IUCV), 474#endif 475#if defined(SOL_CAIF) 476 XLAT(SOL_CAIF), 477#endif 478 XLAT(SOL_SOCKET), /* Never used! */ 479 /* The SOL_* array should remain not NULL-terminated. */ 480}; 481/*** WARNING: DANGER WILL ROBINSON: NOTE "socketlayers" array above 482 falls into "protocols" array below!!!! This is intended!!! ***/ 483static const struct xlat protocols[] = { 484 XLAT(IPPROTO_IP), 485 XLAT(IPPROTO_ICMP), 486 XLAT(IPPROTO_TCP), 487 XLAT(IPPROTO_UDP), 488#ifdef IPPROTO_IGMP 489 XLAT(IPPROTO_IGMP), 490#endif 491#ifdef IPPROTO_GGP 492 XLAT(IPPROTO_GGP), 493#endif 494#ifdef IPPROTO_IPIP 495 XLAT(IPPROTO_IPIP), 496#endif 497#ifdef IPPROTO_EGP 498 XLAT(IPPROTO_EGP), 499#endif 500#ifdef IPPROTO_PUP 501 XLAT(IPPROTO_PUP), 502#endif 503#ifdef IPPROTO_IDP 504 XLAT(IPPROTO_IDP), 505#endif 506#ifdef IPPROTO_TP 507 XLAT(IPPROTO_TP), 508#endif 509#ifdef IPPROTO_DCCP 510 XLAT(IPPROTO_DCCP), 511#endif 512#ifdef IPPROTO_IPV6 513 XLAT(IPPROTO_IPV6), 514#endif 515#ifdef IPPROTO_ROUTING 516 XLAT(IPPROTO_ROUTING), 517#endif 518#ifdef IPPROTO_FRAGMENT 519 XLAT(IPPROTO_FRAGMENT), 520#endif 521#ifdef IPPROTO_RSVP 522 XLAT(IPPROTO_RSVP), 523#endif 524#ifdef IPPROTO_GRE 525 XLAT(IPPROTO_GRE), 526#endif 527#ifdef IPPROTO_ESP 528 XLAT(IPPROTO_ESP), 529#endif 530#ifdef IPPROTO_AH 531 XLAT(IPPROTO_AH), 532#endif 533#ifdef IPPROTO_ICMPV6 534 XLAT(IPPROTO_ICMPV6), 535#endif 536#ifdef IPPROTO_NONE 537 XLAT(IPPROTO_NONE), 538#endif 539#ifdef IPPROTO_DSTOPTS 540 XLAT(IPPROTO_DSTOPTS), 541#endif 542#ifdef IPPROTO_HELLO 543 XLAT(IPPROTO_HELLO), 544#endif 545#ifdef IPPROTO_ND 546 XLAT(IPPROTO_ND), 547#endif 548#ifdef IPPROTO_MTP 549 XLAT(IPPROTO_MTP), 550#endif 551#ifdef IPPROTO_ENCAP 552 XLAT(IPPROTO_ENCAP), 553#endif 554#ifdef IPPROTO_PIM 555 XLAT(IPPROTO_PIM), 556#endif 557#ifdef IPPROTO_COMP 558 XLAT(IPPROTO_COMP), 559#endif 560#ifdef IPPROTO_SCTP 561 XLAT(IPPROTO_SCTP), 562#endif 563#ifdef IPPROTO_UDPLITE 564 XLAT(IPPROTO_UDPLITE), 565#endif 566#ifdef IPPROTO_RAW 567 XLAT(IPPROTO_RAW), 568#endif 569#ifdef IPPROTO_MAX 570 XLAT(IPPROTO_MAX), 571#endif 572 { 0, NULL }, 573}; 574static const struct xlat msg_flags[] = { 575 XLAT(MSG_OOB), 576#ifdef MSG_PEEK 577 XLAT(MSG_PEEK), 578#endif 579#ifdef MSG_DONTROUTE 580 XLAT(MSG_DONTROUTE), 581#endif 582#ifdef MSG_CTRUNC 583 XLAT(MSG_CTRUNC), 584#endif 585#ifdef MSG_PROBE 586 XLAT(MSG_PROBE), 587#endif 588#ifdef MSG_TRUNC 589 XLAT(MSG_TRUNC), 590#endif 591#ifdef MSG_DONTWAIT 592 XLAT(MSG_DONTWAIT), 593#endif 594#ifdef MSG_EOR 595 XLAT(MSG_EOR), 596#endif 597#ifdef MSG_WAITALL 598 XLAT(MSG_WAITALL), 599#endif 600#ifdef MSG_FIN 601 XLAT(MSG_FIN), 602#endif 603#ifdef MSG_SYN 604 XLAT(MSG_SYN), 605#endif 606#ifdef MSG_CONFIRM 607 XLAT(MSG_CONFIRM), 608#endif 609#ifdef MSG_RST 610 XLAT(MSG_RST), 611#endif 612#ifdef MSG_ERRQUEUE 613 XLAT(MSG_ERRQUEUE), 614#endif 615#ifdef MSG_NOSIGNAL 616 XLAT(MSG_NOSIGNAL), 617#endif 618#ifdef MSG_MORE 619 XLAT(MSG_MORE), 620#endif 621#ifdef MSG_WAITFORONE 622 XLAT(MSG_WAITFORONE), 623#endif 624#ifdef MSG_EOF 625 XLAT(MSG_EOF), 626#endif 627#ifdef MSG_FASTOPEN 628 XLAT(MSG_FASTOPEN), 629#endif 630#ifdef MSG_CMSG_CLOEXEC 631 XLAT(MSG_CMSG_CLOEXEC), 632#endif 633 { 0, NULL }, 634}; 635 636static const struct xlat sockoptions[] = { 637#ifdef SO_ACCEPTCONN 638 XLAT(SO_ACCEPTCONN), 639#endif 640#ifdef SO_ALLRAW 641 XLAT(SO_ALLRAW), 642#endif 643#ifdef SO_ATTACH_FILTER 644 XLAT(SO_ATTACH_FILTER), 645#endif 646#ifdef SO_BINDTODEVICE 647 XLAT(SO_BINDTODEVICE), 648#endif 649#ifdef SO_BROADCAST 650 XLAT(SO_BROADCAST), 651#endif 652#ifdef SO_BSDCOMPAT 653 XLAT(SO_BSDCOMPAT), 654#endif 655#ifdef SO_DEBUG 656 XLAT(SO_DEBUG), 657#endif 658#ifdef SO_DETACH_FILTER 659 XLAT(SO_DETACH_FILTER), 660#endif 661#ifdef SO_DONTROUTE 662 XLAT(SO_DONTROUTE), 663#endif 664#ifdef SO_ERROR 665 XLAT(SO_ERROR), 666#endif 667#ifdef SO_ICS 668 XLAT(SO_ICS), 669#endif 670#ifdef SO_IMASOCKET 671 XLAT(SO_IMASOCKET), 672#endif 673#ifdef SO_KEEPALIVE 674 XLAT(SO_KEEPALIVE), 675#endif 676#ifdef SO_LINGER 677 XLAT(SO_LINGER), 678#endif 679#ifdef SO_LISTENING 680 XLAT(SO_LISTENING), 681#endif 682#ifdef SO_MGMT 683 XLAT(SO_MGMT), 684#endif 685#ifdef SO_NO_CHECK 686 XLAT(SO_NO_CHECK), 687#endif 688#ifdef SO_OOBINLINE 689 XLAT(SO_OOBINLINE), 690#endif 691#ifdef SO_ORDREL 692 XLAT(SO_ORDREL), 693#endif 694#ifdef SO_PARALLELSVR 695 XLAT(SO_PARALLELSVR), 696#endif 697#ifdef SO_PASSCRED 698 XLAT(SO_PASSCRED), 699#endif 700#ifdef SO_PEERCRED 701 XLAT(SO_PEERCRED), 702#endif 703#ifdef SO_PEERNAME 704 XLAT(SO_PEERNAME), 705#endif 706#ifdef SO_PEERSEC 707 XLAT(SO_PEERSEC), 708#endif 709#ifdef SO_PRIORITY 710 XLAT(SO_PRIORITY), 711#endif 712#ifdef SO_PROTOTYPE 713 XLAT(SO_PROTOTYPE), 714#endif 715#ifdef SO_RCVBUF 716 XLAT(SO_RCVBUF), 717#endif 718#ifdef SO_RCVLOWAT 719 XLAT(SO_RCVLOWAT), 720#endif 721#ifdef SO_RCVTIMEO 722 XLAT(SO_RCVTIMEO), 723#endif 724#ifdef SO_RDWR 725 XLAT(SO_RDWR), 726#endif 727#ifdef SO_REUSEADDR 728 XLAT(SO_REUSEADDR), 729#endif 730#ifdef SO_REUSEPORT 731 XLAT(SO_REUSEPORT), 732#endif 733#ifdef SO_SECURITY_AUTHENTICATION 734 XLAT(SO_SECURITY_AUTHENTICATION), 735#endif 736#ifdef SO_SECURITY_ENCRYPTION_NETWORK 737 XLAT(SO_SECURITY_ENCRYPTION_NETWORK), 738#endif 739#ifdef SO_SECURITY_ENCRYPTION_TRANSPORT 740 XLAT(SO_SECURITY_ENCRYPTION_TRANSPORT), 741#endif 742#ifdef SO_SEMA 743 XLAT(SO_SEMA), 744#endif 745#ifdef SO_SNDBUF 746 XLAT(SO_SNDBUF), 747#endif 748#ifdef SO_SNDLOWAT 749 XLAT(SO_SNDLOWAT), 750#endif 751#ifdef SO_SNDTIMEO 752 XLAT(SO_SNDTIMEO), 753#endif 754#ifdef SO_TIMESTAMP 755 XLAT(SO_TIMESTAMP), 756#endif 757#ifdef SO_TYPE 758 XLAT(SO_TYPE), 759#endif 760#ifdef SO_USELOOPBACK 761 XLAT(SO_USELOOPBACK), 762#endif 763 { 0, NULL }, 764}; 765 766#if !defined(SOL_IP) && defined(IPPROTO_IP) 767#define SOL_IP IPPROTO_IP 768#endif 769 770#ifdef SOL_IP 771static const struct xlat sockipoptions[] = { 772#ifdef IP_TOS 773 XLAT(IP_TOS), 774#endif 775#ifdef IP_TTL 776 XLAT(IP_TTL), 777#endif 778#ifdef IP_HDRINCL 779 XLAT(IP_HDRINCL), 780#endif 781#ifdef IP_OPTIONS 782 XLAT(IP_OPTIONS), 783#endif 784#ifdef IP_ROUTER_ALERT 785 XLAT(IP_ROUTER_ALERT), 786#endif 787#ifdef IP_RECVOPTIONS 788 XLAT(IP_RECVOPTIONS), 789#endif 790#ifdef IP_RECVOPTS 791 XLAT(IP_RECVOPTS), 792#endif 793#ifdef IP_RECVRETOPTS 794 XLAT(IP_RECVRETOPTS), 795#endif 796#ifdef IP_RECVDSTADDR 797 XLAT(IP_RECVDSTADDR), 798#endif 799#ifdef IP_RETOPTS 800 XLAT(IP_RETOPTS), 801#endif 802#ifdef IP_PKTINFO 803 XLAT(IP_PKTINFO), 804#endif 805#ifdef IP_PKTOPTIONS 806 XLAT(IP_PKTOPTIONS), 807#endif 808#ifdef IP_MTU_DISCOVER 809 XLAT(IP_MTU_DISCOVER), 810#endif 811#ifdef IP_RECVERR 812 XLAT(IP_RECVERR), 813#endif 814#ifdef IP_RECVTTL 815 XLAT(IP_RECVTTL), 816#endif 817#ifdef IP_RECVTOS 818 XLAT(IP_RECVTOS), 819#endif 820#ifdef IP_MTU 821 XLAT(IP_MTU), 822#endif 823#ifdef IP_MULTICAST_IF 824 XLAT(IP_MULTICAST_IF), 825#endif 826#ifdef IP_MULTICAST_TTL 827 XLAT(IP_MULTICAST_TTL), 828#endif 829#ifdef IP_MULTICAST_LOOP 830 XLAT(IP_MULTICAST_LOOP), 831#endif 832#ifdef IP_ADD_MEMBERSHIP 833 XLAT(IP_ADD_MEMBERSHIP), 834#endif 835#ifdef IP_DROP_MEMBERSHIP 836 XLAT(IP_DROP_MEMBERSHIP), 837#endif 838#ifdef IP_BROADCAST_IF 839 XLAT(IP_BROADCAST_IF), 840#endif 841#ifdef IP_RECVIFINDEX 842 XLAT(IP_RECVIFINDEX), 843#endif 844#ifdef IP_MSFILTER 845 XLAT(IP_MSFILTER), 846#endif 847#ifdef MCAST_MSFILTER 848 XLAT(MCAST_MSFILTER), 849#endif 850#ifdef IP_FREEBIND 851 XLAT(IP_FREEBIND), 852#endif 853#ifdef IP_IPSEC_POLICY 854 XLAT(IP_IPSEC_POLICY), 855#endif 856#ifdef IP_XFRM_POLICY 857 XLAT(IP_XFRM_POLICY), 858#endif 859#ifdef IP_PASSSEC 860 XLAT(IP_PASSSEC), 861#endif 862#ifdef IP_TRANSPARENT 863 XLAT(IP_TRANSPARENT), 864#endif 865#ifdef IP_ORIGDSTADDR 866 XLAT(IP_ORIGDSTADDR), 867#endif 868#ifdef IP_RECVORIGDSTADDR 869 XLAT(IP_RECVORIGDSTADDR), 870#endif 871#ifdef IP_MINTTL 872 XLAT(IP_MINTTL), 873#endif 874#ifdef IP_NODEFRAG 875 XLAT(IP_NODEFRAG), 876#endif 877#ifdef IP_UNBLOCK_SOURCE 878 XLAT(IP_UNBLOCK_SOURCE), 879#endif 880#ifdef IP_BLOCK_SOURCE 881 XLAT(IP_BLOCK_SOURCE), 882#endif 883#ifdef IP_ADD_SOURCE_MEMBERSHIP 884 XLAT(IP_ADD_SOURCE_MEMBERSHIP), 885#endif 886#ifdef IP_DROP_SOURCE_MEMBERSHIP 887 XLAT(IP_DROP_SOURCE_MEMBERSHIP), 888#endif 889#ifdef MCAST_JOIN_GROUP 890 XLAT(MCAST_JOIN_GROUP), 891#endif 892#ifdef MCAST_BLOCK_SOURCE 893 XLAT(MCAST_BLOCK_SOURCE), 894#endif 895#ifdef MCAST_UNBLOCK_SOURCE 896 XLAT(MCAST_UNBLOCK_SOURCE), 897#endif 898#ifdef MCAST_LEAVE_GROUP 899 XLAT(MCAST_LEAVE_GROUP), 900#endif 901#ifdef MCAST_JOIN_SOURCE_GROUP 902 XLAT(MCAST_JOIN_SOURCE_GROUP), 903#endif 904#ifdef MCAST_LEAVE_SOURCE_GROUP 905 XLAT(MCAST_LEAVE_SOURCE_GROUP), 906#endif 907#ifdef IP_MULTICAST_ALL 908 XLAT(IP_MULTICAST_ALL), 909#endif 910#ifdef IP_UNICAST_IF 911 XLAT(IP_UNICAST_IF), 912#endif 913 { 0, NULL }, 914}; 915#endif /* SOL_IP */ 916 917#ifdef SOL_IPV6 918static const struct xlat sockipv6options[] = { 919#ifdef IPV6_ADDRFORM 920 XLAT(IPV6_ADDRFORM), 921#endif 922#ifdef MCAST_FILTER 923 XLAT(MCAST_FILTER), 924#endif 925#ifdef IPV6_PKTOPTIONS 926 XLAT(IPV6_PKTOPTIONS), 927#endif 928#ifdef IPV6_MTU 929 XLAT(IPV6_MTU), 930#endif 931#ifdef IPV6_V6ONLY 932 XLAT(IPV6_V6ONLY), 933#endif 934#ifdef IPV6_PKTINFO 935 XLAT(IPV6_PKTINFO), 936#endif 937#ifdef IPV6_HOPLIMIT 938 XLAT(IPV6_HOPLIMIT), 939#endif 940#ifdef IPV6_RTHDR 941 XLAT(IPV6_RTHDR), 942#endif 943#ifdef IPV6_HOPOPTS 944 XLAT(IPV6_HOPOPTS), 945#endif 946#ifdef IPV6_DSTOPTS 947 XLAT(IPV6_DSTOPTS), 948#endif 949#ifdef IPV6_FLOWINFO 950 XLAT(IPV6_FLOWINFO), 951#endif 952#ifdef IPV6_UNICAST_HOPS 953 XLAT(IPV6_UNICAST_HOPS), 954#endif 955#ifdef IPV6_MULTICAST_HOPS 956 XLAT(IPV6_MULTICAST_HOPS), 957#endif 958#ifdef IPV6_MULTICAST_LOOP 959 XLAT(IPV6_MULTICAST_LOOP), 960#endif 961#ifdef IPV6_MULTICAST_IF 962 XLAT(IPV6_MULTICAST_IF), 963#endif 964#ifdef IPV6_MTU_DISCOVER 965 XLAT(IPV6_MTU_DISCOVER), 966#endif 967#ifdef IPV6_RECVERR 968 XLAT(IPV6_RECVERR), 969#endif 970#ifdef IPV6_FLOWINFO_SEND 971 XLAT(IPV6_FLOWINFO_SEND), 972#endif 973#ifdef IPV6_ADD_MEMBERSHIP 974 XLAT(IPV6_ADD_MEMBERSHIP), 975#endif 976#ifdef IPV6_DROP_MEMBERSHIP 977 XLAT(IPV6_DROP_MEMBERSHIP), 978#endif 979#ifdef IPV6_ROUTER_ALERT 980 XLAT(IPV6_ROUTER_ALERT), 981#endif 982 { 0, NULL }, 983}; 984#endif /* SOL_IPV6 */ 985 986#ifdef SOL_IPX 987static const struct xlat sockipxoptions[] = { 988 XLAT(IPX_TYPE), 989 { 0, NULL }, 990}; 991#endif /* SOL_IPX */ 992 993#ifdef SOL_RAW 994static const struct xlat sockrawoptions[] = { 995#if defined(ICMP_FILTER) 996 XLAT(ICMP_FILTER), 997#endif 998 { 0, NULL }, 999}; 1000#endif /* SOL_RAW */ 1001 1002#ifdef SOL_PACKET 1003static const struct xlat sockpacketoptions[] = { 1004#ifdef PACKET_ADD_MEMBERSHIP 1005 XLAT(PACKET_ADD_MEMBERSHIP), 1006#endif 1007#ifdef PACKET_DROP_MEMBERSHIP 1008 XLAT(PACKET_DROP_MEMBERSHIP), 1009#endif 1010#if defined(PACKET_RECV_OUTPUT) 1011 XLAT(PACKET_RECV_OUTPUT), 1012#endif 1013#if defined(PACKET_RX_RING) 1014 XLAT(PACKET_RX_RING), 1015#endif 1016#if defined(PACKET_STATISTICS) 1017 XLAT(PACKET_STATISTICS), 1018#endif 1019#if defined(PACKET_COPY_THRESH) 1020 XLAT(PACKET_COPY_THRESH), 1021#endif 1022#if defined(PACKET_AUXDATA) 1023 XLAT(PACKET_AUXDATA), 1024#endif 1025#if defined(PACKET_ORIGDEV) 1026 XLAT(PACKET_ORIGDEV), 1027#endif 1028#if defined(PACKET_VERSION) 1029 XLAT(PACKET_VERSION), 1030#endif 1031#if defined(PACKET_HDRLEN) 1032 XLAT(PACKET_HDRLEN), 1033#endif 1034#if defined(PACKET_RESERVE) 1035 XLAT(PACKET_RESERVE), 1036#endif 1037#if defined(PACKET_TX_RING) 1038 XLAT(PACKET_TX_RING), 1039#endif 1040#if defined(PACKET_LOSS) 1041 XLAT(PACKET_LOSS), 1042#endif 1043 { 0, NULL }, 1044}; 1045#endif /* SOL_PACKET */ 1046 1047#ifdef SOL_SCTP 1048static const struct xlat socksctpoptions[] = { 1049#if defined(SCTP_RTOINFO) 1050 XLAT(SCTP_RTOINFO), 1051#endif 1052#if defined(SCTP_ASSOCINFO) 1053 XLAT(SCTP_ASSOCINFO), 1054#endif 1055#if defined(SCTP_INITMSG) 1056 XLAT(SCTP_INITMSG), 1057#endif 1058#if defined(SCTP_NODELAY) 1059 XLAT(SCTP_NODELAY), 1060#endif 1061#if defined(SCTP_AUTOCLOSE) 1062 XLAT(SCTP_AUTOCLOSE), 1063#endif 1064#if defined(SCTP_SET_PEER_PRIMARY_ADDR) 1065 XLAT(SCTP_SET_PEER_PRIMARY_ADDR), 1066#endif 1067#if defined(SCTP_PRIMARY_ADDR) 1068 XLAT(SCTP_PRIMARY_ADDR), 1069#endif 1070#if defined(SCTP_ADAPTATION_LAYER) 1071 XLAT(SCTP_ADAPTATION_LAYER), 1072#endif 1073#if defined(SCTP_DISABLE_FRAGMENTS) 1074 XLAT(SCTP_DISABLE_FRAGMENTS), 1075#endif 1076#if defined(SCTP_PEER_ADDR_PARAMS) 1077 XLAT(SCTP_PEER_ADDR_PARAMS), 1078#endif 1079#if defined(SCTP_DEFAULT_SEND_PARAM) 1080 XLAT(SCTP_DEFAULT_SEND_PARAM), 1081#endif 1082#if defined(SCTP_EVENTS) 1083 XLAT(SCTP_EVENTS), 1084#endif 1085#if defined(SCTP_I_WANT_MAPPED_V4_ADDR) 1086 XLAT(SCTP_I_WANT_MAPPED_V4_ADDR), 1087#endif 1088#if defined(SCTP_MAXSEG) 1089 XLAT(SCTP_MAXSEG), 1090#endif 1091#if defined(SCTP_STATUS) 1092 XLAT(SCTP_STATUS), 1093#endif 1094#if defined(SCTP_GET_PEER_ADDR_INFO) 1095 XLAT(SCTP_GET_PEER_ADDR_INFO), 1096#endif 1097#if defined(SCTP_DELAYED_ACK) 1098 XLAT(SCTP_DELAYED_ACK), 1099#endif 1100#if defined(SCTP_CONTEXT) 1101 XLAT(SCTP_CONTEXT), 1102#endif 1103#if defined(SCTP_FRAGMENT_INTERLEAVE) 1104 XLAT(SCTP_FRAGMENT_INTERLEAVE), 1105#endif 1106#if defined(SCTP_PARTIAL_DELIVERY_POINT) 1107 XLAT(SCTP_PARTIAL_DELIVERY_POINT), 1108#endif 1109#if defined(SCTP_MAX_BURST) 1110 XLAT(SCTP_MAX_BURST), 1111#endif 1112#if defined(SCTP_AUTH_CHUNK) 1113 XLAT(SCTP_AUTH_CHUNK), 1114#endif 1115#if defined(SCTP_HMAC_IDENT) 1116 XLAT(SCTP_HMAC_IDENT), 1117#endif 1118#if defined(SCTP_AUTH_KEY) 1119 XLAT(SCTP_AUTH_KEY), 1120#endif 1121#if defined(SCTP_AUTH_ACTIVE_KEY) 1122 XLAT(SCTP_AUTH_ACTIVE_KEY), 1123#endif 1124#if defined(SCTP_AUTH_DELETE_KEY) 1125 XLAT(SCTP_AUTH_DELETE_KEY), 1126#endif 1127#if defined(SCTP_PEER_AUTH_CHUNKS) 1128 XLAT(SCTP_PEER_AUTH_CHUNKS), 1129#endif 1130#if defined(SCTP_LOCAL_AUTH_CHUNKS) 1131 XLAT(SCTP_LOCAL_AUTH_CHUNKS), 1132#endif 1133#if defined(SCTP_GET_ASSOC_NUMBER) 1134 XLAT(SCTP_GET_ASSOC_NUMBER), 1135#endif 1136 1137 /* linux specific things */ 1138#if defined(SCTP_SOCKOPT_BINDX_ADD) 1139 XLAT(SCTP_SOCKOPT_BINDX_ADD), 1140#endif 1141#if defined(SCTP_SOCKOPT_BINDX_REM) 1142 XLAT(SCTP_SOCKOPT_BINDX_REM), 1143#endif 1144#if defined(SCTP_SOCKOPT_PEELOFF) 1145 XLAT(SCTP_SOCKOPT_PEELOFF), 1146#endif 1147#if defined(SCTP_GET_PEER_ADDRS_NUM_OLD) 1148 XLAT(SCTP_GET_PEER_ADDRS_NUM_OLD), 1149#endif 1150#if defined(SCTP_GET_PEER_ADDRS_OLD) 1151 XLAT(SCTP_GET_PEER_ADDRS_OLD), 1152#endif 1153#if defined(SCTP_GET_LOCAL_ADDRS_NUM_OLD) 1154 XLAT(SCTP_GET_LOCAL_ADDRS_NUM_OLD), 1155#endif 1156#if defined(SCTP_GET_LOCAL_ADDRS_OLD) 1157 XLAT(SCTP_GET_LOCAL_ADDRS_OLD), 1158#endif 1159#if defined(SCTP_SOCKOPT_CONNECTX_OLD) 1160 XLAT(SCTP_SOCKOPT_CONNECTX_OLD), 1161#endif 1162#if defined(SCTP_GET_PEER_ADDRS) 1163 XLAT(SCTP_GET_PEER_ADDRS), 1164#endif 1165#if defined(SCTP_GET_LOCAL_ADDRS) 1166 XLAT(SCTP_GET_LOCAL_ADDRS), 1167#endif 1168 1169 { 0, NULL }, 1170}; 1171#endif 1172 1173#if !defined(SOL_TCP) && defined(IPPROTO_TCP) 1174#define SOL_TCP IPPROTO_TCP 1175#endif 1176 1177#ifdef SOL_TCP 1178static const struct xlat socktcpoptions[] = { 1179 XLAT(TCP_NODELAY), 1180 XLAT(TCP_MAXSEG), 1181#ifdef TCP_CORK 1182 XLAT(TCP_CORK), 1183#endif 1184#ifdef TCP_KEEPIDLE 1185 XLAT(TCP_KEEPIDLE), 1186#endif 1187#ifdef TCP_KEEPINTVL 1188 XLAT(TCP_KEEPINTVL), 1189#endif 1190#ifdef TCP_KEEPCNT 1191 XLAT(TCP_KEEPCNT), 1192#endif 1193#ifdef TCP_SYNCNT 1194 XLAT(TCP_SYNCNT), 1195#endif 1196#ifdef TCP_LINGER2 1197 XLAT(TCP_LINGER2), 1198#endif 1199#ifdef TCP_DEFER_ACCEPT 1200 XLAT(TCP_DEFER_ACCEPT), 1201#endif 1202#ifdef TCP_WINDOW_CLAMP 1203 XLAT(TCP_WINDOW_CLAMP), 1204#endif 1205#ifdef TCP_INFO 1206 XLAT(TCP_INFO), 1207#endif 1208#ifdef TCP_QUICKACK 1209 XLAT(TCP_QUICKACK), 1210#endif 1211#ifdef TCP_CONGESTION 1212 XLAT(TCP_CONGESTION), 1213#endif 1214#ifdef TCP_MD5SIG 1215 XLAT(TCP_MD5SIG), 1216#endif 1217#ifdef TCP_COOKIE_TRANSACTIONS 1218 XLAT(TCP_COOKIE_TRANSACTIONS), 1219#endif 1220#ifdef TCP_THIN_LINEAR_TIMEOUTS 1221 XLAT(TCP_THIN_LINEAR_TIMEOUTS), 1222#endif 1223#ifdef TCP_THIN_DUPACK 1224 XLAT(TCP_THIN_DUPACK), 1225#endif 1226#ifdef TCP_USER_TIMEOUT 1227 XLAT(TCP_USER_TIMEOUT), 1228#endif 1229#ifdef TCP_REPAIR 1230 XLAT(TCP_REPAIR), 1231#endif 1232#ifdef TCP_REPAIR_QUEUE 1233 XLAT(TCP_REPAIR_QUEUE), 1234#endif 1235#ifdef TCP_QUEUE_SEQ 1236 XLAT(TCP_QUEUE_SEQ), 1237#endif 1238#ifdef TCP_REPAIR_OPTIONS 1239 XLAT(TCP_REPAIR_OPTIONS), 1240#endif 1241#ifdef TCP_FASTOPEN 1242 XLAT(TCP_FASTOPEN), 1243#endif 1244#ifdef TCP_TIMESTAMP 1245 XLAT(TCP_TIMESTAMP), 1246#endif 1247 { 0, NULL }, 1248}; 1249#endif /* SOL_TCP */ 1250 1251#ifdef SOL_RAW 1252static const struct xlat icmpfilterflags[] = { 1253#if defined(ICMP_ECHOREPLY) 1254 { (1<<ICMP_ECHOREPLY), "ICMP_ECHOREPLY" }, 1255#endif 1256#if defined(ICMP_DEST_UNREACH) 1257 { (1<<ICMP_DEST_UNREACH), "ICMP_DEST_UNREACH" }, 1258#endif 1259#if defined(ICMP_SOURCE_QUENCH) 1260 { (1<<ICMP_SOURCE_QUENCH), "ICMP_SOURCE_QUENCH" }, 1261#endif 1262#if defined(ICMP_REDIRECT) 1263 { (1<<ICMP_REDIRECT), "ICMP_REDIRECT" }, 1264#endif 1265#if defined(ICMP_ECHO) 1266 { (1<<ICMP_ECHO), "ICMP_ECHO" }, 1267#endif 1268#if defined(ICMP_TIME_EXCEEDED) 1269 { (1<<ICMP_TIME_EXCEEDED), "ICMP_TIME_EXCEEDED" }, 1270#endif 1271#if defined(ICMP_PARAMETERPROB) 1272 { (1<<ICMP_PARAMETERPROB), "ICMP_PARAMETERPROB" }, 1273#endif 1274#if defined(ICMP_TIMESTAMP) 1275 { (1<<ICMP_TIMESTAMP), "ICMP_TIMESTAMP" }, 1276#endif 1277#if defined(ICMP_TIMESTAMPREPLY) 1278 { (1<<ICMP_TIMESTAMPREPLY), "ICMP_TIMESTAMPREPLY" }, 1279#endif 1280#if defined(ICMP_INFO_REQUEST) 1281 { (1<<ICMP_INFO_REQUEST), "ICMP_INFO_REQUEST" }, 1282#endif 1283#if defined(ICMP_INFO_REPLY) 1284 { (1<<ICMP_INFO_REPLY), "ICMP_INFO_REPLY" }, 1285#endif 1286#if defined(ICMP_ADDRESS) 1287 { (1<<ICMP_ADDRESS), "ICMP_ADDRESS" }, 1288#endif 1289#if defined(ICMP_ADDRESSREPLY) 1290 { (1<<ICMP_ADDRESSREPLY), "ICMP_ADDRESSREPLY" }, 1291#endif 1292 { 0, NULL }, 1293}; 1294#endif /* SOL_RAW */ 1295 1296#if defined(AF_PACKET) /* from e.g. linux/if_packet.h */ 1297static const struct xlat af_packet_types[] = { 1298#if defined(PACKET_HOST) 1299 XLAT(PACKET_HOST), 1300#endif 1301#if defined(PACKET_BROADCAST) 1302 XLAT(PACKET_BROADCAST), 1303#endif 1304#if defined(PACKET_MULTICAST) 1305 XLAT(PACKET_MULTICAST), 1306#endif 1307#if defined(PACKET_OTHERHOST) 1308 XLAT(PACKET_OTHERHOST), 1309#endif 1310#if defined(PACKET_OUTGOING) 1311 XLAT(PACKET_OUTGOING), 1312#endif 1313#if defined(PACKET_LOOPBACK) 1314 XLAT(PACKET_LOOPBACK), 1315#endif 1316#if defined(PACKET_FASTROUTE) 1317 XLAT(PACKET_FASTROUTE), 1318#endif 1319 { 0, NULL }, 1320}; 1321#endif /* defined(AF_PACKET) */ 1322 1323void 1324printsock(struct tcb *tcp, long addr, int addrlen) 1325{ 1326 union { 1327 char pad[128]; 1328 struct sockaddr sa; 1329 struct sockaddr_in sin; 1330 struct sockaddr_un sau; 1331#ifdef HAVE_INET_NTOP 1332 struct sockaddr_in6 sa6; 1333#endif 1334#if defined(AF_IPX) 1335 struct sockaddr_ipx sipx; 1336#endif 1337#ifdef AF_PACKET 1338 struct sockaddr_ll ll; 1339#endif 1340#ifdef AF_NETLINK 1341 struct sockaddr_nl nl; 1342#endif 1343 } addrbuf; 1344 char string_addr[100]; 1345 1346 if (addr == 0) { 1347 tprints("NULL"); 1348 return; 1349 } 1350 if (!verbose(tcp)) { 1351 tprintf("%#lx", addr); 1352 return; 1353 } 1354 1355 if (addrlen < 2 || addrlen > sizeof(addrbuf)) 1356 addrlen = sizeof(addrbuf); 1357 1358 memset(&addrbuf, 0, sizeof(addrbuf)); 1359 if (umoven(tcp, addr, addrlen, addrbuf.pad) < 0) { 1360 tprints("{...}"); 1361 return; 1362 } 1363 addrbuf.pad[sizeof(addrbuf.pad) - 1] = '\0'; 1364 1365 tprints("{sa_family="); 1366 printxval(addrfams, addrbuf.sa.sa_family, "AF_???"); 1367 tprints(", "); 1368 1369 switch (addrbuf.sa.sa_family) { 1370 case AF_UNIX: 1371 if (addrlen == 2) { 1372 tprints("NULL"); 1373 } else if (addrbuf.sau.sun_path[0]) { 1374 tprints("sun_path="); 1375 printpathn(tcp, addr + 2, strlen(addrbuf.sau.sun_path)); 1376 } else { 1377 tprints("sun_path=@"); 1378 printpathn(tcp, addr + 3, strlen(addrbuf.sau.sun_path + 1)); 1379 } 1380 break; 1381 case AF_INET: 1382 tprintf("sin_port=htons(%u), sin_addr=inet_addr(\"%s\")", 1383 ntohs(addrbuf.sin.sin_port), inet_ntoa(addrbuf.sin.sin_addr)); 1384 break; 1385#ifdef HAVE_INET_NTOP 1386 case AF_INET6: 1387 inet_ntop(AF_INET6, &addrbuf.sa6.sin6_addr, string_addr, sizeof(string_addr)); 1388 tprintf("sin6_port=htons(%u), inet_pton(AF_INET6, \"%s\", &sin6_addr), sin6_flowinfo=%u", 1389 ntohs(addrbuf.sa6.sin6_port), string_addr, 1390 addrbuf.sa6.sin6_flowinfo); 1391#ifdef HAVE_STRUCT_SOCKADDR_IN6_SIN6_SCOPE_ID 1392 { 1393#if defined(HAVE_IF_INDEXTONAME) && defined(IN6_IS_ADDR_LINKLOCAL) && defined(IN6_IS_ADDR_MC_LINKLOCAL) 1394 int numericscope = 0; 1395 if (IN6_IS_ADDR_LINKLOCAL(&addrbuf.sa6.sin6_addr) 1396 || IN6_IS_ADDR_MC_LINKLOCAL(&addrbuf.sa6.sin6_addr)) { 1397 char scopebuf[IFNAMSIZ + 1]; 1398 1399 if (if_indextoname(addrbuf.sa6.sin6_scope_id, scopebuf) == NULL) 1400 numericscope++; 1401 else 1402 tprintf(", sin6_scope_id=if_nametoindex(\"%s\")", scopebuf); 1403 } else 1404 numericscope++; 1405 1406 if (numericscope) 1407#endif 1408 tprintf(", sin6_scope_id=%u", addrbuf.sa6.sin6_scope_id); 1409 } 1410#endif 1411 break; 1412#endif 1413#if defined(AF_IPX) 1414 case AF_IPX: 1415 { 1416 int i; 1417 tprintf("sipx_port=htons(%u), ", 1418 ntohs(addrbuf.sipx.sipx_port)); 1419 /* Yes, I know, this does not look too 1420 * strace-ish, but otherwise the IPX 1421 * addresses just look monstrous... 1422 * Anyways, feel free if you don't like 1423 * this way.. :) 1424 */ 1425 tprintf("%08lx:", (unsigned long)ntohl(addrbuf.sipx.sipx_network)); 1426 for (i = 0; i < IPX_NODE_LEN; i++) 1427 tprintf("%02x", addrbuf.sipx.sipx_node[i]); 1428 tprintf("/[%02x]", addrbuf.sipx.sipx_type); 1429 } 1430 break; 1431#endif /* AF_IPX */ 1432#ifdef AF_PACKET 1433 case AF_PACKET: 1434 { 1435 int i; 1436 tprintf("proto=%#04x, if%d, pkttype=", 1437 ntohs(addrbuf.ll.sll_protocol), 1438 addrbuf.ll.sll_ifindex); 1439 printxval(af_packet_types, addrbuf.ll.sll_pkttype, "?"); 1440 tprintf(", addr(%d)={%d, ", 1441 addrbuf.ll.sll_halen, 1442 addrbuf.ll.sll_hatype); 1443 for (i = 0; i < addrbuf.ll.sll_halen; i++) 1444 tprintf("%02x", addrbuf.ll.sll_addr[i]); 1445 } 1446 break; 1447 1448#endif /* AF_PACKET */ 1449#ifdef AF_NETLINK 1450 case AF_NETLINK: 1451 tprintf("pid=%d, groups=%08x", addrbuf.nl.nl_pid, addrbuf.nl.nl_groups); 1452 break; 1453#endif /* AF_NETLINK */ 1454 /* AF_AX25 AF_APPLETALK AF_NETROM AF_BRIDGE AF_AAL5 1455 AF_X25 AF_ROSE etc. still need to be done */ 1456 1457 default: 1458 tprints("sa_data="); 1459 printstr(tcp, (long) &((struct sockaddr *) addr)->sa_data, 1460 sizeof addrbuf.sa.sa_data); 1461 break; 1462 } 1463 tprints("}"); 1464} 1465 1466#if HAVE_SENDMSG 1467static const struct xlat scmvals[] = { 1468#ifdef SCM_RIGHTS 1469 XLAT(SCM_RIGHTS), 1470#endif 1471#ifdef SCM_CREDENTIALS 1472 XLAT(SCM_CREDENTIALS), 1473#endif 1474 { 0, NULL } 1475}; 1476 1477static void 1478printcmsghdr(struct tcb *tcp, unsigned long addr, unsigned long len) 1479{ 1480 struct cmsghdr *cmsg = len < sizeof(struct cmsghdr) ? 1481 NULL : malloc(len); 1482 if (cmsg == NULL || umoven(tcp, addr, len, (char *) cmsg) < 0) { 1483 tprintf(", msg_control=%#lx", addr); 1484 free(cmsg); 1485 return; 1486 } 1487 1488 tprintf(", {cmsg_len=%u, cmsg_level=", (unsigned) cmsg->cmsg_len); 1489 printxval(socketlayers, cmsg->cmsg_level, "SOL_???"); 1490 tprints(", cmsg_type="); 1491 1492 if (cmsg->cmsg_level == SOL_SOCKET) { 1493 unsigned long cmsg_len; 1494 1495 printxval(scmvals, cmsg->cmsg_type, "SCM_???"); 1496 cmsg_len = (len < cmsg->cmsg_len) ? len : cmsg->cmsg_len; 1497 1498 if (cmsg->cmsg_type == SCM_RIGHTS 1499 && CMSG_LEN(sizeof(int)) <= cmsg_len) { 1500 int *fds = (int *) CMSG_DATA(cmsg); 1501 int first = 1; 1502 1503 tprints(", {"); 1504 while ((char *) fds < ((char *) cmsg + cmsg_len)) { 1505 if (!first) 1506 tprints(", "); 1507 tprintf("%d", *fds++); 1508 first = 0; 1509 } 1510 tprints("}}"); 1511 free(cmsg); 1512 return; 1513 } 1514 if (cmsg->cmsg_type == SCM_CREDENTIALS 1515 && CMSG_LEN(sizeof(struct ucred)) <= cmsg_len) { 1516 struct ucred *uc = (struct ucred *) CMSG_DATA(cmsg); 1517 1518 tprintf("{pid=%ld, uid=%ld, gid=%ld}}", 1519 (long)uc->pid, (long)uc->uid, (long)uc->gid); 1520 free(cmsg); 1521 return; 1522 } 1523 } 1524 free(cmsg); 1525 tprints(", ...}"); 1526} 1527 1528static void 1529do_msghdr(struct tcb *tcp, struct msghdr *msg, unsigned long data_size) 1530{ 1531 tprintf("{msg_name(%d)=", msg->msg_namelen); 1532 printsock(tcp, (long)msg->msg_name, msg->msg_namelen); 1533 1534 tprintf(", msg_iov(%lu)=", (unsigned long)msg->msg_iovlen); 1535 tprint_iov_upto(tcp, (unsigned long)msg->msg_iovlen, 1536 (unsigned long)msg->msg_iov, 1, data_size); 1537 1538#ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL 1539 tprintf(", msg_controllen=%lu", (unsigned long)msg->msg_controllen); 1540 if (msg->msg_controllen) 1541 printcmsghdr(tcp, (unsigned long) msg->msg_control, 1542 msg->msg_controllen); 1543 tprints(", msg_flags="); 1544 printflags(msg_flags, msg->msg_flags, "MSG_???"); 1545#else /* !HAVE_STRUCT_MSGHDR_MSG_CONTROL */ 1546 tprintf("msg_accrights=%#lx, msg_accrightslen=%u", 1547 (unsigned long) msg->msg_accrights, msg->msg_accrightslen); 1548#endif /* !HAVE_STRUCT_MSGHDR_MSG_CONTROL */ 1549 tprints("}"); 1550} 1551 1552struct msghdr32 { 1553 uint32_t /* void* */ msg_name; 1554 uint32_t /* socklen_t */msg_namelen; 1555 uint32_t /* iovec* */ msg_iov; 1556 uint32_t /* size_t */ msg_iovlen; 1557 uint32_t /* void* */ msg_control; 1558 uint32_t /* size_t */ msg_controllen; 1559 uint32_t /* int */ msg_flags; 1560}; 1561struct mmsghdr32 { 1562 struct msghdr32 msg_hdr; 1563 uint32_t /* unsigned */ msg_len; 1564}; 1565 1566static void 1567printmsghdr(struct tcb *tcp, long addr, unsigned long data_size) 1568{ 1569 struct msghdr msg; 1570 1571#if SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4 1572 if (current_wordsize == 4) { 1573 struct msghdr32 msg32; 1574 1575 if (umove(tcp, addr, &msg32) < 0) { 1576 tprintf("%#lx", addr); 1577 return; 1578 } 1579 msg.msg_name = (void*)(long)msg32.msg_name; 1580 msg.msg_namelen = msg32.msg_namelen; 1581 msg.msg_iov = (void*)(long)msg32.msg_iov; 1582 msg.msg_iovlen = msg32.msg_iovlen; 1583 msg.msg_control = (void*)(long)msg32.msg_control; 1584 msg.msg_controllen = msg32.msg_controllen; 1585 msg.msg_flags = msg32.msg_flags; 1586 } else 1587#endif 1588 if (umove(tcp, addr, &msg) < 0) { 1589 tprintf("%#lx", addr); 1590 return; 1591 } 1592 do_msghdr(tcp, &msg, data_size); 1593} 1594 1595static void 1596printmmsghdr(struct tcb *tcp, long addr, unsigned int idx, unsigned long msg_len) 1597{ 1598 struct mmsghdr { 1599 struct msghdr msg_hdr; 1600 unsigned msg_len; 1601 } mmsg; 1602 1603#if SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4 1604 if (current_wordsize == 4) { 1605 struct mmsghdr32 mmsg32; 1606 1607 addr += sizeof(mmsg32) * idx; 1608 if (umove(tcp, addr, &mmsg32) < 0) { 1609 tprintf("%#lx", addr); 1610 return; 1611 } 1612 mmsg.msg_hdr.msg_name = (void*)(long)mmsg32.msg_hdr.msg_name; 1613 mmsg.msg_hdr.msg_namelen = mmsg32.msg_hdr.msg_namelen; 1614 mmsg.msg_hdr.msg_iov = (void*)(long)mmsg32.msg_hdr.msg_iov; 1615 mmsg.msg_hdr.msg_iovlen = mmsg32.msg_hdr.msg_iovlen; 1616 mmsg.msg_hdr.msg_control = (void*)(long)mmsg32.msg_hdr.msg_control; 1617 mmsg.msg_hdr.msg_controllen = mmsg32.msg_hdr.msg_controllen; 1618 mmsg.msg_hdr.msg_flags = mmsg32.msg_hdr.msg_flags; 1619 mmsg.msg_len = mmsg32.msg_len; 1620 } else 1621#endif 1622 { 1623 addr += sizeof(mmsg) * idx; 1624 if (umove(tcp, addr, &mmsg) < 0) { 1625 tprintf("%#lx", addr); 1626 return; 1627 } 1628 } 1629 tprints("{"); 1630 do_msghdr(tcp, &mmsg.msg_hdr, msg_len ? msg_len : mmsg.msg_len); 1631 tprintf(", %u}", mmsg.msg_len); 1632} 1633 1634static void 1635decode_mmsg(struct tcb *tcp, unsigned long msg_len) 1636{ 1637 /* mmsgvec */ 1638 if (syserror(tcp)) { 1639 tprintf("%#lx", tcp->u_arg[1]); 1640 } else { 1641 unsigned int len = tcp->u_rval; 1642 unsigned int i; 1643 1644 tprints("{"); 1645 for (i = 0; i < len; ++i) { 1646 if (i) 1647 tprints(", "); 1648 printmmsghdr(tcp, tcp->u_arg[1], i, msg_len); 1649 } 1650 tprints("}"); 1651 } 1652 /* vlen */ 1653 tprintf(", %u, ", (unsigned int) tcp->u_arg[2]); 1654 /* flags */ 1655 printflags(msg_flags, tcp->u_arg[3], "MSG_???"); 1656} 1657 1658#endif /* HAVE_SENDMSG */ 1659 1660/* 1661 * low bits of the socket type define real socket type, 1662 * other bits are socket type flags. 1663 */ 1664static void 1665tprint_sock_type(struct tcb *tcp, int flags) 1666{ 1667 const char *str = xlookup(socktypes, flags & SOCK_TYPE_MASK); 1668 1669 if (str) { 1670 tprints(str); 1671 flags &= ~SOCK_TYPE_MASK; 1672 if (!flags) 1673 return; 1674 tprints("|"); 1675 } 1676 printflags(sock_type_flags, flags, "SOCK_???"); 1677} 1678 1679int 1680sys_socket(struct tcb *tcp) 1681{ 1682 if (entering(tcp)) { 1683 printxval(domains, tcp->u_arg[0], "PF_???"); 1684 tprints(", "); 1685 tprint_sock_type(tcp, tcp->u_arg[1]); 1686 tprints(", "); 1687 switch (tcp->u_arg[0]) { 1688 case PF_INET: 1689#ifdef PF_INET6 1690 case PF_INET6: 1691#endif 1692 printxval(protocols, tcp->u_arg[2], "IPPROTO_???"); 1693 break; 1694#ifdef PF_IPX 1695 case PF_IPX: 1696 /* BTW: I don't believe this.. */ 1697 tprints("["); 1698 printxval(domains, tcp->u_arg[2], "PF_???"); 1699 tprints("]"); 1700 break; 1701#endif /* PF_IPX */ 1702 default: 1703 tprintf("%lu", tcp->u_arg[2]); 1704 break; 1705 } 1706 } 1707 return 0; 1708} 1709 1710int 1711sys_bind(struct tcb *tcp) 1712{ 1713 if (entering(tcp)) { 1714 printfd(tcp, tcp->u_arg[0]); 1715 tprints(", "); 1716 printsock(tcp, tcp->u_arg[1], tcp->u_arg[2]); 1717 tprintf(", %lu", tcp->u_arg[2]); 1718 } 1719 return 0; 1720} 1721 1722int 1723sys_connect(struct tcb *tcp) 1724{ 1725 return sys_bind(tcp); 1726} 1727 1728int 1729sys_listen(struct tcb *tcp) 1730{ 1731 if (entering(tcp)) { 1732 printfd(tcp, tcp->u_arg[0]); 1733 tprints(", "); 1734 tprintf("%lu", tcp->u_arg[1]); 1735 } 1736 return 0; 1737} 1738 1739static int 1740do_accept(struct tcb *tcp, int flags_arg) 1741{ 1742 if (entering(tcp)) { 1743 printfd(tcp, tcp->u_arg[0]); 1744 tprints(", "); 1745 return 0; 1746 } 1747 if (!tcp->u_arg[2]) 1748 tprintf("%#lx, NULL", tcp->u_arg[1]); 1749 else { 1750 int len; 1751 if (tcp->u_arg[1] == 0 || syserror(tcp) 1752 || umove(tcp, tcp->u_arg[2], &len) < 0) { 1753 tprintf("%#lx", tcp->u_arg[1]); 1754 } else { 1755 printsock(tcp, tcp->u_arg[1], len); 1756 } 1757 tprints(", "); 1758 printnum_int(tcp, tcp->u_arg[2], "%u"); 1759 } 1760 if (flags_arg >= 0) { 1761 tprints(", "); 1762 printflags(sock_type_flags, tcp->u_arg[flags_arg], 1763 "SOCK_???"); 1764 } 1765 return 0; 1766} 1767 1768int 1769sys_accept(struct tcb *tcp) 1770{ 1771 return do_accept(tcp, -1); 1772} 1773 1774int 1775sys_accept4(struct tcb *tcp) 1776{ 1777 return do_accept(tcp, 3); 1778} 1779 1780int 1781sys_send(struct tcb *tcp) 1782{ 1783 if (entering(tcp)) { 1784 printfd(tcp, tcp->u_arg[0]); 1785 tprints(", "); 1786 printstr(tcp, tcp->u_arg[1], tcp->u_arg[2]); 1787 tprintf(", %lu, ", tcp->u_arg[2]); 1788 /* flags */ 1789 printflags(msg_flags, tcp->u_arg[3], "MSG_???"); 1790 } 1791 return 0; 1792} 1793 1794int 1795sys_sendto(struct tcb *tcp) 1796{ 1797 if (entering(tcp)) { 1798 printfd(tcp, tcp->u_arg[0]); 1799 tprints(", "); 1800 printstr(tcp, tcp->u_arg[1], tcp->u_arg[2]); 1801 tprintf(", %lu, ", tcp->u_arg[2]); 1802 /* flags */ 1803 printflags(msg_flags, tcp->u_arg[3], "MSG_???"); 1804 /* to address */ 1805 tprints(", "); 1806 printsock(tcp, tcp->u_arg[4], tcp->u_arg[5]); 1807 /* to length */ 1808 tprintf(", %lu", tcp->u_arg[5]); 1809 } 1810 return 0; 1811} 1812 1813#ifdef HAVE_SENDMSG 1814 1815int 1816sys_sendmsg(struct tcb *tcp) 1817{ 1818 if (entering(tcp)) { 1819 printfd(tcp, tcp->u_arg[0]); 1820 tprints(", "); 1821 printmsghdr(tcp, tcp->u_arg[1], (unsigned long) -1L); 1822 /* flags */ 1823 tprints(", "); 1824 printflags(msg_flags, tcp->u_arg[2], "MSG_???"); 1825 } 1826 return 0; 1827} 1828 1829int 1830sys_sendmmsg(struct tcb *tcp) 1831{ 1832 if (entering(tcp)) { 1833 /* sockfd */ 1834 printfd(tcp, tcp->u_arg[0]); 1835 tprints(", "); 1836 if (!verbose(tcp)) { 1837 tprintf("%#lx, %u, ", 1838 tcp->u_arg[1], (unsigned int) tcp->u_arg[2]); 1839 printflags(msg_flags, tcp->u_arg[3], "MSG_???"); 1840 } 1841 } else { 1842 if (verbose(tcp)) 1843 decode_mmsg(tcp, (unsigned long) -1L); 1844 } 1845 return 0; 1846} 1847 1848#endif /* HAVE_SENDMSG */ 1849 1850int 1851sys_recv(struct tcb *tcp) 1852{ 1853 if (entering(tcp)) { 1854 printfd(tcp, tcp->u_arg[0]); 1855 tprints(", "); 1856 } else { 1857 if (syserror(tcp)) 1858 tprintf("%#lx", tcp->u_arg[1]); 1859 else 1860 printstr(tcp, tcp->u_arg[1], tcp->u_rval); 1861 1862 tprintf(", %lu, ", tcp->u_arg[2]); 1863 printflags(msg_flags, tcp->u_arg[3], "MSG_???"); 1864 } 1865 return 0; 1866} 1867 1868int 1869sys_recvfrom(struct tcb *tcp) 1870{ 1871 int fromlen; 1872 1873 if (entering(tcp)) { 1874 printfd(tcp, tcp->u_arg[0]); 1875 tprints(", "); 1876 } else { 1877 if (syserror(tcp)) { 1878 tprintf("%#lx, %lu, %lu, %#lx, %#lx", 1879 tcp->u_arg[1], tcp->u_arg[2], tcp->u_arg[3], 1880 tcp->u_arg[4], tcp->u_arg[5]); 1881 return 0; 1882 } 1883 /* buf */ 1884 printstr(tcp, tcp->u_arg[1], tcp->u_rval); 1885 /* len */ 1886 tprintf(", %lu, ", tcp->u_arg[2]); 1887 /* flags */ 1888 printflags(msg_flags, tcp->u_arg[3], "MSG_???"); 1889 /* from address, len */ 1890 if (!tcp->u_arg[4] || !tcp->u_arg[5]) { 1891 if (tcp->u_arg[4] == 0) 1892 tprints(", NULL"); 1893 else 1894 tprintf(", %#lx", tcp->u_arg[4]); 1895 if (tcp->u_arg[5] == 0) 1896 tprints(", NULL"); 1897 else 1898 tprintf(", %#lx", tcp->u_arg[5]); 1899 return 0; 1900 } 1901 if (umove(tcp, tcp->u_arg[5], &fromlen) < 0) { 1902 tprints(", {...}, [?]"); 1903 return 0; 1904 } 1905 tprints(", "); 1906 printsock(tcp, tcp->u_arg[4], tcp->u_arg[5]); 1907 /* from length */ 1908 tprintf(", [%u]", fromlen); 1909 } 1910 return 0; 1911} 1912 1913#ifdef HAVE_SENDMSG 1914 1915int 1916sys_recvmsg(struct tcb *tcp) 1917{ 1918 if (entering(tcp)) { 1919 printfd(tcp, tcp->u_arg[0]); 1920 tprints(", "); 1921 } else { 1922 if (syserror(tcp) || !verbose(tcp)) 1923 tprintf("%#lx", tcp->u_arg[1]); 1924 else 1925 printmsghdr(tcp, tcp->u_arg[1], tcp->u_rval); 1926 /* flags */ 1927 tprints(", "); 1928 printflags(msg_flags, tcp->u_arg[2], "MSG_???"); 1929 } 1930 return 0; 1931} 1932 1933int 1934sys_recvmmsg(struct tcb *tcp) 1935{ 1936 /* +5 chars are for "left " prefix */ 1937 static char str[5 + TIMESPEC_TEXT_BUFSIZE]; 1938 1939 if (entering(tcp)) { 1940 printfd(tcp, tcp->u_arg[0]); 1941 tprints(", "); 1942 if (verbose(tcp)) { 1943 sprint_timespec(str, tcp, tcp->u_arg[4]); 1944 /* Abusing tcp->auxstr as temp storage. 1945 * Will be used and freed on syscall exit. 1946 */ 1947 tcp->auxstr = strdup(str); 1948 } else { 1949 tprintf("%#lx, %ld, ", tcp->u_arg[1], tcp->u_arg[2]); 1950 printflags(msg_flags, tcp->u_arg[3], "MSG_???"); 1951 tprints(", "); 1952 print_timespec(tcp, tcp->u_arg[4]); 1953 } 1954 return 0; 1955 } else { 1956 if (verbose(tcp)) { 1957 decode_mmsg(tcp, 0); 1958 /* timeout on entrance */ 1959 tprintf(", %s", tcp->auxstr ? tcp->auxstr : "{...}"); 1960 free((void *) tcp->auxstr); 1961 tcp->auxstr = NULL; 1962 } 1963 if (syserror(tcp)) 1964 return 0; 1965 if (tcp->u_rval == 0) { 1966 tcp->auxstr = "Timeout"; 1967 return RVAL_STR; 1968 } 1969 if (!verbose(tcp)) 1970 return 0; 1971 /* timeout on exit */ 1972 sprint_timespec(stpcpy(str, "left "), tcp, tcp->u_arg[4]); 1973 tcp->auxstr = str; 1974 return RVAL_STR; 1975 } 1976} 1977 1978#endif /* HAVE_SENDMSG */ 1979 1980static const struct xlat shutdown_modes[] = { 1981 { 0, "SHUT_RD" }, 1982 { 1, "SHUT_WR" }, 1983 { 2, "SHUT_RDWR" }, 1984 { 0, NULL } 1985}; 1986 1987int 1988sys_shutdown(struct tcb *tcp) 1989{ 1990 if (entering(tcp)) { 1991 printfd(tcp, tcp->u_arg[0]); 1992 tprints(", "); 1993 printxval(shutdown_modes, tcp->u_arg[1], "SHUT_???"); 1994 } 1995 return 0; 1996} 1997 1998int 1999sys_getsockname(struct tcb *tcp) 2000{ 2001 return sys_accept(tcp); 2002} 2003 2004int 2005sys_getpeername(struct tcb *tcp) 2006{ 2007 return sys_accept(tcp); 2008} 2009 2010static int 2011do_pipe(struct tcb *tcp, int flags_arg) 2012{ 2013 if (exiting(tcp)) { 2014 if (syserror(tcp)) { 2015 tprintf("%#lx", tcp->u_arg[0]); 2016 } else { 2017#if !defined(SPARC) && !defined(SPARC64) && !defined(SH) && !defined(IA64) 2018 int fds[2]; 2019 2020 if (umoven(tcp, tcp->u_arg[0], sizeof fds, (char *) fds) < 0) 2021 tprints("[...]"); 2022 else 2023 tprintf("[%u, %u]", fds[0], fds[1]); 2024#elif defined(SPARC) || defined(SPARC64) || defined(SH) || defined(IA64) 2025 tprintf("[%lu, %lu]", tcp->u_rval, getrval2(tcp)); 2026#else 2027 tprintf("%#lx", tcp->u_arg[0]); 2028#endif 2029 } 2030 if (flags_arg >= 0) { 2031 tprints(", "); 2032 printflags(open_mode_flags, tcp->u_arg[flags_arg], "O_???"); 2033 } 2034 } 2035 return 0; 2036} 2037 2038int 2039sys_pipe(struct tcb *tcp) 2040{ 2041 return do_pipe(tcp, -1); 2042} 2043 2044int 2045sys_pipe2(struct tcb *tcp) 2046{ 2047 return do_pipe(tcp, 1); 2048} 2049 2050int 2051sys_socketpair(struct tcb *tcp) 2052{ 2053 int fds[2]; 2054 2055 if (entering(tcp)) { 2056 printxval(domains, tcp->u_arg[0], "PF_???"); 2057 tprints(", "); 2058 tprint_sock_type(tcp, tcp->u_arg[1]); 2059 tprints(", "); 2060 switch (tcp->u_arg[0]) { 2061 case PF_INET: 2062 printxval(protocols, tcp->u_arg[2], "IPPROTO_???"); 2063 break; 2064#ifdef PF_IPX 2065 case PF_IPX: 2066 /* BTW: I don't believe this.. */ 2067 tprints("["); 2068 printxval(domains, tcp->u_arg[2], "PF_???"); 2069 tprints("]"); 2070 break; 2071#endif /* PF_IPX */ 2072 default: 2073 tprintf("%lu", tcp->u_arg[2]); 2074 break; 2075 } 2076 } else { 2077 if (syserror(tcp)) { 2078 tprintf(", %#lx", tcp->u_arg[3]); 2079 return 0; 2080 } 2081 if (umoven(tcp, tcp->u_arg[3], sizeof fds, (char *) fds) < 0) 2082 tprints(", [...]"); 2083 else 2084 tprintf(", [%u, %u]", fds[0], fds[1]); 2085 } 2086 return 0; 2087} 2088 2089int 2090sys_getsockopt(struct tcb *tcp) 2091{ 2092 if (entering(tcp)) { 2093 printfd(tcp, tcp->u_arg[0]); 2094 tprints(", "); 2095 printxval(socketlayers, tcp->u_arg[1], "SOL_???"); 2096 tprints(", "); 2097 switch (tcp->u_arg[1]) { 2098 case SOL_SOCKET: 2099 printxval(sockoptions, tcp->u_arg[2], "SO_???"); 2100 break; 2101#ifdef SOL_IP 2102 case SOL_IP: 2103 printxval(sockipoptions, tcp->u_arg[2], "IP_???"); 2104 break; 2105#endif 2106#ifdef SOL_IPV6 2107 case SOL_IPV6: 2108 printxval(sockipv6options, tcp->u_arg[2], "IPV6_???"); 2109 break; 2110#endif 2111#ifdef SOL_IPX 2112 case SOL_IPX: 2113 printxval(sockipxoptions, tcp->u_arg[2], "IPX_???"); 2114 break; 2115#endif 2116#ifdef SOL_PACKET 2117 case SOL_PACKET: 2118 printxval(sockpacketoptions, tcp->u_arg[2], "PACKET_???"); 2119 break; 2120#endif 2121#ifdef SOL_TCP 2122 case SOL_TCP: 2123 printxval(socktcpoptions, tcp->u_arg[2], "TCP_???"); 2124 break; 2125#endif 2126#ifdef SOL_SCTP 2127 case SOL_SCTP: 2128 printxval(socksctpoptions, tcp->u_arg[2], "SCTP_???"); 2129 break; 2130#endif 2131 2132 /* SOL_AX25 SOL_ROSE SOL_ATALK SOL_NETROM SOL_UDP SOL_DECNET SOL_X25 2133 * etc. still need work */ 2134 default: 2135 tprintf("%lu", tcp->u_arg[2]); 2136 break; 2137 } 2138 tprints(", "); 2139 } else { 2140 int len; 2141 if (syserror(tcp) || umove(tcp, tcp->u_arg[4], &len) < 0) { 2142 tprintf("%#lx, %#lx", 2143 tcp->u_arg[3], tcp->u_arg[4]); 2144 return 0; 2145 } 2146 2147 switch (tcp->u_arg[1]) { 2148 case SOL_SOCKET: 2149 switch (tcp->u_arg[2]) { 2150#ifdef SO_LINGER 2151 case SO_LINGER: 2152 if (len == sizeof(struct linger)) { 2153 struct linger linger; 2154 if (umove(tcp, 2155 tcp->u_arg[3], 2156 &linger) < 0) 2157 break; 2158 tprintf("{onoff=%d, linger=%d}, " 2159 "[%d]", 2160 linger.l_onoff, 2161 linger.l_linger, 2162 len); 2163 return 0; 2164 } 2165 break; 2166#endif 2167#ifdef SO_PEERCRED 2168 case SO_PEERCRED: 2169 if (len == sizeof(struct ucred)) { 2170 struct ucred uc; 2171 if (umove(tcp, 2172 tcp->u_arg[3], 2173 &uc) < 0) 2174 break; 2175 tprintf("{pid=%ld, uid=%ld, gid=%ld}, " 2176 "[%d]", 2177 (long)uc.pid, 2178 (long)uc.uid, 2179 (long)uc.gid, 2180 len); 2181 return 0; 2182 } 2183 break; 2184#endif 2185 } 2186 break; 2187 case SOL_PACKET: 2188 switch (tcp->u_arg[2]) { 2189#ifdef PACKET_STATISTICS 2190 case PACKET_STATISTICS: 2191 if (len == sizeof(struct tpacket_stats)) { 2192 struct tpacket_stats stats; 2193 if (umove(tcp, 2194 tcp->u_arg[3], 2195 &stats) < 0) 2196 break; 2197 tprintf("{packets=%u, drops=%u}, " 2198 "[%d]", 2199 stats.tp_packets, 2200 stats.tp_drops, 2201 len); 2202 return 0; 2203 } 2204 break; 2205#endif 2206 } 2207 break; 2208 } 2209 2210 if (len == sizeof(int)) { 2211 printnum_int(tcp, tcp->u_arg[3], "%d"); 2212 } 2213 else { 2214 printstr(tcp, tcp->u_arg[3], len); 2215 } 2216 tprintf(", [%d]", len); 2217 } 2218 return 0; 2219} 2220 2221#if defined(ICMP_FILTER) 2222static void printicmpfilter(struct tcb *tcp, long addr) 2223{ 2224 struct icmp_filter filter; 2225 2226 if (!addr) { 2227 tprints("NULL"); 2228 return; 2229 } 2230 if (syserror(tcp) || !verbose(tcp)) { 2231 tprintf("%#lx", addr); 2232 return; 2233 } 2234 if (umove(tcp, addr, &filter) < 0) { 2235 tprints("{...}"); 2236 return; 2237 } 2238 2239 tprints("~("); 2240 printflags(icmpfilterflags, ~filter.data, "ICMP_???"); 2241 tprints(")"); 2242} 2243#endif /* ICMP_FILTER */ 2244 2245static int 2246printsockopt(struct tcb *tcp, int level, int name, long addr, int len) 2247{ 2248 printxval(socketlayers, level, "SOL_??"); 2249 tprints(", "); 2250 switch (level) { 2251 case SOL_SOCKET: 2252 printxval(sockoptions, name, "SO_???"); 2253 switch (name) { 2254#if defined(SO_LINGER) 2255 case SO_LINGER: 2256 if (len == sizeof(struct linger)) { 2257 struct linger linger; 2258 if (umove(tcp, addr, &linger) < 0) 2259 break; 2260 tprintf(", {onoff=%d, linger=%d}", 2261 linger.l_onoff, 2262 linger.l_linger); 2263 return 0; 2264 } 2265 break; 2266#endif 2267 } 2268 break; 2269#ifdef SOL_IP 2270 case SOL_IP: 2271 printxval(sockipoptions, name, "IP_???"); 2272 break; 2273#endif 2274#ifdef SOL_IPV6 2275 case SOL_IPV6: 2276 printxval(sockipv6options, name, "IPV6_???"); 2277 break; 2278#endif 2279#ifdef SOL_IPX 2280 case SOL_IPX: 2281 printxval(sockipxoptions, name, "IPX_???"); 2282 break; 2283#endif 2284#ifdef SOL_PACKET 2285 case SOL_PACKET: 2286 printxval(sockpacketoptions, name, "PACKET_???"); 2287 /* TODO: decode packate_mreq for PACKET_*_MEMBERSHIP */ 2288 switch (name) { 2289#ifdef PACKET_RX_RING 2290 case PACKET_RX_RING: 2291#endif 2292#ifdef PACKET_TX_RING 2293 case PACKET_TX_RING: 2294#endif 2295#if defined(PACKET_RX_RING) || defined(PACKET_TX_RING) 2296 if (len == sizeof(struct tpacket_req)) { 2297 struct tpacket_req req; 2298 if (umove(tcp, addr, &req) < 0) 2299 break; 2300 tprintf(", {block_size=%u, block_nr=%u, frame_size=%u, frame_nr=%u}", 2301 req.tp_block_size, 2302 req.tp_block_nr, 2303 req.tp_frame_size, 2304 req.tp_frame_nr); 2305 return 0; 2306 } 2307 break; 2308#endif /* PACKET_RX_RING || PACKET_TX_RING */ 2309 } 2310 break; 2311#endif 2312#ifdef SOL_TCP 2313 case SOL_TCP: 2314 printxval(socktcpoptions, name, "TCP_???"); 2315 break; 2316#endif 2317#ifdef SOL_SCTP 2318 case SOL_SCTP: 2319 printxval(socksctpoptions, name, "SCTP_???"); 2320 break; 2321#endif 2322#ifdef SOL_RAW 2323 case SOL_RAW: 2324 printxval(sockrawoptions, name, "RAW_???"); 2325 switch (name) { 2326#if defined(ICMP_FILTER) 2327 case ICMP_FILTER: 2328 tprints(", "); 2329 printicmpfilter(tcp, addr); 2330 return 0; 2331#endif 2332 } 2333 break; 2334#endif 2335 2336 /* SOL_AX25 SOL_ATALK SOL_NETROM SOL_UDP SOL_DECNET SOL_X25 2337 * etc. still need work */ 2338 2339 default: 2340 tprintf("%u", name); 2341 } 2342 2343 /* default arg printing */ 2344 2345 tprints(", "); 2346 2347 if (len == sizeof(int)) { 2348 printnum_int(tcp, addr, "%d"); 2349 } 2350 else { 2351 printstr(tcp, addr, len); 2352 } 2353 return 0; 2354} 2355 2356int 2357sys_setsockopt(struct tcb *tcp) 2358{ 2359 if (entering(tcp)) { 2360 printfd(tcp, tcp->u_arg[0]); 2361 tprints(", "); 2362 printsockopt(tcp, tcp->u_arg[1], tcp->u_arg[2], 2363 tcp->u_arg[3], tcp->u_arg[4]); 2364 tprintf(", %lu", tcp->u_arg[4]); 2365 } 2366 return 0; 2367} 2368