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-2017 The strace developers.
   8  * All rights reserved.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  * 3. The name of the author may not be used to endorse or promote products
  19  *    derived from this software without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  22  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  23  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  24  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  25  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  26  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  27  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  28  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  29  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  30  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31  */
  32
  33 #include "defs.h"
  34 #include "print_fields.h"
  35 #include "msghdr.h"
  36 #include <limits.h>
  37 #include <arpa/inet.h>
  38 #include <netinet/in.h>
  39
  40 #include "xlat/msg_flags.h"
  41 #include "xlat/scmvals.h"
  42 #include "xlat/ip_cmsg_types.h"
  43
  44 #ifndef current_wordsize
  45 struct cmsghdr32 {
  46         uint32_t cmsg_len;
  47         int cmsg_level;
  48         int cmsg_type;
  49 };
  50 #endif
  51
  52 typedef union {
  53         char *ptr;
  54         struct cmsghdr *cmsg;
  55 #ifndef current_wordsize
  56         struct cmsghdr32 *cmsg32;
  57 #endif
  58 } union_cmsghdr;
  59
  60 static void
  61 print_scm_rights(struct tcb *tcp, const void *cmsg_data,
  62                  const unsigned int data_len)
  63 {
  64         const int *fds = cmsg_data;
  65         const unsigned int nfds = data_len / sizeof(*fds);
  66         unsigned int i;
  67
  68         tprints("[");
  69
  70         for (i = 0; i < nfds; ++i) {
  71                 if (i)
  72                         tprints(", ");
  73                 if (abbrev(tcp) && i >= max_strlen) {
  74                         tprints("...");
  75                         break;
  76                 }
  77                 printfd(tcp, fds[i]);
  78         }
  79
  80         tprints("]");
  81 }
  82
  83 static void
  84 print_scm_creds(struct tcb *tcp, const void *cmsg_data,
  85                 const unsigned int data_len)
  86 {
  87         const struct ucred *uc = cmsg_data;
  88
  89         PRINT_FIELD_U("{", *uc, pid);
  90         PRINT_FIELD_UID(", ", *uc, uid);
  91         PRINT_FIELD_UID(", ", *uc, gid);
  92         tprints("}");
  93 }
  94
  95 static void
  96 print_scm_security(struct tcb *tcp, const void *cmsg_data,
  97                    const unsigned int data_len)
  98 {
  99         print_quoted_string(cmsg_data, data_len, 0);
 100 }
 101
 102 static void
 103 print_scm_timestamp(struct tcb *tcp, const void *cmsg_data,
 104                     const unsigned int data_len)
 105 {
 106         print_struct_timeval_data_size(cmsg_data, data_len);
 107 }
 108
 109 static void
 110 print_scm_timestampns(struct tcb *tcp, const void *cmsg_data,
 111                       const unsigned int data_len)
 112 {
 113         print_struct_timespec_data_size(cmsg_data, data_len);
 114 }
 115
 116 static void
 117 print_scm_timestamping(struct tcb *tcp, const void *cmsg_data,
 118                        const unsigned int data_len)
 119 {
 120         print_struct_timespec_array_data_size(cmsg_data, 3, data_len);
 121 }
 122
 123 static void
 124 print_cmsg_ip_pktinfo(struct tcb *tcp, const void *cmsg_data,
 125                       const unsigned int data_len)
 126 {
 127         const struct in_pktinfo *info = cmsg_data;
 128
 129         PRINT_FIELD_IFINDEX("{", *info, ipi_ifindex);
 130         PRINT_FIELD_INET4_ADDR(", ", *info, ipi_spec_dst);
 131         PRINT_FIELD_INET4_ADDR(", ", *info, ipi_addr);
 132         tprints("}");
 133 }
 134
 135 static void
 136 print_cmsg_uint(struct tcb *tcp, const void *cmsg_data,
 137                 const unsigned int data_len)
 138 {
 139         const unsigned int *p = cmsg_data;
 140
 141         tprintf("[%u]", *p);
 142 }
 143
 144 static void
 145 print_cmsg_uint8_t(struct tcb *tcp, const void *cmsg_data,
 146                    const unsigned int data_len)
 147 {
 148         const uint8_t *p = cmsg_data;
 149
 150         tprintf("[%#x]", *p);
 151 }
 152
 153 static void
 154 print_cmsg_ip_opts(struct tcb *tcp, const void *cmsg_data,
 155                    const unsigned int data_len)
 156 {
 157         const unsigned char *opts = cmsg_data;
 158         unsigned int i;
 159
 160         tprints("[");
 161         for (i = 0; i < data_len; ++i) {
 162                 if (i)
 163                         tprints(", ");
 164                 if (abbrev(tcp) && i >= max_strlen) {
 165                         tprints("...");
 166                         break;
 167                 }
 168                 tprintf("0x%02x", opts[i]);
 169         }
 170         tprints("]");
 171 }
 172
 173 struct sock_ee {
 174         uint32_t ee_errno;
 175         uint8_t  ee_origin;
 176         uint8_t  ee_type;
 177         uint8_t  ee_code;
 178         uint8_t  ee_pad;
 179         uint32_t ee_info;
 180         uint32_t ee_data;
 181         struct sockaddr_in offender;
 182 };
 183
 184 static void
 185 print_cmsg_ip_recverr(struct tcb *tcp, const void *cmsg_data,
 186                       const unsigned int data_len)
 187 {
 188         const struct sock_ee *const err = cmsg_data;
 189
 190         PRINT_FIELD_U("{", *err, ee_errno);
 191         PRINT_FIELD_U(", ", *err, ee_origin);
 192         PRINT_FIELD_U(", ", *err, ee_type);
 193         PRINT_FIELD_U(", ", *err, ee_code);
 194         PRINT_FIELD_U(", ", *err, ee_info);
 195         PRINT_FIELD_U(", ", *err, ee_data);
 196         PRINT_FIELD_SOCKADDR(", ", *err, offender);
 197         tprints("}");
 198 }
 199
 200 static void
 201 print_cmsg_ip_origdstaddr(struct tcb *tcp, const void *cmsg_data,
 202                           const unsigned int data_len)
 203 {
 204         const unsigned int addr_len =
 205                 data_len > sizeof(struct sockaddr_storage)
 206                 ? sizeof(struct sockaddr_storage) : data_len;
 207
 208         print_sockaddr(cmsg_data, addr_len);
 209 }
 210
 211 typedef void (* const cmsg_printer)(struct tcb *, const void *, unsigned int);
 212
 213 static const struct {
 214         const cmsg_printer printer;
 215         const unsigned int min_len;
 216 } cmsg_socket_printers[] = {
 217         [SCM_RIGHTS] = { print_scm_rights, sizeof(int) },
 218         [SCM_CREDENTIALS] = { print_scm_creds, sizeof(struct ucred) },
 219         [SCM_SECURITY] = { print_scm_security, 1 },
 220         [SCM_TIMESTAMP] = { print_scm_timestamp, 1 },
 221         [SCM_TIMESTAMPNS] = { print_scm_timestampns, 1 },
 222         [SCM_TIMESTAMPING] = { print_scm_timestamping, 1 }
 223 }, cmsg_ip_printers[] = {
 224         [IP_PKTINFO] = { print_cmsg_ip_pktinfo, sizeof(struct in_pktinfo) },
 225         [IP_TTL] = { print_cmsg_uint, sizeof(unsigned int) },
 226         [IP_TOS] = { print_cmsg_uint8_t, 1 },
 227         [IP_RECVOPTS] = { print_cmsg_ip_opts, 1 },
 228         [IP_RETOPTS] = { print_cmsg_ip_opts, 1 },
 229         [IP_RECVERR] = { print_cmsg_ip_recverr, sizeof(struct sock_ee) },
 230         [IP_ORIGDSTADDR] = { print_cmsg_ip_origdstaddr, sizeof(struct sockaddr_in) },
 231         [IP_CHECKSUM] = { print_cmsg_uint, sizeof(unsigned int) },
 232         [SCM_SECURITY] = { print_scm_security, 1 }
 233 };
 234
 235 static void
 236 print_cmsg_type_data(struct tcb *tcp, const int cmsg_level, const int cmsg_type,
 237                      const void *cmsg_data, const unsigned int data_len)
 238 {
 239         const unsigned int utype = cmsg_type;
 240         switch (cmsg_level) {
 241         case SOL_SOCKET:
 242                 printxval(scmvals, cmsg_type, "SCM_???");
 243                 if (utype < ARRAY_SIZE(cmsg_socket_printers)
 244                     && cmsg_socket_printers[utype].printer
 245                     && data_len >= cmsg_socket_printers[utype].min_len) {
 246                         tprints(", cmsg_data=");
 247                         cmsg_socket_printers[utype].printer(tcp, cmsg_data, data_len);
 248                 }
 249                 break;
 250         case SOL_IP:
 251                 printxval(ip_cmsg_types, cmsg_type, "IP_???");
 252                 if (utype < ARRAY_SIZE(cmsg_ip_printers)
 253                     && cmsg_ip_printers[utype].printer
 254                     && data_len >= cmsg_ip_printers[utype].min_len) {
 255                         tprints(", cmsg_data=");
 256                         cmsg_ip_printers[utype].printer(tcp, cmsg_data, data_len);
 257                 }
 258                 break;
 259         default:
 260                 tprintf("%#x", cmsg_type);
 261         }
 262 }
 263
 264 static unsigned int
 265 get_optmem_max(void)
 266 {
 267         static int optmem_max;
 268
 269         if (!optmem_max) {
 270                 if (read_int_from_file("/proc/sys/net/core/optmem_max",
 271                                        &optmem_max) || optmem_max <= 0) {
 272                         optmem_max = sizeof(long long) * (2 * IOV_MAX + 512);
 273                 } else {
 274                         optmem_max = (optmem_max + sizeof(long long) - 1)
 275                                      & ~(sizeof(long long) - 1);
 276                 }
 277         }
 278
 279         return optmem_max;
 280 }
 281
 282 static void
 283 decode_msg_control(struct tcb *const tcp, const kernel_ulong_t addr,
 284                    const kernel_ulong_t in_control_len)
 285 {
 286         if (!in_control_len)
 287                 return;
 288         tprints(", msg_control=");
 289
 290         const unsigned int cmsg_size =
 291 #ifndef current_wordsize
 292                 (current_wordsize < sizeof(long)) ? sizeof(struct cmsghdr32) :
 293 #endif
 294                         sizeof(struct cmsghdr);
 295
 296         unsigned int control_len = in_control_len > get_optmem_max()
 297                                    ? get_optmem_max() : in_control_len;
 298         unsigned int buf_len = control_len;
 299         char *buf = buf_len < cmsg_size ? NULL : malloc(buf_len);
 300         if (!buf || umoven(tcp, addr, buf_len, buf) < 0) {
 301                 printaddr(addr);
 302                 free(buf);
 303                 return;
 304         }
 305
 306         union_cmsghdr u = { .ptr = buf };
 307
 308         tprints("[");
 309         while (buf_len >= cmsg_size) {
 310                 const kernel_ulong_t cmsg_len =
 311 #ifndef current_wordsize
 312                         (current_wordsize < sizeof(long)) ? u.cmsg32->cmsg_len :
 313 #endif
 314                                 u.cmsg->cmsg_len;
 315                 const int cmsg_level =
 316 #ifndef current_wordsize
 317                         (current_wordsize < sizeof(long)) ? u.cmsg32->cmsg_level :
 318 #endif
 319                                 u.cmsg->cmsg_level;
 320                 const int cmsg_type =
 321 #ifndef current_wordsize
 322                         (current_wordsize < sizeof(long)) ? u.cmsg32->cmsg_type :
 323 #endif
 324                                 u.cmsg->cmsg_type;
 325
 326                 if (u.ptr != buf)
 327                         tprints(", ");
 328                 tprintf("{cmsg_len=%" PRI_klu ", cmsg_level=", cmsg_len);
 329                 printxval(socketlayers, cmsg_level, "SOL_???");
 330                 tprints(", cmsg_type=");
 331
 332                 kernel_ulong_t len = cmsg_len > buf_len ? buf_len : cmsg_len;
 333
 334                 print_cmsg_type_data(tcp, cmsg_level, cmsg_type,
 335                                      (const void *) (u.ptr + cmsg_size),
 336                                      len > cmsg_size ? len - cmsg_size : 0);
 337                 tprints("}");
 338
 339                 if (len < cmsg_size) {
 340                         buf_len -= cmsg_size;
 341                         break;
 342                 }
 343                 len = (cmsg_len + current_wordsize - 1) &
 344                         ~((kernel_ulong_t) current_wordsize - 1);
 345                 if (len >= buf_len) {
 346                         buf_len = 0;
 347                         break;
 348                 }
 349                 u.ptr += len;
 350                 buf_len -= len;
 351         }
 352         if (buf_len) {
 353                 tprints(", ");
 354                 printaddr(addr + (control_len - buf_len));
 355         } else if (control_len < in_control_len) {
 356                 tprints(", ...");
 357         }
 358         tprints("]");
 359         free(buf);
 360 }
 361
 362 void
 363 print_struct_msghdr(struct tcb *tcp, const struct msghdr *msg,
 364                     const int *const p_user_msg_namelen,
 365                     const kernel_ulong_t data_size)
 366 {
 367         const int msg_namelen =
 368                 p_user_msg_namelen && (int) msg->msg_namelen > *p_user_msg_namelen
 369                 ? *p_user_msg_namelen : (int) msg->msg_namelen;
 370
 371         tprints("{msg_name=");
 372         const int family =
 373                 decode_sockaddr(tcp, ptr_to_kulong(msg->msg_name), msg_namelen);
 374         const enum iov_decode decode =
 375                 (family == AF_NETLINK) ? IOV_DECODE_NETLINK : IOV_DECODE_STR;
 376
 377         tprints(", msg_namelen=");
 378         if (p_user_msg_namelen && *p_user_msg_namelen != (int) msg->msg_namelen)
 379                 tprintf("%d->", *p_user_msg_namelen);
 380         tprintf("%d", msg->msg_namelen);
 381
 382         tprints(", msg_iov=");
 383         tprint_iov_upto(tcp, msg->msg_iovlen,
 384                         ptr_to_kulong(msg->msg_iov), decode, data_size);
 385         PRINT_FIELD_U(", ", *msg, msg_iovlen);
 386
 387         decode_msg_control(tcp, ptr_to_kulong(msg->msg_control),
 388                            msg->msg_controllen);
 389         PRINT_FIELD_U(", ", *msg, msg_controllen);
 390
 391         PRINT_FIELD_FLAGS(", ", *msg, msg_flags, msg_flags, "MSG_???");
 392         tprints("}");
 393 }
 394
 395 static bool
 396 fetch_msghdr_namelen(struct tcb *const tcp, const kernel_ulong_t addr,
 397                      int *const p_msg_namelen)
 398 {
 399         struct msghdr msg;
 400
 401         if (addr && verbose(tcp) && fetch_struct_msghdr(tcp, addr, &msg)) {
 402                 *p_msg_namelen = msg.msg_namelen;
 403                 return true;
 404         } else {
 405                 return false;
 406         }
 407 }
 408
 409 static void
 410 decode_msghdr(struct tcb *const tcp, const int *const p_user_msg_namelen,
 411               const kernel_ulong_t addr, const kernel_ulong_t data_size)
 412 {
 413         struct msghdr msg;
 414
 415         if (addr && verbose(tcp) && fetch_struct_msghdr(tcp, addr, &msg))
 416                 print_struct_msghdr(tcp, &msg, p_user_msg_namelen, data_size);
 417         else
 418                 printaddr(addr);
 419 }
 420
 421 void
 422 dumpiov_in_msghdr(struct tcb *const tcp, const kernel_ulong_t addr,
 423                   const kernel_ulong_t data_size)
 424 {
 425         struct msghdr msg;
 426
 427         if (fetch_struct_msghdr(tcp, addr, &msg)) {
 428                 dumpiov_upto(tcp, msg.msg_iovlen,
 429                              ptr_to_kulong(msg.msg_iov), data_size);
 430         }
 431 }
 432
 433 SYS_FUNC(sendmsg)
 434 {
 435         printfd(tcp, tcp->u_arg[0]);
 436         tprints(", ");
 437         decode_msghdr(tcp, 0, tcp->u_arg[1], -1);
 438         /* flags */
 439         tprints(", ");
 440         printflags(msg_flags, tcp->u_arg[2], "MSG_???");
 441
 442         return RVAL_DECODED;
 443 }
 444
 445 SYS_FUNC(recvmsg)
 446 {
 447         int msg_namelen;
 448
 449         if (entering(tcp)) {
 450                 printfd(tcp, tcp->u_arg[0]);
 451                 tprints(", ");
 452                 if (fetch_msghdr_namelen(tcp, tcp->u_arg[1], &msg_namelen)) {
 453                         set_tcb_priv_ulong(tcp, msg_namelen);
 454                         return 0;
 455                 }
 456                 printaddr(tcp->u_arg[1]);
 457         } else {
 458                 msg_namelen = get_tcb_priv_ulong(tcp);
 459
 460                 if (syserror(tcp))
 461                         tprintf("{msg_namelen=%d}", msg_namelen);
 462                 else
 463                         decode_msghdr(tcp, &msg_namelen, tcp->u_arg[1],
 464                                       tcp->u_rval);
 465         }
 466
 467         /* flags */
 468         tprints(", ");
 469         printflags(msg_flags, tcp->u_arg[2], "MSG_???");
 470
 471         return RVAL_DECODED;
 472 }