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/uio.h>
  35 #include <sys/un.h>
  36 #include <netinet/in.h>
  37 #ifdef HAVE_NETINET_TCP_H
  38 # include <netinet/tcp.h>
  39 #endif
  40 #ifdef HAVE_NETINET_UDP_H
  41 # include <netinet/udp.h>
  42 #endif
  43 #ifdef HAVE_NETINET_SCTP_H
  44 # include <netinet/sctp.h>
  45 #endif
  46 #include <arpa/inet.h>
  47 #include <net/if.h>
  48 #include <asm/types.h>
  49 #if defined(__GLIBC__)
  50 # include <netipx/ipx.h>
  51 #else
  52 # include <linux/ipx.h>
  53 #endif
  54
  55 #if defined(HAVE_LINUX_IP_VS_H)
  56 # include <linux/ip_vs.h>
  57 #endif
  58 #if defined(HAVE_LINUX_NETLINK_H)
  59 # include <linux/netlink.h>
  60 #endif
  61 #if defined(HAVE_LINUX_NETFILTER_ARP_ARP_TABLES_H)
  62 # include <linux/netfilter_arp/arp_tables.h>
  63 #endif
  64 #if defined(HAVE_LINUX_NETFILTER_BRIDGE_EBTABLES_H)
  65 # include <linux/netfilter_bridge/ebtables.h>
  66 #endif
  67 #if defined(HAVE_LINUX_NETFILTER_IPV4_IP_TABLES_H)
  68 # include <linux/netfilter_ipv4/ip_tables.h>
  69 #endif
  70 #if defined(HAVE_LINUX_NETFILTER_IPV6_IP6_TABLES_H)
  71 # include <linux/netfilter_ipv6/ip6_tables.h>
  72 #endif
  73 #if defined(HAVE_LINUX_IF_PACKET_H)
  74 # include <linux/if_packet.h>
  75 #endif
  76 #if defined(HAVE_LINUX_ICMP_H)
  77 # include <linux/icmp.h>
  78 #endif
  79 #ifdef HAVE_BLUETOOTH_BLUETOOTH_H
  80 # include <bluetooth/bluetooth.h>
  81 # include <bluetooth/hci.h>
  82 # include <bluetooth/l2cap.h>
  83 # include <bluetooth/rfcomm.h>
  84 # include <bluetooth/sco.h>
  85 #endif
  86 #ifndef PF_UNSPEC
  87 # define PF_UNSPEC AF_UNSPEC
  88 #endif
  89
  90 #include "xlat/domains.h"
  91 #include "xlat/addrfams.h"
  92 #include "xlat/socktypes.h"
  93 #include "xlat/sock_type_flags.h"
  94 #ifndef SOCK_TYPE_MASK
  95 # define SOCK_TYPE_MASK 0xf
  96 #endif
  97
  98 #include "xlat/socketlayers.h"
  99
 100 #include "xlat/inet_protocols.h"
 101
 102 #ifdef PF_NETLINK
 103 # if !defined NETLINK_SOCK_DIAG && defined NETLINK_INET_DIAG
 104 #  define NETLINK_SOCK_DIAG NETLINK_INET_DIAG
 105 # endif
 106 # include "xlat/netlink_protocols.h"
 107 #endif
 108
 109 #if defined(HAVE_BLUETOOTH_BLUETOOTH_H)
 110 # include "xlat/bt_protocols.h"
 111 #endif
 112
 113 #include "xlat/msg_flags.h"
 114
 115 #if defined(AF_PACKET) /* from e.g. linux/if_packet.h */
 116 # include "xlat/af_packet_types.h"
 117 #endif
 118
 119 static void
 120 print_ifindex(unsigned int ifindex)
 121 {
 122 #ifdef HAVE_IF_INDEXTONAME
 123         char buf[IFNAMSIZ + 1];
 124
 125         if (if_indextoname(ifindex, buf)) {
 126                 tprints("if_nametoindex(");
 127                 print_quoted_string(buf, sizeof(buf), QUOTE_0_TERMINATED);
 128                 tprints(")");
 129                 return;
 130         }
 131 #endif
 132         tprintf("%u", ifindex);
 133 }
 134
 135 typedef union {
 136         char pad[128];
 137         struct sockaddr sa;
 138         struct sockaddr_in sin;
 139         struct sockaddr_un sau;
 140 #ifdef HAVE_INET_NTOP
 141         struct sockaddr_in6 sa6;
 142 #endif
 143 #if defined(AF_IPX)
 144         struct sockaddr_ipx sipx;
 145 #endif
 146 #ifdef AF_PACKET
 147         struct sockaddr_ll ll;
 148 #endif
 149 #ifdef AF_NETLINK
 150         struct sockaddr_nl nl;
 151 #endif
 152 #ifdef HAVE_BLUETOOTH_BLUETOOTH_H
 153         struct sockaddr_hci hci;
 154         struct sockaddr_l2 l2;
 155         struct sockaddr_rc rc;
 156         struct sockaddr_sco sco;
 157 #endif
 158 } sockaddr_buf_t;
 159
 160 static void
 161 print_sockaddr(struct tcb *tcp, const sockaddr_buf_t *addr, const int addrlen)
 162 {
 163         tprints("{sa_family=");
 164         printxval(addrfams, addr->sa.sa_family, "AF_???");
 165         tprints(", ");
 166
 167         switch (addr->sa.sa_family) {
 168         case AF_UNIX:
 169                 if (addrlen == 2) {
 170                         tprints("NULL");
 171                 } else if (addr->sau.sun_path[0]) {
 172                         tprints("sun_path=");
 173                         print_quoted_string(addr->sau.sun_path,
 174                                             sizeof(addr->sau.sun_path) + 1,
 175                                             QUOTE_0_TERMINATED);
 176                 } else {
 177                         tprints("sun_path=@");
 178                         print_quoted_string(addr->sau.sun_path + 1,
 179                                             sizeof(addr->sau.sun_path),
 180                                             QUOTE_0_TERMINATED);
 181                 }
 182                 break;
 183         case AF_INET:
 184                 tprintf("sin_port=htons(%u), sin_addr=inet_addr(\"%s\")",
 185                         ntohs(addr->sin.sin_port), inet_ntoa(addr->sin.sin_addr));
 186                 break;
 187 #ifdef HAVE_INET_NTOP
 188         case AF_INET6:
 189                 {
 190                         char string_addr[100];
 191                         inet_ntop(AF_INET6, &addr->sa6.sin6_addr,
 192                                   string_addr, sizeof(string_addr));
 193                         tprintf("sin6_port=htons(%u), inet_pton(AF_INET6"
 194                                 ", \"%s\", &sin6_addr), sin6_flowinfo=%u",
 195                                 ntohs(addr->sa6.sin6_port), string_addr,
 196                                 addr->sa6.sin6_flowinfo);
 197 # ifdef HAVE_STRUCT_SOCKADDR_IN6_SIN6_SCOPE_ID
 198                         tprints(", sin6_scope_id=");
 199 #  if defined IN6_IS_ADDR_LINKLOCAL && defined IN6_IS_ADDR_MC_LINKLOCAL
 200                         if (IN6_IS_ADDR_LINKLOCAL(&addr->sa6.sin6_addr)
 201                             || IN6_IS_ADDR_MC_LINKLOCAL(&addr->sa6.sin6_addr))
 202                                 print_ifindex(addr->sa6.sin6_scope_id);
 203                         else
 204 #  endif
 205                                 tprintf("%u", addr->sa6.sin6_scope_id);
 206 # endif /* HAVE_STRUCT_SOCKADDR_IN6_SIN6_SCOPE_ID */
 207                 }
 208                 break;
 209 #endif
 210 #if defined(AF_IPX)
 211         case AF_IPX:
 212                 {
 213                         int i;
 214                         tprintf("sipx_port=htons(%u), ",
 215                                         ntohs(addr->sipx.sipx_port));
 216                         /* Yes, I know, this does not look too
 217                          * strace-ish, but otherwise the IPX
 218                          * addresses just look monstrous...
 219                          * Anyways, feel free if you don't like
 220                          * this way.. :)
 221                          */
 222                         tprintf("%08lx:", (unsigned long)ntohl(addr->sipx.sipx_network));
 223                         for (i = 0; i < IPX_NODE_LEN; i++)
 224                                 tprintf("%02x", addr->sipx.sipx_node[i]);
 225                         tprintf("/[%02x]", addr->sipx.sipx_type);
 226                 }
 227                 break;
 228 #endif /* AF_IPX */
 229 #ifdef AF_PACKET
 230         case AF_PACKET:
 231                 {
 232                         int i;
 233                         tprintf("proto=%#04x, if%d, pkttype=",
 234                                         ntohs(addr->ll.sll_protocol),
 235                                         addr->ll.sll_ifindex);
 236                         printxval(af_packet_types, addr->ll.sll_pkttype, "PACKET_???");
 237                         tprintf(", addr(%d)={%d, ",
 238                                         addr->ll.sll_halen,
 239                                         addr->ll.sll_hatype);
 240                         for (i = 0; i < addr->ll.sll_halen; i++)
 241                                 tprintf("%02x", addr->ll.sll_addr[i]);
 242                 }
 243                 break;
 244
 245 #endif /* AF_PACKET */
 246 #ifdef AF_NETLINK
 247         case AF_NETLINK:
 248                 tprintf("pid=%d, groups=%08x", addr->nl.nl_pid, addr->nl.nl_groups);
 249                 break;
 250 #endif /* AF_NETLINK */
 251 #if defined(AF_BLUETOOTH) && defined(HAVE_BLUETOOTH_BLUETOOTH_H)
 252         case AF_BLUETOOTH:
 253                 tprintf("{sco_bdaddr=%02X:%02X:%02X:%02X:%02X:%02X} or "
 254                         "{rc_bdaddr=%02X:%02X:%02X:%02X:%02X:%02X, rc_channel=%d} or "
 255                         "{l2_psm=htobs(%d), l2_bdaddr=%02X:%02X:%02X:%02X:%02X:%02X, l2_cid=htobs(%d)} or "
 256                         "{hci_dev=htobs(%d)}",
 257                         addr->sco.sco_bdaddr.b[0], addr->sco.sco_bdaddr.b[1],
 258                         addr->sco.sco_bdaddr.b[2], addr->sco.sco_bdaddr.b[3],
 259                         addr->sco.sco_bdaddr.b[4], addr->sco.sco_bdaddr.b[5],
 260                         addr->rc.rc_bdaddr.b[0], addr->rc.rc_bdaddr.b[1],
 261                         addr->rc.rc_bdaddr.b[2], addr->rc.rc_bdaddr.b[3],
 262                         addr->rc.rc_bdaddr.b[4], addr->rc.rc_bdaddr.b[5],
 263                         addr->rc.rc_channel,
 264                         btohs(addr->l2.l2_psm), addr->l2.l2_bdaddr.b[0],
 265                         addr->l2.l2_bdaddr.b[1], addr->l2.l2_bdaddr.b[2],
 266                         addr->l2.l2_bdaddr.b[3], addr->l2.l2_bdaddr.b[4],
 267                         addr->l2.l2_bdaddr.b[5], btohs(addr->l2.l2_cid),
 268                         btohs(addr->hci.hci_dev));
 269                 break;
 270 #endif /* AF_BLUETOOTH && HAVE_BLUETOOTH_BLUETOOTH_H */
 271         /* AF_AX25 AF_APPLETALK AF_NETROM AF_BRIDGE AF_AAL5
 272         AF_X25 AF_ROSE etc. still need to be done */
 273
 274         default:
 275                 tprints("sa_data=");
 276                 print_quoted_string(addr->sa.sa_data,
 277                                     sizeof(addr->sa.sa_data), 0);
 278                 break;
 279         }
 280         tprints("}");
 281 }
 282
 283 void
 284 printsock(struct tcb *tcp, long addr, int addrlen)
 285 {
 286         sockaddr_buf_t addrbuf;
 287
 288         if (addrlen < 2) {
 289                 printaddr(addr);
 290                 return;
 291         }
 292
 293         if (addrlen > (int) sizeof(addrbuf))
 294                 addrlen = sizeof(addrbuf);
 295
 296         memset(&addrbuf, 0, sizeof(addrbuf));
 297         if (umoven_or_printaddr(tcp, addr, addrlen, addrbuf.pad))
 298                 return;
 299         addrbuf.pad[sizeof(addrbuf.pad) - 1] = '\0';
 300
 301         print_sockaddr(tcp, &addrbuf, addrlen);
 302 }
 303
 304 #include "xlat/scmvals.h"
 305 #include "xlat/ip_cmsg_types.h"
 306
 307 #if SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4
 308 struct cmsghdr32 {
 309         uint32_t cmsg_len;
 310         int cmsg_level;
 311         int cmsg_type;
 312 };
 313 #endif
 314
 315 typedef union {
 316         char *ptr;
 317         struct cmsghdr *cmsg;
 318 #if SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4
 319         struct cmsghdr32 *cmsg32;
 320 #endif
 321 } union_cmsghdr;
 322
 323 static void
 324 print_scm_rights(struct tcb *tcp, const void *cmsg_data,
 325                  const size_t data_len)
 326 {
 327         const int *fds = cmsg_data;
 328         const char *end = (const char *) cmsg_data + data_len;
 329         bool seen = false;
 330
 331         if (sizeof(*fds) > data_len)
 332                 return;
 333
 334         tprints(", [");
 335         while ((const char *) fds < end) {
 336                 if (seen)
 337                         tprints(", ");
 338                 else
 339                         seen = true;
 340                 printfd(tcp, *fds++);
 341         }
 342         tprints("]");
 343 }
 344
 345 static void
 346 print_scm_creds(struct tcb *tcp, const void *cmsg_data,
 347                 const size_t data_len)
 348 {
 349         const struct ucred *uc = cmsg_data;
 350
 351         if (sizeof(*uc) > data_len)
 352                 return;
 353
 354         tprintf(", {pid=%u, uid=%u, gid=%u}",
 355                 (unsigned) uc->pid, (unsigned) uc->uid, (unsigned) uc->gid);
 356 }
 357
 358 static void
 359 print_scm_security(struct tcb *tcp, const void *cmsg_data,
 360                    const size_t data_len)
 361 {
 362         if (!data_len)
 363                 return;
 364
 365         tprints(", ");
 366         print_quoted_string(cmsg_data, data_len, 0);
 367 }
 368
 369 static void
 370 print_cmsg_ip_pktinfo(struct tcb *tcp, const void *cmsg_data,
 371                       const size_t data_len)
 372 {
 373         const struct in_pktinfo *info = cmsg_data;
 374
 375         if (sizeof(*info) > data_len)
 376                 return;
 377
 378         tprints(", {ipi_ifindex=");
 379         print_ifindex(info->ipi_ifindex);
 380         tprintf(", ipi_spec_dst=inet_addr(\"%s\"), ipi_addr=inet_addr(\"%s\")}",
 381                 inet_ntoa(info->ipi_spec_dst), inet_ntoa(info->ipi_addr));
 382 }
 383
 384 static void
 385 print_cmsg_ip_ttl(struct tcb *tcp, const void *cmsg_data,
 386                   const size_t data_len)
 387 {
 388         const unsigned int *ttl = cmsg_data;
 389
 390         if (sizeof(*ttl) > data_len)
 391                 return;
 392
 393         tprintf(", {ttl=%u}", *ttl);
 394 }
 395
 396 static void
 397 print_cmsg_ip_tos(struct tcb *tcp, const void *cmsg_data,
 398                   const size_t data_len)
 399 {
 400         const uint8_t *tos = cmsg_data;
 401
 402         if (sizeof(*tos) > data_len)
 403                 return;
 404
 405         tprintf(", {tos=%x}", *tos);
 406 }
 407
 408 static void
 409 print_cmsg_ip_checksum(struct tcb *tcp, const void *cmsg_data,
 410                        const size_t data_len)
 411 {
 412         const uint32_t *csum = cmsg_data;
 413
 414         if (sizeof(*csum) > data_len)
 415                 return;
 416
 417         tprintf(", {csum=%u}", *csum);
 418 }
 419
 420 static void
 421 print_cmsg_ip_opts(struct tcb *tcp, const void *cmsg_data,
 422                    const size_t data_len)
 423 {
 424         const unsigned char *opts = cmsg_data;
 425         size_t i;
 426
 427         if (!data_len)
 428                 return;
 429
 430         tprints(", {opts=0x");
 431         for (i = 0; i < data_len; ++i)
 432                 tprintf("%02x", opts[i]);
 433         tprints("}");
 434 }
 435
 436 static void
 437 print_cmsg_ip_recverr(struct tcb *tcp, const void *cmsg_data,
 438                       const size_t data_len)
 439 {
 440         const struct {
 441                 uint32_t ee_errno;
 442                 uint8_t  ee_origin;
 443                 uint8_t  ee_type;
 444                 uint8_t  ee_code;
 445                 uint8_t  ee_pad;
 446                 uint32_t ee_info;
 447                 uint32_t ee_data;
 448                 struct sockaddr_in offender;
 449         } *err = cmsg_data;
 450
 451         if (sizeof(*err) > data_len)
 452                 return;
 453
 454         tprintf(", {ee_errno=%u, ee_origin=%u, ee_type=%u, ee_code=%u"
 455                 ", ee_info=%u, ee_data=%u, offender=",
 456                 err->ee_errno, err->ee_origin, err->ee_type,
 457                 err->ee_code, err->ee_info, err->ee_data);
 458         print_sockaddr(tcp, (const void *) &err->offender,
 459                 sizeof(err->offender));
 460         tprints("}");
 461 }
 462
 463 static void
 464 print_cmsg_ip_origdstaddr(struct tcb *tcp, const void *cmsg_data,
 465                           const size_t data_len)
 466 {
 467         if (sizeof(struct sockaddr_in) > data_len)
 468                 return;
 469
 470         tprints(", ");
 471         print_sockaddr(tcp, cmsg_data, data_len);
 472 }
 473
 474 static void
 475 print_cmsg_type_data(struct tcb *tcp, const int cmsg_level, const int cmsg_type,
 476                      const void *cmsg_data, const size_t data_len)
 477 {
 478         switch (cmsg_level) {
 479         case SOL_SOCKET:
 480                 printxval(scmvals, cmsg_type, "SCM_???");
 481                 switch (cmsg_type) {
 482                 case SCM_RIGHTS:
 483                         print_scm_rights(tcp, cmsg_data, data_len);
 484                         break;
 485                 case SCM_CREDENTIALS:
 486                         print_scm_creds(tcp, cmsg_data, data_len);
 487                         break;
 488                 case SCM_SECURITY:
 489                         print_scm_security(tcp, cmsg_data, data_len);
 490                         break;
 491                 }
 492                 break;
 493         case SOL_IP:
 494                 printxval(ip_cmsg_types, cmsg_type, "IP_???");
 495                 switch (cmsg_type) {
 496                 case IP_PKTINFO:
 497                         print_cmsg_ip_pktinfo(tcp, cmsg_data, data_len);
 498                         break;
 499                 case IP_TTL:
 500                         print_cmsg_ip_ttl(tcp, cmsg_data, data_len);
 501                         break;
 502                 case IP_TOS:
 503                         print_cmsg_ip_tos(tcp, cmsg_data, data_len);
 504                         break;
 505                 case IP_RECVOPTS:
 506                 case IP_RETOPTS:
 507                         print_cmsg_ip_opts(tcp, cmsg_data, data_len);
 508                         break;
 509                 case IP_RECVERR:
 510                         print_cmsg_ip_recverr(tcp, cmsg_data, data_len);
 511                         break;
 512                 case IP_ORIGDSTADDR:
 513                         print_cmsg_ip_origdstaddr(tcp, cmsg_data, data_len);
 514                         break;
 515                 case IP_CHECKSUM:
 516                         print_cmsg_ip_checksum(tcp, cmsg_data, data_len);
 517                         break;
 518                 case SCM_SECURITY:
 519                         print_scm_security(tcp, cmsg_data, data_len);
 520                         break;
 521                 }
 522                 break;
 523         default:
 524                 tprintf("%u", cmsg_type);
 525         }
 526 }
 527
 528 static void
 529 printcmsghdr(struct tcb *tcp, unsigned long addr, size_t len)
 530 {
 531         const size_t cmsg_size =
 532 #if SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4
 533                 (current_wordsize < sizeof(long)) ? sizeof(struct cmsghdr32) :
 534 #endif
 535                         sizeof(struct cmsghdr);
 536
 537         char *buf = len < cmsg_size ? NULL : malloc(len);
 538         if (!buf || umoven(tcp, addr, len, buf) < 0) {
 539                 tprints(", msg_control=");
 540                 printaddr(addr);
 541                 free(buf);
 542                 return;
 543         }
 544
 545         union_cmsghdr u = { .ptr = buf };
 546
 547         tprints(", [");
 548         while (len >= cmsg_size) {
 549                 size_t cmsg_len =
 550 #if SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4
 551                         (current_wordsize < sizeof(long)) ? u.cmsg32->cmsg_len :
 552 #endif
 553                                 u.cmsg->cmsg_len;
 554                 int cmsg_level =
 555 #if SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4
 556                         (current_wordsize < sizeof(long)) ? u.cmsg32->cmsg_level :
 557 #endif
 558                                 u.cmsg->cmsg_level;
 559                 int cmsg_type =
 560 #if SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4
 561                         (current_wordsize < sizeof(long)) ? u.cmsg32->cmsg_type :
 562 #endif
 563                                 u.cmsg->cmsg_type;
 564
 565                 if (u.ptr != buf)
 566                         tprints(", ");
 567                 tprintf("{cmsg_len=%lu, cmsg_level=", (unsigned long) cmsg_len);
 568                 printxval(socketlayers, cmsg_level, "SOL_???");
 569                 tprints(", cmsg_type=");
 570
 571                 if (cmsg_len > len)
 572                         cmsg_len = len;
 573
 574                 print_cmsg_type_data(tcp, cmsg_level, cmsg_type,
 575                                      (const void *) (u.ptr + cmsg_size),
 576                                      cmsg_len > cmsg_size ? cmsg_len - cmsg_size: 0);
 577                 tprints("}");
 578
 579                 if (cmsg_len < cmsg_size) {
 580                         len -= cmsg_size;
 581                         break;
 582                 }
 583                 cmsg_len = (cmsg_len + current_wordsize - 1) &
 584                         (size_t) ~(current_wordsize - 1);
 585                 if (cmsg_len >= len) {
 586                         len = 0;
 587                         break;
 588                 }
 589                 u.ptr += cmsg_len;
 590                 len -= cmsg_len;
 591         }
 592         if (len)
 593                 tprints(", ...");
 594         tprints("]");
 595         free(buf);
 596 }
 597
 598 static void
 599 do_msghdr(struct tcb *tcp, struct msghdr *msg, unsigned long data_size)
 600 {
 601         tprintf("{msg_name(%d)=", msg->msg_namelen);
 602         printsock(tcp, (long)msg->msg_name, msg->msg_namelen);
 603
 604         tprintf(", msg_iov(%lu)=", (unsigned long)msg->msg_iovlen);
 605         tprint_iov_upto(tcp, (unsigned long)msg->msg_iovlen,
 606                    (unsigned long)msg->msg_iov, 1, data_size);
 607
 608 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
 609         tprintf(", msg_controllen=%lu", (unsigned long)msg->msg_controllen);
 610         if (msg->msg_controllen)
 611                 printcmsghdr(tcp, (unsigned long) msg->msg_control,
 612                              msg->msg_controllen);
 613         tprints(", msg_flags=");
 614         printflags(msg_flags, msg->msg_flags, "MSG_???");
 615 #else /* !HAVE_STRUCT_MSGHDR_MSG_CONTROL */
 616         tprintf("msg_accrights=%#lx, msg_accrightslen=%u",
 617                 (unsigned long) msg->msg_accrights, msg->msg_accrightslen);
 618 #endif /* !HAVE_STRUCT_MSGHDR_MSG_CONTROL */
 619         tprints("}");
 620 }
 621
 622 struct msghdr32 {
 623         uint32_t /* void* */    msg_name;
 624         uint32_t /* socklen_t */msg_namelen;
 625         uint32_t /* iovec* */   msg_iov;
 626         uint32_t /* size_t */   msg_iovlen;
 627         uint32_t /* void* */    msg_control;
 628         uint32_t /* size_t */   msg_controllen;
 629         uint32_t /* int */      msg_flags;
 630 };
 631 struct mmsghdr32 {
 632         struct msghdr32         msg_hdr;
 633         uint32_t /* unsigned */ msg_len;
 634 };
 635
 636 #ifndef HAVE_STRUCT_MMSGHDR
 637 struct mmsghdr {
 638         struct msghdr msg_hdr;
 639         unsigned msg_len;
 640 };
 641 #endif
 642
 643 #if SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4
 644 static void
 645 copy_from_msghdr32(struct msghdr *to_msg, struct msghdr32 *from_msg32)
 646 {
 647         to_msg->msg_name       = (void*)(long)from_msg32->msg_name;
 648         to_msg->msg_namelen    =              from_msg32->msg_namelen;
 649         to_msg->msg_iov        = (void*)(long)from_msg32->msg_iov;
 650         to_msg->msg_iovlen     =              from_msg32->msg_iovlen;
 651         to_msg->msg_control    = (void*)(long)from_msg32->msg_control;
 652         to_msg->msg_controllen =              from_msg32->msg_controllen;
 653         to_msg->msg_flags      =              from_msg32->msg_flags;
 654 }
 655 #endif
 656
 657 static bool
 658 extractmsghdr(struct tcb *tcp, long addr, struct msghdr *msg)
 659 {
 660 #if SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4
 661         if (current_wordsize == 4) {
 662                 struct msghdr32 msg32;
 663
 664                 if (umove(tcp, addr, &msg32) < 0)
 665                         return false;
 666                 copy_from_msghdr32(msg, &msg32);
 667         } else
 668 #endif
 669         if (umove(tcp, addr, msg) < 0)
 670                 return false;
 671         return true;
 672 }
 673
 674 static bool
 675 extractmmsghdr(struct tcb *tcp, long addr, unsigned int idx, struct mmsghdr *mmsg)
 676 {
 677 #if SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4
 678         if (current_wordsize == 4) {
 679                 struct mmsghdr32 mmsg32;
 680
 681                 addr += sizeof(struct mmsghdr32) * idx;
 682                 if (umove(tcp, addr, &mmsg32) < 0)
 683                         return false;
 684
 685                 copy_from_msghdr32(&mmsg->msg_hdr, &mmsg32.msg_hdr);
 686                 mmsg->msg_len = mmsg32.msg_len;
 687         } else
 688 #endif
 689         {
 690                 addr += sizeof(*mmsg) * idx;
 691                 if (umove(tcp, addr, mmsg) < 0)
 692                         return false;
 693         }
 694         return true;
 695 }
 696
 697 static void
 698 printmsghdr(struct tcb *tcp, long addr, unsigned long data_size)
 699 {
 700         struct msghdr msg;
 701
 702         if (verbose(tcp) && extractmsghdr(tcp, addr, &msg))
 703                 do_msghdr(tcp, &msg, data_size);
 704         else
 705                 printaddr(addr);
 706 }
 707
 708 void
 709 dumpiov_in_msghdr(struct tcb *tcp, long addr)
 710 {
 711         struct msghdr msg;
 712
 713         if (extractmsghdr(tcp, addr, &msg))
 714                 dumpiov(tcp, msg.msg_iovlen, (long)msg.msg_iov);
 715 }
 716
 717 static void
 718 printmmsghdr(struct tcb *tcp, long addr, unsigned int idx, unsigned long msg_len)
 719 {
 720         struct mmsghdr mmsg;
 721
 722         if (extractmmsghdr(tcp, addr, idx, &mmsg)) {
 723                 tprints("{");
 724                 do_msghdr(tcp, &mmsg.msg_hdr, msg_len ? msg_len : mmsg.msg_len);
 725                 tprintf(", %u}", mmsg.msg_len);
 726         }
 727         else
 728                 printaddr(addr);
 729 }
 730
 731 static void
 732 decode_mmsg(struct tcb *tcp, unsigned long msg_len)
 733 {
 734         /* mmsgvec */
 735         if (syserror(tcp)) {
 736                 printaddr(tcp->u_arg[1]);
 737         } else {
 738                 unsigned int len = tcp->u_rval;
 739                 unsigned int i;
 740
 741                 tprints("{");
 742                 for (i = 0; i < len; ++i) {
 743                         if (i)
 744                                 tprints(", ");
 745                         printmmsghdr(tcp, tcp->u_arg[1], i, msg_len);
 746                 }
 747                 tprints("}");
 748         }
 749         /* vlen */
 750         tprintf(", %u, ", (unsigned int) tcp->u_arg[2]);
 751         /* flags */
 752         printflags(msg_flags, tcp->u_arg[3], "MSG_???");
 753 }
 754
 755 void
 756 dumpiov_in_mmsghdr(struct tcb *tcp, long addr)
 757 {
 758         unsigned int len = tcp->u_rval;
 759         unsigned int i;
 760         struct mmsghdr mmsg;
 761
 762         for (i = 0; i < len; ++i) {
 763                 if (extractmmsghdr(tcp, addr, i, &mmsg)) {
 764                         tprintf(" = %lu buffers in vector %u\n",
 765                                 (unsigned long)mmsg.msg_hdr.msg_iovlen, i);
 766                         dumpiov(tcp, mmsg.msg_hdr.msg_iovlen,
 767                                 (long)mmsg.msg_hdr.msg_iov);
 768                 }
 769         }
 770 }
 771
 772 /*
 773  * low bits of the socket type define real socket type,
 774  * other bits are socket type flags.
 775  */
 776 static void
 777 tprint_sock_type(int flags)
 778 {
 779         const char *str = xlookup(socktypes, flags & SOCK_TYPE_MASK);
 780
 781         if (str) {
 782                 tprints(str);
 783                 flags &= ~SOCK_TYPE_MASK;
 784                 if (!flags)
 785                         return;
 786                 tprints("|");
 787         }
 788         printflags(sock_type_flags, flags, "SOCK_???");
 789 }
 790
 791 SYS_FUNC(socket)
 792 {
 793         printxval(domains, tcp->u_arg[0], "PF_???");
 794         tprints(", ");
 795         tprint_sock_type(tcp->u_arg[1]);
 796         tprints(", ");
 797         switch (tcp->u_arg[0]) {
 798         case PF_INET:
 799 #ifdef PF_INET6
 800         case PF_INET6:
 801 #endif
 802                 printxval(inet_protocols, tcp->u_arg[2], "IPPROTO_???");
 803                 break;
 804 #ifdef PF_IPX
 805         case PF_IPX:
 806                 /* BTW: I don't believe this.. */
 807                 tprints("[");
 808                 printxval(domains, tcp->u_arg[2], "PF_???");
 809                 tprints("]");
 810                 break;
 811 #endif /* PF_IPX */
 812 #ifdef PF_NETLINK
 813         case PF_NETLINK:
 814                 printxval(netlink_protocols, tcp->u_arg[2], "NETLINK_???");
 815                 break;
 816 #endif
 817 #if defined(PF_BLUETOOTH) && defined(HAVE_BLUETOOTH_BLUETOOTH_H)
 818         case PF_BLUETOOTH:
 819                 printxval(bt_protocols, tcp->u_arg[2], "BTPROTO_???");
 820                 break;
 821 #endif
 822         default:
 823                 tprintf("%lu", tcp->u_arg[2]);
 824                 break;
 825         }
 826
 827         return RVAL_DECODED | RVAL_FD;
 828 }
 829
 830 SYS_FUNC(bind)
 831 {
 832         printfd(tcp, tcp->u_arg[0]);
 833         tprints(", ");
 834         printsock(tcp, tcp->u_arg[1], tcp->u_arg[2]);
 835         tprintf(", %lu", tcp->u_arg[2]);
 836
 837         return RVAL_DECODED;
 838 }
 839
 840 SYS_FUNC(listen)
 841 {
 842         printfd(tcp, tcp->u_arg[0]);
 843         tprints(", ");
 844         tprintf("%lu", tcp->u_arg[1]);
 845
 846         return RVAL_DECODED;
 847 }
 848
 849 static int
 850 do_sockname(struct tcb *tcp, int flags_arg)
 851 {
 852         if (entering(tcp)) {
 853                 printfd(tcp, tcp->u_arg[0]);
 854                 tprints(", ");
 855                 return 0;
 856         }
 857
 858         int len;
 859         if (!tcp->u_arg[2] || !verbose(tcp) || syserror(tcp) ||
 860             umove(tcp, tcp->u_arg[2], &len) < 0) {
 861                 printaddr(tcp->u_arg[1]);
 862                 tprints(", ");
 863                 printaddr(tcp->u_arg[2]);
 864         } else {
 865                 printsock(tcp, tcp->u_arg[1], len);
 866                 tprintf(", [%d]", len);
 867         }
 868
 869         if (flags_arg >= 0) {
 870                 tprints(", ");
 871                 printflags(sock_type_flags, tcp->u_arg[flags_arg],
 872                            "SOCK_???");
 873         }
 874         return 0;
 875 }
 876
 877 SYS_FUNC(accept)
 878 {
 879         do_sockname(tcp, -1);
 880         return RVAL_FD;
 881 }
 882
 883 SYS_FUNC(accept4)
 884 {
 885         do_sockname(tcp, 3);
 886         return RVAL_FD;
 887 }
 888
 889 SYS_FUNC(send)
 890 {
 891         printfd(tcp, tcp->u_arg[0]);
 892         tprints(", ");
 893         printstr(tcp, tcp->u_arg[1], tcp->u_arg[2]);
 894         tprintf(", %lu, ", tcp->u_arg[2]);
 895         /* flags */
 896         printflags(msg_flags, tcp->u_arg[3], "MSG_???");
 897
 898         return RVAL_DECODED;
 899 }
 900
 901 SYS_FUNC(sendto)
 902 {
 903         printfd(tcp, tcp->u_arg[0]);
 904         tprints(", ");
 905         printstr(tcp, tcp->u_arg[1], tcp->u_arg[2]);
 906         tprintf(", %lu, ", tcp->u_arg[2]);
 907         /* flags */
 908         printflags(msg_flags, tcp->u_arg[3], "MSG_???");
 909         /* to address */
 910         tprints(", ");
 911         printsock(tcp, tcp->u_arg[4], tcp->u_arg[5]);
 912         /* to length */
 913         tprintf(", %lu", tcp->u_arg[5]);
 914
 915         return RVAL_DECODED;
 916 }
 917
 918 SYS_FUNC(sendmsg)
 919 {
 920         printfd(tcp, tcp->u_arg[0]);
 921         tprints(", ");
 922         printmsghdr(tcp, tcp->u_arg[1], (unsigned long) -1L);
 923         /* flags */
 924         tprints(", ");
 925         printflags(msg_flags, tcp->u_arg[2], "MSG_???");
 926
 927         return RVAL_DECODED;
 928 }
 929
 930 SYS_FUNC(sendmmsg)
 931 {
 932         if (entering(tcp)) {
 933                 /* sockfd */
 934                 printfd(tcp, tcp->u_arg[0]);
 935                 tprints(", ");
 936                 if (!verbose(tcp)) {
 937                         tprintf("%#lx, %u, ",
 938                                 tcp->u_arg[1], (unsigned int) tcp->u_arg[2]);
 939                         printflags(msg_flags, tcp->u_arg[3], "MSG_???");
 940                 }
 941         } else {
 942                 if (verbose(tcp))
 943                         decode_mmsg(tcp, (unsigned long) -1L);
 944         }
 945         return 0;
 946 }
 947
 948 SYS_FUNC(recv)
 949 {
 950         if (entering(tcp)) {
 951                 printfd(tcp, tcp->u_arg[0]);
 952                 tprints(", ");
 953         } else {
 954                 if (syserror(tcp))
 955                         printaddr(tcp->u_arg[1]);
 956                 else
 957                         printstr(tcp, tcp->u_arg[1], tcp->u_rval);
 958
 959                 tprintf(", %lu, ", tcp->u_arg[2]);
 960                 printflags(msg_flags, tcp->u_arg[3], "MSG_???");
 961         }
 962         return 0;
 963 }
 964
 965 SYS_FUNC(recvfrom)
 966 {
 967         int fromlen;
 968
 969         if (entering(tcp)) {
 970                 printfd(tcp, tcp->u_arg[0]);
 971                 tprints(", ");
 972         } else {
 973                 /* buf */
 974                 if (syserror(tcp)) {
 975                         printaddr(tcp->u_arg[1]);
 976                 } else {
 977                         printstr(tcp, tcp->u_arg[1], tcp->u_rval);
 978                 }
 979                 /* len */
 980                 tprintf(", %lu, ", tcp->u_arg[2]);
 981                 /* flags */
 982                 printflags(msg_flags, tcp->u_arg[3], "MSG_???");
 983                 tprints(", ");
 984                 if (syserror(tcp) || !tcp->u_arg[4] || !tcp->u_arg[5] ||
 985                     umove(tcp, tcp->u_arg[5], &fromlen) < 0) {
 986                         /* from address, len */
 987                         printaddr(tcp->u_arg[4]);
 988                         tprints(", ");
 989                         printaddr(tcp->u_arg[5]);
 990                         return 0;
 991                 }
 992                 /* from address */
 993                 printsock(tcp, tcp->u_arg[4], fromlen);
 994                 /* from length */
 995                 tprintf(", [%u]", fromlen);
 996         }
 997         return 0;
 998 }
 999
