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 "inet_protocols" array below!!!!   This is intended!!! ***/
 483 static const struct xlat inet_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
 575 #ifdef PF_NETLINK
 576 static const struct xlat netlink_protocols[] = {
 577 #ifdef NETLINK_ROUTE
 578         XLAT(NETLINK_ROUTE),
 579 #endif
 580 #ifdef NETLINK_UNUSED
 581         XLAT(NETLINK_UNUSED),
 582 #endif
 583 #ifdef NETLINK_USERSOCK
 584         XLAT(NETLINK_USERSOCK),
 585 #endif
 586 #ifdef NETLINK_FIREWALL
 587         XLAT(NETLINK_FIREWALL),
 588 #endif
 589 #ifdef NETLINK_SOCK_DIAG
 590         XLAT(NETLINK_SOCK_DIAG),
 591 #endif
 592 #ifdef NETLINK_NFLOG
 593         XLAT(NETLINK_NFLOG),
 594 #endif
 595 #ifdef NETLINK_XFRM
 596         XLAT(NETLINK_XFRM),
 597 #endif
 598 #ifdef NETLINK_SELINUX
 599         XLAT(NETLINK_SELINUX),
 600 #endif
 601 #ifdef NETLINK_ISCSI
 602         XLAT(NETLINK_ISCSI),
 603 #endif
 604 #ifdef NETLINK_AUDIT
 605         XLAT(NETLINK_AUDIT),
 606 #endif
 607 #ifdef NETLINK_FIB_LOOKUP
 608         XLAT(NETLINK_FIB_LOOKUP),
 609 #endif
 610 #ifdef NETLINK_CONNECTOR
 611         XLAT(NETLINK_CONNECTOR),
 612 #endif
 613 #ifdef NETLINK_NETFILTER
 614         XLAT(NETLINK_NETFILTER),
 615 #endif
 616 #ifdef NETLINK_IP6_FW
 617         XLAT(NETLINK_IP6_FW),
 618 #endif
 619 #ifdef NETLINK_DNRTMSG
 620         XLAT(NETLINK_DNRTMSG),
 621 #endif
 622 #ifdef NETLINK_KOBJECT_UEVENT
 623         XLAT(NETLINK_KOBJECT_UEVENT),
 624 #endif
 625 #ifdef NETLINK_GENERIC
 626         XLAT(NETLINK_GENERIC),
 627 #endif
 628 #ifdef NETLINK_SCSITRANSPORT
 629         XLAT(NETLINK_SCSITRANSPORT),
 630 #endif
 631 #ifdef NETLINK_ECRYPTFS
 632         XLAT(NETLINK_ECRYPTFS),
 633 #endif
 634 #ifdef NETLINK_RDMA
 635         XLAT(NETLINK_RDMA),
 636 #endif
 637 #ifdef NETLINK_CRYPTO
 638         XLAT(NETLINK_CRYPTO),
 639 #endif
 640         XLAT_END
 641 };
 642 #endif
 643
 644 static const struct xlat msg_flags[] = {
 645         XLAT(MSG_OOB),
 646 #ifdef MSG_PEEK
 647         XLAT(MSG_PEEK),
 648 #endif
 649 #ifdef MSG_DONTROUTE
 650         XLAT(MSG_DONTROUTE),
 651 #endif
 652 #ifdef MSG_CTRUNC
 653         XLAT(MSG_CTRUNC),
 654 #endif
 655 #ifdef MSG_PROBE
 656         XLAT(MSG_PROBE),
 657 #endif
 658 #ifdef MSG_TRUNC
 659         XLAT(MSG_TRUNC),
 660 #endif
 661 #ifdef MSG_DONTWAIT
 662         XLAT(MSG_DONTWAIT),
 663 #endif
 664 #ifdef MSG_EOR
 665         XLAT(MSG_EOR),
 666 #endif
 667 #ifdef MSG_WAITALL
 668         XLAT(MSG_WAITALL),
 669 #endif
 670 #ifdef MSG_FIN
 671         XLAT(MSG_FIN),
 672 #endif
 673 #ifdef MSG_SYN
 674         XLAT(MSG_SYN),
 675 #endif
 676 #ifdef MSG_CONFIRM
 677         XLAT(MSG_CONFIRM),
 678 #endif
 679 #ifdef MSG_RST
 680         XLAT(MSG_RST),
 681 #endif
 682 #ifdef MSG_ERRQUEUE
 683         XLAT(MSG_ERRQUEUE),
 684 #endif
 685 #ifdef MSG_NOSIGNAL
 686         XLAT(MSG_NOSIGNAL),
 687 #endif
 688 #ifdef MSG_MORE
 689         XLAT(MSG_MORE),
 690 #endif
 691 #ifdef MSG_WAITFORONE
 692         XLAT(MSG_WAITFORONE),
 693 #endif
 694 #ifdef MSG_EOF
 695         XLAT(MSG_EOF),
 696 #endif
 697 #ifdef MSG_FASTOPEN
 698         XLAT(MSG_FASTOPEN),
 699 #endif
 700 #ifdef MSG_CMSG_CLOEXEC
 701         XLAT(MSG_CMSG_CLOEXEC),
 702 #endif
 703         XLAT_END
 704 };
 705
 706 static const struct xlat sockoptions[] = {
 707 #ifdef SO_ACCEPTCONN
 708         XLAT(SO_ACCEPTCONN),
 709 #endif
 710 #ifdef SO_ALLRAW
 711         XLAT(SO_ALLRAW),
 712 #endif
 713 #ifdef SO_ATTACH_FILTER
 714         XLAT(SO_ATTACH_FILTER),
 715 #endif
 716 #ifdef SO_BINDTODEVICE
 717         XLAT(SO_BINDTODEVICE),
 718 #endif
 719 #ifdef SO_BROADCAST
 720         XLAT(SO_BROADCAST),
 721 #endif
 722 #ifdef SO_BSDCOMPAT
 723         XLAT(SO_BSDCOMPAT),
 724 #endif
 725 #ifdef SO_DEBUG
 726         XLAT(SO_DEBUG),
 727 #endif
 728 #ifdef SO_DETACH_FILTER
 729         XLAT(SO_DETACH_FILTER),
 730 #endif
 731 #ifdef SO_DONTROUTE
 732         XLAT(SO_DONTROUTE),
 733 #endif
 734 #ifdef SO_ERROR
 735         XLAT(SO_ERROR),
 736 #endif
 737 #ifdef SO_ICS
 738         XLAT(SO_ICS),
 739 #endif
 740 #ifdef SO_IMASOCKET
 741         XLAT(SO_IMASOCKET),
 742 #endif
 743 #ifdef SO_KEEPALIVE
 744         XLAT(SO_KEEPALIVE),
 745 #endif
 746 #ifdef SO_LINGER
 747         XLAT(SO_LINGER),
 748 #endif
 749 #ifdef SO_LISTENING
 750         XLAT(SO_LISTENING),
 751 #endif
 752 #ifdef SO_MGMT
 753         XLAT(SO_MGMT),
 754 #endif
 755 #ifdef SO_NO_CHECK
 756         XLAT(SO_NO_CHECK),
 757 #endif
 758 #ifdef SO_OOBINLINE
 759         XLAT(SO_OOBINLINE),
 760 #endif
 761 #ifdef SO_ORDREL
 762         XLAT(SO_ORDREL),
 763 #endif
 764 #ifdef SO_PARALLELSVR
 765         XLAT(SO_PARALLELSVR),
 766 #endif
 767 #ifdef SO_PASSCRED
 768         XLAT(SO_PASSCRED),
 769 #endif
 770 #ifdef SO_PEERCRED
 771         XLAT(SO_PEERCRED),
 772 #endif
 773 #ifdef SO_PEERNAME
 774         XLAT(SO_PEERNAME),
 775 #endif
 776 #ifdef SO_PEERSEC
 777         XLAT(SO_PEERSEC),
 778 #endif
 779 #ifdef SO_PRIORITY
 780         XLAT(SO_PRIORITY),
 781 #endif
 782 #ifdef SO_PROTOTYPE
 783         XLAT(SO_PROTOTYPE),
 784 #endif
 785 #ifdef SO_RCVBUF
 786         XLAT(SO_RCVBUF),
 787 #endif
 788 #ifdef SO_RCVLOWAT
 789         XLAT(SO_RCVLOWAT),
 790 #endif
 791 #ifdef SO_RCVTIMEO
 792         XLAT(SO_RCVTIMEO),
 793 #endif
 794 #ifdef SO_RDWR
 795         XLAT(SO_RDWR),
 796 #endif
 797 #ifdef SO_REUSEADDR
 798         XLAT(SO_REUSEADDR),
 799 #endif
 800 #ifdef SO_REUSEPORT
 801         XLAT(SO_REUSEPORT),
 802 #endif
 803 #ifdef SO_SECURITY_AUTHENTICATION
 804         XLAT(SO_SECURITY_AUTHENTICATION),
 805 #endif
 806 #ifdef SO_SECURITY_ENCRYPTION_NETWORK
 807         XLAT(SO_SECURITY_ENCRYPTION_NETWORK),
 808 #endif
 809 #ifdef SO_SECURITY_ENCRYPTION_TRANSPORT
 810         XLAT(SO_SECURITY_ENCRYPTION_TRANSPORT),
 811 #endif
 812 #ifdef SO_SEMA
 813         XLAT(SO_SEMA),
 814 #endif
 815 #ifdef SO_SNDBUF
 816         XLAT(SO_SNDBUF),
 817 #endif
 818 #ifdef SO_SNDLOWAT
 819         XLAT(SO_SNDLOWAT),
 820 #endif
 821 #ifdef SO_SNDTIMEO
 822         XLAT(SO_SNDTIMEO),
 823 #endif
 824 #ifdef SO_TIMESTAMP
 825         XLAT(SO_TIMESTAMP),
 826 #endif
 827 #ifdef SO_TYPE
 828         XLAT(SO_TYPE),
 829 #endif
 830 #ifdef SO_USELOOPBACK
 831         XLAT(SO_USELOOPBACK),
 832 #endif
 833         XLAT_END
 834 };
 835
 836 #if !defined(SOL_IP) && defined(IPPROTO_IP)
 837 #define SOL_IP IPPROTO_IP
 838 #endif
 839
 840 #ifdef SOL_IP
 841 static const struct xlat sockipoptions[] = {
 842 #ifdef IP_TOS
 843         XLAT(IP_TOS),
 844 #endif
 845 #ifdef IP_TTL
 846         XLAT(IP_TTL),
 847 #endif
 848 #ifdef IP_HDRINCL
 849         XLAT(IP_HDRINCL),
 850 #endif
 851 #ifdef IP_OPTIONS
 852         XLAT(IP_OPTIONS),
 853 #endif
 854 #ifdef IP_ROUTER_ALERT
 855         XLAT(IP_ROUTER_ALERT),
 856 #endif
 857 #ifdef IP_RECVOPTIONS
 858         XLAT(IP_RECVOPTIONS),
 859 #endif
 860 #ifdef IP_RECVOPTS
 861         XLAT(IP_RECVOPTS),
 862 #endif
 863 #ifdef IP_RECVRETOPTS
 864         XLAT(IP_RECVRETOPTS),
 865 #endif
 866 #ifdef IP_RECVDSTADDR
 867         XLAT(IP_RECVDSTADDR),
 868 #endif
 869 #ifdef IP_RETOPTS
 870         XLAT(IP_RETOPTS),
 871 #endif
 872 #ifdef IP_PKTINFO
 873         XLAT(IP_PKTINFO),
 874 #endif
 875 #ifdef IP_PKTOPTIONS
 876         XLAT(IP_PKTOPTIONS),
 877 #endif
 878 #ifdef IP_MTU_DISCOVER
 879         XLAT(IP_MTU_DISCOVER),
 880 #endif
 881 #ifdef IP_RECVERR
 882         XLAT(IP_RECVERR),
 883 #endif
 884 #ifdef IP_RECVTTL
 885         XLAT(IP_RECVTTL),
 886 #endif
 887 #ifdef IP_RECVTOS
 888         XLAT(IP_RECVTOS),
 889 #endif
 890 #ifdef IP_MTU
 891         XLAT(IP_MTU),
 892 #endif
 893 #ifdef IP_MULTICAST_IF
 894         XLAT(IP_MULTICAST_IF),
 895 #endif
 896 #ifdef IP_MULTICAST_TTL
 897         XLAT(IP_MULTICAST_TTL),
 898 #endif
 899 #ifdef IP_MULTICAST_LOOP
 900         XLAT(IP_MULTICAST_LOOP),
 901 #endif
 902 #ifdef IP_ADD_MEMBERSHIP
 903         XLAT(IP_ADD_MEMBERSHIP),
 904 #endif
 905 #ifdef IP_DROP_MEMBERSHIP
 906         XLAT(IP_DROP_MEMBERSHIP),
 907 #endif
 908 #ifdef IP_BROADCAST_IF
 909         XLAT(IP_BROADCAST_IF),
 910 #endif
 911 #ifdef IP_RECVIFINDEX
 912         XLAT(IP_RECVIFINDEX),
 913 #endif
 914 #ifdef IP_MSFILTER
 915         XLAT(IP_MSFILTER),
 916 #endif
 917 #ifdef MCAST_MSFILTER
 918         XLAT(MCAST_MSFILTER),
 919 #endif
 920 #ifdef IP_FREEBIND
 921         XLAT(IP_FREEBIND),
 922 #endif
 923 #ifdef IP_IPSEC_POLICY
 924         XLAT(IP_IPSEC_POLICY),
 925 #endif
 926 #ifdef IP_XFRM_POLICY
 927         XLAT(IP_XFRM_POLICY),
 928 #endif
 929 #ifdef IP_PASSSEC
 930         XLAT(IP_PASSSEC),
 931 #endif
 932 #ifdef IP_TRANSPARENT
 933         XLAT(IP_TRANSPARENT),
 934 #endif
 935 #ifdef IP_ORIGDSTADDR
 936         XLAT(IP_ORIGDSTADDR),
 937 #endif
 938 #ifdef IP_RECVORIGDSTADDR
 939         XLAT(IP_RECVORIGDSTADDR),
 940 #endif
 941 #ifdef IP_MINTTL
 942         XLAT(IP_MINTTL),
 943 #endif
 944 #ifdef IP_NODEFRAG
 945         XLAT(IP_NODEFRAG),
 946 #endif
 947 #ifdef IP_UNBLOCK_SOURCE
 948         XLAT(IP_UNBLOCK_SOURCE),
 949 #endif
 950 #ifdef IP_BLOCK_SOURCE
 951         XLAT(IP_BLOCK_SOURCE),
 952 #endif
 953 #ifdef IP_ADD_SOURCE_MEMBERSHIP
 954         XLAT(IP_ADD_SOURCE_MEMBERSHIP),
 955 #endif
 956 #ifdef IP_DROP_SOURCE_MEMBERSHIP
 957         XLAT(IP_DROP_SOURCE_MEMBERSHIP),
 958 #endif
 959 #ifdef MCAST_JOIN_GROUP
 960         XLAT(MCAST_JOIN_GROUP),
 961 #endif
 962 #ifdef MCAST_BLOCK_SOURCE
 963         XLAT(MCAST_BLOCK_SOURCE),
 964 #endif
 965 #ifdef MCAST_UNBLOCK_SOURCE
 966         XLAT(MCAST_UNBLOCK_SOURCE),
 967 #endif
 968 #ifdef MCAST_LEAVE_GROUP
 969         XLAT(MCAST_LEAVE_GROUP),
 970 #endif
 971 #ifdef MCAST_JOIN_SOURCE_GROUP
 972         XLAT(MCAST_JOIN_SOURCE_GROUP),
 973 #endif
 974 #ifdef MCAST_LEAVE_SOURCE_GROUP
 975         XLAT(MCAST_LEAVE_SOURCE_GROUP),
 976 #endif
 977 #ifdef IP_MULTICAST_ALL
 978         XLAT(IP_MULTICAST_ALL),
 979 #endif
 980 #ifdef IP_UNICAST_IF
 981         XLAT(IP_UNICAST_IF),
 982 #endif
 983         XLAT_END
 984 };
 985 #endif /* SOL_IP */
 986
 987 #ifdef SOL_IPV6
 988 static const struct xlat sockipv6options[] = {
 989 #ifdef IPV6_ADDRFORM
 990         XLAT(IPV6_ADDRFORM),
 991 #endif
 992 #ifdef MCAST_FILTER
 993         XLAT(MCAST_FILTER),
 994 #endif
 995 #ifdef IPV6_PKTOPTIONS
 996         XLAT(IPV6_PKTOPTIONS),
 997 #endif
 998 #ifdef IPV6_MTU
 999         XLAT(IPV6_MTU),
1000 #endif
1001 #ifdef IPV6_V6ONLY
1002         XLAT(IPV6_V6ONLY),
1003 #endif
1004 #ifdef IPV6_PKTINFO
1005         XLAT(IPV6_PKTINFO),
1006 #endif
1007 #ifdef IPV6_HOPLIMIT
1008         XLAT(IPV6_HOPLIMIT),
1009 #endif
1010 #ifdef IPV6_RTHDR
1011         XLAT(IPV6_RTHDR),
1012 #endif
1013 #ifdef IPV6_HOPOPTS
1014         XLAT(IPV6_HOPOPTS),
1015 #endif
1016 #ifdef IPV6_DSTOPTS
1017         XLAT(IPV6_DSTOPTS),
1018 #endif
1019 #ifdef IPV6_FLOWINFO
1020         XLAT(IPV6_FLOWINFO),
1021 #endif
1022 #ifdef IPV6_UNICAST_HOPS
1023         XLAT(IPV6_UNICAST_HOPS),
1024 #endif
1025 #ifdef IPV6_MULTICAST_HOPS
1026         XLAT(IPV6_MULTICAST_HOPS),
1027 #endif
1028 #ifdef IPV6_MULTICAST_LOOP
1029         XLAT(IPV6_MULTICAST_LOOP),
1030 #endif
1031 #ifdef IPV6_MULTICAST_IF
1032         XLAT(IPV6_MULTICAST_IF),
1033 #endif
1034 #ifdef IPV6_MTU_DISCOVER
1035         XLAT(IPV6_MTU_DISCOVER),
1036 #endif
1037 #ifdef IPV6_RECVERR
1038         XLAT(IPV6_RECVERR),
1039 #endif
1040 #ifdef IPV6_FLOWINFO_SEND
1041         XLAT(IPV6_FLOWINFO_SEND),
1042 #endif
1043 #ifdef IPV6_ADD_MEMBERSHIP
1044         XLAT(IPV6_ADD_MEMBERSHIP),
1045 #endif
1046 #ifdef IPV6_DROP_MEMBERSHIP
1047         XLAT(IPV6_DROP_MEMBERSHIP),
1048 #endif
1049 #ifdef IPV6_ROUTER_ALERT
1050         XLAT(IPV6_ROUTER_ALERT),
1051 #endif
1052         XLAT_END
1053 };
1054 #endif /* SOL_IPV6 */
1055
1056 #ifdef SOL_IPX
1057 static const struct xlat sockipxoptions[] = {
1058         XLAT(IPX_TYPE),
1059         XLAT_END
1060 };
1061 #endif /* SOL_IPX */
1062
1063 #ifdef SOL_RAW
1064 static const struct xlat sockrawoptions[] = {
1065 #if defined(ICMP_FILTER)
1066         XLAT(ICMP_FILTER),
1067 #endif
1068         XLAT_END
1069 };
1070 #endif /* SOL_RAW */
1071
1072 #ifdef SOL_PACKET
1073 static const struct xlat sockpacketoptions[] = {
1074 #ifdef PACKET_ADD_MEMBERSHIP
1075         XLAT(PACKET_ADD_MEMBERSHIP),
1076 #endif
1077 #ifdef PACKET_DROP_MEMBERSHIP
1078         XLAT(PACKET_DROP_MEMBERSHIP),
1079 #endif
1080 #if defined(PACKET_RECV_OUTPUT)
1081         XLAT(PACKET_RECV_OUTPUT),
1082 #endif
1083 #if defined(PACKET_RX_RING)
1084         XLAT(PACKET_RX_RING),
1085 #endif
1086 #if defined(PACKET_STATISTICS)
1087         XLAT(PACKET_STATISTICS),
1088 #endif
1089 #if defined(PACKET_COPY_THRESH)
1090         XLAT(PACKET_COPY_THRESH),
1091 #endif
1092 #if defined(PACKET_AUXDATA)
1093         XLAT(PACKET_AUXDATA),
1094 #endif
1095 #if defined(PACKET_ORIGDEV)
1096         XLAT(PACKET_ORIGDEV),
1097 #endif
1098 #if defined(PACKET_VERSION)
1099         XLAT(PACKET_VERSION),
1100 #endif
1101 #if defined(PACKET_HDRLEN)
1102         XLAT(PACKET_HDRLEN),
1103 #endif
1104 #if defined(PACKET_RESERVE)
1105         XLAT(PACKET_RESERVE),
1106 #endif
1107 #if defined(PACKET_TX_RING)
1108         XLAT(PACKET_TX_RING),
1109 #endif
1110 #if defined(PACKET_LOSS)
1111         XLAT(PACKET_LOSS),
1112 #endif
1113         XLAT_END
1114 };
1115 #endif /* SOL_PACKET */
1116
1117 #ifdef SOL_SCTP
1118 static const struct xlat socksctpoptions[] = {
1119 #if defined(SCTP_RTOINFO)
1120         XLAT(SCTP_RTOINFO),
1121 #endif
1122 #if defined(SCTP_ASSOCINFO)
1123         XLAT(SCTP_ASSOCINFO),
1124 #endif
1125 #if defined(SCTP_INITMSG)
1126         XLAT(SCTP_INITMSG),
1127 #endif
1128 #if defined(SCTP_NODELAY)
1129         XLAT(SCTP_NODELAY),
1130 #endif
1131 #if defined(SCTP_AUTOCLOSE)
1132         XLAT(SCTP_AUTOCLOSE),
1133 #endif
1134 #if defined(SCTP_SET_PEER_PRIMARY_ADDR)
1135         XLAT(SCTP_SET_PEER_PRIMARY_ADDR),
1136 #endif
1137 #if defined(SCTP_PRIMARY_ADDR)
1138         XLAT(SCTP_PRIMARY_ADDR),
1139 #endif
1140 #if defined(SCTP_ADAPTATION_LAYER)
1141         XLAT(SCTP_ADAPTATION_LAYER),
1142 #endif
1143 #if defined(SCTP_DISABLE_FRAGMENTS)
1144         XLAT(SCTP_DISABLE_FRAGMENTS),
1145 #endif
1146 #if defined(SCTP_PEER_ADDR_PARAMS)
1147         XLAT(SCTP_PEER_ADDR_PARAMS),
1148 #endif
1149 #if defined(SCTP_DEFAULT_SEND_PARAM)
1150         XLAT(SCTP_DEFAULT_SEND_PARAM),
1151 #endif
1152 #if defined(SCTP_EVENTS)
1153         XLAT(SCTP_EVENTS),
1154 #endif
1155 #if defined(SCTP_I_WANT_MAPPED_V4_ADDR)
1156         XLAT(SCTP_I_WANT_MAPPED_V4_ADDR),
1157 #endif
1158 #if defined(SCTP_MAXSEG)
1159         XLAT(SCTP_MAXSEG),
1160 #endif
1161 #if defined(SCTP_STATUS)
1162         XLAT(SCTP_STATUS),
1163 #endif
1164 #if defined(SCTP_GET_PEER_ADDR_INFO)
1165         XLAT(SCTP_GET_PEER_ADDR_INFO),
1166 #endif
1167 #if defined(SCTP_DELAYED_ACK)
1168         XLAT(SCTP_DELAYED_ACK),
1169 #endif
1170 #if defined(SCTP_CONTEXT)
1171         XLAT(SCTP_CONTEXT),
1172 #endif
1173 #if defined(SCTP_FRAGMENT_INTERLEAVE)
1174         XLAT(SCTP_FRAGMENT_INTERLEAVE),
1175 #endif
1176 #if defined(SCTP_PARTIAL_DELIVERY_POINT)
1177         XLAT(SCTP_PARTIAL_DELIVERY_POINT),
1178 #endif
1179 #if defined(SCTP_MAX_BURST)
1180         XLAT(SCTP_MAX_BURST),
1181 #endif
1182 #if defined(SCTP_AUTH_CHUNK)
1183         XLAT(SCTP_AUTH_CHUNK),
1184 #endif
1185 #if defined(SCTP_HMAC_IDENT)
1186         XLAT(SCTP_HMAC_IDENT),
1187 #endif
1188 #if defined(SCTP_AUTH_KEY)
1189         XLAT(SCTP_AUTH_KEY),
1190 #endif
1191 #if defined(SCTP_AUTH_ACTIVE_KEY)
1192         XLAT(SCTP_AUTH_ACTIVE_KEY),
1193 #endif
1194 #if defined(SCTP_AUTH_DELETE_KEY)
1195         XLAT(SCTP_AUTH_DELETE_KEY),
1196 #endif
1197 #if defined(SCTP_PEER_AUTH_CHUNKS)
1198         XLAT(SCTP_PEER_AUTH_CHUNKS),
1199 #endif
1200 #if defined(SCTP_LOCAL_AUTH_CHUNKS)
1201         XLAT(SCTP_LOCAL_AUTH_CHUNKS),
1202 #endif
1203 #if defined(SCTP_GET_ASSOC_NUMBER)
1204         XLAT(SCTP_GET_ASSOC_NUMBER),
1205 #endif
1206
1207         /* linux specific things */
1208 #if defined(SCTP_SOCKOPT_BINDX_ADD)
1209         XLAT(SCTP_SOCKOPT_BINDX_ADD),
1210 #endif
1211 #if defined(SCTP_SOCKOPT_BINDX_REM)
1212         XLAT(SCTP_SOCKOPT_BINDX_REM),
1213 #endif
1214 #if defined(SCTP_SOCKOPT_PEELOFF)
1215         XLAT(SCTP_SOCKOPT_PEELOFF),
1216 #endif
1217 #if defined(SCTP_GET_PEER_ADDRS_NUM_OLD)
1218         XLAT(SCTP_GET_PEER_ADDRS_NUM_OLD),
1219 #endif
1220 #if defined(SCTP_GET_PEER_ADDRS_OLD)
1221         XLAT(SCTP_GET_PEER_ADDRS_OLD),
1222 #endif
1223 #if defined(SCTP_GET_LOCAL_ADDRS_NUM_OLD)
1224         XLAT(SCTP_GET_LOCAL_ADDRS_NUM_OLD),
1225 #endif
1226 #if defined(SCTP_GET_LOCAL_ADDRS_OLD)
1227         XLAT(SCTP_GET_LOCAL_ADDRS_OLD),
1228 #endif
1229 #if defined(SCTP_SOCKOPT_CONNECTX_OLD)
1230         XLAT(SCTP_SOCKOPT_CONNECTX_OLD),
1231 #endif
1232 #if defined(SCTP_GET_PEER_ADDRS)
1233         XLAT(SCTP_GET_PEER_ADDRS),
1234 #endif
1235 #if defined(SCTP_GET_LOCAL_ADDRS)
1236         XLAT(SCTP_GET_LOCAL_ADDRS),
1237 #endif
1238
1239         XLAT_END
1240 };
1241 #endif
1242
1243 #if !defined(SOL_TCP) && defined(IPPROTO_TCP)
1244 #define SOL_TCP IPPROTO_TCP
1245 #endif
1246
1247 #ifdef SOL_TCP
1248 static const struct xlat socktcpoptions[] = {
1249         XLAT(TCP_NODELAY),
1250         XLAT(TCP_MAXSEG),
1251 #ifdef TCP_CORK
1252         XLAT(TCP_CORK),
1253 #endif
1254 #ifdef TCP_KEEPIDLE
1255         XLAT(TCP_KEEPIDLE),
1256 #endif
1257 #ifdef TCP_KEEPINTVL
1258         XLAT(TCP_KEEPINTVL),
1259 #endif
1260 #ifdef TCP_KEEPCNT
1261         XLAT(TCP_KEEPCNT),
1262 #endif
1263 #ifdef TCP_SYNCNT
1264         XLAT(TCP_SYNCNT),
1265 #endif
1266 #ifdef TCP_LINGER2
1267         XLAT(TCP_LINGER2),
1268 #endif
1269 #ifdef TCP_DEFER_ACCEPT
1270         XLAT(TCP_DEFER_ACCEPT),
1271 #endif
1272 #ifdef TCP_WINDOW_CLAMP
1273         XLAT(TCP_WINDOW_CLAMP),
1274 #endif
1275 #ifdef TCP_INFO
1276         XLAT(TCP_INFO),
1277 #endif
1278 #ifdef TCP_QUICKACK
1279         XLAT(TCP_QUICKACK),
1280 #endif
1281 #ifdef TCP_CONGESTION
1282         XLAT(TCP_CONGESTION),
1283 #endif
1284 #ifdef TCP_MD5SIG
1285         XLAT(TCP_MD5SIG),
1286 #endif
1287 #ifdef TCP_COOKIE_TRANSACTIONS
1288         XLAT(TCP_COOKIE_TRANSACTIONS),
1289 #endif
1290 #ifdef TCP_THIN_LINEAR_TIMEOUTS
1291         XLAT(TCP_THIN_LINEAR_TIMEOUTS),
1292 #endif
1293 #ifdef TCP_THIN_DUPACK
1294         XLAT(TCP_THIN_DUPACK),
1295 #endif
1296 #ifdef TCP_USER_TIMEOUT
1297         XLAT(TCP_USER_TIMEOUT),
1298 #endif
1299 #ifdef TCP_REPAIR
1300         XLAT(TCP_REPAIR),
1301 #endif
1302 #ifdef TCP_REPAIR_QUEUE
1303         XLAT(TCP_REPAIR_QUEUE),
1304 #endif
1305 #ifdef TCP_QUEUE_SEQ
1306         XLAT(TCP_QUEUE_SEQ),
1307 #endif
1308 #ifdef TCP_REPAIR_OPTIONS
1309         XLAT(TCP_REPAIR_OPTIONS),
1310 #endif
1311 #ifdef TCP_FASTOPEN
1312         XLAT(TCP_FASTOPEN),
1313 #endif
1314 #ifdef TCP_TIMESTAMP
1315         XLAT(TCP_TIMESTAMP),
1316 #endif
1317         XLAT_END
1318 };
1319 #endif /* SOL_TCP */
1320
1321 #ifdef SOL_RAW
1322 static const struct xlat icmpfilterflags[] = {
1323 #if defined(ICMP_ECHOREPLY)
1324         { (1<<ICMP_ECHOREPLY),          "ICMP_ECHOREPLY"        },
1325 #endif
1326 #if defined(ICMP_DEST_UNREACH)
1327         { (1<<ICMP_DEST_UNREACH),       "ICMP_DEST_UNREACH"     },
1328 #endif
1329 #if defined(ICMP_SOURCE_QUENCH)
1330         { (1<<ICMP_SOURCE_QUENCH),      "ICMP_SOURCE_QUENCH"    },
1331 #endif
1332 #if defined(ICMP_REDIRECT)
1333         { (1<<ICMP_REDIRECT),           "ICMP_REDIRECT"         },
1334 #endif
1335 #if defined(ICMP_ECHO)
1336         { (1<<ICMP_ECHO),               "ICMP_ECHO"             },
1337 #endif
1338 #if defined(ICMP_TIME_EXCEEDED)
1339         { (1<<ICMP_TIME_EXCEEDED),      "ICMP_TIME_EXCEEDED"    },
1340 #endif
1341 #if defined(ICMP_PARAMETERPROB)
1342         { (1<<ICMP_PARAMETERPROB),      "ICMP_PARAMETERPROB"    },
1343 #endif
1344 #if defined(ICMP_TIMESTAMP)
1345         { (1<<ICMP_TIMESTAMP),          "ICMP_TIMESTAMP"        },
1346 #endif
1347 #if defined(ICMP_TIMESTAMPREPLY)
1348         { (1<<ICMP_TIMESTAMPREPLY),     "ICMP_TIMESTAMPREPLY"   },
1349 #endif
1350 #if defined(ICMP_INFO_REQUEST)
1351         { (1<<ICMP_INFO_REQUEST),       "ICMP_INFO_REQUEST"     },
1352 #endif
1353 #if defined(ICMP_INFO_REPLY)
1354         { (1<<ICMP_INFO_REPLY),         "ICMP_INFO_REPLY"       },
1355 #endif
1356 #if defined(ICMP_ADDRESS)
1357         { (1<<ICMP_ADDRESS),            "ICMP_ADDRESS"          },
1358 #endif
1359 #if defined(ICMP_ADDRESSREPLY)
1360         { (1<<ICMP_ADDRESSREPLY),       "ICMP_ADDRESSREPLY"     },
1361 #endif
1362         XLAT_END
1363 };
1364 #endif /* SOL_RAW */
1365
1366 #if defined(AF_PACKET) /* from e.g. linux/if_packet.h */
1367 static const struct xlat af_packet_types[] = {
1368 #if defined(PACKET_HOST)
1369         XLAT(PACKET_HOST),
1370 #endif
1371 #if defined(PACKET_BROADCAST)
1372         XLAT(PACKET_BROADCAST),
1373 #endif
1374 #if defined(PACKET_MULTICAST)
1375         XLAT(PACKET_MULTICAST),
1376 #endif
1377 #if defined(PACKET_OTHERHOST)
1378         XLAT(PACKET_OTHERHOST),
1379 #endif
1380 #if defined(PACKET_OUTGOING)
1381         XLAT(PACKET_OUTGOING),
1382 #endif
1383 #if defined(PACKET_LOOPBACK)
1384         XLAT(PACKET_LOOPBACK),
1385 #endif
1386 #if defined(PACKET_FASTROUTE)
1387         XLAT(PACKET_FASTROUTE),
1388 #endif
1389         XLAT_END
1390 };
1391 #endif /* defined(AF_PACKET) */
1392
1393 void
1394 printsock(struct tcb *tcp, long addr, int addrlen)
1395 {
1396         union {
1397                 char pad[128];
1398                 struct sockaddr sa;
1399                 struct sockaddr_in sin;
1400                 struct sockaddr_un sau;
1401 #ifdef HAVE_INET_NTOP
1402                 struct sockaddr_in6 sa6;
1403 #endif
1404 #if defined(AF_IPX)
1405                 struct sockaddr_ipx sipx;
1406 #endif
1407 #ifdef AF_PACKET
1408                 struct sockaddr_ll ll;
1409 #endif
1410 #ifdef AF_NETLINK
1411                 struct sockaddr_nl nl;
1412 #endif
1413         } addrbuf;
1414         char string_addr[100];
1415
1416         if (addr == 0) {
1417                 tprints("NULL");
1418                 return;
1419         }
1420         if (!verbose(tcp)) {
1421                 tprintf("%#lx", addr);
1422                 return;
1423         }
1424
1425         if (addrlen < 2 || addrlen > sizeof(addrbuf))
1426                 addrlen = sizeof(addrbuf);
1427
1428         memset(&addrbuf, 0, sizeof(addrbuf));
1429         if (umoven(tcp, addr, addrlen, addrbuf.pad) < 0) {
1430                 tprints("{...}");
1431                 return;
1432         }
1433         addrbuf.pad[sizeof(addrbuf.pad) - 1] = '\0';
1434
1435         tprints("{sa_family=");
1436         printxval(addrfams, addrbuf.sa.sa_family, "AF_???");
1437         tprints(", ");
1438
1439         switch (addrbuf.sa.sa_family) {
1440         case AF_UNIX:
1441                 if (addrlen == 2) {
1442                         tprints("NULL");
1443                 } else if (addrbuf.sau.sun_path[0]) {
1444                         tprints("sun_path=");
1445                         printpathn(tcp, addr + 2, strlen(addrbuf.sau.sun_path));
1446                 } else {
1447                         tprints("sun_path=@");
1448                         printpathn(tcp, addr + 3, strlen(addrbuf.sau.sun_path + 1));
1449                 }
1450                 break;
1451         case AF_INET:
1452                 tprintf("sin_port=htons(%u), sin_addr=inet_addr(\"%s\")",
1453                         ntohs(addrbuf.sin.sin_port), inet_ntoa(addrbuf.sin.sin_addr));
1454                 break;
1455 #ifdef HAVE_INET_NTOP
1456         case AF_INET6:
1457                 inet_ntop(AF_INET6, &addrbuf.sa6.sin6_addr, string_addr, sizeof(string_addr));
1458                 tprintf("sin6_port=htons(%u), inet_pton(AF_INET6, \"%s\", &sin6_addr), sin6_flowinfo=%u",
1459                                 ntohs(addrbuf.sa6.sin6_port), string_addr,
1460                                 addrbuf.sa6.sin6_flowinfo);
1461 #ifdef HAVE_STRUCT_SOCKADDR_IN6_SIN6_SCOPE_ID
1462                 {
1463 #if defined(HAVE_IF_INDEXTONAME) && defined(IN6_IS_ADDR_LINKLOCAL) && defined(IN6_IS_ADDR_MC_LINKLOCAL)
1464                         int numericscope = 0;
1465                         if (IN6_IS_ADDR_LINKLOCAL(&addrbuf.sa6.sin6_addr)
1466                             || IN6_IS_ADDR_MC_LINKLOCAL(&addrbuf.sa6.sin6_addr)) {
1467                                 char scopebuf[IFNAMSIZ + 1];
1468
1469                                 if (if_indextoname(addrbuf.sa6.sin6_scope_id, scopebuf) == NULL)
1470                                         numericscope++;
1471                                 else
1472                                         tprintf(", sin6_scope_id=if_nametoindex(\"%s\")", scopebuf);
1473                         } else
1474                                 numericscope++;
1475
1476                         if (numericscope)
1477 #endif
1478                                 tprintf(", sin6_scope_id=%u", addrbuf.sa6.sin6_scope_id);
1479                 }
1480 #endif
1481                 break;
1482 #endif
1483 #if defined(AF_IPX)
1484         case AF_IPX:
1485                 {
1486                         int i;
1487                         tprintf("sipx_port=htons(%u), ",
1488                                         ntohs(addrbuf.sipx.sipx_port));
1489                         /* Yes, I know, this does not look too
1490                          * strace-ish, but otherwise the IPX
1491                          * addresses just look monstrous...
1492                          * Anyways, feel free if you don't like
1493                          * this way.. :)
1494                          */
1495                         tprintf("%08lx:", (unsigned long)ntohl(addrbuf.sipx.sipx_network));
1496                         for (i = 0; i < IPX_NODE_LEN; i++)
1497                                 tprintf("%02x", addrbuf.sipx.sipx_node[i]);
1498                         tprintf("/[%02x]", addrbuf.sipx.sipx_type);
1499                 }
1500                 break;
1501 #endif /* AF_IPX */
1502 #ifdef AF_PACKET
1503         case AF_PACKET:
1504                 {
1505                         int i;
1506                         tprintf("proto=%#04x, if%d, pkttype=",
1507                                         ntohs(addrbuf.ll.sll_protocol),
1508                                         addrbuf.ll.sll_ifindex);
1509                         printxval(af_packet_types, addrbuf.ll.sll_pkttype, "?");
1510                         tprintf(", addr(%d)={%d, ",
1511                                         addrbuf.ll.sll_halen,
1512                                         addrbuf.ll.sll_hatype);
1513                         for (i = 0; i < addrbuf.ll.sll_halen; i++)
1514                                 tprintf("%02x", addrbuf.ll.sll_addr[i]);
1515                 }
1516                 break;
1517
1518 #endif /* AF_PACKET */
1519 #ifdef AF_NETLINK
1520         case AF_NETLINK:
1521                 tprintf("pid=%d, groups=%08x", addrbuf.nl.nl_pid, addrbuf.nl.nl_groups);
1522                 break;
1523 #endif /* AF_NETLINK */
1524         /* AF_AX25 AF_APPLETALK AF_NETROM AF_BRIDGE AF_AAL5
1525         AF_X25 AF_ROSE etc. still need to be done */
1526
1527         default:
1528                 tprints("sa_data=");
1529                 printstr(tcp, (long) &((struct sockaddr *) addr)->sa_data,
1530                         sizeof addrbuf.sa.sa_data);
1531                 break;
1532         }
1533         tprints("}");
1534 }
1535
1536 #if HAVE_SENDMSG
1537 static const struct xlat scmvals[] = {
1538 #ifdef SCM_RIGHTS
1539         XLAT(SCM_RIGHTS),
1540 #endif
1541 #ifdef SCM_CREDENTIALS
1542         XLAT(SCM_CREDENTIALS),
1543 #endif
1544         XLAT_END
1545 };
1546
1547 static void
1548 printcmsghdr(struct tcb *tcp, unsigned long addr, unsigned long len)
1549 {
1550         struct cmsghdr *cmsg = len < sizeof(struct cmsghdr) ?
1551                                NULL : malloc(len);
1552         if (cmsg == NULL || umoven(tcp, addr, len, (char *) cmsg) < 0) {
1553                 tprintf(", msg_control=%#lx", addr);
1554                 free(cmsg);
1555                 return;
1556         }
1557
1558         tprintf(", {cmsg_len=%u, cmsg_level=", (unsigned) cmsg->cmsg_len);
1559         printxval(socketlayers, cmsg->cmsg_level, "SOL_???");
1560         tprints(", cmsg_type=");
1561
1562         if (cmsg->cmsg_level == SOL_SOCKET) {
1563                 unsigned long cmsg_len;
1564
1565                 printxval(scmvals, cmsg->cmsg_type, "SCM_???");
1566                 cmsg_len = (len < cmsg->cmsg_len) ? len : cmsg->cmsg_len;
1567
1568                 if (cmsg->cmsg_type == SCM_RIGHTS
1569                     && CMSG_LEN(sizeof(int)) <= cmsg_len) {
1570                         int *fds = (int *) CMSG_DATA(cmsg);
1571                         int first = 1;
1572
1573                         tprints(", {");
1574                         while ((char *) fds < ((char *) cmsg + cmsg_len)) {
1575                                 if (!first)
1576                                         tprints(", ");
1577                                 tprintf("%d", *fds++);
1578                                 first = 0;
1579                         }
1580                         tprints("}}");
1581                         free(cmsg);
1582                         return;
1583                 }
1584                 if (cmsg->cmsg_type == SCM_CREDENTIALS
1585                     && CMSG_LEN(sizeof(struct ucred)) <= cmsg_len) {
1586                         struct ucred *uc = (struct ucred *) CMSG_DATA(cmsg);
1587
1588                         tprintf("{pid=%ld, uid=%ld, gid=%ld}}",
1589                                 (long)uc->pid, (long)uc->uid, (long)uc->gid);
1590                         free(cmsg);
1591                         return;
1592                 }
1593         }
1594         free(cmsg);
1595         tprints(", ...}");
1596 }
1597
1598 static void
1599 do_msghdr(struct tcb *tcp, struct msghdr *msg, unsigned long data_size)
1600 {
1601         tprintf("{msg_name(%d)=", msg->msg_namelen);
1602         printsock(tcp, (long)msg->msg_name, msg->msg_namelen);
1603
1604         tprintf(", msg_iov(%lu)=", (unsigned long)msg->msg_iovlen);
1605         tprint_iov_upto(tcp, (unsigned long)msg->msg_iovlen,
1606                    (unsigned long)msg->msg_iov, 1, data_size);
1607
1608 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
1609         tprintf(", msg_controllen=%lu", (unsigned long)msg->msg_controllen);
1610         if (msg->msg_controllen)
1611                 printcmsghdr(tcp, (unsigned long) msg->msg_control,
1612                              msg->msg_controllen);
1613         tprints(", msg_flags=");
1614         printflags(msg_flags, msg->msg_flags, "MSG_???");
1615 #else /* !HAVE_STRUCT_MSGHDR_MSG_CONTROL */
1616         tprintf("msg_accrights=%#lx, msg_accrightslen=%u",
1617                 (unsigned long) msg->msg_accrights, msg->msg_accrightslen);
1618 #endif /* !HAVE_STRUCT_MSGHDR_MSG_CONTROL */
1619         tprints("}");
1620 }
1621
1622 struct msghdr32 {
1623         uint32_t /* void* */    msg_name;
1624         uint32_t /* socklen_t */msg_namelen;
1625         uint32_t /* iovec* */   msg_iov;
1626         uint32_t /* size_t */   msg_iovlen;
1627         uint32_t /* void* */    msg_control;
1628         uint32_t /* size_t */   msg_controllen;
1629         uint32_t /* int */      msg_flags;
1630 };
1631 struct mmsghdr32 {
1632         struct msghdr32         msg_hdr;
1633         uint32_t /* unsigned */ msg_len;
1634 };
1635
1636 static void
1637 printmsghdr(struct tcb *tcp, long addr, unsigned long data_size)
1638 {
1639         struct msghdr msg;
1640
1641 #if SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4
1642         if (current_wordsize == 4) {
1643                 struct msghdr32 msg32;
1644
1645                 if (umove(tcp, addr, &msg32) < 0) {
1646                         tprintf("%#lx", addr);
1647                         return;
1648                 }
1649                 msg.msg_name       = (void*)(long)msg32.msg_name;
1650                 msg.msg_namelen    =              msg32.msg_namelen;
1651                 msg.msg_iov        = (void*)(long)msg32.msg_iov;
1652                 msg.msg_iovlen     =              msg32.msg_iovlen;
1653                 msg.msg_control    = (void*)(long)msg32.msg_control;
1654                 msg.msg_controllen =              msg32.msg_controllen;
1655                 msg.msg_flags      =              msg32.msg_flags;
1656         } else
1657 #endif
1658         if (umove(tcp, addr, &msg) < 0) {
1659                 tprintf("%#lx", addr);
1660                 return;
1661         }
1662         do_msghdr(tcp, &msg, data_size);
1663 }
1664
1665 static void
1666 printmmsghdr(struct tcb *tcp, long addr, unsigned int idx, unsigned long msg_len)
1667 {
1668         struct mmsghdr {
1669                 struct msghdr msg_hdr;
1670                 unsigned msg_len;
1671         } mmsg;
1672
1673 #if SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4
1674         if (current_wordsize == 4) {
1675                 struct mmsghdr32 mmsg32;
1676
1677                 addr += sizeof(mmsg32) * idx;
1678                 if (umove(tcp, addr, &mmsg32) < 0) {
1679                         tprintf("%#lx", addr);
1680                         return;
1681                 }
1682                 mmsg.msg_hdr.msg_name       = (void*)(long)mmsg32.msg_hdr.msg_name;
1683                 mmsg.msg_hdr.msg_namelen    =              mmsg32.msg_hdr.msg_namelen;
1684                 mmsg.msg_hdr.msg_iov        = (void*)(long)mmsg32.msg_hdr.msg_iov;
1685                 mmsg.msg_hdr.msg_iovlen     =              mmsg32.msg_hdr.msg_iovlen;
1686                 mmsg.msg_hdr.msg_control    = (void*)(long)mmsg32.msg_hdr.msg_control;
1687                 mmsg.msg_hdr.msg_controllen =              mmsg32.msg_hdr.msg_controllen;
1688                 mmsg.msg_hdr.msg_flags      =              mmsg32.msg_hdr.msg_flags;
1689                 mmsg.msg_len                =              mmsg32.msg_len;
1690         } else
1691 #endif
1692         {
1693                 addr += sizeof(mmsg) * idx;
1694                 if (umove(tcp, addr, &mmsg) < 0) {
1695                         tprintf("%#lx", addr);
1696                         return;
1697                 }
1698         }
1699         tprints("{");
1700         do_msghdr(tcp, &mmsg.msg_hdr, msg_len ? msg_len : mmsg.msg_len);
1701         tprintf(", %u}", mmsg.msg_len);
1702 }
1703
1704 static void
1705 decode_mmsg(struct tcb *tcp, unsigned long msg_len)
1706 {
1707         /* mmsgvec */
1708         if (syserror(tcp)) {
1709                 tprintf("%#lx", tcp->u_arg[1]);
1710         } else {
1711                 unsigned int len = tcp->u_rval;
1712                 unsigned int i;
1713
1714                 tprints("{");
1715                 for (i = 0; i < len; ++i) {
1716                         if (i)
1717                                 tprints(", ");
1718                         printmmsghdr(tcp, tcp->u_arg[1], i, msg_len);
1719                 }
1720                 tprints("}");
1721         }
1722         /* vlen */
1723         tprintf(", %u, ", (unsigned int) tcp->u_arg[2]);
1724         /* flags */
1725         printflags(msg_flags, tcp->u_arg[3], "MSG_???");
1726 }
1727
1728 #endif /* HAVE_SENDMSG */
1729
1730 /*
1731  * low bits of the socket type define real socket type,
1732  * other bits are socket type flags.
1733  */
1734 static void
1735 tprint_sock_type(struct tcb *tcp, int flags)
1736 {
1737         const char *str = xlookup(socktypes, flags & SOCK_TYPE_MASK);
1738
1739         if (str) {
1740                 tprints(str);
1741                 flags &= ~SOCK_TYPE_MASK;
1742                 if (!flags)
1743                         return;
1744                 tprints("|");
1745         }
1746         printflags(sock_type_flags, flags, "SOCK_???");
1747 }
1748
1749 int
1750 sys_socket(struct tcb *tcp)
1751 {
1752         if (entering(tcp)) {
1753                 printxval(domains, tcp->u_arg[0], "PF_???");
1754                 tprints(", ");
1755                 tprint_sock_type(tcp, tcp->u_arg[1]);
1756                 tprints(", ");
1757                 switch (tcp->u_arg[0]) {
1758                 case PF_INET:
1759 #ifdef PF_INET6
1760                 case PF_INET6:
1761 #endif
1762                         printxval(inet_protocols, tcp->u_arg[2], "IPPROTO_???");
1763                         break;
1764 #ifdef PF_IPX
1765                 case PF_IPX:
1766                         /* BTW: I don't believe this.. */
1767                         tprints("[");
1768                         printxval(domains, tcp->u_arg[2], "PF_???");
1769                         tprints("]");
1770                         break;
1771 #endif /* PF_IPX */
1772 #ifdef PF_NETLINK
1773                 case PF_NETLINK:
1774                         printxval(netlink_protocols, tcp->u_arg[2], "NETLINK_???");
1775                         break;
1776 #endif
1777                 default:
1778                         tprintf("%lu", tcp->u_arg[2]);
1779                         break;
1780                 }
1781         }
1782         return 0;
1783 }
1784
1785 int
1786 sys_bind(struct tcb *tcp)
1787 {
1788         if (entering(tcp)) {
1789                 printfd(tcp, tcp->u_arg[0]);
1790                 tprints(", ");
1791                 printsock(tcp, tcp->u_arg[1], tcp->u_arg[2]);
1792                 tprintf(", %lu", tcp->u_arg[2]);
1793         }
1794         return 0;
1795 }
1796
1797 int
1798 sys_connect(struct tcb *tcp)
1799 {
1800         return sys_bind(tcp);
1801 }
1802
1803 int
1804 sys_listen(struct tcb *tcp)
1805 {
1806         if (entering(tcp)) {
1807                 printfd(tcp, tcp->u_arg[0]);
1808                 tprints(", ");
1809                 tprintf("%lu", tcp->u_arg[1]);
1810         }
1811         return 0;
1812 }
1813
1814 static int
1815 do_accept(struct tcb *tcp, int flags_arg)
1816 {
1817         if (entering(tcp)) {
1818                 printfd(tcp, tcp->u_arg[0]);
1819                 tprints(", ");
1820                 return 0;
1821         }
1822         if (!tcp->u_arg[2])
1823                 tprintf("%#lx, NULL", tcp->u_arg[1]);
1824         else {
1825                 int len;
1826                 if (tcp->u_arg[1] == 0 || syserror(tcp)
1827                     || umove(tcp, tcp->u_arg[2], &len) < 0) {
1828                         tprintf("%#lx", tcp->u_arg[1]);
1829                 } else {
1830                         printsock(tcp, tcp->u_arg[1], len);
1831                 }
1832                 tprints(", ");
1833                 printnum_int(tcp, tcp->u_arg[2], "%u");
1834         }
1835         if (flags_arg >= 0) {
1836                 tprints(", ");
1837                 printflags(sock_type_flags, tcp->u_arg[flags_arg],
1838                            "SOCK_???");
1839         }
1840         return 0;
1841 }
1842
1843 int
1844 sys_accept(struct tcb *tcp)
1845 {
1846         return do_accept(tcp, -1);
1847 }
1848
1849 int
1850 sys_accept4(struct tcb *tcp)
1851 {
1852         return do_accept(tcp, 3);
1853 }
1854
1855 int
1856 sys_send(struct tcb *tcp)
1857 {
1858         if (entering(tcp)) {
1859                 printfd(tcp, tcp->u_arg[0]);
1860                 tprints(", ");
1861                 printstr(tcp, tcp->u_arg[1], tcp->u_arg[2]);
1862                 tprintf(", %lu, ", tcp->u_arg[2]);
1863                 /* flags */
1864                 printflags(msg_flags, tcp->u_arg[3], "MSG_???");
1865         }
1866         return 0;
1867 }
1868
1869 int
1870 sys_sendto(struct tcb *tcp)
1871 {
1872         if (entering(tcp)) {
1873                 printfd(tcp, tcp->u_arg[0]);
1874                 tprints(", ");
1875                 printstr(tcp, tcp->u_arg[1], tcp->u_arg[2]);
1876                 tprintf(", %lu, ", tcp->u_arg[2]);
1877                 /* flags */
1878                 printflags(msg_flags, tcp->u_arg[3], "MSG_???");
1879                 /* to address */
1880                 tprints(", ");
1881                 printsock(tcp, tcp->u_arg[4], tcp->u_arg[5]);
1882                 /* to length */
1883                 tprintf(", %lu", tcp->u_arg[5]);
1884         }
1885         return 0;
1886 }
1887
1888 #ifdef HAVE_SENDMSG
1889
1890 int
1891 sys_sendmsg(struct tcb *tcp)
1892 {
1893         if (entering(tcp)) {
1894                 printfd(tcp, tcp->u_arg[0]);
1895                 tprints(", ");
1896                 printmsghdr(tcp, tcp->u_arg[1], (unsigned long) -1L);
1897                 /* flags */
1898                 tprints(", ");
1899                 printflags(msg_flags, tcp->u_arg[2], "MSG_???");
1900         }
1901         return 0;
1902 }
1903
1904 int
1905 sys_sendmmsg(struct tcb *tcp)
1906 {
1907         if (entering(tcp)) {
1908                 /* sockfd */
1909                 printfd(tcp, tcp->u_arg[0]);
1910                 tprints(", ");
1911                 if (!verbose(tcp)) {
1912                         tprintf("%#lx, %u, ",
1913                                 tcp->u_arg[1], (unsigned int) tcp->u_arg[2]);
1914                         printflags(msg_flags, tcp->u_arg[3], "MSG_???");
1915                 }
1916         } else {
1917                 if (verbose(tcp))
1918                         decode_mmsg(tcp, (unsigned long) -1L);
1919         }
1920         return 0;
1921 }
1922
1923 #endif /* HAVE_SENDMSG */
1924
1925 int
1926 sys_recv(struct tcb *tcp)
1927 {
1928         if (entering(tcp)) {
1929                 printfd(tcp, tcp->u_arg[0]);
1930                 tprints(", ");
1931         } else {
1932                 if (syserror(tcp))
1933                         tprintf("%#lx", tcp->u_arg[1]);
1934                 else
1935                         printstr(tcp, tcp->u_arg[1], tcp->u_rval);
1936
1937                 tprintf(", %lu, ", tcp->u_arg[2]);
1938                 printflags(msg_flags, tcp->u_arg[3], "MSG_???");
1939         }
1940         return 0;
1941 }
1942
1943 int
1944 sys_recvfrom(struct tcb *tcp)
1945 {
1946         int fromlen;
1947
1948         if (entering(tcp)) {
1949                 printfd(tcp, tcp->u_arg[0]);
1950                 tprints(", ");
1951         } else {
1952                 if (syserror(tcp)) {
1953                         tprintf("%#lx, %lu, %lu, %#lx, %#lx",
1954                                 tcp->u_arg[1], tcp->u_arg[2], tcp->u_arg[3],
1955                                 tcp->u_arg[4], tcp->u_arg[5]);
1956                         return 0;
1957                 }
1958                 /* buf */
1959                 printstr(tcp, tcp->u_arg[1], tcp->u_rval);
1960                 /* len */
1961                 tprintf(", %lu, ", tcp->u_arg[2]);
1962                 /* flags */
1963                 printflags(msg_flags, tcp->u_arg[3], "MSG_???");
1964                 /* from address, len */
1965                 if (!tcp->u_arg[4] || !tcp->u_arg[5]) {
1966                         if (tcp->u_arg[4] == 0)
1967                                 tprints(", NULL");
1968                         else
1969                                 tprintf(", %#lx", tcp->u_arg[4]);
1970                         if (tcp->u_arg[5] == 0)
1971                                 tprints(", NULL");
1972                         else
1973                                 tprintf(", %#lx", tcp->u_arg[5]);
1974                         return 0;
1975                 }
1976                 if (umove(tcp, tcp->u_arg[5], &fromlen) < 0) {
1977                         tprints(", {...}, [?]");
1978                         return 0;
1979                 }
1980                 tprints(", ");
1981                 printsock(tcp, tcp->u_arg[4], tcp->u_arg[5]);
1982                 /* from length */
1983                 tprintf(", [%u]", fromlen);
1984         }
1985         return 0;
1986 }
1987
1988 #ifdef HAVE_SENDMSG
1989
1990 int
1991 sys_recvmsg(struct tcb *tcp)
1992 {
1993         if (entering(tcp)) {
1994                 printfd(tcp, tcp->u_arg[0]);
1995                 tprints(", ");
1996         } else {
1997                 if (syserror(tcp) || !verbose(tcp))
1998                         tprintf("%#lx", tcp->u_arg[1]);
1999                 else
2000                         printmsghdr(tcp, tcp->u_arg[1], tcp->u_rval);
2001                 /* flags */
2002                 tprints(", ");
2003                 printflags(msg_flags, tcp->u_arg[2], "MSG_???");
2004         }
2005         return 0;
2006 }
2007
2008 int
2009 sys_recvmmsg(struct tcb *tcp)
2010 {
2011         /* +5 chars are for "left " prefix */
2012         static char str[5 + TIMESPEC_TEXT_BUFSIZE];
2013
2014         if (entering(tcp)) {
2015                 printfd(tcp, tcp->u_arg[0]);
2016                 tprints(", ");
2017                 if (verbose(tcp)) {
2018                         sprint_timespec(str, tcp, tcp->u_arg[4]);
2019                         /* Abusing tcp->auxstr as temp storage.
2020                          * Will be used and freed on syscall exit.
2021                          */
2022                         tcp->auxstr = strdup(str);
2023                 } else {
2024                         tprintf("%#lx, %ld, ", tcp->u_arg[1], tcp->u_arg[2]);
2025                         printflags(msg_flags, tcp->u_arg[3], "MSG_???");
2026                         tprints(", ");
2027                         print_timespec(tcp, tcp->u_arg[4]);
2028                 }
2029                 return 0;
2030         } else {
2031                 if (verbose(tcp)) {
2032                         decode_mmsg(tcp, 0);
2033                         /* timeout on entrance */
2034                         tprintf(", %s", tcp->auxstr ? tcp->auxstr : "{...}");
2035                         free((void *) tcp->auxstr);
2036                         tcp->auxstr = NULL;
2037                 }
2038                 if (syserror(tcp))
2039                         return 0;
2040                 if (tcp->u_rval == 0) {
2041                         tcp->auxstr = "Timeout";
2042                         return RVAL_STR;
2043                 }
2044                 if (!verbose(tcp))
2045                         return 0;
2046                 /* timeout on exit */
2047                 sprint_timespec(stpcpy(str, "left "), tcp, tcp->u_arg[4]);
2048                 tcp->auxstr = str;
2049                 return RVAL_STR;
2050         }
2051 }
2052
2053 #endif /* HAVE_SENDMSG */
2054
2055 static const struct xlat shutdown_modes[] = {
2056         { 0,    "SHUT_RD"       },
2057         { 1,    "SHUT_WR"       },
2058         { 2,    "SHUT_RDWR"     },
2059         XLAT_END
2060 };
2061
2062 int
2063 sys_shutdown(struct tcb *tcp)
2064 {
2065         if (entering(tcp)) {
2066                 printfd(tcp, tcp->u_arg[0]);
2067                 tprints(", ");
2068                 printxval(shutdown_modes, tcp->u_arg[1], "SHUT_???");
2069         }
2070         return 0;
2071 }
2072
2073 int
2074 sys_getsockname(struct tcb *tcp)
2075 {
2076         return sys_accept(tcp);
2077 }
2078
2079 int
2080 sys_getpeername(struct tcb *tcp)
2081 {
2082         return sys_accept(tcp);
2083 }
2084
2085 static int
2086 do_pipe(struct tcb *tcp, int flags_arg)
2087 {
2088         if (exiting(tcp)) {
2089                 if (syserror(tcp)) {
2090                         tprintf("%#lx", tcp->u_arg[0]);
2091                 } else {
2092 #if !defined(SPARC) && !defined(SPARC64) && !defined(SH) && !defined(IA64)
2093                         int fds[2];
2094
2095                         if (umoven(tcp, tcp->u_arg[0], sizeof fds, (char *) fds) < 0)
2096                                 tprints("[...]");
2097                         else
2098                                 tprintf("[%u, %u]", fds[0], fds[1]);
2099 #elif defined(SPARC) || defined(SPARC64) || defined(SH) || defined(IA64)
2100                         tprintf("[%lu, %lu]", tcp->u_rval, getrval2(tcp));
2101 #else
2102                         tprintf("%#lx", tcp->u_arg[0]);
2103 #endif
2104                 }
2105                 if (flags_arg >= 0) {
2106                         tprints(", ");
2107                         printflags(open_mode_flags, tcp->u_arg[flags_arg], "O_???");
2108                 }
2109         }
2110         return 0;
2111 }
2112
2113 int
2114 sys_pipe(struct tcb *tcp)
2115 {
2116         return do_pipe(tcp, -1);
2117 }
2118
2119 int
2120 sys_pipe2(struct tcb *tcp)
2121 {
2122         return do_pipe(tcp, 1);
2123 }
2124
2125 int
2126 sys_socketpair(struct tcb *tcp)
2127 {
2128         int fds[2];
2129
2130         if (entering(tcp)) {
2131                 printxval(domains, tcp->u_arg[0], "PF_???");
2132                 tprints(", ");
2133                 tprint_sock_type(tcp, tcp->u_arg[1]);
2134                 tprintf(", %lu", tcp->u_arg[2]);
2135         } else {
2136                 if (syserror(tcp)) {
2137                         tprintf(", %#lx", tcp->u_arg[3]);
2138                         return 0;
2139                 }
2140                 if (umoven(tcp, tcp->u_arg[3], sizeof fds, (char *) fds) < 0)
2141                         tprints(", [...]");
2142                 else
2143                         tprintf(", [%u, %u]", fds[0], fds[1]);
2144         }
2145         return 0;
2146 }
2147
2148 int
2149 sys_getsockopt(struct tcb *tcp)
2150 {
2151         if (entering(tcp)) {
2152                 printfd(tcp, tcp->u_arg[0]);
2153                 tprints(", ");
2154                 printxval(socketlayers, tcp->u_arg[1], "SOL_???");
2155                 tprints(", ");
2156                 switch (tcp->u_arg[1]) {
2157                 case SOL_SOCKET:
2158                         printxval(sockoptions, tcp->u_arg[2], "SO_???");
2159                         break;
2160 #ifdef SOL_IP
2161                 case SOL_IP:
2162                         printxval(sockipoptions, tcp->u_arg[2], "IP_???");
2163                         break;
2164 #endif
2165 #ifdef SOL_IPV6
2166                 case SOL_IPV6:
2167                         printxval(sockipv6options, tcp->u_arg[2], "IPV6_???");
2168                         break;
2169 #endif
2170 #ifdef SOL_IPX
2171                 case SOL_IPX:
2172                         printxval(sockipxoptions, tcp->u_arg[2], "IPX_???");
2173                         break;
2174 #endif
2175 #ifdef SOL_PACKET
2176                 case SOL_PACKET:
2177                         printxval(sockpacketoptions, tcp->u_arg[2], "PACKET_???");
2178                         break;
2179 #endif
2180 #ifdef SOL_TCP
2181                 case SOL_TCP:
2182                         printxval(socktcpoptions, tcp->u_arg[2], "TCP_???");
2183                         break;
2184 #endif
2185 #ifdef SOL_SCTP
2186                 case SOL_SCTP:
2187                         printxval(socksctpoptions, tcp->u_arg[2], "SCTP_???");
2188                         break;
2189 #endif
2190
2191                 /* SOL_AX25 SOL_ROSE SOL_ATALK SOL_NETROM SOL_UDP SOL_DECNET SOL_X25
2192                  * etc. still need work */
2193                 default:
2194                         tprintf("%lu", tcp->u_arg[2]);
2195                         break;
2196                 }
2197                 tprints(", ");
2198         } else {
2199                 int len;
2200                 if (syserror(tcp) || umove(tcp, tcp->u_arg[4], &len) < 0) {
2201                         tprintf("%#lx, %#lx",
2202                                 tcp->u_arg[3], tcp->u_arg[4]);
2203                         return 0;
2204                 }
2205
2206                 switch (tcp->u_arg[1]) {
2207                 case SOL_SOCKET:
2208                         switch (tcp->u_arg[2]) {
2209 #ifdef SO_LINGER
2210                         case SO_LINGER:
2211                                 if (len == sizeof(struct linger)) {
2212                                         struct linger linger;
2213                                         if (umove(tcp,
2214                                                    tcp->u_arg[3],
2215                                                    &linger) < 0)
2216                                                 break;
2217                                         tprintf("{onoff=%d, linger=%d}, "
2218                                                 "[%d]",
2219                                                 linger.l_onoff,
2220                                                 linger.l_linger,
2221                                                 len);
2222                                         return 0;
2223                                 }
2224                                 break;
2225 #endif
2226 #ifdef SO_PEERCRED
2227                         case SO_PEERCRED:
2228                                 if (len == sizeof(struct ucred)) {
2229                                         struct ucred uc;
2230                                         if (umove(tcp,
2231                                                    tcp->u_arg[3],
2232                                                    &uc) < 0)
2233                                                 break;
2234                                         tprintf("{pid=%ld, uid=%ld, gid=%ld}, "
2235                                                 "[%d]",
2236                                                 (long)uc.pid,
2237                                                 (long)uc.uid,
2238                                                 (long)uc.gid,
2239                                                 len);
2240                                         return 0;
2241                                 }
2242                                 break;
2243 #endif
2244                         }
2245                         break;
2246                 case SOL_PACKET:
2247                         switch (tcp->u_arg[2]) {
2248 #ifdef PACKET_STATISTICS
2249                         case PACKET_STATISTICS:
2250                                 if (len == sizeof(struct tpacket_stats)) {
2251                                         struct tpacket_stats stats;
2252                                         if (umove(tcp,
2253                                                    tcp->u_arg[3],
2254                                                    &stats) < 0)
2255                                                 break;
2256                                         tprintf("{packets=%u, drops=%u}, "
2257                                                 "[%d]",
2258                                                 stats.tp_packets,
2259                                                 stats.tp_drops,
2260                                                 len);
2261                                         return 0;
2262                                 }
2263                                 break;
2264 #endif
2265                         }
2266                         break;
2267                 }
2268
2269                 if (len == sizeof(int)) {
2270                         printnum_int(tcp, tcp->u_arg[3], "%d");
2271                 }
2272                 else {
2273                         printstr(tcp, tcp->u_arg[3], len);
2274                 }
2275                 tprintf(", [%d]", len);
2276         }
2277         return 0;
2278 }
2279
2280 #if defined(ICMP_FILTER)
2281 static void printicmpfilter(struct tcb *tcp, long addr)
2282 {
2283         struct icmp_filter      filter;
2284
2285         if (!addr) {
2286                 tprints("NULL");
2287                 return;
2288         }
2289         if (syserror(tcp) || !verbose(tcp)) {
2290                 tprintf("%#lx", addr);
2291                 return;
2292         }
2293         if (umove(tcp, addr, &filter) < 0) {
2294                 tprints("{...}");
2295                 return;
2296         }
2297
2298         tprints("~(");
2299         printflags(icmpfilterflags, ~filter.data, "ICMP_???");
2300         tprints(")");
2301 }
2302 #endif /* ICMP_FILTER */
2303
2304 static int
2305 printsockopt(struct tcb *tcp, int level, int name, long addr, int len)
2306 {
2307         printxval(socketlayers, level, "SOL_??");
2308         tprints(", ");
2309         switch (level) {
2310         case SOL_SOCKET:
2311                 printxval(sockoptions, name, "SO_???");
2312                 switch (name) {
2313 #if defined(SO_LINGER)
2314                 case SO_LINGER:
2315                         if (len == sizeof(struct linger)) {
2316                                 struct linger linger;
2317                                 if (umove(tcp, addr, &linger) < 0)
2318                                         break;
2319                                 tprintf(", {onoff=%d, linger=%d}",
2320                                         linger.l_onoff,
2321                                         linger.l_linger);
2322                                 return 0;
2323                         }
2324                         break;
2325 #endif
2326                 }
2327                 break;
2328 #ifdef SOL_IP
2329         case SOL_IP:
2330                 printxval(sockipoptions, name, "IP_???");
2331                 break;
2332 #endif
2333 #ifdef SOL_IPV6
2334         case SOL_IPV6:
2335                 printxval(sockipv6options, name, "IPV6_???");
2336                 break;
2337 #endif
2338 #ifdef SOL_IPX
2339         case SOL_IPX:
2340                 printxval(sockipxoptions, name, "IPX_???");
2341                 break;
2342 #endif
2343 #ifdef SOL_PACKET
2344         case SOL_PACKET:
2345                 printxval(sockpacketoptions, name, "PACKET_???");
2346                 /* TODO: decode packate_mreq for PACKET_*_MEMBERSHIP */
2347                 switch (name) {
2348 #ifdef PACKET_RX_RING
2349                 case PACKET_RX_RING:
2350 #endif
2351 #ifdef PACKET_TX_RING
2352                 case PACKET_TX_RING:
2353 #endif
2354 #if defined(PACKET_RX_RING) || defined(PACKET_TX_RING)
2355                         if (len == sizeof(struct tpacket_req)) {
2356                                 struct tpacket_req req;
2357                                 if (umove(tcp, addr, &req) < 0)
2358                                         break;
2359                                 tprintf(", {block_size=%u, block_nr=%u, frame_size=%u, frame_nr=%u}",
2360                                         req.tp_block_size,
2361                                         req.tp_block_nr,
2362                                         req.tp_frame_size,
2363                                         req.tp_frame_nr);
2364                                 return 0;
2365                         }
2366                         break;
2367 #endif /* PACKET_RX_RING || PACKET_TX_RING */
2368                 }
2369                 break;
2370 #endif
2371 #ifdef SOL_TCP
2372         case SOL_TCP:
2373                 printxval(socktcpoptions, name, "TCP_???");
2374                 break;
2375 #endif
2376 #ifdef SOL_SCTP
2377         case SOL_SCTP:
2378                 printxval(socksctpoptions, name, "SCTP_???");
2379                 break;
2380 #endif
2381 #ifdef SOL_RAW
2382         case SOL_RAW:
2383                 printxval(sockrawoptions, name, "RAW_???");
2384                 switch (name) {
2385 #if defined(ICMP_FILTER)
2386                         case ICMP_FILTER:
2387                                 tprints(", ");
2388                                 printicmpfilter(tcp, addr);
2389                                 return 0;
2390 #endif
2391                 }
2392                 break;
2393 #endif
2394
2395                 /* SOL_AX25 SOL_ATALK SOL_NETROM SOL_UDP SOL_DECNET SOL_X25
2396                  * etc. still need work  */
2397
2398         default:
2399                 tprintf("%u", name);
2400         }
2401
2402         /* default arg printing */
2403
2404         tprints(", ");
2405
2406         if (len == sizeof(int)) {
2407                 printnum_int(tcp, addr, "%d");
2408         }
2409         else {
2410                 printstr(tcp, addr, len);
2411         }
2412         return 0;
2413 }
2414
2415 int
2416 sys_setsockopt(struct tcb *tcp)
2417 {
2418         if (entering(tcp)) {
2419                 printfd(tcp, tcp->u_arg[0]);
2420                 tprints(", ");
2421                 printsockopt(tcp, tcp->u_arg[1], tcp->u_arg[2],
2422                               tcp->u_arg[3], tcp->u_arg[4]);
2423                 tprintf(", %lu", tcp->u_arg[4]);
2424         }
2425         return 0;
2426 }