granicus.if.org Git - strace/blob - net.c

   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
  97 static 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         XLAT_END
 222 };
 223 const 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         XLAT_END
 348 };
 349 static 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         XLAT_END
 368 };
 369 static 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         XLAT_END
 377 };
 378 #ifndef SOCK_TYPE_MASK
 379 # define SOCK_TYPE_MASK 0xf
 380 #endif
 381 static 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!!! ***/
 483 static 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         XLAT_END
 573 };
 574 static 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         XLAT_END
 634 };
 635
 636 static 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         XLAT_END
 764 };
 765
 766 #if !defined(SOL_IP) && defined(IPPROTO_IP)
 767 #define SOL_IP IPPROTO_IP
 768 #endif
 769
 770 #ifdef SOL_IP
 771 static 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         XLAT_END
 914 };
 915 #endif /* SOL_IP */
 916
 917 #ifdef SOL_IPV6
 918 static 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         XLAT_END
 983 };
 984 #endif /* SOL_IPV6 */
 985
 986 #ifdef SOL_IPX
 987 static const struct xlat sockipxoptions[] = {
 988         XLAT(IPX_TYPE),
 989         XLAT_END
 990 };
 991 #endif /* SOL_IPX */
 992
 993 #ifdef SOL_RAW
 994 static const struct xlat sockrawoptions[] = {
 995 #if defined(ICMP_FILTER)
 996         XLAT(ICMP_FILTER),
 997 #endif
 998         XLAT_END
 999 };
1000 #endif /* SOL_RAW */
1001
1002 #ifdef SOL_PACKET
1003 static 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         XLAT_END
1044 };
1045 #endif /* SOL_PACKET */
1046
1047 #ifdef SOL_SCTP
1048 static 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         XLAT_END
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
1178 static 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         XLAT_END
1248 };
1249 #endif /* SOL_TCP */
1250
1251 #ifdef SOL_RAW
1252 static 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         XLAT_END
1293 };
1294 #endif /* SOL_RAW */
1295
1296 #if defined(AF_PACKET) /* from e.g. linux/if_packet.h */
1297 static 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         XLAT_END
1320 };
1321 #endif /* defined(AF_PACKET) */
1322
1323 void
1324 printsock(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
1467 static 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         XLAT_END
1475 };
1476
1477 static void
1478 printcmsghdr(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
1528 static void
1529 do_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
1552 struct 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 };
1561 struct mmsghdr32 {
1562         struct msghdr32         msg_hdr;
1563         uint32_t /* unsigned */ msg_len;
1564 };
1565
1566 static void
1567 printmsghdr(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
1595 static void
1596 printmmsghdr(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
1634 static void
1635 decode_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  */
1664 static void
1665 tprint_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
1679 int
1680 sys_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
1710 int
1711 sys_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
1722 int
1723 sys_connect(struct tcb *tcp)
1724 {
1725         return sys_bind(tcp);
1726 }
1727
1728 int
1729 sys_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
1739 static int
1740 do_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
1768 int
1769 sys_accept(struct tcb *tcp)
1770 {
1771         return do_accept(tcp, -1);
1772 }
1773
1774 int
1775 sys_accept4(struct tcb *tcp)
1776 {
1777         return do_accept(tcp, 3);
1778 }
1779
1780 int
1781 sys_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
1794 int
1795 sys_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
1815 int
1816 sys_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
1829 int
1830 sys_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
1850 int
1851 sys_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
1868 int
1869 sys_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
1915 int
1916 sys_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
1933 int
1934 sys_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
1980 static const struct xlat shutdown_modes[] = {
1981         { 0,    "SHUT_RD"       },
1982         { 1,    "SHUT_WR"       },
1983         { 2,    "SHUT_RDWR"     },
1984         XLAT_END
1985 };
1986
1987 int
1988 sys_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
1998 int
1999 sys_getsockname(struct tcb *tcp)
2000 {
2001         return sys_accept(tcp);
2002 }
2003
2004 int
2005 sys_getpeername(struct tcb *tcp)
2006 {
2007         return sys_accept(tcp);
2008 }
2009
2010 static int
2011 do_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
2038 int
2039 sys_pipe(struct tcb *tcp)
2040 {
2041         return do_pipe(tcp, -1);
2042 }
2043
2044 int
2045 sys_pipe2(struct tcb *tcp)
2046 {
2047         return do_pipe(tcp, 1);
2048 }
2049
2050 int
2051 sys_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
2089 int
2090 sys_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)
2222 static 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
2245 static int
2246 printsockopt(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
2356 int
2357 sys_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 }