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-1996 Rick Sladkey <jrs@world.std.com>
5 * Copyright (c) 1996-1999 Wichert Akkerman <wichert@cistron.nl>
6 * Copyright (c) 2003-2015 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 #ifdef STRACE_UID_SIZE
33 # if STRACE_UID_SIZE != 16
34 # error invalid STRACE_UID_SIZE
35 # endif
36
37 # define SIZEIFY(x) SIZEIFY_(x,STRACE_UID_SIZE)
38 # define SIZEIFY_(x,size) SIZEIFY__(x,size)
39 # define SIZEIFY__(x,size) x ## size
40
41 # define printuid SIZEIFY(printuid)
42 # define sys_chown SIZEIFY(sys_chown)
43 # define sys_fchown SIZEIFY(sys_fchown)
44 # define sys_getgroups SIZEIFY(sys_getgroups)
45 # define sys_getresuid SIZEIFY(sys_getresuid)
46 # define sys_getuid SIZEIFY(sys_getuid)
47 # define sys_setfsuid SIZEIFY(sys_setfsuid)
48 # define sys_setgroups SIZEIFY(sys_setgroups)
49 # define sys_setresuid SIZEIFY(sys_setresuid)
50 # define sys_setreuid SIZEIFY(sys_setreuid)
51 # define sys_setuid SIZEIFY(sys_setuid)
52 #endif /* STRACE_UID_SIZE */
53
54 #include "defs.h"
55
56 #ifdef STRACE_UID_SIZE
57 # if !NEED_UID16_PARSERS
58 # undef STRACE_UID_SIZE
59 # endif
60 #else
61 # define STRACE_UID_SIZE 32
62 #endif
63
64 #ifdef STRACE_UID_SIZE
65
66 # undef uid_t
67 # define uid_t uid_t_(STRACE_UID_SIZE)
68 # define uid_t_(size) uid_t__(size)
69 # define uid_t__(size) uint ## size ## _t
70
SYS_FUNC(getuid)71 SYS_FUNC(getuid)
72 {
73 return RVAL_UDECIMAL | RVAL_DECODED;
74 }
75
SYS_FUNC(setfsuid)76 SYS_FUNC(setfsuid)
77 {
78 if (entering(tcp))
79 tprintf("%u", (uid_t) tcp->u_arg[0]);
80
81 return RVAL_UDECIMAL | RVAL_DECODED;
82 }
83
SYS_FUNC(setuid)84 SYS_FUNC(setuid)
85 {
86 printuid("", tcp->u_arg[0]);
87
88 return RVAL_DECODED;
89 }
90
91 static void
get_print_uid(struct tcb * tcp,const char * prefix,const long addr)92 get_print_uid(struct tcb *tcp, const char *prefix, const long addr)
93 {
94 uid_t uid;
95
96 tprints(prefix);
97 if (!umove_or_printaddr(tcp, addr, &uid))
98 tprintf("[%u]", uid);
99 }
100
SYS_FUNC(getresuid)101 SYS_FUNC(getresuid)
102 {
103 if (entering(tcp))
104 return 0;
105
106 get_print_uid(tcp, "", tcp->u_arg[0]);
107 get_print_uid(tcp, ", ", tcp->u_arg[1]);
108 get_print_uid(tcp, ", ", tcp->u_arg[2]);
109
110 return 0;
111 }
112
SYS_FUNC(setreuid)113 SYS_FUNC(setreuid)
114 {
115 printuid("", tcp->u_arg[0]);
116 printuid(", ", tcp->u_arg[1]);
117
118 return RVAL_DECODED;
119 }
120
SYS_FUNC(setresuid)121 SYS_FUNC(setresuid)
122 {
123 printuid("", tcp->u_arg[0]);
124 printuid(", ", tcp->u_arg[1]);
125 printuid(", ", tcp->u_arg[2]);
126
127 return RVAL_DECODED;
128 }
129
SYS_FUNC(chown)130 SYS_FUNC(chown)
131 {
132 printpath(tcp, tcp->u_arg[0]);
133 printuid(", ", tcp->u_arg[1]);
134 printuid(", ", tcp->u_arg[2]);
135
136 return RVAL_DECODED;
137 }
138
SYS_FUNC(fchown)139 SYS_FUNC(fchown)
140 {
141 printfd(tcp, tcp->u_arg[0]);
142 printuid(", ", tcp->u_arg[1]);
143 printuid(", ", tcp->u_arg[2]);
144
145 return RVAL_DECODED;
146 }
147
148 void
printuid(const char * text,const unsigned int uid)149 printuid(const char *text, const unsigned int uid)
150 {
151 if ((unsigned int) -1 == uid || (uid_t) -1 == uid)
152 tprintf("%s-1", text);
153 else
154 tprintf("%s%u", text, uid);
155 }
156
SYS_FUNC(setgroups)157 SYS_FUNC(setgroups)
158 {
159 unsigned long cur, abbrev_end;
160 uid_t gid;
161 int failed = 0;
162 const unsigned long len = tcp->u_arg[0];
163 const unsigned long start = tcp->u_arg[1];
164 const unsigned long size = len * sizeof(gid);
165 const unsigned long end = start + size;
166
167 tprintf("%lu, ", len);
168 if (len == 0) {
169 tprints("[]");
170 return RVAL_DECODED;
171 }
172 if (!start || !verbose(tcp) ||
173 size / sizeof(gid) != len || end < start) {
174 printaddr(start);
175 return RVAL_DECODED;
176 }
177 if (abbrev(tcp)) {
178 abbrev_end = start + max_strlen * sizeof(gid);
179 if (abbrev_end < start)
180 abbrev_end = end;
181 } else {
182 abbrev_end = end;
183 }
184 tprints("[");
185 for (cur = start; cur < end; cur += sizeof(gid)) {
186 if (cur > start)
187 tprints(", ");
188 if (cur >= abbrev_end) {
189 tprints("...");
190 break;
191 }
192 if (umoven(tcp, cur, sizeof(gid), &gid) < 0) {
193 tprints("?");
194 failed = 1;
195 break;
196 }
197 tprintf("%u", (unsigned int) gid);
198 }
199 tprints("]");
200 if (failed) {
201 tprints(" ");
202 printaddr(start);
203 }
204
205 return RVAL_DECODED;
206 }
207
SYS_FUNC(getgroups)208 SYS_FUNC(getgroups)
209 {
210 if (entering(tcp)) {
211 tprintf("%lu, ", tcp->u_arg[0]);
212 } else {
213 unsigned long cur, abbrev_end;
214 uid_t gid;
215 int failed = 0;
216 const unsigned long len = tcp->u_rval;
217 const unsigned long size = len * sizeof(gid);
218 const unsigned long start = tcp->u_arg[1];
219 const unsigned long end = start + size;
220
221 if (!start) {
222 printaddr(start);
223 return 0;
224 }
225 if (len == 0) {
226 tprints("[]");
227 return 0;
228 }
229 if (!verbose(tcp) || syserror(tcp) ||
230 size / sizeof(gid) != len || end < start) {
231 printaddr(start);
232 return 0;
233 }
234 if (abbrev(tcp)) {
235 abbrev_end = start + max_strlen * sizeof(gid);
236 if (abbrev_end < start)
237 abbrev_end = end;
238 } else {
239 abbrev_end = end;
240 }
241 tprints("[");
242 for (cur = start; cur < end; cur += sizeof(gid)) {
243 if (cur > start)
244 tprints(", ");
245 if (cur >= abbrev_end) {
246 tprints("...");
247 break;
248 }
249 if (umoven(tcp, cur, sizeof(gid), &gid) < 0) {
250 tprints("?");
251 failed = 1;
252 break;
253 }
254 tprintf("%u", (unsigned int) gid);
255 }
256 tprints("]");
257 if (failed) {
258 tprints(" ");
259 printaddr(start);
260 }
261 }
262 return 0;
263 }
264
265 #endif /* STRACE_UID_SIZE */
266