• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2010 Andreas Schwab <schwab@linux-m68k.org>
3  * Copyright (c) 2012-2013 Denys Vlasenko <vda.linux@googlemail.com>
4  * Copyright (c) 2014 Masatake YAMATO <yamato@redhat.com>
5  * Copyright (c) 2010-2016 Dmitry V. Levin <ldv@altlinux.org>
6  * Copyright (c) 2016-2018 The strace developers.
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 "xstring.h"
35 #include <limits.h>
36 
37 static int
fetch_struct_mmsghdr_or_printaddr(struct tcb * const tcp,const kernel_ulong_t addr,const unsigned int len,void * const mh)38 fetch_struct_mmsghdr_or_printaddr(struct tcb *const tcp,
39 				  const kernel_ulong_t addr,
40 				  const unsigned int len, void *const mh)
41 {
42 	if ((entering(tcp) || !syserror(tcp))
43 	    && fetch_struct_mmsghdr(tcp, addr, mh)) {
44 		return 0;
45 	} else {
46 		printaddr(addr);
47 		return -1;
48 	}
49 }
50 
51 struct print_struct_mmsghdr_config {
52 	const int *p_user_msg_namelen;
53 	unsigned int msg_len_vlen;
54 	unsigned int count;
55 	bool use_msg_len;
56 };
57 
58 static bool
print_struct_mmsghdr(struct tcb * tcp,void * elem_buf,size_t elem_size,void * data)59 print_struct_mmsghdr(struct tcb *tcp, void *elem_buf,
60 		     size_t elem_size, void *data)
61 {
62 	const struct mmsghdr *const mmsg = elem_buf;
63 	struct print_struct_mmsghdr_config *const c = data;
64 
65 	if (!c->count) {
66 		tprints("...");
67 		return false;
68 	}
69 	--c->count;
70 
71 	tprints("{msg_hdr=");
72 	print_struct_msghdr(tcp, &mmsg->msg_hdr, c->p_user_msg_namelen,
73 			    c->use_msg_len ? mmsg->msg_len : (kernel_ulong_t) -1);
74 	if (c->msg_len_vlen) {
75 		tprintf(", msg_len=%u", mmsg->msg_len);
76 		--c->msg_len_vlen;
77 	}
78 	tprints("}");
79 
80 	if (c->p_user_msg_namelen)
81 		++c->p_user_msg_namelen;
82 
83 	return true;
84 }
85 
86 static void
free_mmsgvec_data(void * ptr)87 free_mmsgvec_data(void *ptr)
88 {
89 	char **pstr = ptr;
90 	free(*pstr);
91 	*pstr = 0;
92 
93 	free(ptr);
94 }
95 
96 struct mmsgvec_data {
97 	char *timeout;
98 	unsigned int count;
99 	int namelen[IOV_MAX];
100 };
101 
102 static void
save_mmsgvec_namelen(struct tcb * const tcp,kernel_ulong_t addr,unsigned int len,const char * const timeout)103 save_mmsgvec_namelen(struct tcb *const tcp, kernel_ulong_t addr,
104 		     unsigned int len, const char *const timeout)
105 {
106 	if (len > IOV_MAX)
107 		len = IOV_MAX;
108 
109 	const size_t data_size = offsetof(struct mmsgvec_data, namelen)
110 				 + sizeof(int) * len;
111 	struct mmsgvec_data *const data = xmalloc(data_size);
112 	data->timeout = xstrdup(timeout);
113 
114 	unsigned int i, fetched;
115 
116 	for (i = 0; i < len; ++i, addr += fetched) {
117 		struct mmsghdr mh;
118 
119 		fetched = fetch_struct_mmsghdr(tcp, addr, &mh);
120 		if (!fetched)
121 			break;
122 		data->namelen[i] = mh.msg_hdr.msg_namelen;
123 	}
124 	data->count = i;
125 
126 	set_tcb_priv_data(tcp, data, free_mmsgvec_data);
127 }
128 
129 static void
decode_mmsgvec(struct tcb * const tcp,const kernel_ulong_t addr,const unsigned int vlen,const unsigned int msg_len_vlen,const bool use_msg_len)130 decode_mmsgvec(struct tcb *const tcp, const kernel_ulong_t addr,
131 	       const unsigned int vlen, const unsigned int msg_len_vlen,
132 	       const bool use_msg_len)
133 {
134 	struct mmsghdr mmsg;
135 	struct print_struct_mmsghdr_config c = {
136 		.msg_len_vlen = msg_len_vlen,
137 		.count = IOV_MAX,
138 		.use_msg_len = use_msg_len
139 	};
140 	const struct mmsgvec_data *const data = get_tcb_priv_data(tcp);
141 
142 	if (data) {
143 		if (data->count < c.count)
144 			c.count = data->count;
145 		c.p_user_msg_namelen = data->namelen;
146 	}
147 
148 	print_array(tcp, addr, vlen, &mmsg, sizeof_struct_mmsghdr(),
149 		    fetch_struct_mmsghdr_or_printaddr,
150 		    print_struct_mmsghdr, &c);
151 }
152 
153 void
dumpiov_in_mmsghdr(struct tcb * const tcp,kernel_ulong_t addr)154 dumpiov_in_mmsghdr(struct tcb *const tcp, kernel_ulong_t addr)
155 {
156 	unsigned int len = tcp->u_rval;
157 	unsigned int i, fetched;
158 	struct mmsghdr mmsg;
159 
160 	for (i = 0; i < len; ++i, addr += fetched) {
161 		fetched = fetch_struct_mmsghdr(tcp, addr, &mmsg);
162 		if (!fetched)
163 			break;
164 		tprintf(" = %" PRI_klu " buffers in vector %u\n",
165 			(kernel_ulong_t) mmsg.msg_hdr.msg_iovlen, i);
166 		dumpiov_upto(tcp, mmsg.msg_hdr.msg_iovlen,
167 			     ptr_to_kulong(mmsg.msg_hdr.msg_iov),
168 			     mmsg.msg_len);
169 	}
170 }
171 
SYS_FUNC(sendmmsg)172 SYS_FUNC(sendmmsg)
173 {
174 	if (entering(tcp)) {
175 		/* sockfd */
176 		printfd(tcp, tcp->u_arg[0]);
177 		tprints(", ");
178 		if (!verbose(tcp)) {
179 			/* msgvec */
180 			printaddr(tcp->u_arg[1]);
181 			/* vlen */
182 			tprintf(", %u, ", (unsigned int) tcp->u_arg[2]);
183 			/* flags */
184 			printflags(msg_flags, tcp->u_arg[3], "MSG_???");
185 			return RVAL_DECODED;
186 		}
187 	} else {
188 		const unsigned int msg_len_vlen =
189 			syserror(tcp) ? 0 : tcp->u_rval;
190 		/* msgvec */
191 		temporarily_clear_syserror(tcp);
192 		decode_mmsgvec(tcp, tcp->u_arg[1], tcp->u_arg[2],
193 			       msg_len_vlen, false);
194 		restore_cleared_syserror(tcp);
195 		/* vlen */
196 		tprintf(", %u, ", (unsigned int) tcp->u_arg[2]);
197 		/* flags */
198 		printflags(msg_flags, tcp->u_arg[3], "MSG_???");
199 	}
200 	return 0;
201 }
202 
SYS_FUNC(recvmmsg)203 SYS_FUNC(recvmmsg)
204 {
205 	if (entering(tcp)) {
206 		printfd(tcp, tcp->u_arg[0]);
207 		tprints(", ");
208 		if (verbose(tcp)) {
209 			save_mmsgvec_namelen(tcp, tcp->u_arg[1], tcp->u_arg[2],
210 					     sprint_timespec(tcp, tcp->u_arg[4]));
211 		} else {
212 			/* msgvec */
213 			printaddr(tcp->u_arg[1]);
214 			/* vlen */
215 			tprintf(", %u, ", (unsigned int) tcp->u_arg[2]);
216 			/* flags */
217 			printflags(msg_flags, tcp->u_arg[3], "MSG_???");
218 			tprints(", ");
219 			print_timespec(tcp, tcp->u_arg[4]);
220 		}
221 		return 0;
222 	} else {
223 		if (verbose(tcp)) {
224 			/* msgvec */
225 			decode_mmsgvec(tcp, tcp->u_arg[1], tcp->u_rval,
226 				       tcp->u_rval, true);
227 			/* vlen */
228 			tprintf(", %u, ", (unsigned int) tcp->u_arg[2]);
229 			/* flags */
230 			printflags(msg_flags, tcp->u_arg[3], "MSG_???");
231 			tprints(", ");
232 			/* timeout on entrance */
233 			tprints(*(const char **) get_tcb_priv_data(tcp));
234 		}
235 		if (syserror(tcp))
236 			return 0;
237 		if (tcp->u_rval == 0) {
238 			tcp->auxstr = "Timeout";
239 			return RVAL_STR;
240 		}
241 		if (!verbose(tcp) || !tcp->u_arg[4])
242 			return 0;
243 		/* timeout on exit */
244 		static char str[sizeof("left") + TIMESPEC_TEXT_BUFSIZE];
245 		xsprintf(str, "left %s", sprint_timespec(tcp, tcp->u_arg[4]));
246 		tcp->auxstr = str;
247 		return RVAL_STR;
248 	}
249 }
250