granicus.if.org Git - strace/blob - msghdr.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  * Copyright (c) 2005-2016 Dmitry V. Levin <ldv@altlinux.org>
   7  * Copyright (c) 2016-2019 The strace developers.
   8  * All rights reserved.
   9  *
  10  * SPDX-License-Identifier: LGPL-2.1-or-later
  11  */
  12
  13 #include "defs.h"
  14 #include "print_fields.h"
  15 #include "msghdr.h"
  16 #include <limits.h>
  17 #include <arpa/inet.h>
  18 #include <netinet/in.h>
  19
  20 #define XLAT_MACROS_ONLY
  21 #include "xlat/sock_options.h"
  22 #undef XLAT_MACROS_ONLY
  23 #include "xlat/msg_flags.h"
  24 #include "xlat/scmvals.h"
  25 #include "xlat/ip_cmsg_types.h"
  26
  27 #ifndef current_wordsize
  28 struct cmsghdr32 {
  29         uint32_t cmsg_len;
  30         int cmsg_level;
  31         int cmsg_type;
  32 };
  33 #endif
  34
  35 typedef union {
  36         char *ptr;
  37         struct cmsghdr *cmsg;
  38 #ifndef current_wordsize
  39         struct cmsghdr32 *cmsg32;
  40 #endif
  41 } union_cmsghdr;
  42
  43 static void
  44 print_scm_rights(struct tcb *tcp, const void *cmsg_data,
  45                  const unsigned int data_len)
  46 {
  47         const int *fds = cmsg_data;
  48         const unsigned int nfds = data_len / sizeof(*fds);
  49         unsigned int i;
  50
  51         tprints("[");
  52
  53         for (i = 0; i < nfds; ++i) {
  54                 if (i)
  55                         tprints(", ");
  56                 if (abbrev(tcp) && i >= max_strlen) {
  57                         tprints("...");
  58                         break;
  59                 }
  60                 printfd(tcp, fds[i]);
  61         }
  62
  63         tprints("]");
  64 }
  65
  66 static void
  67 print_scm_creds(struct tcb *tcp, const void *cmsg_data,
  68                 const unsigned int data_len)
  69 {
  70         const struct ucred *uc = cmsg_data;
  71
  72         PRINT_FIELD_U("{", *uc, pid);
  73         PRINT_FIELD_UID(", ", *uc, uid);
  74         PRINT_FIELD_UID(", ", *uc, gid);
  75         tprints("}");
  76 }
  77
  78 static void
  79 print_scm_security(struct tcb *tcp, const void *cmsg_data,
  80                    const unsigned int data_len)
  81 {
  82         print_quoted_string(cmsg_data, data_len, 0);
  83 }
  84
  85 static void
  86 print_scm_timestamp_old(struct tcb *tcp, const void *cmsg_data,
  87                         const unsigned int data_len)
  88 {
  89         print_struct_timeval_data_size(cmsg_data, data_len);
  90 }
  91
  92 static void
  93 print_scm_timestampns_old(struct tcb *tcp, const void *cmsg_data,
  94                           const unsigned int data_len)
  95 {
  96         print_struct_timespec_data_size(cmsg_data, data_len);
  97 }
  98
  99 static void
 100 print_scm_timestamping_old(struct tcb *tcp, const void *cmsg_data,
 101                            const unsigned int data_len)
 102 {
 103         print_struct_timespec_array_data_size(cmsg_data, 3, data_len);
 104 }
 105
 106 static void
 107 print_scm_timestamp_new(struct tcb *tcp, const void *cmsg_data,
 108                         const unsigned int data_len)
 109 {
 110         print_timeval64_data_size(cmsg_data, data_len);
 111 }
 112
 113 static void
 114 print_scm_timestampns_new(struct tcb *tcp, const void *cmsg_data,
 115                         const unsigned int data_len)
 116 {
 117         print_timespec64_data_size(cmsg_data, data_len);
 118 }
 119
 120 static void
 121 print_scm_timestamping_new(struct tcb *tcp, const void *cmsg_data,
 122                            const unsigned int data_len)
 123 {
 124         print_timespec64_array_data_size(cmsg_data, 3, data_len);
 125 }
 126
 127 static void
 128 print_cmsg_ip_pktinfo(struct tcb *tcp, const void *cmsg_data,
 129                       const unsigned int data_len)
 130 {
 131         const struct in_pktinfo *info = cmsg_data;
 132
 133         PRINT_FIELD_IFINDEX("{", *info, ipi_ifindex);
 134         PRINT_FIELD_INET_ADDR(", ", *info, ipi_spec_dst, AF_INET);
 135         PRINT_FIELD_INET_ADDR(", ", *info, ipi_addr, AF_INET);
 136         tprints("}");
 137 }
 138
 139 static void
 140 print_cmsg_uint(struct tcb *tcp, const void *cmsg_data,
 141                 const unsigned int data_len)
 142 {
 143         const unsigned int *p = cmsg_data;
 144
 145         tprintf("[%u]", *p);
 146 }
 147
 148 static void
 149 print_cmsg_uint8_t(struct tcb *tcp, const void *cmsg_data,
 150                    const unsigned int data_len)
 151 {
 152         const uint8_t *p = cmsg_data;
 153
 154         tprintf("[%#x]", *p);
 155 }
 156
 157 static void
 158 print_cmsg_ip_opts(struct tcb *tcp, const void *cmsg_data,
 159                    const unsigned int data_len)
 160 {
 161         const unsigned char *opts = cmsg_data;
 162         unsigned int i;
 163
 164         tprints("[");
 165         for (i = 0; i < data_len; ++i) {
 166                 if (i)
 167                         tprints(", ");
 168                 if (abbrev(tcp) && i >= max_strlen) {
 169                         tprints("...");
 170                         break;
 171                 }
 172                 tprintf("0x%02x", opts[i]);
 173         }
 174         tprints("]");
 175 }
 176
 177 struct sock_ee {
 178         uint32_t ee_errno;
 179         uint8_t  ee_origin;
 180         uint8_t  ee_type;
 181         uint8_t  ee_code;
 182         uint8_t  ee_pad;
 183         uint32_t ee_info;
 184         uint32_t ee_data;
 185         struct sockaddr_in offender;
 186 };
 187
 188 static void
 189 print_cmsg_ip_recverr(struct tcb *tcp, const void *cmsg_data,
 190                       const unsigned int data_len)
 191 {
 192         const struct sock_ee *const err = cmsg_data;
 193
 194         PRINT_FIELD_U("{", *err, ee_errno);
 195         PRINT_FIELD_U(", ", *err, ee_origin);
 196         PRINT_FIELD_U(", ", *err, ee_type);
 197         PRINT_FIELD_U(", ", *err, ee_code);
 198         PRINT_FIELD_U(", ", *err, ee_info);
 199         PRINT_FIELD_U(", ", *err, ee_data);
 200         PRINT_FIELD_SOCKADDR(", ", *err, offender);
 201         tprints("}");
 202 }
 203
 204 static void
 205 print_cmsg_ip_origdstaddr(struct tcb *tcp, const void *cmsg_data,
 206                           const unsigned int data_len)
 207 {
 208         const unsigned int addr_len =
 209                 data_len > sizeof(struct sockaddr_storage)
 210                 ? sizeof(struct sockaddr_storage) : data_len;
 211
 212         print_sockaddr(cmsg_data, addr_len);
 213 }
 214
 215 typedef void (* const cmsg_printer)(struct tcb *, const void *, unsigned int);
 216
 217 static const struct {
 218         const cmsg_printer printer;
 219         const unsigned int min_len;
 220 } cmsg_socket_printers[] = {
 221         [SCM_RIGHTS] = { print_scm_rights, sizeof(int) },
 222         [SCM_CREDENTIALS] = { print_scm_creds, sizeof(struct ucred) },
 223         [SCM_SECURITY] = { print_scm_security, 1 },
 224         [SO_TIMESTAMP_OLD] = { print_scm_timestamp_old, 1 },
 225         [SO_TIMESTAMPNS_OLD] = { print_scm_timestampns_old, 1 },
 226         [SO_TIMESTAMPING_OLD] = { print_scm_timestamping_old, 1 },
 227         [SO_TIMESTAMP_NEW] = { print_scm_timestamp_new, 1 },
 228         [SO_TIMESTAMPNS_NEW] = { print_scm_timestampns_new, 1 },
 229         [SO_TIMESTAMPING_NEW] = { print_scm_timestamping_new, 1 }
 230 }, cmsg_ip_printers[] = {
 231         [IP_PKTINFO] = { print_cmsg_ip_pktinfo, sizeof(struct in_pktinfo) },
 232         [IP_TTL] = { print_cmsg_uint, sizeof(unsigned int) },
 233         [IP_TOS] = { print_cmsg_uint8_t, 1 },
 234         [IP_RECVOPTS] = { print_cmsg_ip_opts, 1 },
 235         [IP_RETOPTS] = { print_cmsg_ip_opts, 1 },
 236         [IP_RECVERR] = { print_cmsg_ip_recverr, sizeof(struct sock_ee) },
 237         [IP_ORIGDSTADDR] = { print_cmsg_ip_origdstaddr, sizeof(struct sockaddr_in) },
 238         [IP_CHECKSUM] = { print_cmsg_uint, sizeof(unsigned int) },
 239         [SCM_SECURITY] = { print_scm_security, 1 }
 240 };
 241
 242 static void
 243 print_cmsg_type_data(struct tcb *tcp, const int cmsg_level, const int cmsg_type,
 244                      const void *cmsg_data, const unsigned int data_len)
 245 {
 246         const unsigned int utype = cmsg_type;
 247         switch (cmsg_level) {
 248         case SOL_SOCKET:
 249                 printxval(scmvals, cmsg_type, "SCM_???");
 250                 if (utype < ARRAY_SIZE(cmsg_socket_printers)
 251                     && cmsg_socket_printers[utype].printer
 252                     && data_len >= cmsg_socket_printers[utype].min_len) {
 253                         tprints(", cmsg_data=");
 254                         cmsg_socket_printers[utype].printer(tcp, cmsg_data, data_len);
 255                 }
 256                 break;
 257         case SOL_IP:
 258                 printxval(ip_cmsg_types, cmsg_type, "IP_???");
 259                 if (utype < ARRAY_SIZE(cmsg_ip_printers)
 260                     && cmsg_ip_printers[utype].printer
 261                     && data_len >= cmsg_ip_printers[utype].min_len) {
 262                         tprints(", cmsg_data=");
 263                         cmsg_ip_printers[utype].printer(tcp, cmsg_data, data_len);
 264                 }
 265                 break;
 266         default:
 267                 tprintf("%#x", cmsg_type);
 268         }
 269 }
 270
 271 static unsigned int
 272 get_optmem_max(struct tcb *tcp)
 273 {
 274         static int optmem_max;
 275
 276         if (!optmem_max) {
 277                 if (read_int_from_file(tcp, "/proc/sys/net/core/optmem_max",
 278                                        &optmem_max) || optmem_max <= 0) {
 279                         optmem_max = sizeof(long long) * (2 * IOV_MAX + 512);
 280                 } else {
 281                         optmem_max = (optmem_max + sizeof(long long) - 1)
 282                                      & ~(sizeof(long long) - 1);
 283                 }
 284         }
 285
 286         return optmem_max;
 287 }
 288
 289 static void
 290 decode_msg_control(struct tcb *const tcp, const kernel_ulong_t addr,
 291                    const kernel_ulong_t in_control_len)
 292 {
 293         if (!in_control_len)
 294                 return;
 295         tprints(", msg_control=");
 296
 297         const unsigned int cmsg_size =
 298 #ifndef current_wordsize
 299                 (current_wordsize < sizeof(long)) ? sizeof(struct cmsghdr32) :
 300 #endif
 301                         sizeof(struct cmsghdr);
 302
 303         unsigned int control_len = in_control_len > get_optmem_max(tcp)
 304                                    ? get_optmem_max(tcp) : in_control_len;
 305         unsigned int buf_len = control_len;
 306         char *buf = buf_len < cmsg_size ? NULL : malloc(buf_len);
 307         if (!buf || umoven(tcp, addr, buf_len, buf) < 0) {
 308                 printaddr(addr);
 309                 free(buf);
 310                 return;
 311         }
 312
 313         union_cmsghdr u = { .ptr = buf };
 314
 315         tprints("[");
 316         while (buf_len >= cmsg_size) {
 317                 const kernel_ulong_t cmsg_len =
 318 #ifndef current_wordsize
 319                         (current_wordsize < sizeof(long)) ? u.cmsg32->cmsg_len :
 320 #endif
 321                                 u.cmsg->cmsg_len;
 322                 const int cmsg_level =
 323 #ifndef current_wordsize
 324                         (current_wordsize < sizeof(long)) ? u.cmsg32->cmsg_level :
 325 #endif
 326                                 u.cmsg->cmsg_level;
 327                 const int cmsg_type =
 328 #ifndef current_wordsize
 329                         (current_wordsize < sizeof(long)) ? u.cmsg32->cmsg_type :
 330 #endif
 331                                 u.cmsg->cmsg_type;
 332
 333                 if (u.ptr != buf)
 334                         tprints(", ");
 335                 tprintf("{cmsg_len=%" PRI_klu ", cmsg_level=", cmsg_len);
 336                 printxval(socketlayers, cmsg_level, "SOL_???");
 337                 tprints(", cmsg_type=");
 338
 339                 kernel_ulong_t len = cmsg_len > buf_len ? buf_len : cmsg_len;
 340
 341                 print_cmsg_type_data(tcp, cmsg_level, cmsg_type,
 342                                      (const void *) (u.ptr + cmsg_size),
 343                                      len > cmsg_size ? len - cmsg_size : 0);
 344                 tprints("}");
 345
 346                 if (len < cmsg_size) {
 347                         buf_len -= cmsg_size;
 348                         break;
 349                 }
 350                 len = (cmsg_len + current_wordsize - 1) &
 351                         ~((kernel_ulong_t) current_wordsize - 1);
 352                 if (len >= buf_len) {
 353                         buf_len = 0;
 354                         break;
 355                 }
 356                 u.ptr += len;
 357                 buf_len -= len;
 358         }
 359         if (buf_len) {
 360                 tprints(", ...");
 361                 printaddr_comment(addr + (control_len - buf_len));
 362         } else if (control_len < in_control_len) {
 363                 tprints(", ...");
 364         }
 365         tprints("]");
 366         free(buf);
 367 }
 368
 369 void
 370 print_struct_msghdr(struct tcb *tcp, const struct msghdr *msg,
 371                     const int *const p_user_msg_namelen,
 372                     const kernel_ulong_t data_size)
 373 {
 374         const int msg_namelen =
 375                 p_user_msg_namelen && (int) msg->msg_namelen > *p_user_msg_namelen
 376                 ? *p_user_msg_namelen : (int) msg->msg_namelen;
 377
 378         tprints("{msg_name=");
 379         const int family =
 380                 decode_sockaddr(tcp, ptr_to_kulong(msg->msg_name), msg_namelen);
 381         const enum iov_decode decode =
 382                 (family == AF_NETLINK) ? IOV_DECODE_NETLINK : IOV_DECODE_STR;
 383
 384         tprints(", msg_namelen=");
 385         if (p_user_msg_namelen && *p_user_msg_namelen != (int) msg->msg_namelen)
 386                 tprintf("%d->", *p_user_msg_namelen);
 387         tprintf("%d", msg->msg_namelen);
 388
 389         tprints(", msg_iov=");
 390         tprint_iov_upto(tcp, msg->msg_iovlen,
 391                         ptr_to_kulong(msg->msg_iov), decode, data_size);
 392         PRINT_FIELD_U(", ", *msg, msg_iovlen);
 393
 394         decode_msg_control(tcp, ptr_to_kulong(msg->msg_control),
 395                            msg->msg_controllen);
 396         PRINT_FIELD_U(", ", *msg, msg_controllen);
 397
 398         PRINT_FIELD_FLAGS(", ", *msg, msg_flags, msg_flags, "MSG_???");
 399         tprints("}");
 400 }
 401
 402 static bool
 403 fetch_msghdr_namelen(struct tcb *const tcp, const kernel_ulong_t addr,
 404                      int *const p_msg_namelen)
 405 {
 406         struct msghdr msg;
 407
 408         if (addr && verbose(tcp) && fetch_struct_msghdr(tcp, addr, &msg)) {
 409                 *p_msg_namelen = msg.msg_namelen;
 410                 return true;
 411         } else {
 412                 return false;
 413         }
 414 }
 415
 416 static void
 417 decode_msghdr(struct tcb *const tcp, const int *const p_user_msg_namelen,
 418               const kernel_ulong_t addr, const kernel_ulong_t data_size)
 419 {
 420         struct msghdr msg;
 421
 422         if (addr && verbose(tcp) && fetch_struct_msghdr(tcp, addr, &msg))
 423                 print_struct_msghdr(tcp, &msg, p_user_msg_namelen, data_size);
 424         else
 425                 printaddr(addr);
 426 }
 427
 428 void
 429 dumpiov_in_msghdr(struct tcb *const tcp, const kernel_ulong_t addr,
 430                   const kernel_ulong_t data_size)
 431 {
 432         struct msghdr msg;
 433
 434         if (fetch_struct_msghdr(tcp, addr, &msg)) {
 435                 dumpiov_upto(tcp, msg.msg_iovlen,
 436                              ptr_to_kulong(msg.msg_iov), data_size);
 437         }
 438 }
 439
 440 SYS_FUNC(sendmsg)
 441 {
 442         printfd(tcp, tcp->u_arg[0]);
 443         tprints(", ");
 444         decode_msghdr(tcp, 0, tcp->u_arg[1], -1);
 445         /* flags */
 446         tprints(", ");
 447         printflags(msg_flags, tcp->u_arg[2], "MSG_???");
 448
 449         return RVAL_DECODED;
 450 }
 451
 452 SYS_FUNC(recvmsg)
 453 {
 454         int msg_namelen;
 455
 456         if (entering(tcp)) {
 457                 printfd(tcp, tcp->u_arg[0]);
 458                 tprints(", ");
 459                 if (fetch_msghdr_namelen(tcp, tcp->u_arg[1], &msg_namelen)) {
 460                         set_tcb_priv_ulong(tcp, msg_namelen);
 461                         return 0;
 462                 }
 463                 printaddr(tcp->u_arg[1]);
 464         } else {
 465                 msg_namelen = get_tcb_priv_ulong(tcp);
 466
 467                 if (syserror(tcp))
 468                         tprintf("{msg_namelen=%d}", msg_namelen);
 469                 else
 470                         decode_msghdr(tcp, &msg_namelen, tcp->u_arg[1],
 471                                       tcp->u_rval);
 472         }
 473
 474         /* flags */
 475         tprints(", ");
 476         printflags(msg_flags, tcp->u_arg[2], "MSG_???");
 477
 478         return RVAL_DECODED;
 479 }