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