Branch data Line data Source code
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 <limits.h>
35 : : #include <arpa/inet.h>
36 : : #include <netinet/in.h>
37 : :
38 : : #include "xlat/msg_flags.h"
39 : : #include "xlat/scmvals.h"
40 : : #include "xlat/ip_cmsg_types.h"
41 : :
42 : : #ifndef current_wordsize
43 : : struct cmsghdr32 {
44 : : uint32_t cmsg_len;
45 : : int cmsg_level;
46 : : int cmsg_type;
47 : : };
48 : : #endif
49 : :
50 : : typedef union {
51 : : char *ptr;
52 : : struct cmsghdr *cmsg;
53 : : #ifndef current_wordsize
54 : : struct cmsghdr32 *cmsg32;
55 : : #endif
56 : : } union_cmsghdr;
57 : :
58 : : static void
59 : 249056 : print_scm_rights(struct tcb *tcp, const void *cmsg_data,
60 : : const unsigned int data_len)
61 : : {
62 : 249056 : const int *fds = cmsg_data;
63 : 249056 : const unsigned int nfds = data_len / sizeof(*fds);
64 : : unsigned int i;
65 : :
66 : 249056 : tprints("[");
67 : :
68 [ + + ]: 895055 : for (i = 0; i < nfds; ++i) {
69 [ + + ]: 646011 : if (i)
70 : 396955 : tprints(", ");
71 [ + + ][ + + ]: 646011 : if (abbrev(tcp) && i >= max_strlen) {
72 : 12 : tprints("...");
73 : 12 : break;
74 : : }
75 : 645999 : printfd(tcp, fds[i]);
76 : : }
77 : :
78 : 249056 : tprints("]");
79 : 249056 : }
80 : :
81 : : static void
82 : 6 : print_scm_creds(struct tcb *tcp, const void *cmsg_data,
83 : : const unsigned int data_len)
84 : : {
85 : 6 : const struct ucred *uc = cmsg_data;
86 : :
87 : 6 : tprintf("{pid=%u, uid=%u, gid=%u}",
88 : 6 : (unsigned) uc->pid, (unsigned) uc->uid, (unsigned) uc->gid);
89 : 6 : }
90 : :
91 : : static void
92 : 4980 : print_scm_security(struct tcb *tcp, const void *cmsg_data,
93 : : const unsigned int data_len)
94 : : {
95 : 4980 : print_quoted_string(cmsg_data, data_len, 0);
96 : 4980 : }
97 : :
98 : : static void
99 : 18 : print_cmsg_ip_pktinfo(struct tcb *tcp, const void *cmsg_data,
100 : : const unsigned int data_len)
101 : : {
102 : 18 : const struct in_pktinfo *info = cmsg_data;
103 : :
104 : 18 : tprints("{ipi_ifindex=");
105 : 18 : print_ifindex(info->ipi_ifindex);
106 : 18 : tprintf(", ipi_spec_dst=inet_addr(\"%s\")",
107 : : inet_ntoa(info->ipi_spec_dst));
108 : 18 : tprintf(", ipi_addr=inet_addr(\"%s\")}",
109 : : inet_ntoa(info->ipi_addr));
110 : 18 : }
111 : :
112 : : static void
113 : 30 : print_cmsg_uint(struct tcb *tcp, const void *cmsg_data,
114 : : const unsigned int data_len)
115 : : {
116 : 30 : const unsigned int *p = cmsg_data;
117 : :
118 : 30 : tprintf("[%u]", *p);
119 : 30 : }
120 : :
121 : : static void
122 : 18 : print_cmsg_uint8_t(struct tcb *tcp, const void *cmsg_data,
123 : : const unsigned int data_len)
124 : : {
125 : 18 : const uint8_t *p = cmsg_data;
126 : :
127 : 18 : tprintf("[%#x]", *p);
128 : 18 : }
129 : :
130 : : static void
131 : 138 : print_cmsg_ip_opts(struct tcb *tcp, const void *cmsg_data,
132 : : const unsigned int data_len)
133 : : {
134 : 138 : const unsigned char *opts = cmsg_data;
135 : : unsigned int i;
136 : :
137 : 138 : tprints("[");
138 [ + + ]: 1740 : for (i = 0; i < data_len; ++i) {
139 [ + + ]: 1608 : if (i)
140 : 1470 : tprints(", ");
141 [ + + ][ + + ]: 1608 : if (abbrev(tcp) && i >= max_strlen) {
142 : 6 : tprints("...");
143 : 6 : break;
144 : : }
145 : 1602 : tprintf("0x%02x", opts[i]);
146 : : }
147 : 138 : tprints("]");
148 : 138 : }
149 : :
150 : : struct sock_ee {
151 : : uint32_t ee_errno;
152 : : uint8_t ee_origin;
153 : : uint8_t ee_type;
154 : : uint8_t ee_code;
155 : : uint8_t ee_pad;
156 : : uint32_t ee_info;
157 : : uint32_t ee_data;
158 : : struct sockaddr_in offender;
159 : : };
160 : :
161 : : static void
162 : 12 : print_cmsg_ip_recverr(struct tcb *tcp, const void *cmsg_data,
163 : : const unsigned int data_len)
164 : : {
165 : 12 : const struct sock_ee *const err = cmsg_data;
166 : :
167 : 12 : tprintf("{ee_errno=%u, ee_origin=%u, ee_type=%u, ee_code=%u"
168 : : ", ee_info=%u, ee_data=%u, offender=",
169 : 24 : err->ee_errno, err->ee_origin, err->ee_type,
170 : 12 : err->ee_code, err->ee_info, err->ee_data);
171 : 12 : print_sockaddr(tcp, &err->offender, sizeof(err->offender));
172 : 12 : tprints("}");
173 : 12 : }
174 : :
175 : : static void
176 : 17 : print_cmsg_ip_origdstaddr(struct tcb *tcp, const void *cmsg_data,
177 : : const unsigned int data_len)
178 : : {
179 : 17 : const unsigned int addr_len =
180 : : data_len > sizeof(struct sockaddr_storage)
181 : : ? sizeof(struct sockaddr_storage) : data_len;
182 : :
183 : 17 : print_sockaddr(tcp, cmsg_data, addr_len);
184 : 17 : }
185 : :
186 : : typedef void (* const cmsg_printer)(struct tcb *, const void *, unsigned int);
187 : :
188 : : static const struct {
189 : : const cmsg_printer printer;
190 : : const unsigned int min_len;
191 : : } cmsg_socket_printers[] = {
192 : : [SCM_RIGHTS] = { print_scm_rights, sizeof(int) },
193 : : [SCM_CREDENTIALS] = { print_scm_creds, sizeof(struct ucred) },
194 : : [SCM_SECURITY] = { print_scm_security, 1 }
195 : : }, cmsg_ip_printers[] = {
196 : : [IP_PKTINFO] = { print_cmsg_ip_pktinfo, sizeof(struct in_pktinfo) },
197 : : [IP_TTL] = { print_cmsg_uint, sizeof(unsigned int) },
198 : : [IP_TOS] = { print_cmsg_uint8_t, 1 },
199 : : [IP_RECVOPTS] = { print_cmsg_ip_opts, 1 },
200 : : [IP_RETOPTS] = { print_cmsg_ip_opts, 1 },
201 : : [IP_RECVERR] = { print_cmsg_ip_recverr, sizeof(struct sock_ee) },
202 : : [IP_ORIGDSTADDR] = { print_cmsg_ip_origdstaddr, sizeof(struct sockaddr_in) },
203 : : [IP_CHECKSUM] = { print_cmsg_uint, sizeof(unsigned int) },
204 : : [SCM_SECURITY] = { print_scm_security, 1 }
205 : : };
206 : :
207 : : static void
208 : 394149 : print_cmsg_type_data(struct tcb *tcp, const int cmsg_level, const int cmsg_type,
209 : : const void *cmsg_data, const unsigned int data_len)
210 : : {
211 : 394149 : const unsigned int utype = cmsg_type;
212 [ + + + ]: 394149 : switch (cmsg_level) {
213 : : case SOL_SOCKET:
214 : 393874 : printxval(scmvals, cmsg_type, "SCM_???");
215 [ + + ]: 393874 : if (utype < ARRAY_SIZE(cmsg_socket_printers)
216 [ + - ]: 393862 : && cmsg_socket_printers[utype].printer
217 [ + + ]: 393862 : && data_len >= cmsg_socket_printers[utype].min_len) {
218 : 254042 : tprints(", cmsg_data=");
219 : 254042 : cmsg_socket_printers[utype].printer(tcp, cmsg_data, data_len);
220 : : }
221 : 393874 : break;
222 : : case SOL_IP:
223 : 263 : printxval(ip_cmsg_types, cmsg_type, "IP_???");
224 [ + + ]: 263 : if (utype < ARRAY_SIZE(cmsg_ip_printers)
225 [ + - ]: 251 : && cmsg_ip_printers[utype].printer
226 [ + + ]: 251 : && data_len >= cmsg_ip_printers[utype].min_len) {
227 : 233 : tprints(", cmsg_data=");
228 : 233 : cmsg_ip_printers[utype].printer(tcp, cmsg_data, data_len);
229 : : }
230 : 263 : break;
231 : : default:
232 : 12 : tprintf("%#x", cmsg_type);
233 : : }
234 : 394149 : }
235 : :
236 : : static unsigned int
237 : 211874 : get_optmem_max(void)
238 : : {
239 : : static int optmem_max;
240 : :
241 [ + + ]: 211874 : if (!optmem_max) {
242 [ + - ]: 24 : if (read_int_from_file("/proc/sys/net/core/optmem_max",
243 [ - + ]: 24 : &optmem_max) || optmem_max <= 0) {
244 : 0 : optmem_max = sizeof(long long) * (2 * IOV_MAX + 512);
245 : : } else {
246 : 24 : optmem_max = (optmem_max + sizeof(long long) - 1)
247 : 24 : & ~(sizeof(long long) - 1);
248 : : }
249 : : }
250 : :
251 : 211874 : return optmem_max;
252 : : }
253 : :
254 : : static void
255 : 226680 : decode_msg_control(struct tcb *const tcp, const kernel_ulong_t addr,
256 : : const kernel_ulong_t in_control_len)
257 : : {
258 [ + + ]: 226680 : if (!in_control_len)
259 : 18998 : return;
260 : 211862 : tprints(", msg_control=");
261 : :
262 [ + + ]: 211862 : const unsigned int cmsg_size =
263 : : #ifndef current_wordsize
264 : 211862 : (current_wordsize < sizeof(long)) ? sizeof(struct cmsghdr32) :
265 : : #endif
266 : : sizeof(struct cmsghdr);
267 : :
268 [ + + ]: 211862 : unsigned int control_len = in_control_len > get_optmem_max()
269 : : ? get_optmem_max() : in_control_len;
270 : 211862 : unsigned int buf_len = control_len;
271 [ + + ]: 211862 : char *buf = buf_len < cmsg_size ? NULL : malloc(buf_len);
272 [ + + ][ + + ]: 211862 : if (!buf || umoven(tcp, addr, buf_len, buf) < 0) {
273 : 4180 : printaddr(addr);
274 : 4180 : free(buf);
275 : 4180 : return;
276 : : }
277 : :
278 : 207682 : union_cmsghdr u = { .ptr = buf };
279 : :
280 : 207682 : tprints("[");
281 [ + + ]: 439401 : while (buf_len >= cmsg_size) {
282 : 394149 : const kernel_ulong_t cmsg_len =
283 : : #ifndef current_wordsize
284 [ + + ]: 394149 : (current_wordsize < sizeof(long)) ? u.cmsg32->cmsg_len :
285 : : #endif
286 : 341194 : u.cmsg->cmsg_len;
287 : 394149 : const int cmsg_level =
288 : : #ifndef current_wordsize
289 [ + + ]: 394149 : (current_wordsize < sizeof(long)) ? u.cmsg32->cmsg_level :
290 : : #endif
291 : 341194 : u.cmsg->cmsg_level;
292 : 394149 : const int cmsg_type =
293 : : #ifndef current_wordsize
294 [ + + ]: 394149 : (current_wordsize < sizeof(long)) ? u.cmsg32->cmsg_type :
295 : : #endif
296 : 341194 : u.cmsg->cmsg_type;
297 : :
298 [ + + ]: 394149 : if (u.ptr != buf)
299 : 186467 : tprints(", ");
300 : 394149 : tprintf("{cmsg_len=%" PRI_klu ", cmsg_level=", cmsg_len);
301 : 394149 : printxval(socketlayers, cmsg_level, "SOL_???");
302 : 394149 : tprints(", cmsg_type=");
303 : :
304 : 394149 : kernel_ulong_t len = cmsg_len > buf_len ? buf_len : cmsg_len;
305 : :
306 [ + + ]: 394149 : print_cmsg_type_data(tcp, cmsg_level, cmsg_type,
307 : 788298 : (const void *) (u.ptr + cmsg_size),
308 : 707908 : len > cmsg_size ? len - cmsg_size: 0);
309 : 394149 : tprints("}");
310 : :
311 [ + + ]: 394149 : if (len < cmsg_size) {
312 : 57888 : buf_len -= cmsg_size;
313 : 57888 : break;
314 : : }
315 : 672522 : len = (cmsg_len + current_wordsize - 1) &
316 : 336261 : ~((kernel_ulong_t) current_wordsize - 1);
317 [ + + ]: 336261 : if (len >= buf_len) {
318 : 104542 : buf_len = 0;
319 : 104542 : break;
320 : : }
321 : 231719 : u.ptr += len;
322 : 231719 : buf_len -= len;
323 : : }
324 [ + + ]: 207682 : if (buf_len) {
325 : 99644 : tprints(", ");
326 : 99644 : printaddr(addr + (control_len - buf_len));
327 [ + + ]: 108038 : } else if (control_len < in_control_len) {
328 : 12 : tprints(", ...");
329 : : }
330 : 207682 : tprints("]");
331 : 207682 : free(buf);
332 : : }
333 : :
334 : : void
335 : 226680 : print_struct_msghdr(struct tcb *tcp, const struct msghdr *msg,
336 : : const int *const p_user_msg_namelen,
337 : : const kernel_ulong_t data_size)
338 : : {
339 : 226680 : const int msg_namelen =
340 [ + + ]: 1932 : p_user_msg_namelen && (int) msg->msg_namelen > *p_user_msg_namelen
341 [ + + ]: 228612 : ? *p_user_msg_namelen : (int) msg->msg_namelen;
342 : :
343 : 226680 : tprints("{msg_name=");
344 : 226680 : const int family =
345 : 226680 : decode_sockaddr(tcp, ptr_to_kulong(msg->msg_name), msg_namelen);
346 : 226680 : const enum iov_decode decode =
347 [ - + ]: 226680 : (family == AF_NETLINK) ? IOV_DECODE_NETLINK : IOV_DECODE_STR;
348 : :
349 : 226680 : tprints(", msg_namelen=");
350 [ + + ][ + + ]: 226680 : if (p_user_msg_namelen && *p_user_msg_namelen != (int) msg->msg_namelen)
351 : 1860 : tprintf("%d->", *p_user_msg_namelen);
352 : 226680 : tprintf("%d", msg->msg_namelen);
353 : :
354 : 226680 : tprints(", msg_iov=");
355 : :
356 : 226680 : tprint_iov_upto(tcp, msg->msg_iovlen,
357 : 226680 : ptr_to_kulong(msg->msg_iov), decode, data_size);
358 : 226680 : tprintf(", msg_iovlen=%" PRI_klu, (kernel_ulong_t) msg->msg_iovlen);
359 : :
360 : 226680 : decode_msg_control(tcp, ptr_to_kulong(msg->msg_control),
361 : : msg->msg_controllen);
362 : 226680 : tprintf(", msg_controllen=%" PRI_klu, (kernel_ulong_t) msg->msg_controllen);
363 : :
364 : 226680 : tprints(", msg_flags=");
365 : 226680 : printflags(msg_flags, msg->msg_flags, "MSG_???");
366 : 226680 : tprints("}");
367 : 226680 : }
368 : :
369 : : static bool
370 : 72 : fetch_msghdr_namelen(struct tcb *const tcp, const kernel_ulong_t addr,
371 : : int *const p_msg_namelen)
372 : : {
373 : : struct msghdr msg;
374 : :
375 [ + + ][ + - ]: 72 : if (addr && verbose(tcp) && fetch_struct_msghdr(tcp, addr, &msg)) {
[ + + ]
376 : 60 : *p_msg_namelen = msg.msg_namelen;
377 : 60 : return true;
378 : : } else {
379 : 72 : return false;
380 : : }
381 : : }
382 : :
383 : : static void
384 : 212130 : decode_msghdr(struct tcb *const tcp, const int *const p_user_msg_namelen,
385 : : const kernel_ulong_t addr, const kernel_ulong_t data_size)
386 : : {
387 : : struct msghdr msg;
388 : :
389 [ + + ][ + - ]: 212130 : if (addr && verbose(tcp) && fetch_struct_msghdr(tcp, addr, &msg))
[ + + ]
390 : 212106 : print_struct_msghdr(tcp, &msg, p_user_msg_namelen, data_size);
391 : : else
392 : 24 : printaddr(addr);
393 : 212130 : }
394 : :
395 : : void
396 : 18 : dumpiov_in_msghdr(struct tcb *const tcp, const kernel_ulong_t addr,
397 : : const kernel_ulong_t data_size)
398 : : {
399 : : struct msghdr msg;
400 : :
401 [ + - ]: 18 : if (fetch_struct_msghdr(tcp, addr, &msg)) {
402 : 18 : dumpiov_upto(tcp, msg.msg_iovlen,
403 : 18 : ptr_to_kulong(msg.msg_iov), data_size);
404 : : }
405 : 18 : }
406 : :
407 : 212076 : SYS_FUNC(sendmsg)
408 : : {
409 : 212076 : printfd(tcp, tcp->u_arg[0]);
410 : 212076 : tprints(", ");
411 : 212076 : decode_msghdr(tcp, 0, tcp->u_arg[1], -1);
412 : : /* flags */
413 : 212076 : tprints(", ");
414 : 212076 : printflags(msg_flags, tcp->u_arg[2], "MSG_???");
415 : :
416 : 212076 : return RVAL_DECODED;
417 : : }
418 : :
419 : 132 : SYS_FUNC(recvmsg)
420 : : {
421 : : int msg_namelen;
422 : :
423 [ + + ]: 132 : if (entering(tcp)) {
424 : 72 : printfd(tcp, tcp->u_arg[0]);
425 : 72 : tprints(", ");
426 [ + + ]: 72 : if (fetch_msghdr_namelen(tcp, tcp->u_arg[1], &msg_namelen)) {
427 : 60 : set_tcb_priv_ulong(tcp, msg_namelen);
428 : 60 : return 0;
429 : : }
430 : 12 : printaddr(tcp->u_arg[1]);
431 : : } else {
432 : 60 : msg_namelen = get_tcb_priv_ulong(tcp);
433 : :
434 [ + + ]: 60 : if (syserror(tcp))
435 : 6 : tprintf("{msg_namelen=%d}", msg_namelen);
436 : : else
437 : 54 : decode_msghdr(tcp, &msg_namelen, tcp->u_arg[1],
438 : 54 : tcp->u_rval);
439 : : }
440 : :
441 : : /* flags */
442 : 72 : tprints(", ");
443 : 72 : printflags(msg_flags, tcp->u_arg[2], "MSG_???");
444 : :
445 : 132 : return RVAL_DECODED;
446 : : }
|
