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.
10 * SPDX-License-Identifier: LGPL-2.1-or-later
14 #include "print_fields.h"
17 #include <arpa/inet.h>
18 #include <netinet/in.h>
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"
27 #ifndef current_wordsize
38 #ifndef current_wordsize
39 struct cmsghdr32 *cmsg32;
44 print_scm_rights(struct tcb *tcp, const void *cmsg_data,
45 const unsigned int data_len)
47 const int *fds = cmsg_data;
48 const unsigned int nfds = data_len / sizeof(*fds);
53 for (i = 0; i < nfds; ++i) {
56 if (abbrev(tcp) && i >= max_strlen) {
67 print_scm_creds(struct tcb *tcp, const void *cmsg_data,
68 const unsigned int data_len)
70 const struct ucred *uc = cmsg_data;
72 PRINT_FIELD_U("{", *uc, pid);
73 PRINT_FIELD_UID(", ", *uc, uid);
74 PRINT_FIELD_UID(", ", *uc, gid);
79 print_scm_security(struct tcb *tcp, const void *cmsg_data,
80 const unsigned int data_len)
82 print_quoted_string(cmsg_data, data_len, 0);
86 print_scm_timestamp_old(struct tcb *tcp, const void *cmsg_data,
87 const unsigned int data_len)
89 print_struct_timeval_data_size(cmsg_data, data_len);
93 print_scm_timestampns_old(struct tcb *tcp, const void *cmsg_data,
94 const unsigned int data_len)
96 print_struct_timespec_data_size(cmsg_data, data_len);
100 print_scm_timestamping_old(struct tcb *tcp, const void *cmsg_data,
101 const unsigned int data_len)
103 print_struct_timespec_array_data_size(cmsg_data, 3, data_len);
107 print_scm_timestamp_new(struct tcb *tcp, const void *cmsg_data,
108 const unsigned int data_len)
110 print_timeval64_data_size(cmsg_data, data_len);
114 print_scm_timestampns_new(struct tcb *tcp, const void *cmsg_data,
115 const unsigned int data_len)
117 print_timespec64_data_size(cmsg_data, data_len);
121 print_scm_timestamping_new(struct tcb *tcp, const void *cmsg_data,
122 const unsigned int data_len)
124 print_timespec64_array_data_size(cmsg_data, 3, data_len);
128 print_cmsg_ip_pktinfo(struct tcb *tcp, const void *cmsg_data,
129 const unsigned int data_len)
131 const struct in_pktinfo *info = cmsg_data;
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);
140 print_cmsg_uint(struct tcb *tcp, const void *cmsg_data,
141 const unsigned int data_len)
143 const unsigned int *p = cmsg_data;
149 print_cmsg_uint8_t(struct tcb *tcp, const void *cmsg_data,
150 const unsigned int data_len)
152 const uint8_t *p = cmsg_data;
154 tprintf("[%#x]", *p);
158 print_cmsg_ip_opts(struct tcb *tcp, const void *cmsg_data,
159 const unsigned int data_len)
161 const unsigned char *opts = cmsg_data;
165 for (i = 0; i < data_len; ++i) {
168 if (abbrev(tcp) && i >= max_strlen) {
172 tprintf("0x%02x", opts[i]);
185 struct sockaddr_in offender;
189 print_cmsg_ip_recverr(struct tcb *tcp, const void *cmsg_data,
190 const unsigned int data_len)
192 const struct sock_ee *const err = cmsg_data;
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);
205 print_cmsg_ip_origdstaddr(struct tcb *tcp, const void *cmsg_data,
206 const unsigned int data_len)
208 const unsigned int addr_len =
209 data_len > sizeof(struct sockaddr_storage)
210 ? sizeof(struct sockaddr_storage) : data_len;
212 print_sockaddr(cmsg_data, addr_len);
215 typedef void (* const cmsg_printer)(struct tcb *, const void *, unsigned int);
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 }
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)
246 const unsigned int utype = cmsg_type;
247 switch (cmsg_level) {
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);
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);
267 tprintf("%#x", cmsg_type);
272 get_optmem_max(struct tcb *tcp)
274 static int 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);
281 optmem_max = (optmem_max + sizeof(long long) - 1)
282 & ~(sizeof(long long) - 1);
290 decode_msg_control(struct tcb *const tcp, const kernel_ulong_t addr,
291 const kernel_ulong_t in_control_len)
295 tprints(", msg_control=");
297 const unsigned int cmsg_size =
298 #ifndef current_wordsize
299 (current_wordsize < sizeof(long)) ? sizeof(struct cmsghdr32) :
301 sizeof(struct cmsghdr);
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) {
313 union_cmsghdr u = { .ptr = buf };
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 :
322 const int cmsg_level =
323 #ifndef current_wordsize
324 (current_wordsize < sizeof(long)) ? u.cmsg32->cmsg_level :
327 const int cmsg_type =
328 #ifndef current_wordsize
329 (current_wordsize < sizeof(long)) ? u.cmsg32->cmsg_type :
335 tprintf("{cmsg_len=%" PRI_klu ", cmsg_level=", cmsg_len);
336 printxval(socketlayers, cmsg_level, "SOL_???");
337 tprints(", cmsg_type=");
339 kernel_ulong_t len = cmsg_len > buf_len ? buf_len : cmsg_len;
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);
346 if (len < cmsg_size) {
347 buf_len -= cmsg_size;
350 len = (cmsg_len + current_wordsize - 1) &
351 ~((kernel_ulong_t) current_wordsize - 1);
352 if (len >= buf_len) {
361 printaddr_comment(addr + (control_len - buf_len));
362 } else if (control_len < in_control_len) {
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)
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;
378 tprints("{msg_name=");
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;
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);
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);
394 decode_msg_control(tcp, ptr_to_kulong(msg->msg_control),
395 msg->msg_controllen);
396 PRINT_FIELD_U(", ", *msg, msg_controllen);
398 PRINT_FIELD_FLAGS(", ", *msg, msg_flags, msg_flags, "MSG_???");
403 fetch_msghdr_namelen(struct tcb *const tcp, const kernel_ulong_t addr,
404 int *const p_msg_namelen)
408 if (addr && verbose(tcp) && fetch_struct_msghdr(tcp, addr, &msg)) {
409 *p_msg_namelen = msg.msg_namelen;
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)
422 if (addr && verbose(tcp) && fetch_struct_msghdr(tcp, addr, &msg))
423 print_struct_msghdr(tcp, &msg, p_user_msg_namelen, data_size);
429 dumpiov_in_msghdr(struct tcb *const tcp, const kernel_ulong_t addr,
430 const kernel_ulong_t data_size)
434 if (fetch_struct_msghdr(tcp, addr, &msg)) {
435 dumpiov_upto(tcp, msg.msg_iovlen,
436 ptr_to_kulong(msg.msg_iov), data_size);
442 printfd(tcp, tcp->u_arg[0]);
444 decode_msghdr(tcp, 0, tcp->u_arg[1], -1);
447 printflags(msg_flags, tcp->u_arg[2], "MSG_???");
457 printfd(tcp, tcp->u_arg[0]);
459 if (fetch_msghdr_namelen(tcp, tcp->u_arg[1], &msg_namelen)) {
460 set_tcb_priv_ulong(tcp, msg_namelen);
463 printaddr(tcp->u_arg[1]);
465 msg_namelen = get_tcb_priv_ulong(tcp);
468 tprintf("{msg_namelen=%d}", msg_namelen);
470 decode_msghdr(tcp, &msg_namelen, tcp->u_arg[1],
476 printflags(msg_flags, tcp->u_arg[2], "MSG_???");