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-2018 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
print_scm_rights(struct tcb * tcp,const void * cmsg_data,const unsigned int data_len)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
print_scm_creds(struct tcb * tcp,const void * cmsg_data,const unsigned int data_len)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
print_scm_security(struct tcb * tcp,const void * cmsg_data,const unsigned int data_len)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
print_scm_timestamp(struct tcb * tcp,const void * cmsg_data,const unsigned int data_len)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
print_scm_timestampns(struct tcb * tcp,const void * cmsg_data,const unsigned int data_len)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
print_scm_timestamping(struct tcb * tcp,const void * cmsg_data,const unsigned int data_len)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
print_cmsg_ip_pktinfo(struct tcb * tcp,const void * cmsg_data,const unsigned int data_len)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
print_cmsg_uint(struct tcb * tcp,const void * cmsg_data,const unsigned int data_len)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
print_cmsg_uint8_t(struct tcb * tcp,const void * cmsg_data,const unsigned int data_len)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
print_cmsg_ip_opts(struct tcb * tcp,const void * cmsg_data,const unsigned int data_len)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
print_cmsg_ip_recverr(struct tcb * tcp,const void * cmsg_data,const unsigned int data_len)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
print_cmsg_ip_origdstaddr(struct tcb * tcp,const void * cmsg_data,const unsigned int data_len)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
print_cmsg_type_data(struct tcb * tcp,const int cmsg_level,const int cmsg_type,const void * cmsg_data,const unsigned int data_len)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
get_optmem_max(struct tcb * tcp)265 get_optmem_max(struct tcb *tcp)
266 {
267 	static int optmem_max;
268 
269 	if (!optmem_max) {
270 		if (read_int_from_file(tcp, "/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
decode_msg_control(struct tcb * const tcp,const kernel_ulong_t addr,const kernel_ulong_t in_control_len)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(tcp)
297 				   ? get_optmem_max(tcp) : 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_comment(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
print_struct_msghdr(struct tcb * tcp,const struct msghdr * msg,const int * const p_user_msg_namelen,const kernel_ulong_t data_size)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
fetch_msghdr_namelen(struct tcb * const tcp,const kernel_ulong_t addr,int * const p_msg_namelen)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
decode_msghdr(struct tcb * const tcp,const int * const p_user_msg_namelen,const kernel_ulong_t addr,const kernel_ulong_t data_size)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
dumpiov_in_msghdr(struct tcb * const tcp,const kernel_ulong_t addr,const kernel_ulong_t data_size)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 
SYS_FUNC(sendmsg)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 
SYS_FUNC(recvmsg)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 }
473