1000 SYS_FUNC(recvmsg)
1001 {
1002         if (entering(tcp)) {
1003                 printfd(tcp, tcp->u_arg[0]);
1004                 tprints(", ");
1005         } else {
1006                 if (syserror(tcp))
1007                         printaddr(tcp->u_arg[1]);
1008                 else
1009                         printmsghdr(tcp, tcp->u_arg[1], tcp->u_rval);
1010                 /* flags */
1011                 tprints(", ");
1012                 printflags(msg_flags, tcp->u_arg[2], "MSG_???");
1013         }
1014         return 0;
1015 }
1016
1017 SYS_FUNC(recvmmsg)
1018 {
1019         static char str[sizeof("left") + TIMESPEC_TEXT_BUFSIZE];
1020
1021         if (entering(tcp)) {
1022                 printfd(tcp, tcp->u_arg[0]);
1023                 tprints(", ");
1024                 if (verbose(tcp)) {
1025                         /* Abusing tcp->auxstr as temp storage.
1026                          * Will be used and cleared on syscall exit.
1027                          */
1028                         tcp->auxstr = sprint_timespec(tcp, tcp->u_arg[4]);
1029                 } else {
1030                         tprintf("%#lx, %ld, ", tcp->u_arg[1], tcp->u_arg[2]);
1031                         printflags(msg_flags, tcp->u_arg[3], "MSG_???");
1032                         tprints(", ");
1033                         print_timespec(tcp, tcp->u_arg[4]);
1034                 }
1035                 return 0;
1036         } else {
1037                 if (verbose(tcp)) {
1038                         decode_mmsg(tcp, 0);
1039                         tprints(", ");
1040                         /* timeout on entrance */
1041                         tprints(tcp->auxstr);
1042                         tcp->auxstr = NULL;
1043                 }
1044                 if (syserror(tcp))
1045                         return 0;
1046                 if (tcp->u_rval == 0) {
1047                         tcp->auxstr = "Timeout";
1048                         return RVAL_STR;
1049                 }
1050                 if (!verbose(tcp))
1051                         return 0;
1052                 /* timeout on exit */
1053                 snprintf(str, sizeof(str), "left %s",
1054                          sprint_timespec(tcp, tcp->u_arg[4]));
1055                 tcp->auxstr = str;
1056                 return RVAL_STR;
1057         }
1058 }
1059
1060 #include "xlat/shutdown_modes.h"
1061
1062 SYS_FUNC(shutdown)
1063 {
1064         printfd(tcp, tcp->u_arg[0]);
1065         tprints(", ");
1066         printxval(shutdown_modes, tcp->u_arg[1], "SHUT_???");
1067
1068         return RVAL_DECODED;
1069 }
1070
1071 SYS_FUNC(getsockname)
1072 {
1073         return do_sockname(tcp, -1);
1074 }
1075
1076 static void
1077 printpair_fd(struct tcb *tcp, const int i0, const int i1)
1078 {
1079         tprints("[");
1080         printfd(tcp, i0);
1081         tprints(", ");
1082         printfd(tcp, i1);
1083         tprints("]");
1084 }
1085
1086 static void
1087 decode_pair_fd(struct tcb *tcp, const long addr)
1088 {
1089         int pair[2];
1090
1091         if (umove_or_printaddr(tcp, addr, &pair))
1092                 return;
1093
1094         printpair_fd(tcp, pair[0], pair[1]);
1095 }
1096
1097 static int
1098 do_pipe(struct tcb *tcp, int flags_arg)
1099 {
1100         if (exiting(tcp)) {
1101                 if (syserror(tcp)) {
1102                         printaddr(tcp->u_arg[0]);
1103                 } else {
1104 #ifdef HAVE_GETRVAL2
1105                         if (flags_arg < 0) {
1106                                 printpair_fd(tcp, tcp->u_rval, getrval2(tcp));
1107                         } else
1108 #endif
1109                                 decode_pair_fd(tcp, tcp->u_arg[0]);
1110                 }
1111                 if (flags_arg >= 0) {
1112                         tprints(", ");
1113                         printflags(open_mode_flags, tcp->u_arg[flags_arg], "O_???");
1114                 }
1115         }
1116         return 0;
1117 }
1118
1119 SYS_FUNC(pipe)
1120 {
1121         return do_pipe(tcp, -1);
1122 }
1123
1124 SYS_FUNC(pipe2)
1125 {
1126         return do_pipe(tcp, 1);
1127 }
1128
1129 SYS_FUNC(socketpair)
1130 {
1131         if (entering(tcp)) {
1132                 printxval(domains, tcp->u_arg[0], "PF_???");
1133                 tprints(", ");
1134                 tprint_sock_type(tcp->u_arg[1]);
1135                 tprintf(", %lu", tcp->u_arg[2]);
1136         } else {
1137                 tprints(", ");
1138                 decode_pair_fd(tcp, tcp->u_arg[3]);
1139         }
1140         return 0;
1141 }
1142
1143 #include "xlat/sockoptions.h"
1144 #include "xlat/sockipoptions.h"
1145 #include "xlat/getsockipoptions.h"
1146 #include "xlat/setsockipoptions.h"
1147 #include "xlat/sockipv6options.h"
1148 #include "xlat/getsockipv6options.h"
1149 #include "xlat/setsockipv6options.h"
1150 #include "xlat/sockipxoptions.h"
1151 #include "xlat/sockrawoptions.h"
1152 #include "xlat/sockpacketoptions.h"
1153 #include "xlat/socksctpoptions.h"
1154 #include "xlat/socktcpoptions.h"
1155
1156 static void
1157 print_sockopt_fd_level_name(struct tcb *tcp, int fd, int level, int name, bool is_getsockopt)
1158 {
1159         printfd(tcp, fd);
1160         tprints(", ");
1161         printxval(socketlayers, level, "SOL_??");
1162         tprints(", ");
1163
1164         switch (level) {
1165         case SOL_SOCKET:
1166                 printxval(sockoptions, name, "SO_???");
1167                 break;
1168         case SOL_IP:
1169                 printxvals(name, "IP_???", sockipoptions,
1170                         is_getsockopt ? getsockipoptions : setsockipoptions, NULL);
1171                 break;
1172         case SOL_IPV6:
1173                 printxvals(name, "IPV6_???", sockipv6options,
1174                         is_getsockopt ? getsockipv6options : setsockipv6options, NULL);
1175                 break;
1176         case SOL_IPX:
1177                 printxval(sockipxoptions, name, "IPX_???");
1178                 break;
1179         case SOL_PACKET:
1180                 printxval(sockpacketoptions, name, "PACKET_???");
1181                 break;
1182         case SOL_TCP:
1183                 printxval(socktcpoptions, name, "TCP_???");
1184                 break;
1185         case SOL_SCTP:
1186                 printxval(socksctpoptions, name, "SCTP_???");
1187                 break;
1188         case SOL_RAW:
1189                 printxval(sockrawoptions, name, "RAW_???");
1190                 break;
1191
1192                 /* Other SOL_* protocol levels still need work. */
1193
1194         default:
1195                 tprintf("%u", name);
1196         }
1197
1198         tprints(", ");
1199 }
1200
1201 #ifdef SO_LINGER
1202 static void
1203 print_linger(struct tcb *tcp, long addr, int len)
1204 {
1205         struct linger linger;
1206
1207         if (len != sizeof(linger) ||
1208             umove(tcp, addr, &linger) < 0) {
1209                 printaddr(addr);
1210                 return;
1211         }
1212
1213         tprintf("{onoff=%d, linger=%d}",
1214                 linger.l_onoff,
1215                 linger.l_linger);
1216 }
1217 #endif /* SO_LINGER */
1218
1219 #ifdef SO_PEERCRED
1220 static void
1221 print_ucred(struct tcb *tcp, long addr, int len)
1222 {
1223         struct ucred uc;
1224
1225         if (len != sizeof(uc) ||
1226             umove(tcp, addr, &uc) < 0) {
1227                 printaddr(addr);
1228         } else {
1229                 tprintf("{pid=%u, uid=%u, gid=%u}",
1230                         (unsigned) uc.pid,
1231                         (unsigned) uc.uid,
1232                         (unsigned) uc.gid);
1233         }
1234 }
1235 #endif /* SO_PEERCRED */
1236
1237 #ifdef PACKET_STATISTICS
1238 static void
1239 print_tpacket_stats(struct tcb *tcp, long addr, int len)
1240 {
1241         struct tpacket_stats stats;
1242
1243         if (len != sizeof(stats) ||
1244             umove(tcp, addr, &stats) < 0) {
1245                 printaddr(addr);
1246         } else {
1247                 tprintf("{packets=%u, drops=%u}",
1248                         stats.tp_packets,
1249                         stats.tp_drops);
1250         }
1251 }
1252 #endif /* PACKET_STATISTICS */
1253
1254 #ifdef ICMP_FILTER
1255 # include "xlat/icmpfilterflags.h"
1256
1257 static void
1258 print_icmp_filter(struct tcb *tcp, long addr, int len)
1259 {
1260         struct icmp_filter      filter;
1261
1262         if (len != sizeof(filter) ||
1263             umove(tcp, addr, &filter) < 0) {
1264                 printaddr(addr);
1265                 return;
1266         }
1267
1268         tprints("~(");
1269         printflags(icmpfilterflags, ~filter.data, "ICMP_???");
1270         tprints(")");
1271 }
1272 #endif /* ICMP_FILTER */
1273
1274 static void
1275 print_getsockopt(struct tcb *tcp, int level, int name, long addr, int len)
1276 {
1277         if (addr && verbose(tcp))
1278         switch (level) {
1279         case SOL_SOCKET:
1280                 switch (name) {
1281 #ifdef SO_LINGER
1282                 case SO_LINGER:
1283                         print_linger(tcp, addr, len);
1284                         goto done;
1285 #endif
1286 #ifdef SO_PEERCRED
1287                 case SO_PEERCRED:
1288                         print_ucred(tcp, addr, len);
1289                         goto done;
1290 #endif
1291                 }
1292                 break;
1293
1294         case SOL_PACKET:
1295                 switch (name) {
1296 #ifdef PACKET_STATISTICS
1297                 case PACKET_STATISTICS:
1298                         print_tpacket_stats(tcp, addr, len);
1299                         goto done;
1300 #endif
1301                 }
1302                 break;
1303
1304         case SOL_RAW:
1305                 switch (name) {
1306 #ifdef ICMP_FILTER
1307                 case ICMP_FILTER:
1308                         print_icmp_filter(tcp, addr, len);
1309                         goto done;
1310 #endif
1311                 }
1312                 break;
1313         }
1314
1315         /* default arg printing */
1316
1317         if (verbose(tcp)) {
1318                 if (len == sizeof(int)) {
1319                         printnum_int(tcp, addr, "%d");
1320                 } else {
1321                         printstr(tcp, addr, len);
1322                 }
1323         } else {
1324                 printaddr(addr);
1325         }
1326 done:
1327         tprintf(", [%d]", len);
1328 }
1329
1330 SYS_FUNC(getsockopt)
1331 {
1332         if (entering(tcp)) {
1333                 print_sockopt_fd_level_name(tcp, tcp->u_arg[0],
1334                                             tcp->u_arg[1], tcp->u_arg[2], true);
1335         } else {
1336                 int len;
1337
1338                 if (syserror(tcp) || umove(tcp, tcp->u_arg[4], &len) < 0) {
1339                         tprintf("%#lx, %#lx",
1340                                 tcp->u_arg[3], tcp->u_arg[4]);
1341                 } else {
1342                         print_getsockopt(tcp, tcp->u_arg[1], tcp->u_arg[2],
1343                                          tcp->u_arg[3], len);
1344                 }
1345         }
1346         return 0;
1347 }
1348
1349 #ifdef IP_ADD_MEMBERSHIP
1350 static void
1351 print_mreq(struct tcb *tcp, long addr, unsigned int len)
1352 {
1353         struct ip_mreq mreq;
1354
1355         if (len < sizeof(mreq)) {
1356                 printstr(tcp, addr, len);
1357                 return;
1358         }
1359         if (umove_or_printaddr(tcp, addr, &mreq))
1360                 return;
1361
1362         tprints("{imr_multiaddr=inet_addr(");
1363         print_quoted_string(inet_ntoa(mreq.imr_multiaddr),
1364                             16, QUOTE_0_TERMINATED);
1365         tprints("), imr_interface=inet_addr(");
1366         print_quoted_string(inet_ntoa(mreq.imr_interface),
1367                             16, QUOTE_0_TERMINATED);
1368         tprints(")}");
1369 }
1370 #endif /* IP_ADD_MEMBERSHIP */
1371
1372 #ifdef IPV6_ADD_MEMBERSHIP
1373 static void
1374 print_mreq6(struct tcb *tcp, long addr, unsigned int len)
1375 {
1376         struct ipv6_mreq mreq;
1377
1378         if (len < sizeof(mreq))
1379                 goto fail;
1380
1381         if (umove_or_printaddr(tcp, addr, &mreq))
1382                 return;
1383
1384 #ifdef HAVE_INET_NTOP
1385         const struct in6_addr *in6 = &mreq.ipv6mr_multiaddr;
1386         char address[INET6_ADDRSTRLEN];
1387
1388         if (!inet_ntop(AF_INET6, in6, address, sizeof(address)))
1389                 goto fail;
1390
1391         tprints("{ipv6mr_multiaddr=inet_pton(");
1392         print_quoted_string(address, sizeof(address), QUOTE_0_TERMINATED);
1393         tprints("), ipv6mr_interface=");
1394         print_ifindex(mreq.ipv6mr_interface);
1395         tprints("}");
1396         return;
1397 #endif /* HAVE_INET_NTOP */
1398
1399 fail:
1400         printstr(tcp, addr, len);
1401 }
1402 #endif /* IPV6_ADD_MEMBERSHIP */
1403
1404 #ifdef MCAST_JOIN_GROUP
1405 static void
1406 print_group_req(struct tcb *tcp, long addr, int len)
1407 {
1408         struct group_req greq;
1409
1410         if (len != sizeof(greq) ||
1411             umove(tcp, addr, &greq) < 0) {
1412                 printaddr(addr);
1413                 return;
1414         }
1415
1416         tprintf("{gr_interface=%u, gr_group=", greq.gr_interface);
1417         print_sockaddr(tcp, (const void *) &greq.gr_group,
1418                        sizeof(greq.gr_group));
1419         tprintf("}");
1420
1421 }
1422 #endif /* MCAST_JOIN_GROUP */
1423
1424 #ifdef PACKET_RX_RING
1425 static void
1426 print_tpacket_req(struct tcb *tcp, long addr, int len)
1427 {
1428         struct tpacket_req req;
1429
1430         if (len != sizeof(req) ||
1431             umove(tcp, addr, &req) < 0) {
1432                 printaddr(addr);
1433         } else {
1434                 tprintf("{block_size=%u, block_nr=%u, "
1435                         "frame_size=%u, frame_nr=%u}",
1436                         req.tp_block_size,
1437                         req.tp_block_nr,
1438                         req.tp_frame_size,
1439                         req.tp_frame_nr);
1440         }
1441 }
1442 #endif /* PACKET_RX_RING */
1443
1444 #ifdef PACKET_ADD_MEMBERSHIP
1445 # include "xlat/packet_mreq_type.h"
1446
1447 static void
1448 print_packet_mreq(struct tcb *tcp, long addr, int len)
1449 {
1450         struct packet_mreq mreq;
1451
1452         if (len != sizeof(mreq) ||
1453             umove(tcp, addr, &mreq) < 0) {
1454                 printaddr(addr);
1455         } else {
1456                 unsigned int i;
1457
1458                 tprintf("{mr_ifindex=%u, mr_type=", mreq.mr_ifindex);
1459                 printxval(packet_mreq_type, mreq.mr_type, "PACKET_MR_???");
1460                 tprintf(", mr_alen=%u, mr_address=", mreq.mr_alen);
1461                 if (mreq.mr_alen > ARRAY_SIZE(mreq.mr_address))
1462                         mreq.mr_alen = ARRAY_SIZE(mreq.mr_address);
1463                 for (i = 0; i < mreq.mr_alen; ++i)
1464                         tprintf("%02x", mreq.mr_address[i]);
1465                 tprints("}");
1466         }
1467 }
1468 #endif /* PACKET_ADD_MEMBERSHIP */
1469
1470 static void
1471 print_setsockopt(struct tcb *tcp, int level, int name, long addr, int len)
1472 {
1473         if (addr && verbose(tcp))
1474         switch (level) {
1475         case SOL_SOCKET:
1476                 switch (name) {
1477 #ifdef SO_LINGER
1478                 case SO_LINGER:
1479                         print_linger(tcp, addr, len);
1480                         goto done;
1481 #endif
1482                 }
1483                 break;
1484
1485         case SOL_IP:
1486                 switch (name) {
1487 #ifdef IP_ADD_MEMBERSHIP
1488                 case IP_ADD_MEMBERSHIP:
1489                 case IP_DROP_MEMBERSHIP:
1490                         print_mreq(tcp, addr, len);
1491                         goto done;
1492 #endif /* IP_ADD_MEMBERSHIP */
1493 #ifdef MCAST_JOIN_GROUP
1494                 case MCAST_JOIN_GROUP:
1495                 case MCAST_LEAVE_GROUP:
1496                         print_group_req(tcp, addr, len);
1497                         goto done;
1498 #endif /* MCAST_JOIN_GROUP */
1499                 }
1500                 break;
1501
1502         case SOL_IPV6:
1503                 switch (name) {
1504 #ifdef IPV6_ADD_MEMBERSHIP
1505                 case IPV6_ADD_MEMBERSHIP:
1506                 case IPV6_DROP_MEMBERSHIP:
1507 # ifdef IPV6_JOIN_ANYCAST
1508                 case IPV6_JOIN_ANYCAST:
1509 # endif
1510 # ifdef IPV6_LEAVE_ANYCAST
1511                 case IPV6_LEAVE_ANYCAST:
1512 # endif
1513                         print_mreq6(tcp, addr, len);
1514                         goto done;
1515 #endif /* IPV6_ADD_MEMBERSHIP */
1516                 }
1517                 break;
1518
1519         case SOL_PACKET:
1520                 switch (name) {
1521 #ifdef PACKET_RX_RING
1522                 case PACKET_RX_RING:
1523 # ifdef PACKET_TX_RING
1524                 case PACKET_TX_RING:
1525 # endif
1526                         print_tpacket_req(tcp, addr, len);
1527                         goto done;
1528 #endif /* PACKET_RX_RING */
1529 #ifdef PACKET_ADD_MEMBERSHIP
1530                 case PACKET_ADD_MEMBERSHIP:
1531                 case PACKET_DROP_MEMBERSHIP:
1532                         print_packet_mreq(tcp, addr, len);
1533                         goto done;
1534 #endif /* PACKET_ADD_MEMBERSHIP */
1535                 }
1536                 break;
1537
1538         case SOL_RAW:
1539                 switch (name) {
1540 #ifdef ICMP_FILTER
1541                 case ICMP_FILTER:
1542                         print_icmp_filter(tcp, addr, len);
1543                         goto done;
1544 #endif
1545                 }
1546                 break;
1547         }
1548
1549         /* default arg printing */
1550
1551         if (verbose(tcp)) {
1552                 if (len == sizeof(int)) {
1553                         printnum_int(tcp, addr, "%d");
1554                 } else {
1555                         printstr(tcp, addr, len);
1556                 }
1557         } else {
1558                 printaddr(addr);
1559         }
1560 done:
1561         tprintf(", %d", len);
1562 }
1563
1564 SYS_FUNC(setsockopt)
1565 {
1566         print_sockopt_fd_level_name(tcp, tcp->u_arg[0],
1567                                     tcp->u_arg[1], tcp->u_arg[2], false);
1568         print_setsockopt(tcp, tcp->u_arg[1], tcp->u_arg[2],
1569                          tcp->u_arg[3], tcp->u_arg[4]);
1570
1571         return RVAL_DECODED;
1572 }