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-1999 Wichert Akkerman <wichert@cistron.nl>
6 * Copyright (c) 1999 IBM Deutschland Entwicklung GmbH, IBM Corporation
7 * Linux for s390 port by D.J. Barrow
8 * <barrow_dj@mail.yahoo.com,djbarrow@de.ibm.com>
9 * Copyright (c) 1999-2018 The strace developers.
10 * All rights reserved.
11 *
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
14 * are met:
15 * 1. Redistributions of source code must retain the above copyright
16 * notice, this list of conditions and the following disclaimer.
17 * 2. Redistributions in binary form must reproduce the above copyright
18 * notice, this list of conditions and the following disclaimer in the
19 * documentation and/or other materials provided with the distribution.
20 * 3. The name of the author may not be used to endorse or promote products
21 * derived from this software without specific prior written permission.
22 *
23 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
24 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
25 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
26 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
27 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
28 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
29 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
30 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
31 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
32 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33 */
34
35 #include "defs.h"
36 #include <limits.h>
37 #include <fcntl.h>
38 #include <stdarg.h>
39 #include <sys/stat.h>
40 #include <sys/sysmacros.h>
41 #ifdef HAVE_SYS_XATTR_H
42 # include <sys/xattr.h>
43 #endif
44 #include <sys/uio.h>
45
46 #include "largefile_wrappers.h"
47 #include "xlat.h"
48 #include "xstring.h"
49
50 int
ts_nz(const struct timespec * a)51 ts_nz(const struct timespec *a)
52 {
53 return a->tv_sec || a->tv_nsec;
54 }
55
56 int
ts_cmp(const struct timespec * a,const struct timespec * b)57 ts_cmp(const struct timespec *a, const struct timespec *b)
58 {
59 if (a->tv_sec < b->tv_sec
60 || (a->tv_sec == b->tv_sec && a->tv_nsec < b->tv_nsec))
61 return -1;
62 if (a->tv_sec > b->tv_sec
63 || (a->tv_sec == b->tv_sec && a->tv_nsec > b->tv_nsec))
64 return 1;
65 return 0;
66 }
67
68 double
ts_float(const struct timespec * tv)69 ts_float(const struct timespec *tv)
70 {
71 return tv->tv_sec + tv->tv_nsec/1000000000.0;
72 }
73
74 void
ts_add(struct timespec * tv,const struct timespec * a,const struct timespec * b)75 ts_add(struct timespec *tv, const struct timespec *a, const struct timespec *b)
76 {
77 tv->tv_sec = a->tv_sec + b->tv_sec;
78 tv->tv_nsec = a->tv_nsec + b->tv_nsec;
79 if (tv->tv_nsec >= 1000000000) {
80 tv->tv_sec++;
81 tv->tv_nsec -= 1000000000;
82 }
83 }
84
85 void
ts_sub(struct timespec * tv,const struct timespec * a,const struct timespec * b)86 ts_sub(struct timespec *tv, const struct timespec *a, const struct timespec *b)
87 {
88 tv->tv_sec = a->tv_sec - b->tv_sec;
89 tv->tv_nsec = a->tv_nsec - b->tv_nsec;
90 if (tv->tv_nsec < 0) {
91 tv->tv_sec--;
92 tv->tv_nsec += 1000000000;
93 }
94 }
95
96 void
ts_div(struct timespec * tv,const struct timespec * a,int n)97 ts_div(struct timespec *tv, const struct timespec *a, int n)
98 {
99 long long nsec = (a->tv_sec % n * 1000000000LL + a->tv_nsec + n / 2) / n;
100 tv->tv_sec = a->tv_sec / n + nsec / 1000000000;
101 tv->tv_nsec = nsec % 1000000000;
102 }
103
104 void
ts_mul(struct timespec * tv,const struct timespec * a,int n)105 ts_mul(struct timespec *tv, const struct timespec *a, int n)
106 {
107 long long nsec = a->tv_nsec * n;
108 tv->tv_sec = a->tv_sec * n + nsec / 1000000000;
109 tv->tv_nsec = nsec % 1000000000;
110 }
111
112 #if !defined HAVE_STPCPY
113 char *
stpcpy(char * dst,const char * src)114 stpcpy(char *dst, const char *src)
115 {
116 while ((*dst = *src++) != '\0')
117 dst++;
118 return dst;
119 }
120 #endif
121
122 /* Find a next bit which is set.
123 * Starts testing at cur_bit.
124 * Returns -1 if no more bits are set.
125 *
126 * We never touch bytes we don't need to.
127 * On big-endian, array is assumed to consist of
128 * current_wordsize wide words: for example, is current_wordsize is 4,
129 * the bytes are walked in 3,2,1,0, 7,6,5,4, 11,10,9,8 ... sequence.
130 * On little-endian machines, word size is immaterial.
131 */
132 int
next_set_bit(const void * bit_array,unsigned cur_bit,unsigned size_bits)133 next_set_bit(const void *bit_array, unsigned cur_bit, unsigned size_bits)
134 {
135 const unsigned endian = 1;
136 int little_endian = *(char *) (void *) &endian;
137
138 const uint8_t *array = bit_array;
139 unsigned pos = cur_bit / 8;
140 unsigned pos_xor_mask = little_endian ? 0 : current_wordsize-1;
141
142 for (;;) {
143 uint8_t bitmask;
144 uint8_t cur_byte;
145
146 if (cur_bit >= size_bits)
147 return -1;
148 cur_byte = array[pos ^ pos_xor_mask];
149 if (cur_byte == 0) {
150 cur_bit = (cur_bit + 8) & (-8);
151 pos++;
152 continue;
153 }
154 bitmask = 1 << (cur_bit & 7);
155 for (;;) {
156 if (cur_byte & bitmask)
157 return cur_bit;
158 cur_bit++;
159 if (cur_bit >= size_bits)
160 return -1;
161 bitmask <<= 1;
162 /* This check *can't be* optimized out: */
163 if (bitmask == 0)
164 break;
165 }
166 pos++;
167 }
168 }
169
170 /*
171 * Fetch 64bit argument at position arg_no and
172 * return the index of the next argument.
173 */
174 int
getllval(struct tcb * tcp,unsigned long long * val,int arg_no)175 getllval(struct tcb *tcp, unsigned long long *val, int arg_no)
176 {
177 #if SIZEOF_KERNEL_LONG_T > 4
178 # ifndef current_klongsize
179 if (current_klongsize < SIZEOF_KERNEL_LONG_T) {
180 # if defined(AARCH64) || defined(POWERPC64)
181 /* Align arg_no to the next even number. */
182 arg_no = (arg_no + 1) & 0xe;
183 # endif /* AARCH64 || POWERPC64 */
184 *val = ULONG_LONG(tcp->u_arg[arg_no], tcp->u_arg[arg_no + 1]);
185 arg_no += 2;
186 } else
187 # endif /* !current_klongsize */
188 {
189 *val = tcp->u_arg[arg_no];
190 arg_no++;
191 }
192 #else /* SIZEOF_KERNEL_LONG_T == 4 */
193 # if defined __ARM_EABI__ \
194 || defined LINUX_MIPSO32 \
195 || defined POWERPC \
196 || defined XTENSA
197 /* Align arg_no to the next even number. */
198 arg_no = (arg_no + 1) & 0xe;
199 # elif defined SH
200 /*
201 * The SH4 ABI does allow long longs in odd-numbered registers, but
202 * does not allow them to be split between registers and memory - and
203 * there are only four argument registers for normal functions. As a
204 * result, pread, for example, takes an extra padding argument before
205 * the offset. This was changed late in the 2.4 series (around 2.4.20).
206 */
207 if (arg_no == 3)
208 arg_no++;
209 # endif /* __ARM_EABI__ || LINUX_MIPSO32 || POWERPC || XTENSA || SH */
210 *val = ULONG_LONG(tcp->u_arg[arg_no], tcp->u_arg[arg_no + 1]);
211 arg_no += 2;
212 #endif
213
214 return arg_no;
215 }
216
217 /*
218 * Print 64bit argument at position arg_no and
219 * return the index of the next argument.
220 */
221 int
printllval(struct tcb * tcp,const char * format,int arg_no)222 printllval(struct tcb *tcp, const char *format, int arg_no)
223 {
224 unsigned long long val = 0;
225
226 arg_no = getllval(tcp, &val, arg_no);
227 tprintf(format, val);
228 return arg_no;
229 }
230
231 void
printaddr64(const uint64_t addr)232 printaddr64(const uint64_t addr)
233 {
234 if (!addr)
235 tprints("NULL");
236 else
237 tprintf("%#" PRIx64, addr);
238 }
239
240 #define DEF_PRINTNUM(name, type) \
241 bool \
242 printnum_ ## name(struct tcb *const tcp, const kernel_ulong_t addr, \
243 const char *const fmt) \
244 { \
245 type num; \
246 if (umove_or_printaddr(tcp, addr, &num)) \
247 return false; \
248 tprints("["); \
249 tprintf(fmt, num); \
250 tprints("]"); \
251 return true; \
252 }
253
254 #define DEF_PRINTNUM_ADDR(name, type) \
255 bool \
256 printnum_addr_ ## name(struct tcb *tcp, const kernel_ulong_t addr) \
257 { \
258 type num; \
259 if (umove_or_printaddr(tcp, addr, &num)) \
260 return false; \
261 tprints("["); \
262 printaddr64(num); \
263 tprints("]"); \
264 return true; \
265 }
266
267 #define DEF_PRINTPAIR(name, type) \
268 bool \
269 printpair_ ## name(struct tcb *const tcp, const kernel_ulong_t addr, \
270 const char *const fmt) \
271 { \
272 type pair[2]; \
273 if (umove_or_printaddr(tcp, addr, &pair)) \
274 return false; \
275 tprints("["); \
276 tprintf(fmt, pair[0]); \
277 tprints(", "); \
278 tprintf(fmt, pair[1]); \
279 tprints("]"); \
280 return true; \
281 }
282
DEF_PRINTNUM(int,int)283 DEF_PRINTNUM(int, int)
284 DEF_PRINTNUM_ADDR(int, unsigned int)
285 DEF_PRINTPAIR(int, int)
286 DEF_PRINTNUM(short, short)
287 DEF_PRINTNUM(int64, uint64_t)
288 DEF_PRINTNUM_ADDR(int64, uint64_t)
289 DEF_PRINTPAIR(int64, uint64_t)
290
291 #ifndef current_wordsize
292 bool
293 printnum_long_int(struct tcb *const tcp, const kernel_ulong_t addr,
294 const char *const fmt_long, const char *const fmt_int)
295 {
296 if (current_wordsize > sizeof(int)) {
297 return printnum_int64(tcp, addr, fmt_long);
298 } else {
299 return printnum_int(tcp, addr, fmt_int);
300 }
301 }
302
303 bool
printnum_addr_long_int(struct tcb * tcp,const kernel_ulong_t addr)304 printnum_addr_long_int(struct tcb *tcp, const kernel_ulong_t addr)
305 {
306 if (current_wordsize > sizeof(int)) {
307 return printnum_addr_int64(tcp, addr);
308 } else {
309 return printnum_addr_int(tcp, addr);
310 }
311 }
312 #endif /* !current_wordsize */
313
314 #ifndef current_klongsize
315 bool
printnum_addr_klong_int(struct tcb * tcp,const kernel_ulong_t addr)316 printnum_addr_klong_int(struct tcb *tcp, const kernel_ulong_t addr)
317 {
318 if (current_klongsize > sizeof(int)) {
319 return printnum_addr_int64(tcp, addr);
320 } else {
321 return printnum_addr_int(tcp, addr);
322 }
323 }
324 #endif /* !current_klongsize */
325
326 /**
327 * Prints time to a (static internal) buffer and returns pointer to it.
328 * Returns NULL if the provided time specification is not correct.
329 *
330 * @param sec Seconds since epoch.
331 * @param part_sec Amount of second parts since the start of a second.
332 * @param max_part_sec Maximum value of a valid part_sec.
333 * @param width 1 + floor(log10(max_part_sec)).
334 * @return Pointer to a statically allocated string on success,
335 * NULL on error.
336 */
337 static const char *
sprinttime_ex(const long long sec,const unsigned long long part_sec,const unsigned int max_part_sec,const int width)338 sprinttime_ex(const long long sec, const unsigned long long part_sec,
339 const unsigned int max_part_sec, const int width)
340 {
341 static char buf[sizeof(int) * 3 * 6 + sizeof(part_sec) * 3
342 + sizeof("+0000")];
343
344 if ((sec == 0 && part_sec == 0) || part_sec > max_part_sec)
345 return NULL;
346
347 time_t t = (time_t) sec;
348 struct tm *tmp = (sec == t) ? localtime(&t) : NULL;
349 if (!tmp)
350 return NULL;
351
352 size_t pos = strftime(buf, sizeof(buf), "%FT%T", tmp);
353 if (!pos)
354 return NULL;
355
356 if (part_sec > 0)
357 pos += xsnprintf(buf + pos, sizeof(buf) - pos, ".%0*llu",
358 width, part_sec);
359
360 return strftime(buf + pos, sizeof(buf) - pos, "%z", tmp) ? buf : NULL;
361 }
362
363 const char *
sprinttime(long long sec)364 sprinttime(long long sec)
365 {
366 return sprinttime_ex(sec, 0, 0, 0);
367 }
368
369 const char *
sprinttime_usec(long long sec,unsigned long long usec)370 sprinttime_usec(long long sec, unsigned long long usec)
371 {
372 return sprinttime_ex(sec, usec, 999999, 6);
373 }
374
375 const char *
sprinttime_nsec(long long sec,unsigned long long nsec)376 sprinttime_nsec(long long sec, unsigned long long nsec)
377 {
378 return sprinttime_ex(sec, nsec, 999999999, 9);
379 }
380
381 enum sock_proto
getfdproto(struct tcb * tcp,int fd)382 getfdproto(struct tcb *tcp, int fd)
383 {
384 #ifdef HAVE_SYS_XATTR_H
385 size_t bufsize = 256;
386 char buf[bufsize];
387 ssize_t r;
388 char path[sizeof("/proc/%u/fd/%u") + 2 * sizeof(int)*3];
389
390 if (fd < 0)
391 return SOCK_PROTO_UNKNOWN;
392
393 xsprintf(path, "/proc/%u/fd/%u", tcp->pid, fd);
394 r = getxattr(path, "system.sockprotoname", buf, bufsize - 1);
395 if (r <= 0)
396 return SOCK_PROTO_UNKNOWN;
397 else {
398 /*
399 * This is a protection for the case when the kernel
400 * side does not append a null byte to the buffer.
401 */
402 buf[r] = '\0';
403
404 return get_proto_by_name(buf);
405 }
406 #else
407 return SOCK_PROTO_UNKNOWN;
408 #endif
409 }
410
411 unsigned long
getfdinode(struct tcb * tcp,int fd)412 getfdinode(struct tcb *tcp, int fd)
413 {
414 char path[PATH_MAX + 1];
415
416 if (getfdpath(tcp, fd, path, sizeof(path)) >= 0) {
417 const char *str = STR_STRIP_PREFIX(path, "socket:[");
418
419 if (str != path) {
420 const size_t str_len = strlen(str);
421 if (str_len && str[str_len - 1] == ']')
422 return strtoul(str, NULL, 10);
423 }
424 }
425
426 return 0;
427 }
428
429 static bool
printsocket(struct tcb * tcp,int fd,const char * path)430 printsocket(struct tcb *tcp, int fd, const char *path)
431 {
432 const char *str = STR_STRIP_PREFIX(path, "socket:[");
433 size_t len;
434 unsigned long inode;
435
436 return (str != path)
437 && (len = strlen(str))
438 && (str[len - 1] == ']')
439 && (inode = strtoul(str, NULL, 10))
440 && print_sockaddr_by_inode(tcp, fd, inode);
441 }
442
443 static bool
printdev(struct tcb * tcp,int fd,const char * path)444 printdev(struct tcb *tcp, int fd, const char *path)
445 {
446 struct_stat st;
447
448 if (path[0] != '/')
449 return false;
450
451 if (stat_file(path, &st)) {
452 debug_func_perror_msg("stat(\"%s\")", path);
453 return false;
454 }
455
456 switch (st.st_mode & S_IFMT) {
457 case S_IFBLK:
458 case S_IFCHR:
459 print_quoted_string_ex(path, strlen(path),
460 QUOTE_OMIT_LEADING_TRAILING_QUOTES,
461 "<>");
462 tprintf("<%s %u:%u>",
463 S_ISBLK(st.st_mode)? "block" : "char",
464 major(st.st_rdev), minor(st.st_rdev));
465 return true;
466 }
467
468 return false;
469 }
470
471 void
printfd(struct tcb * tcp,int fd)472 printfd(struct tcb *tcp, int fd)
473 {
474 char path[PATH_MAX + 1];
475 if (show_fd_path && getfdpath(tcp, fd, path, sizeof(path)) >= 0) {
476 tprintf("%d<", fd);
477 if (show_fd_path <= 1
478 || (!printsocket(tcp, fd, path)
479 && !printdev(tcp, fd, path))) {
480 print_quoted_string_ex(path, strlen(path),
481 QUOTE_OMIT_LEADING_TRAILING_QUOTES, "<>");
482 }
483 tprints(">");
484 } else
485 tprintf("%d", fd);
486 }
487
488 /*
489 * Quote string `instr' of length `size'
490 * Write up to (3 + `size' * 4) bytes to `outstr' buffer.
491 *
492 * `escape_chars' specifies characters (in addition to characters with
493 * codes 0..31, 127..255, single and double quotes) that should be escaped.
494 *
495 * If QUOTE_0_TERMINATED `style' flag is set,
496 * treat `instr' as a NUL-terminated string,
497 * checking up to (`size' + 1) bytes of `instr'.
498 *
499 * If QUOTE_OMIT_LEADING_TRAILING_QUOTES `style' flag is set,
500 * do not add leading and trailing quoting symbols.
501 *
502 * Returns 0 if QUOTE_0_TERMINATED is set and NUL was seen, 1 otherwise.
503 * Note that if QUOTE_0_TERMINATED is not set, always returns 1.
504 */
505 int
string_quote(const char * instr,char * outstr,const unsigned int size,const unsigned int style,const char * escape_chars)506 string_quote(const char *instr, char *outstr, const unsigned int size,
507 const unsigned int style, const char *escape_chars)
508 {
509 const unsigned char *ustr = (const unsigned char *) instr;
510 char *s = outstr;
511 unsigned int i;
512 int usehex, c, eol;
513 bool escape;
514
515 if (style & QUOTE_0_TERMINATED)
516 eol = '\0';
517 else
518 eol = 0x100; /* this can never match a char */
519
520 usehex = 0;
521 if ((xflag > 1) || (style & QUOTE_FORCE_HEX)) {
522 usehex = 1;
523 } else if (xflag) {
524 /* Check for presence of symbol which require
525 to hex-quote the whole string. */
526 for (i = 0; i < size; ++i) {
527 c = ustr[i];
528 /* Check for NUL-terminated string. */
529 if (c == eol)
530 break;
531
532 /* Force hex unless c is printable or whitespace */
533 if (c > 0x7e) {
534 usehex = 1;
535 break;
536 }
537 /* In ASCII isspace is only these chars: "\t\n\v\f\r".
538 * They happen to have ASCII codes 9,10,11,12,13.
539 */
540 if (c < ' ' && (unsigned)(c - 9) >= 5) {
541 usehex = 1;
542 break;
543 }
544 }
545 }
546
547 if (style & QUOTE_EMIT_COMMENT)
548 s = stpcpy(s, " /* ");
549 if (!(style & QUOTE_OMIT_LEADING_TRAILING_QUOTES))
550 *s++ = '\"';
551
552 if (usehex) {
553 /* Hex-quote the whole string. */
554 for (i = 0; i < size; ++i) {
555 c = ustr[i];
556 /* Check for NUL-terminated string. */
557 if (c == eol)
558 goto asciz_ended;
559 *s++ = '\\';
560 *s++ = 'x';
561 *s++ = "0123456789abcdef"[c >> 4];
562 *s++ = "0123456789abcdef"[c & 0xf];
563 }
564
565 goto string_ended;
566 }
567
568 for (i = 0; i < size; ++i) {
569 c = ustr[i];
570 /* Check for NUL-terminated string. */
571 if (c == eol)
572 goto asciz_ended;
573 if ((i == (size - 1)) &&
574 (style & QUOTE_OMIT_TRAILING_0) && (c == '\0'))
575 goto asciz_ended;
576 switch (c) {
577 case '\"': case '\\':
578 *s++ = '\\';
579 *s++ = c;
580 break;
581 case '\f':
582 *s++ = '\\';
583 *s++ = 'f';
584 break;
585 case '\n':
586 *s++ = '\\';
587 *s++ = 'n';
588 break;
589 case '\r':
590 *s++ = '\\';
591 *s++ = 'r';
592 break;
593 case '\t':
594 *s++ = '\\';
595 *s++ = 't';
596 break;
597 case '\v':
598 *s++ = '\\';
599 *s++ = 'v';
600 break;
601 default:
602 escape = (c < ' ') || (c > 0x7e);
603
604 if (!escape && escape_chars)
605 escape = !!strchr(escape_chars, c);
606
607 if (!escape) {
608 *s++ = c;
609 } else {
610 /* Print \octal */
611 *s++ = '\\';
612 if (i + 1 < size
613 && ustr[i + 1] >= '0'
614 && ustr[i + 1] <= '7'
615 ) {
616 /* Print \ooo */
617 *s++ = '0' + (c >> 6);
618 *s++ = '0' + ((c >> 3) & 0x7);
619 } else {
620 /* Print \[[o]o]o */
621 if ((c >> 3) != 0) {
622 if ((c >> 6) != 0)
623 *s++ = '0' + (c >> 6);
624 *s++ = '0' + ((c >> 3) & 0x7);
625 }
626 }
627 *s++ = '0' + (c & 0x7);
628 }
629 }
630 }
631
632 string_ended:
633 if (!(style & QUOTE_OMIT_LEADING_TRAILING_QUOTES))
634 *s++ = '\"';
635 if (style & QUOTE_EMIT_COMMENT)
636 s = stpcpy(s, " */");
637 *s = '\0';
638
639 /* Return zero if we printed entire ASCIZ string (didn't truncate it) */
640 if (style & QUOTE_0_TERMINATED && ustr[i] == '\0') {
641 /* We didn't see NUL yet (otherwise we'd jump to 'asciz_ended')
642 * but next char is NUL.
643 */
644 return 0;
645 }
646
647 return 1;
648
649 asciz_ended:
650 if (!(style & QUOTE_OMIT_LEADING_TRAILING_QUOTES))
651 *s++ = '\"';
652 if (style & QUOTE_EMIT_COMMENT)
653 s = stpcpy(s, " */");
654 *s = '\0';
655 /* Return zero: we printed entire ASCIZ string (didn't truncate it) */
656 return 0;
657 }
658
659 #ifndef ALLOCA_CUTOFF
660 # define ALLOCA_CUTOFF 4032
661 #endif
662 #define use_alloca(n) ((n) <= ALLOCA_CUTOFF)
663
664 /*
665 * Quote string `str' of length `size' and print the result.
666 *
667 * If QUOTE_0_TERMINATED `style' flag is set,
668 * treat `str' as a NUL-terminated string and
669 * quote at most (`size' - 1) bytes.
670 *
671 * If QUOTE_OMIT_LEADING_TRAILING_QUOTES `style' flag is set,
672 * do not add leading and trailing quoting symbols.
673 *
674 * Returns 0 if QUOTE_0_TERMINATED is set and NUL was seen, 1 otherwise.
675 * Note that if QUOTE_0_TERMINATED is not set, always returns 1.
676 */
677 int
print_quoted_string_ex(const char * str,unsigned int size,const unsigned int style,const char * escape_chars)678 print_quoted_string_ex(const char *str, unsigned int size,
679 const unsigned int style, const char *escape_chars)
680 {
681 char *buf;
682 char *outstr;
683 unsigned int alloc_size;
684 int rc;
685
686 if (size && style & QUOTE_0_TERMINATED)
687 --size;
688
689 alloc_size = 4 * size;
690 if (alloc_size / 4 != size) {
691 error_func_msg("requested %u bytes exceeds %u bytes limit",
692 size, -1U / 4);
693 tprints("???");
694 return -1;
695 }
696 alloc_size += 1 + (style & QUOTE_OMIT_LEADING_TRAILING_QUOTES ? 0 : 2) +
697 (style & QUOTE_EMIT_COMMENT ? 7 : 0);
698
699 if (use_alloca(alloc_size)) {
700 outstr = alloca(alloc_size);
701 buf = NULL;
702 } else {
703 outstr = buf = malloc(alloc_size);
704 if (!buf) {
705 error_func_msg("memory exhausted when tried to allocate"
706 " %u bytes", alloc_size);
707 tprints("???");
708 return -1;
709 }
710 }
711
712 rc = string_quote(str, outstr, size, style, escape_chars);
713 tprints(outstr);
714
715 free(buf);
716 return rc;
717 }
718
719 inline int
print_quoted_string(const char * str,unsigned int size,const unsigned int style)720 print_quoted_string(const char *str, unsigned int size,
721 const unsigned int style)
722 {
723 return print_quoted_string_ex(str, size, style, NULL);
724 }
725
726 /*
727 * Quote a NUL-terminated string `str' of length up to `size' - 1
728 * and print the result.
729 *
730 * Returns 0 if NUL was seen, 1 otherwise.
731 */
732 int
print_quoted_cstring(const char * str,unsigned int size)733 print_quoted_cstring(const char *str, unsigned int size)
734 {
735 int unterminated =
736 print_quoted_string(str, size, QUOTE_0_TERMINATED);
737
738 if (unterminated)
739 tprints("...");
740
741 return unterminated;
742 }
743
744 /*
745 * Print path string specified by address `addr' and length `n'.
746 * If path length exceeds `n', append `...' to the output.
747 *
748 * Returns the result of umovenstr.
749 */
750 int
printpathn(struct tcb * const tcp,const kernel_ulong_t addr,unsigned int n)751 printpathn(struct tcb *const tcp, const kernel_ulong_t addr, unsigned int n)
752 {
753 char path[PATH_MAX];
754 int nul_seen;
755
756 if (!addr) {
757 tprints("NULL");
758 return -1;
759 }
760
761 /* Cap path length to the path buffer size */
762 if (n > sizeof(path) - 1)
763 n = sizeof(path) - 1;
764
765 /* Fetch one byte more to find out whether path length > n. */
766 nul_seen = umovestr(tcp, addr, n + 1, path);
767 if (nul_seen < 0)
768 printaddr(addr);
769 else {
770 path[n++] = !nul_seen;
771 print_quoted_cstring(path, n);
772 }
773
774 return nul_seen;
775 }
776
777 int
printpath(struct tcb * const tcp,const kernel_ulong_t addr)778 printpath(struct tcb *const tcp, const kernel_ulong_t addr)
779 {
780 /* Size must correspond to char path[] size in printpathn */
781 return printpathn(tcp, addr, PATH_MAX - 1);
782 }
783
784 /*
785 * Print string specified by address `addr' and length `len'.
786 * If `user_style' has QUOTE_0_TERMINATED bit set, treat the string
787 * as a NUL-terminated string.
788 * Pass `user_style' on to `string_quote'.
789 * Append `...' to the output if either the string length exceeds `max_strlen',
790 * or QUOTE_0_TERMINATED bit is set and the string length exceeds `len'.
791 *
792 * Returns the result of umovenstr if style has QUOTE_0_TERMINATED,
793 * or the result of umoven otherwise.
794 */
795 int
printstr_ex(struct tcb * const tcp,const kernel_ulong_t addr,const kernel_ulong_t len,const unsigned int user_style)796 printstr_ex(struct tcb *const tcp, const kernel_ulong_t addr,
797 const kernel_ulong_t len, const unsigned int user_style)
798 {
799 static char *str;
800 static char *outstr;
801
802 unsigned int size;
803 unsigned int style = user_style;
804 int rc;
805 int ellipsis;
806
807 if (!addr) {
808 tprints("NULL");
809 return -1;
810 }
811 /* Allocate static buffers if they are not allocated yet. */
812 if (!str) {
813 const unsigned int outstr_size =
814 4 * max_strlen + /* for quotes and NUL */ 3;
815 /*
816 * We can assume that outstr_size / 4 == max_strlen
817 * since we have a guarantee that max_strlen <= -1U / 4.
818 */
819
820 str = xmalloc(max_strlen + 1);
821 outstr = xmalloc(outstr_size);
822 }
823
824 /* Fetch one byte more because string_quote may look one byte ahead. */
825 size = max_strlen + 1;
826
827 if (size > len)
828 size = len;
829 if (style & QUOTE_0_TERMINATED)
830 rc = umovestr(tcp, addr, size, str);
831 else
832 rc = umoven(tcp, addr, size, str);
833
834 if (rc < 0) {
835 printaddr(addr);
836 return rc;
837 }
838
839 if (size > max_strlen)
840 size = max_strlen;
841 else
842 str[size] = '\xff';
843
844 /* If string_quote didn't see NUL and (it was supposed to be ASCIZ str
845 * or we were requested to print more than -s NUM chars)...
846 */
847 ellipsis = string_quote(str, outstr, size, style, NULL)
848 && len
849 && ((style & QUOTE_0_TERMINATED)
850 || len > max_strlen);
851
852 tprints(outstr);
853 if (ellipsis)
854 tprints("...");
855
856 return rc;
857 }
858
859 void
dumpiov_upto(struct tcb * const tcp,const int len,const kernel_ulong_t addr,kernel_ulong_t data_size)860 dumpiov_upto(struct tcb *const tcp, const int len, const kernel_ulong_t addr,
861 kernel_ulong_t data_size)
862 {
863 #if ANY_WORDSIZE_LESS_THAN_KERNEL_LONG
864 union {
865 struct { uint32_t base; uint32_t len; } *iov32;
866 struct { uint64_t base; uint64_t len; } *iov64;
867 } iovu;
868 #define iov iovu.iov64
869 #define sizeof_iov \
870 (current_wordsize == 4 ? (unsigned int) sizeof(*iovu.iov32) \
871 : (unsigned int) sizeof(*iovu.iov64))
872 #define iov_iov_base(i) \
873 (current_wordsize == 4 ? (uint64_t) iovu.iov32[i].base : iovu.iov64[i].base)
874 #define iov_iov_len(i) \
875 (current_wordsize == 4 ? (uint64_t) iovu.iov32[i].len : iovu.iov64[i].len)
876 #else
877 struct iovec *iov;
878 #define sizeof_iov ((unsigned int) sizeof(*iov))
879 #define iov_iov_base(i) ptr_to_kulong(iov[i].iov_base)
880 #define iov_iov_len(i) iov[i].iov_len
881 #endif
882 int i;
883 unsigned int size = sizeof_iov * len;
884 if (size / sizeof_iov != (unsigned int) len) {
885 error_func_msg("requested %u iovec elements exceeds"
886 " %u iovec limit", len, -1U / sizeof_iov);
887 return;
888 }
889
890 iov = malloc(size);
891 if (!iov) {
892 error_func_msg("memory exhausted when tried to allocate"
893 " %u bytes", size);
894 return;
895 }
896 if (umoven(tcp, addr, size, iov) >= 0) {
897 for (i = 0; i < len; i++) {
898 kernel_ulong_t iov_len = iov_iov_len(i);
899 if (iov_len > data_size)
900 iov_len = data_size;
901 if (!iov_len)
902 break;
903 data_size -= iov_len;
904 /* include the buffer number to make it easy to
905 * match up the trace with the source */
906 tprintf(" * %" PRI_klu " bytes in buffer %d\n", iov_len, i);
907 dumpstr(tcp, iov_iov_base(i), iov_len);
908 }
909 }
910 free(iov);
911 #undef sizeof_iov
912 #undef iov_iov_base
913 #undef iov_iov_len
914 #undef iov
915 }
916
917 void
dumpstr(struct tcb * const tcp,const kernel_ulong_t addr,const int len)918 dumpstr(struct tcb *const tcp, const kernel_ulong_t addr, const int len)
919 {
920 static int strsize = -1;
921 static unsigned char *str;
922
923 char outbuf[
924 (
925 (sizeof(
926 "xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx xx "
927 "1234567890123456") + /*in case I'm off by few:*/ 4)
928 /*align to 8 to make memset easier:*/ + 7) & -8
929 ];
930 const unsigned char *src;
931 int i;
932
933 if ((len < 0) || (len > INT_MAX - 16))
934 return;
935
936 memset(outbuf, ' ', sizeof(outbuf));
937
938 if (strsize < len + 16) {
939 free(str);
940 str = malloc(len + 16);
941 if (!str) {
942 strsize = -1;
943 error_func_msg("memory exhausted when tried to allocate"
944 " %zu bytes", (size_t) (len + 16));
945 return;
946 }
947 strsize = len + 16;
948 }
949
950 if (umoven(tcp, addr, len, str) < 0)
951 return;
952
953 /* Space-pad to 16 bytes */
954 i = len;
955 while (i & 0xf)
956 str[i++] = ' ';
957
958 i = 0;
959 src = str;
960 while (i < len) {
961 char *dst = outbuf;
962 /* Hex dump */
963 do {
964 if (i < len) {
965 *dst++ = "0123456789abcdef"[*src >> 4];
966 *dst++ = "0123456789abcdef"[*src & 0xf];
967 } else {
968 *dst++ = ' ';
969 *dst++ = ' ';
970 }
971 dst++; /* space is there by memset */
972 i++;
973 if ((i & 7) == 0)
974 dst++; /* space is there by memset */
975 src++;
976 } while (i & 0xf);
977 /* ASCII dump */
978 i -= 16;
979 src -= 16;
980 do {
981 if (*src >= ' ' && *src < 0x7f)
982 *dst++ = *src;
983 else
984 *dst++ = '.';
985 src++;
986 } while (++i & 0xf);
987 *dst = '\0';
988 tprintf(" | %05x %s |\n", i - 16, outbuf);
989 }
990 }
991
992 bool
tfetch_mem64(struct tcb * const tcp,const uint64_t addr,const unsigned int len,void * const our_addr)993 tfetch_mem64(struct tcb *const tcp, const uint64_t addr,
994 const unsigned int len, void *const our_addr)
995 {
996 return addr && verbose(tcp) &&
997 (entering(tcp) || !syserror(tcp)) &&
998 !umoven(tcp, addr, len, our_addr);
999 }
1000
1001 bool
tfetch_mem64_ignore_syserror(struct tcb * const tcp,const uint64_t addr,const unsigned int len,void * const our_addr)1002 tfetch_mem64_ignore_syserror(struct tcb *const tcp, const uint64_t addr,
1003 const unsigned int len, void *const our_addr)
1004 {
1005 return addr && verbose(tcp) &&
1006 !umoven(tcp, addr, len, our_addr);
1007 }
1008
1009 int
umoven_or_printaddr64(struct tcb * const tcp,const uint64_t addr,const unsigned int len,void * const our_addr)1010 umoven_or_printaddr64(struct tcb *const tcp, const uint64_t addr,
1011 const unsigned int len, void *const our_addr)
1012 {
1013 if (tfetch_mem64(tcp, addr, len, our_addr))
1014 return 0;
1015 printaddr64(addr);
1016 return -1;
1017 }
1018
1019 int
umoven_or_printaddr64_ignore_syserror(struct tcb * const tcp,const uint64_t addr,const unsigned int len,void * const our_addr)1020 umoven_or_printaddr64_ignore_syserror(struct tcb *const tcp,
1021 const uint64_t addr,
1022 const unsigned int len,
1023 void *const our_addr)
1024 {
1025 if (tfetch_mem64_ignore_syserror(tcp, addr, len, our_addr))
1026 return 0;
1027 printaddr64(addr);
1028 return -1;
1029 }
1030
1031 bool
print_int32_array_member(struct tcb * tcp,void * elem_buf,size_t elem_size,void * data)1032 print_int32_array_member(struct tcb *tcp, void *elem_buf, size_t elem_size,
1033 void *data)
1034 {
1035 tprintf("%" PRId32, *(int32_t *) elem_buf);
1036
1037 return true;
1038 }
1039
1040 bool
print_uint32_array_member(struct tcb * tcp,void * elem_buf,size_t elem_size,void * data)1041 print_uint32_array_member(struct tcb *tcp, void *elem_buf, size_t elem_size,
1042 void *data)
1043 {
1044 tprintf("%" PRIu32, *(uint32_t *) elem_buf);
1045
1046 return true;
1047 }
1048
1049 bool
print_uint64_array_member(struct tcb * tcp,void * elem_buf,size_t elem_size,void * data)1050 print_uint64_array_member(struct tcb *tcp, void *elem_buf, size_t elem_size,
1051 void *data)
1052 {
1053 tprintf("%" PRIu64, *(uint64_t *) elem_buf);
1054
1055 return true;
1056 }
1057
1058 /*
1059 * Iteratively fetch and print up to nmemb elements of elem_size size
1060 * from the array that starts at tracee's address start_addr.
1061 *
1062 * Array elements are being fetched to the address specified by elem_buf.
1063 *
1064 * The fetcher callback function specified by tfetch_mem_func should follow
1065 * the same semantics as tfetch_mem function.
1066 *
1067 * The printer callback function specified by print_func is expected
1068 * to print something; if it returns false, no more iterations will be made.
1069 *
1070 * The pointer specified by opaque_data is passed to each invocation
1071 * of print_func callback function.
1072 *
1073 * This function prints:
1074 * - "NULL", if start_addr is NULL;
1075 * - "[]", if nmemb is 0;
1076 * - start_addr, if nmemb * elem_size overflows or wraps around;
1077 * - start_addr, if the first tfetch_mem_func invocation returned false;
1078 * - elements of the array, delimited by ", ", with the array itself
1079 * enclosed with [] brackets.
1080 *
1081 * If abbrev(tcp) is true, then
1082 * - the maximum number of elements printed equals to max_strlen;
1083 * - "..." is printed instead of max_strlen+1 element
1084 * and no more iterations will be made.
1085 *
1086 * This function returns true only if tfetch_mem_func has returned true
1087 * at least once.
1088 */
1089 bool
print_array_ex(struct tcb * const tcp,const kernel_ulong_t start_addr,const size_t nmemb,void * const elem_buf,const size_t elem_size,tfetch_mem_fn tfetch_mem_func,print_fn print_func,void * const opaque_data,unsigned int flags,const struct xlat * index_xlat,size_t index_xlat_size,const char * index_dflt)1090 print_array_ex(struct tcb *const tcp,
1091 const kernel_ulong_t start_addr,
1092 const size_t nmemb,
1093 void *const elem_buf,
1094 const size_t elem_size,
1095 tfetch_mem_fn tfetch_mem_func,
1096 print_fn print_func,
1097 void *const opaque_data,
1098 unsigned int flags,
1099 const struct xlat *index_xlat,
1100 size_t index_xlat_size,
1101 const char *index_dflt)
1102 {
1103 if (!start_addr) {
1104 tprints("NULL");
1105 return false;
1106 }
1107
1108 if (!nmemb) {
1109 tprints("[]");
1110 return false;
1111 }
1112
1113 const size_t size = nmemb * elem_size;
1114 const kernel_ulong_t end_addr = start_addr + size;
1115
1116 if (end_addr <= start_addr || size / elem_size != nmemb) {
1117 printaddr(start_addr);
1118 return false;
1119 }
1120
1121 const kernel_ulong_t abbrev_end =
1122 (abbrev(tcp) && max_strlen < nmemb) ?
1123 start_addr + elem_size * max_strlen : end_addr;
1124 kernel_ulong_t cur;
1125 kernel_ulong_t idx = 0;
1126 enum xlat_style xlat_style = flags & XLAT_STYLE_MASK;
1127
1128 for (cur = start_addr; cur < end_addr; cur += elem_size, idx++) {
1129 if (cur != start_addr)
1130 tprints(", ");
1131
1132 if (!tfetch_mem_func(tcp, cur, elem_size, elem_buf)) {
1133 if (cur == start_addr)
1134 printaddr(cur);
1135 else {
1136 tprints("...");
1137 printaddr_comment(cur);
1138 }
1139 break;
1140 }
1141
1142 if (cur == start_addr)
1143 tprints("[");
1144
1145 if (cur >= abbrev_end) {
1146 tprints("...");
1147 cur = end_addr;
1148 break;
1149 }
1150
1151 if (flags & PAF_PRINT_INDICES) {
1152 tprints("[");
1153
1154 if (!index_xlat) {
1155 print_xlat_ex(idx, NULL, xlat_style);
1156 } else if (flags & PAF_INDEX_XLAT_VALUE_INDEXED) {
1157 printxval_indexn_ex(index_xlat,
1158 index_xlat_size, idx,
1159 index_dflt, xlat_style);
1160 } else {
1161 printxvals_ex(idx, index_dflt, xlat_style,
1162 (flags & PAF_INDEX_XLAT_SORTED)
1163 && idx ? NULL : index_xlat,
1164 NULL);
1165 }
1166
1167 tprints("] = ");
1168 }
1169
1170 if (!print_func(tcp, elem_buf, elem_size, opaque_data)) {
1171 cur = end_addr;
1172 break;
1173 }
1174 }
1175 if (cur != start_addr)
1176 tprints("]");
1177
1178 return cur >= end_addr;
1179 }
1180
1181 int
printargs(struct tcb * tcp)1182 printargs(struct tcb *tcp)
1183 {
1184 const int n = tcp->s_ent->nargs;
1185 int i;
1186 for (i = 0; i < n; ++i)
1187 tprintf("%s%#" PRI_klx, i ? ", " : "", tcp->u_arg[i]);
1188 return RVAL_DECODED;
1189 }
1190
1191 int
printargs_u(struct tcb * tcp)1192 printargs_u(struct tcb *tcp)
1193 {
1194 const int n = tcp->s_ent->nargs;
1195 int i;
1196 for (i = 0; i < n; ++i)
1197 tprintf("%s%u", i ? ", " : "",
1198 (unsigned int) tcp->u_arg[i]);
1199 return RVAL_DECODED;
1200 }
1201
1202 int
printargs_d(struct tcb * tcp)1203 printargs_d(struct tcb *tcp)
1204 {
1205 const int n = tcp->s_ent->nargs;
1206 int i;
1207 for (i = 0; i < n; ++i)
1208 tprintf("%s%d", i ? ", " : "",
1209 (int) tcp->u_arg[i]);
1210 return RVAL_DECODED;
1211 }
1212
1213 /* Print abnormal high bits of a kernel_ulong_t value. */
1214 void
print_abnormal_hi(const kernel_ulong_t val)1215 print_abnormal_hi(const kernel_ulong_t val)
1216 {
1217 if (current_klongsize > 4) {
1218 const unsigned int hi = (unsigned int) ((uint64_t) val >> 32);
1219 if (hi)
1220 tprintf("%#x<<32|", hi);
1221 }
1222 }
1223
1224 #if defined _LARGEFILE64_SOURCE && defined HAVE_OPEN64
1225 # define open_file open64
1226 #else
1227 # define open_file open
1228 #endif
1229
1230 int
read_int_from_file(struct tcb * tcp,const char * const fname,int * const pvalue)1231 read_int_from_file(struct tcb *tcp, const char *const fname, int *const pvalue)
1232 {
1233 const int fd = open_file(fname, O_RDONLY);
1234 if (fd < 0)
1235 return -1;
1236
1237 long lval;
1238 char buf[sizeof(lval) * 3];
1239 int n = read(fd, buf, sizeof(buf) - 1);
1240 int saved_errno = errno;
1241 close(fd);
1242
1243 if (n < 0) {
1244 errno = saved_errno;
1245 return -1;
1246 }
1247
1248 buf[n] = '\0';
1249 char *endptr = 0;
1250 errno = 0;
1251 lval = strtol(buf, &endptr, 10);
1252 if (!endptr || (*endptr && '\n' != *endptr)
1253 #if INT_MAX < LONG_MAX
1254 || lval > INT_MAX || lval < INT_MIN
1255 #endif
1256 || ERANGE == errno) {
1257 if (!errno)
1258 errno = EINVAL;
1259 return -1;
1260 }
1261
1262 *pvalue = (int) lval;
1263 return 0;
1264 }
1265