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