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