granicus.if.org Git - strace/blob - util.c

   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  * All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  * 3. The name of the author may not be used to endorse or promote products
  20  *    derived from this software without specific prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  23  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  24  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  25  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  26  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  27  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  28  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  29  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  30  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  31  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32  */
  33
  34 #include "defs.h"
  35 #include <sys/param.h>
  36 #include <fcntl.h>
  37 #include <stdarg.h>
  38 #ifdef HAVE_SYS_XATTR_H
  39 # include <sys/xattr.h>
  40 #endif
  41 #include <sys/uio.h>
  42
  43 #include "regs.h"
  44 #include "ptrace.h"
  45
  46 int
  47 string_to_uint(const char *str)
  48 {
  49         char *error;
  50         long value;
  51
  52         if (!*str)
  53                 return -1;
  54         errno = 0;
  55         value = strtol(str, &error, 10);
  56         if (errno || *error || value < 0 || (long)(int)value != value)
  57                 return -1;
  58         return (int)value;
  59 }
  60
  61 int
  62 tv_nz(const struct timeval *a)
  63 {
  64         return a->tv_sec || a->tv_usec;
  65 }
  66
  67 int
  68 tv_cmp(const struct timeval *a, const struct timeval *b)
  69 {
  70         if (a->tv_sec < b->tv_sec
  71             || (a->tv_sec == b->tv_sec && a->tv_usec < b->tv_usec))
  72                 return -1;
  73         if (a->tv_sec > b->tv_sec
  74             || (a->tv_sec == b->tv_sec && a->tv_usec > b->tv_usec))
  75                 return 1;
  76         return 0;
  77 }
  78
  79 double
  80 tv_float(const struct timeval *tv)
  81 {
  82         return tv->tv_sec + tv->tv_usec/1000000.0;
  83 }
  84
  85 void
  86 tv_add(struct timeval *tv, const struct timeval *a, const struct timeval *b)
  87 {
  88         tv->tv_sec = a->tv_sec + b->tv_sec;
  89         tv->tv_usec = a->tv_usec + b->tv_usec;
  90         if (tv->tv_usec >= 1000000) {
  91                 tv->tv_sec++;
  92                 tv->tv_usec -= 1000000;
  93         }
  94 }
  95
  96 void
  97 tv_sub(struct timeval *tv, const struct timeval *a, const struct timeval *b)
  98 {
  99         tv->tv_sec = a->tv_sec - b->tv_sec;
 100         tv->tv_usec = a->tv_usec - b->tv_usec;
 101         if (((long) tv->tv_usec) < 0) {
 102                 tv->tv_sec--;
 103                 tv->tv_usec += 1000000;
 104         }
 105 }
 106
 107 void
 108 tv_div(struct timeval *tv, const struct timeval *a, int n)
 109 {
 110         tv->tv_usec = (a->tv_sec % n * 1000000 + a->tv_usec + n / 2) / n;
 111         tv->tv_sec = a->tv_sec / n + tv->tv_usec / 1000000;
 112         tv->tv_usec %= 1000000;
 113 }
 114
 115 void
 116 tv_mul(struct timeval *tv, const struct timeval *a, int n)
 117 {
 118         tv->tv_usec = a->tv_usec * n;
 119         tv->tv_sec = a->tv_sec * n + tv->tv_usec / 1000000;
 120         tv->tv_usec %= 1000000;
 121 }
 122
 123 const char *
 124 xlookup(const struct xlat *xlat, const unsigned int val)
 125 {
 126         for (; xlat->str != NULL; xlat++)
 127                 if (xlat->val == val)
 128                         return xlat->str;
 129         return NULL;
 130 }
 131
 132 static int
 133 xlat_bsearch_compare(const void *a, const void *b)
 134 {
 135         const unsigned int val1 = (const unsigned long) a;
 136         const unsigned int val2 = ((const struct xlat *) b)->val;
 137         return (val1 > val2) ? 1 : (val1 < val2) ? -1 : 0;
 138 }
 139
 140 const char *
 141 xlat_search(const struct xlat *xlat, const size_t nmemb, const unsigned int val)
 142 {
 143         const struct xlat *e =
 144                 bsearch((const void*) (const unsigned long) val,
 145                         xlat, nmemb, sizeof(*xlat), xlat_bsearch_compare);
 146
 147         return e ? e->str : NULL;
 148 }
 149
 150 #if !defined HAVE_STPCPY
 151 char *
 152 stpcpy(char *dst, const char *src)
 153 {
 154         while ((*dst = *src++) != '\0')
 155                 dst++;
 156         return dst;
 157 }
 158 #endif
 159
 160 /* Find a next bit which is set.
 161  * Starts testing at cur_bit.
 162  * Returns -1 if no more bits are set.
 163  *
 164  * We never touch bytes we don't need to.
 165  * On big-endian, array is assumed to consist of
 166  * current_wordsize wide words: for example, is current_wordsize is 4,
 167  * the bytes are walked in 3,2,1,0, 7,6,5,4, 11,10,9,8 ... sequence.
 168  * On little-endian machines, word size is immaterial.
 169  */
 170 int
 171 next_set_bit(const void *bit_array, unsigned cur_bit, unsigned size_bits)
 172 {
 173         const unsigned endian = 1;
 174         int little_endian = *(char*)&endian;
 175
 176         const uint8_t *array = bit_array;
 177         unsigned pos = cur_bit / 8;
 178         unsigned pos_xor_mask = little_endian ? 0 : current_wordsize-1;
 179
 180         for (;;) {
 181                 uint8_t bitmask;
 182                 uint8_t cur_byte;
 183
 184                 if (cur_bit >= size_bits)
 185                         return -1;
 186                 cur_byte = array[pos ^ pos_xor_mask];
 187                 if (cur_byte == 0) {
 188                         cur_bit = (cur_bit + 8) & (-8);
 189                         pos++;
 190                         continue;
 191                 }
 192                 bitmask = 1 << (cur_bit & 7);
 193                 for (;;) {
 194                         if (cur_byte & bitmask)
 195                                 return cur_bit;
 196                         cur_bit++;
 197                         if (cur_bit >= size_bits)
 198                                 return -1;
 199                         bitmask <<= 1;
 200                         /* This check *can't be* optimized out: */
 201                         if (bitmask == 0)
 202                                 break;
 203                 }
 204                 pos++;
 205         }
 206 }
 207 /*
 208  * Print entry in struct xlat table, if there.
 209  */
 210 void
 211 printxvals(const unsigned int val, const char *dflt, const struct xlat *xlat, ...)
 212 {
 213         va_list args;
 214
 215         va_start(args, xlat);
 216         for (; xlat; xlat = va_arg(args, const struct xlat *)) {
 217                 const char *str = xlookup(xlat, val);
 218
 219                 if (str) {
 220                         tprints(str);
 221                         va_end(args);
 222                         return;
 223                 }
 224         }
 225         /* No hits -- print raw # instead. */
 226         tprintf("%#x /* %s */", val, dflt);
 227
 228         va_end(args);
 229 }
 230
 231 /*
 232  * Fetch 64bit argument at position arg_no and
 233  * return the index of the next argument.
 234  */
 235 int
 236 getllval(struct tcb *tcp, unsigned long long *val, int arg_no)
 237 {
 238 #if SIZEOF_LONG > 4 && SIZEOF_LONG == SIZEOF_LONG_LONG
 239 # if SUPPORTED_PERSONALITIES > 1
 240 #  ifdef X86_64
 241         if (current_personality != 1) {
 242 #  else
 243         if (current_wordsize > 4) {
 244 #  endif
 245 # endif
 246                 *val = tcp->u_arg[arg_no];
 247                 arg_no++;
 248 # if SUPPORTED_PERSONALITIES > 1
 249         } else {
 250 #  if defined(AARCH64) || defined(POWERPC64)
 251                 /* Align arg_no to the next even number. */
 252                 arg_no = (arg_no + 1) & 0xe;
 253 #  endif /* AARCH64 || POWERPC64 */
 254                 *val = LONG_LONG(tcp->u_arg[arg_no], tcp->u_arg[arg_no + 1]);
 255                 arg_no += 2;
 256         }
 257 # endif /* SUPPORTED_PERSONALITIES > 1 */
 258 #elif SIZEOF_LONG > 4
 259 #  error Unsupported configuration: SIZEOF_LONG > 4 && SIZEOF_LONG_LONG > SIZEOF_LONG
 260 #elif defined LINUX_MIPSN32
 261         *val = tcp->ext_arg[arg_no];
 262         arg_no++;
 263 #elif defined X32
 264         if (current_personality == 0) {
 265                 *val = tcp->ext_arg[arg_no];
 266                 arg_no++;
 267         } else {
 268                 *val = LONG_LONG(tcp->u_arg[arg_no], tcp->u_arg[arg_no + 1]);
 269                 arg_no += 2;
 270         }
 271 #else
 272 # if defined __ARM_EABI__ || \
 273      defined LINUX_MIPSO32 || \
 274      defined POWERPC || \
 275      defined XTENSA
 276         /* Align arg_no to the next even number. */
 277         arg_no = (arg_no + 1) & 0xe;
 278 # endif
 279         *val = LONG_LONG(tcp->u_arg[arg_no], tcp->u_arg[arg_no + 1]);
 280         arg_no += 2;
 281 #endif
 282
 283         return arg_no;
 284 }
 285
 286 /*
 287  * Print 64bit argument at position arg_no and
 288  * return the index of the next argument.
 289  */
 290 int
 291 printllval(struct tcb *tcp, const char *format, int arg_no)
 292 {
 293         unsigned long long val = 0;
 294
 295         arg_no = getllval(tcp, &val, arg_no);
 296         tprintf(format, val);
 297         return arg_no;
 298 }
 299
 300 /*
 301  * Interpret `xlat' as an array of flags
 302  * print the entries whose bits are on in `flags'
 303  * return # of flags printed.
 304  */
 305 void
 306 addflags(const struct xlat *xlat, int flags)
 307 {
 308         for (; xlat->str; xlat++) {
 309                 if (xlat->val && (flags & xlat->val) == xlat->val) {
 310                         tprintf("|%s", xlat->str);
 311                         flags &= ~xlat->val;
 312                 }
 313         }
 314         if (flags) {
 315                 tprintf("|%#x", flags);
 316         }
 317 }
 318
 319 /*
 320  * Interpret `xlat' as an array of flags.
 321  * Print to static string the entries whose bits are on in `flags'
 322  * Return static string.
 323  */
 324 const char *
 325 sprintflags(const char *prefix, const struct xlat *xlat, int flags)
 326 {
 327         static char outstr[1024];
 328         char *outptr;
 329         int found = 0;
 330
 331         outptr = stpcpy(outstr, prefix);
 332
 333         if (flags == 0 && xlat->val == 0 && xlat->str) {
 334                 strcpy(outptr, xlat->str);
 335                 return outstr;
 336         }
 337
 338         for (; xlat->str; xlat++) {
 339                 if (xlat->val && (flags & xlat->val) == xlat->val) {
 340                         if (found)
 341                                 *outptr++ = '|';
 342                         outptr = stpcpy(outptr, xlat->str);
 343                         found = 1;
 344                         flags &= ~xlat->val;
 345                         if (!flags)
 346                                 break;
 347                 }
 348         }
 349         if (flags) {
 350                 if (found)
 351                         *outptr++ = '|';
 352                 outptr += sprintf(outptr, "%#x", flags);
 353         }
 354
 355         return outstr;
 356 }
 357
 358 int
 359 printflags(const struct xlat *xlat, int flags, const char *dflt)
 360 {
 361         int n;
 362         const char *sep;
 363
 364         if (flags == 0 && xlat->val == 0 && xlat->str) {
 365                 tprints(xlat->str);
 366                 return 1;
 367         }
 368
 369         sep = "";
 370         for (n = 0; xlat->str; xlat++) {
 371                 if (xlat->val && (flags & xlat->val) == xlat->val) {
 372                         tprintf("%s%s", sep, xlat->str);
 373                         flags &= ~xlat->val;
 374                         sep = "|";
 375                         n++;
 376                 }
 377         }
 378
 379         if (n) {
 380                 if (flags) {
 381                         tprintf("%s%#x", sep, flags);
 382                         n++;
 383                 }
 384         } else {
 385                 if (flags) {
 386                         tprintf("%#x", flags);
 387                         if (dflt)
 388                                 tprintf(" /* %s */", dflt);
 389                 } else {
 390                         if (dflt)
 391                                 tprints("0");
 392                 }
 393         }
 394
 395         return n;
 396 }
 397
 398 void
 399 printaddr(const long addr)
 400 {
 401         if (!addr)
 402                 tprints("NULL");
 403         else
 404                 tprintf("%#lx", addr);
 405 }
 406
 407 #define DEF_PRINTNUM(name, type) \
 408 bool                                                                    \
 409 printnum_ ## name(struct tcb *tcp, const long addr, const char *fmt)    \
 410 {                                                                       \
 411         type num;                                                       \
 412         if (umove_or_printaddr(tcp, addr, &num))                        \
 413                 return false;                                           \
 414         tprints("[");                                                   \
 415         tprintf(fmt, num);                                              \
 416         tprints("]");                                                   \
 417         return true;                                                    \
 418 }
 419
 420 #define DEF_PRINTPAIR(name, type) \
 421 bool                                                                    \
 422 printpair_ ## name(struct tcb *tcp, const long addr, const char *fmt)   \
 423 {                                                                       \
 424         type pair[2];                                                   \
 425         if (umove_or_printaddr(tcp, addr, &pair))                       \
 426                 return false;                                           \
 427         tprints("[");                                                   \
 428         tprintf(fmt, pair[0]);                                          \
 429         tprints(", ");                                                  \
 430         tprintf(fmt, pair[1]);                                          \
 431         tprints("]");                                                   \
 432         return true;                                                    \
 433 }
 434
 435 DEF_PRINTNUM(int, int)
 436 DEF_PRINTPAIR(int, int)
 437 DEF_PRINTNUM(short, short)
 438 DEF_PRINTNUM(int64, uint64_t)
 439 DEF_PRINTPAIR(int64, uint64_t)
 440
 441 #if SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4
 442 bool
 443 printnum_long_int(struct tcb *tcp, const long addr,
 444                   const char *fmt_long, const char *fmt_int)
 445 {
 446         if (current_wordsize > sizeof(int)) {
 447                 return printnum_int64(tcp, addr, fmt_long);
 448         } else {
 449                 return printnum_int(tcp, addr, fmt_int);
 450         }
 451 }
 452 #endif
 453
 454 const char *
 455 sprinttime(time_t t)
 456 {
 457         struct tm *tmp;
 458         static char buf[sizeof(int) * 3 * 6];
 459
 460         if (t == 0) {
 461                 strcpy(buf, "0");
 462                 return buf;
 463         }
 464         tmp = localtime(&t);
 465         if (tmp)
 466                 snprintf(buf, sizeof buf, "%02d/%02d/%02d-%02d:%02d:%02d",
 467                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
 468                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
 469         else
 470                 snprintf(buf, sizeof buf, "%lu", (unsigned long) t);
 471
 472         return buf;
 473 }
 474
 475 static char *
 476 getfdproto(struct tcb *tcp, int fd, char *buf, unsigned bufsize)
 477 {
 478 #ifdef HAVE_SYS_XATTR_H
 479         ssize_t r;
 480         char path[sizeof("/proc/%u/fd/%u") + 2 * sizeof(int)*3];
 481
 482         if (fd < 0)
 483                 return NULL;
 484
 485         sprintf(path, "/proc/%u/fd/%u", tcp->pid, fd);
 486         r = getxattr(path, "system.sockprotoname", buf, bufsize - 1);
 487         if (r <= 0)
 488                 return NULL;
 489         else {
 490                 /*
 491                  * This is a protection for the case when the kernel
 492                  * side does not append a null byte to the buffer.
 493                  */
 494                 buf[r] = '\0';
 495                 return buf;
 496         }
 497 #else
 498         return NULL;
 499 #endif
 500 }
 501
 502 void
 503 printfd(struct tcb *tcp, int fd)
 504 {
 505         char path[PATH_MAX + 1];
 506         if (show_fd_path && getfdpath(tcp, fd, path, sizeof(path)) >= 0) {
 507                 static const char socket_prefix[] = "socket:[";
 508                 const size_t socket_prefix_len = sizeof(socket_prefix) - 1;
 509                 const size_t path_len = strlen(path);
 510
 511                 tprintf("%d<", fd);
 512                 if (show_fd_path > 1 &&
 513                     strncmp(path, socket_prefix, socket_prefix_len) == 0 &&
 514                     path[path_len - 1] == ']') {
 515                         unsigned long inodenr =
 516                                 strtoul(path + socket_prefix_len, NULL, 10);
 517 #define PROTO_NAME_LEN 32
 518                         char proto_buf[PROTO_NAME_LEN];
 519                         const char *proto =
 520                                 getfdproto(tcp, fd, proto_buf, PROTO_NAME_LEN);
 521                         if (!print_sockaddr_by_inode(inodenr, proto))
 522                                 tprints(path);
 523                 } else {
 524                         print_quoted_string(path, path_len,
 525                                             QUOTE_OMIT_LEADING_TRAILING_QUOTES);
 526                 }
 527                 tprints(">");
 528         } else
 529                 tprintf("%d", fd);
 530 }
 531
 532 /*
 533  * Quote string `instr' of length `size'
 534  * Write up to (3 + `size' * 4) bytes to `outstr' buffer.
 535  *
 536  * If QUOTE_0_TERMINATED `style' flag is set,
 537  * treat `instr' as a NUL-terminated string,
 538  * checking up to (`size' + 1) bytes of `instr'.
 539  *
 540  * If QUOTE_OMIT_LEADING_TRAILING_QUOTES `style' flag is set,
 541  * do not add leading and trailing quoting symbols.
 542  *
 543  * Returns 0 if QUOTE_0_TERMINATED is set and NUL was seen, 1 otherwise.
 544  * Note that if QUOTE_0_TERMINATED is not set, always returns 1.
 545  */
 546 static int
 547 string_quote(const char *instr, char *outstr, const unsigned int size,
 548              const unsigned int style)
 549 {
 550         const unsigned char *ustr = (const unsigned char *) instr;
 551         char *s = outstr;
 552         unsigned int i;
 553         int usehex, c, eol;
 554
 555         if (style & QUOTE_0_TERMINATED)
 556                 eol = '\0';
 557         else
 558                 eol = 0x100; /* this can never match a char */
 559
 560         usehex = 0;
 561         if (xflag > 1)
 562                 usehex = 1;
 563         else if (xflag) {
 564                 /* Check for presence of symbol which require
 565                    to hex-quote the whole string. */
 566                 for (i = 0; i < size; ++i) {
 567                         c = ustr[i];
 568                         /* Check for NUL-terminated string. */
 569                         if (c == eol)
 570                                 break;
 571
 572                         /* Force hex unless c is printable or whitespace */
 573                         if (c > 0x7e) {
 574                                 usehex = 1;
 575                                 break;
 576                         }
 577                         /* In ASCII isspace is only these chars: "\t\n\v\f\r".
 578                          * They happen to have ASCII codes 9,10,11,12,13.
 579                          */
 580                         if (c < ' ' && (unsigned)(c - 9) >= 5) {
 581                                 usehex = 1;
 582                                 break;
 583                         }
 584                 }
 585         }
 586
 587         if (!(style & QUOTE_OMIT_LEADING_TRAILING_QUOTES))
 588                 *s++ = '\"';
 589
 590         if (usehex) {
 591                 /* Hex-quote the whole string. */
 592                 for (i = 0; i < size; ++i) {
 593                         c = ustr[i];
 594                         /* Check for NUL-terminated string. */
 595                         if (c == eol)
 596                                 goto asciz_ended;
 597                         *s++ = '\\';
 598                         *s++ = 'x';
 599                         *s++ = "0123456789abcdef"[c >> 4];
 600                         *s++ = "0123456789abcdef"[c & 0xf];
 601                 }
 602         } else {
 603                 for (i = 0; i < size; ++i) {
 604                         c = ustr[i];
 605                         /* Check for NUL-terminated string. */
 606                         if (c == eol)
 607                                 goto asciz_ended;
 608                         switch (c) {
 609                                 case '\"': case '\\':
 610                                         *s++ = '\\';
 611                                         *s++ = c;
 612                                         break;
 613                                 case '\f':
 614                                         *s++ = '\\';
 615                                         *s++ = 'f';
 616                                         break;
 617                                 case '\n':
 618                                         *s++ = '\\';
 619                                         *s++ = 'n';
 620                                         break;
 621                                 case '\r':
 622                                         *s++ = '\\';
 623                                         *s++ = 'r';
 624                                         break;
 625                                 case '\t':
 626                                         *s++ = '\\';
 627                                         *s++ = 't';
 628                                         break;
 629                                 case '\v':
 630                                         *s++ = '\\';
 631                                         *s++ = 'v';
 632                                         break;
 633                                 default:
 634                                         if (c >= ' ' && c <= 0x7e)
 635                                                 *s++ = c;
 636                                         else {
 637                                                 /* Print \octal */
 638                                                 *s++ = '\\';
 639                                                 if (i + 1 < size
 640                                                     && ustr[i + 1] >= '0'
 641                                                     && ustr[i + 1] <= '9'
 642                                                 ) {
 643                                                         /* Print \ooo */
 644                                                         *s++ = '0' + (c >> 6);
 645                                                         *s++ = '0' + ((c >> 3) & 0x7);
 646                                                 } else {
 647                                                         /* Print \[[o]o]o */
 648                                                         if ((c >> 3) != 0) {
 649                                                                 if ((c >> 6) != 0)
 650                                                                         *s++ = '0' + (c >> 6);
 651                                                                 *s++ = '0' + ((c >> 3) & 0x7);
 652                                                         }
 653                                                 }
 654                                                 *s++ = '0' + (c & 0x7);
 655                                         }
 656                                         break;
 657                         }
 658                 }
 659         }
 660
 661         if (!(style & QUOTE_OMIT_LEADING_TRAILING_QUOTES))
 662                 *s++ = '\"';
 663         *s = '\0';
 664
 665         /* Return zero if we printed entire ASCIZ string (didn't truncate it) */
 666         if (style & QUOTE_0_TERMINATED && ustr[i] == '\0') {
 667                 /* We didn't see NUL yet (otherwise we'd jump to 'asciz_ended')
 668                  * but next char is NUL.
 669                  */
 670                 return 0;
 671         }
 672
 673         return 1;
 674
 675  asciz_ended:
 676         if (!(style & QUOTE_OMIT_LEADING_TRAILING_QUOTES))
 677                 *s++ = '\"';
 678         *s = '\0';
 679         /* Return zero: we printed entire ASCIZ string (didn't truncate it) */
 680         return 0;
 681 }
 682
 683 #ifndef ALLOCA_CUTOFF
 684 # define ALLOCA_CUTOFF  4032
 685 #endif
 686 #define use_alloca(n) ((n) <= ALLOCA_CUTOFF)
 687
 688 /*
 689  * Quote string `str' of length `size' and print the result.
 690  *
 691  * If QUOTE_0_TERMINATED `style' flag is set,
 692  * treat `str' as a NUL-terminated string and
 693  * quote at most (`size' - 1) bytes.
 694  *
 695  * If QUOTE_OMIT_LEADING_TRAILING_QUOTES `style' flag is set,
 696  * do not add leading and trailing quoting symbols.
 697  *
 698  * Returns 0 if QUOTE_0_TERMINATED is set and NUL was seen, 1 otherwise.
 699  * Note that if QUOTE_0_TERMINATED is not set, always returns 1.
 700  */
 701 int
 702 print_quoted_string(const char *str, unsigned int size,
 703                     const unsigned int style)
 704 {
 705         char *buf;
 706         char *outstr;
 707         unsigned int alloc_size;
 708         int rc;
 709
 710         if (size && style & QUOTE_0_TERMINATED)
 711                 --size;
 712
 713         alloc_size = 4 * size;
 714         if (alloc_size / 4 != size) {
 715                 error_msg("Out of memory");
 716                 tprints("???");
 717                 return -1;
 718         }
 719         alloc_size += 1 + (style & QUOTE_OMIT_LEADING_TRAILING_QUOTES ? 0 : 2);
 720
 721         if (use_alloca(alloc_size)) {
 722                 outstr = alloca(alloc_size);
 723                 buf = NULL;
 724         } else {
 725                 outstr = buf = malloc(alloc_size);
 726                 if (!buf) {
 727                         error_msg("Out of memory");
 728                         tprints("???");
 729                         return -1;
 730                 }
 731         }
 732
 733         rc = string_quote(str, outstr, size, style);
 734         tprints(outstr);
 735
 736         free(buf);
 737         return rc;
 738 }
 739
 740 /*
 741  * Print path string specified by address `addr' and length `n'.
 742  * If path length exceeds `n', append `...' to the output.
 743  */
 744 void
 745 printpathn(struct tcb *tcp, long addr, unsigned int n)
 746 {
 747         char path[PATH_MAX + 1];
 748         int nul_seen;
 749
 750         if (!addr) {
 751                 tprints("NULL");
 752                 return;
 753         }
 754
 755         /* Cap path length to the path buffer size */
 756         if (n > sizeof path - 1)
 757                 n = sizeof path - 1;
 758
 759         /* Fetch one byte more to find out whether path length > n. */
 760         nul_seen = umovestr(tcp, addr, n + 1, path);
 761         if (nul_seen < 0)
 762                 tprintf("%#lx", addr);
 763         else {
 764                 path[n++] = '\0';
 765                 print_quoted_string(path, n, QUOTE_0_TERMINATED);
 766                 if (!nul_seen)
 767                         tprints("...");
 768         }
 769 }
 770
 771 void
 772 printpath(struct tcb *tcp, long addr)
 773 {
 774         /* Size must correspond to char path[] size in printpathn */
 775         printpathn(tcp, addr, PATH_MAX);
 776 }
 777
 778 /*
 779  * Print string specified by address `addr' and length `len'.
 780  * If `len' < 0, treat the string as a NUL-terminated string.
 781  * If string length exceeds `max_strlen', append `...' to the output.
 782  */
 783 void
 784 printstr(struct tcb *tcp, long addr, long len)
 785 {
 786         static char *str = NULL;
 787         static char *outstr;
 788         unsigned int size;
 789         unsigned int style;
 790         int ellipsis;
 791
 792         if (!addr) {
 793                 tprints("NULL");
 794                 return;
 795         }
 796         /* Allocate static buffers if they are not allocated yet. */
 797         if (!str) {
 798                 unsigned int outstr_size = 4 * max_strlen + /*for quotes and NUL:*/ 3;
 799
 800                 if (outstr_size / 4 != max_strlen)
 801                         die_out_of_memory();
 802                 str = xmalloc(max_strlen + 1);
 803                 outstr = xmalloc(outstr_size);
 804         }
 805
 806         size = max_strlen;
 807         if (len == -1) {
 808                 /*
 809                  * Treat as a NUL-terminated string: fetch one byte more
 810                  * because string_quote may look one byte ahead.
 811                  */
 812                 if (umovestr(tcp, addr, size + 1, str) < 0) {
 813                         tprintf("%#lx", addr);
 814                         return;
 815                 }
 816                 style = QUOTE_0_TERMINATED;
 817         }
 818         else {
 819                 if (size > (unsigned long)len)
 820                         size = (unsigned long)len;
 821                 if (umoven(tcp, addr, size, str) < 0) {
 822                         tprintf("%#lx", addr);
 823                         return;
 824                 }
 825                 style = 0;
 826         }
 827
 828         /* If string_quote didn't see NUL and (it was supposed to be ASCIZ str
 829          * or we were requested to print more than -s NUM chars)...
 830          */
 831         ellipsis = (string_quote(str, outstr, size, style) &&
 832                         (len < 0 || (unsigned long) len > max_strlen));
 833
 834         tprints(outstr);
 835         if (ellipsis)
 836                 tprints("...");
 837 }
 838
 839 void
 840 dumpiov_upto(struct tcb *tcp, int len, long addr, unsigned long data_size)
 841 {
 842 #if SUPPORTED_PERSONALITIES > 1
 843         union {
 844                 struct { uint32_t base; uint32_t len; } *iov32;
 845                 struct { uint64_t base; uint64_t len; } *iov64;
 846         } iovu;
 847 #define iov iovu.iov64
 848 #define sizeof_iov \
 849         (current_wordsize == 4 ? sizeof(*iovu.iov32) : sizeof(*iovu.iov64))
 850 #define iov_iov_base(i) \
 851         (current_wordsize == 4 ? (uint64_t) iovu.iov32[i].base : iovu.iov64[i].base)
 852 #define iov_iov_len(i) \
 853         (current_wordsize == 4 ? (uint64_t) iovu.iov32[i].len : iovu.iov64[i].len)
 854 #else
 855         struct iovec *iov;
 856 #define sizeof_iov sizeof(*iov)
 857 #define iov_iov_base(i) iov[i].iov_base
 858 #define iov_iov_len(i) iov[i].iov_len
 859 #endif
 860         int i;
 861         unsigned size;
 862
 863         size = sizeof_iov * len;
 864         /* Assuming no sane program has millions of iovs */
 865         if ((unsigned)len > 1024*1024 /* insane or negative size? */
 866             || (iov = malloc(size)) == NULL) {
 867                 error_msg("Out of memory");
 868                 return;
 869         }
 870         if (umoven(tcp, addr, size, iov) >= 0) {
 871                 for (i = 0; i < len; i++) {
 872                         unsigned long iov_len = iov_iov_len(i);
 873                         if (iov_len > data_size)
 874                                 iov_len = data_size;
 875                         if (!iov_len)
 876                                 break;
 877                         data_size -= iov_len;
 878                         /* include the buffer number to make it easy to
 879                          * match up the trace with the source */
 880                         tprintf(" * %lu bytes in buffer %d\n", iov_len, i);
 881                         dumpstr(tcp, (long) iov_iov_base(i), iov_len);
 882                 }
 883         }
 884         free(iov);
 885 #undef sizeof_iov
 886 #undef iov_iov_base
 887 #undef iov_iov_len
 888 #undef iov
 889 }
 890
 891 void
 892 dumpstr(struct tcb *tcp, long addr, int len)
 893 {
 894         static int strsize = -1;
 895         static unsigned char *str;
 896
 897         char outbuf[
 898                 (
 899                         (sizeof(
 900                         "xx xx xx xx xx xx xx xx  xx xx xx xx xx xx xx xx  "
 901                         "1234567890123456") + /*in case I'm off by few:*/ 4)
 902                 /*align to 8 to make memset easier:*/ + 7) & -8
 903         ];
 904         const unsigned char *src;
 905         int i;
 906
 907         memset(outbuf, ' ', sizeof(outbuf));
 908
 909         if (strsize < len + 16) {
 910                 free(str);
 911                 str = malloc(len + 16);
 912                 if (!str) {
 913                         strsize = -1;
 914                         error_msg("Out of memory");
 915                         return;
 916                 }
 917                 strsize = len + 16;
 918         }
 919
 920         if (umoven(tcp, addr, len, str) < 0)
 921                 return;
 922
 923         /* Space-pad to 16 bytes */
 924         i = len;
 925         while (i & 0xf)
 926                 str[i++] = ' ';
 927
 928         i = 0;
 929         src = str;
 930         while (i < len) {
 931                 char *dst = outbuf;
 932                 /* Hex dump */
 933                 do {
 934                         if (i < len) {
 935                                 *dst++ = "0123456789abcdef"[*src >> 4];
 936                                 *dst++ = "0123456789abcdef"[*src & 0xf];
 937                         }
 938                         else {
 939                                 *dst++ = ' ';
 940                                 *dst++ = ' ';
 941                         }
 942                         dst++; /* space is there by memset */
 943                         i++;
 944                         if ((i & 7) == 0)
 945                                 dst++; /* space is there by memset */
 946                         src++;
 947                 } while (i & 0xf);
 948                 /* ASCII dump */
 949                 i -= 16;
 950                 src -= 16;
 951                 do {
 952                         if (*src >= ' ' && *src < 0x7f)
 953                                 *dst++ = *src;
 954                         else
 955                                 *dst++ = '.';
 956                         src++;
 957                 } while (++i & 0xf);
 958                 *dst = '\0';
 959                 tprintf(" | %05x  %s |\n", i - 16, outbuf);
 960         }
 961 }
 962
 963 #ifdef HAVE_PROCESS_VM_READV
 964 /* C library supports this, but the kernel might not. */
 965 static bool process_vm_readv_not_supported = 0;
 966 #else
 967
 968 /* Need to do this since process_vm_readv() is not yet available in libc.
 969  * When libc is be updated, only "static bool process_vm_readv_not_supported"
 970  * line should remain.
 971  */
 972 #if !defined(__NR_process_vm_readv)
 973 # if defined(I386)
 974 #  define __NR_process_vm_readv  347
 975 # elif defined(X86_64)
 976 #  define __NR_process_vm_readv  310
 977 # elif defined(POWERPC)
 978 #  define __NR_process_vm_readv  351
 979 # endif
 980 #endif
 981
 982 #if defined(__NR_process_vm_readv)
 983 static bool process_vm_readv_not_supported = 0;
 984 /* Have to avoid duplicating with the C library headers. */
 985 static ssize_t strace_process_vm_readv(pid_t pid,
 986                  const struct iovec *lvec,
 987                  unsigned long liovcnt,
 988                  const struct iovec *rvec,
 989                  unsigned long riovcnt,
 990                  unsigned long flags)
 991 {
 992         return syscall(__NR_process_vm_readv, (long)pid, lvec, liovcnt, rvec, riovcnt, flags);
 993 }
 994 #define process_vm_readv strace_process_vm_readv
 995 #else
 996 static bool process_vm_readv_not_supported = 1;
 997 # define process_vm_readv(...) (errno = ENOSYS, -1)
 998 #endif
 999
1000 #endif /* end of hack */
1001
1002 static ssize_t
1003 vm_read_mem(pid_t pid, void *laddr, long raddr, size_t len)
1004 {
1005         const struct iovec local = {
1006                 .iov_base = laddr,
1007                 .iov_len = len
1008         };
1009         const struct iovec remote = {
1010                 .iov_base = (void *) raddr,
1011                 .iov_len = len
1012         };
1013
1014         return process_vm_readv(pid, &local, 1, &remote, 1, 0);
1015 }
1016
1017 /*
1018  * move `len' bytes of data from process `pid'
1019  * at address `addr' to our space at `our_addr'
1020  */
1021 int
1022 umoven(struct tcb *tcp, long addr, unsigned int len, void *our_addr)
1023 {
1024         char *laddr = our_addr;
1025         int pid = tcp->pid;
1026         unsigned int n, m, nread;
1027         union {
1028                 long val;
1029                 char x[sizeof(long)];
1030         } u;
1031
1032 #if SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4
1033         if (current_wordsize < sizeof(addr))
1034                 addr &= (1ul << 8 * current_wordsize) - 1;
1035 #endif
1036
1037         if (!process_vm_readv_not_supported) {
1038                 int r = vm_read_mem(pid, laddr, addr, len);
1039                 if ((unsigned int) r == len)
1040                         return 0;
1041                 if (r >= 0) {
1042                         error_msg("umoven: short read (%u < %u) @0x%lx",
1043                                   (unsigned int) r, len, addr);
1044                         return -1;
1045                 }
1046                 switch (errno) {
1047                         case ENOSYS:
1048                                 process_vm_readv_not_supported = 1;
1049                                 break;
1050                         case EPERM:
1051                                 /* operation not permitted, try PTRACE_PEEKDATA */
1052                                 break;
1053                         case ESRCH:
1054                                 /* the process is gone */
1055                                 return -1;
1056                         case EFAULT: case EIO:
1057                                 /* address space is inaccessible */
1058                                 return -1;
1059                         default:
1060                                 /* all the rest is strange and should be reported */
1061                                 perror_msg("process_vm_readv");
1062                                 return -1;
1063                 }
1064         }
1065
1066         nread = 0;
1067         if (addr & (sizeof(long) - 1)) {
1068                 /* addr not a multiple of sizeof(long) */
1069                 n = addr & (sizeof(long) - 1);  /* residue */
1070                 addr &= -sizeof(long);          /* aligned address */
1071                 errno = 0;
1072                 u.val = ptrace(PTRACE_PEEKDATA, pid, (char *) addr, 0);
1073                 switch (errno) {
1074                         case 0:
1075                                 break;
1076                         case ESRCH: case EINVAL:
1077                                 /* these could be seen if the process is gone */
1078                                 return -1;
1079                         case EFAULT: case EIO: case EPERM:
1080                                 /* address space is inaccessible */
1081                                 return -1;
1082                         default:
1083                                 /* all the rest is strange and should be reported */
1084                                 perror_msg("umoven: PTRACE_PEEKDATA pid:%d @0x%lx",
1085                                             pid, addr);
1086                                 return -1;
1087                 }
1088                 m = MIN(sizeof(long) - n, len);
1089                 memcpy(laddr, &u.x[n], m);
1090                 addr += sizeof(long);
1091                 laddr += m;
1092                 nread += m;
1093                 len -= m;
1094         }
1095         while (len) {
1096                 errno = 0;
1097                 u.val = ptrace(PTRACE_PEEKDATA, pid, (char *) addr, 0);
1098                 switch (errno) {
1099                         case 0:
1100                                 break;
1101                         case ESRCH: case EINVAL:
1102                                 /* these could be seen if the process is gone */
1103                                 return -1;
1104                         case EFAULT: case EIO: case EPERM:
1105                                 /* address space is inaccessible */
1106                                 if (nread) {
1107                                         perror_msg("umoven: short read (%u < %u) @0x%lx",
1108                                                    nread, nread + len, addr - nread);
1109                                 }
1110                                 return -1;
1111                         default:
1112                                 /* all the rest is strange and should be reported */
1113                                 perror_msg("umoven: PTRACE_PEEKDATA pid:%d @0x%lx",
1114                                             pid, addr);
1115                                 return -1;
1116                 }
1117                 m = MIN(sizeof(long), len);
1118                 memcpy(laddr, u.x, m);
1119                 addr += sizeof(long);
1120                 laddr += m;
1121                 nread += m;
1122                 len -= m;
1123         }
1124
1125         return 0;
1126 }
1127
1128 int
1129 umoven_or_printaddr(struct tcb *tcp, const long addr, const unsigned int len,
1130                     void *our_addr)
1131 {
1132         if (!addr) {
1133                 tprints("NULL");
1134                 return -1;
1135         }
1136         if (!verbose(tcp) || (exiting(tcp) && syserror(tcp)) ||
1137             umoven(tcp, addr, len, our_addr) < 0) {
1138                 tprintf("%#lx", addr);
1139                 return -1;
1140         }
1141         return 0;
1142 }
1143
1144 int
1145 umove_ulong_or_printaddr(struct tcb *tcp, const long addr, unsigned long *ptr)
1146 {
1147         if (current_wordsize < sizeof(*ptr)) {
1148                 uint32_t val32;
1149                 int r = umove_or_printaddr(tcp, addr, &val32);
1150                 if (!r)
1151                         *ptr = (unsigned long) val32;
1152                 return r;
1153         }
1154         return umove_or_printaddr(tcp, addr, ptr);
1155 }
1156
1157 int
1158 umove_ulong_array_or_printaddr(struct tcb *tcp, const long addr,
1159                                unsigned long *ptr, size_t n)
1160 {
1161         if (current_wordsize < sizeof(*ptr)) {
1162                 uint32_t ptr32[n];
1163                 int r = umove_or_printaddr(tcp, addr, &ptr32);
1164                 if (!r) {
1165                         size_t i;
1166
1167                         for (i = 0; i < n; ++i)
1168                                 ptr[i] = (unsigned long) ptr32[i];
1169                 }
1170                 return r;
1171         }
1172         return umoven_or_printaddr(tcp, addr, n * sizeof(*ptr), ptr);
1173 }
1174
1175 /*
1176  * Like `umove' but make the additional effort of looking
1177  * for a terminating zero byte.
1178  *
1179  * Returns < 0 on error, > 0 if NUL was seen,
1180  * (TODO if useful: return count of bytes including NUL),
1181  * else 0 if len bytes were read but no NUL byte seen.
1182  *
1183  * Note: there is no guarantee we won't overwrite some bytes
1184  * in laddr[] _after_ terminating NUL (but, of course,
1185  * we never write past laddr[len-1]).
1186  */
1187 int
1188 umovestr(struct tcb *tcp, long addr, unsigned int len, char *laddr)
1189 {
1190 #if SIZEOF_LONG == 4
1191         const unsigned long x01010101 = 0x01010101ul;
1192         const unsigned long x80808080 = 0x80808080ul;
1193 #elif SIZEOF_LONG == 8
1194         const unsigned long x01010101 = 0x0101010101010101ul;
1195         const unsigned long x80808080 = 0x8080808080808080ul;
1196 #else
1197 # error SIZEOF_LONG > 8
1198 #endif
1199
1200         int pid = tcp->pid;
1201         unsigned int n, m, nread;
1202         union {
1203                 unsigned long val;
1204                 char x[sizeof(long)];
1205         } u;
1206
1207 #if SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4
1208         if (current_wordsize < sizeof(addr))
1209                 addr &= (1ul << 8 * current_wordsize) - 1;
1210 #endif
1211
1212         nread = 0;
1213         if (!process_vm_readv_not_supported) {
1214                 const size_t page_size = get_pagesize();
1215                 const size_t page_mask = page_size - 1;
1216
1217                 while (len > 0) {
1218                         unsigned int chunk_len;
1219                         unsigned int end_in_page;
1220
1221                         /*
1222                          * Don't cross pages, otherwise we can get EFAULT
1223                          * and fail to notice that terminating NUL lies
1224                          * in the existing (first) page.
1225                          */
1226                         chunk_len = len > page_size ? page_size : len;
1227                         end_in_page = (addr + chunk_len) & page_mask;
1228                         if (chunk_len > end_in_page) /* crosses to the next page */
1229                                 chunk_len -= end_in_page;
1230
1231                         int r = vm_read_mem(pid, laddr, addr, chunk_len);
1232                         if (r > 0) {
1233                                 if (memchr(laddr, '\0', r))
1234                                         return 1;
1235                                 addr += r;
1236                                 laddr += r;
1237                                 nread += r;
1238                                 len -= r;
1239                                 continue;
1240                         }
1241                         switch (errno) {
1242                                 case ENOSYS:
1243                                         process_vm_readv_not_supported = 1;
1244                                         goto vm_readv_didnt_work;
1245                                 case ESRCH:
1246                                         /* the process is gone */
1247                                         return -1;
1248                                 case EPERM:
1249                                         /* operation not permitted, try PTRACE_PEEKDATA */
1250                                         if (!nread)
1251                                                 goto vm_readv_didnt_work;
1252                                         /* fall through */
1253                                 case EFAULT: case EIO:
1254                                         /* address space is inaccessible */
1255                                         if (nread) {
1256                                                 perror_msg("umovestr: short read (%d < %d) @0x%lx",
1257                                                            nread, nread + len, addr - nread);
1258                                         }
1259                                         return -1;
1260                                 default:
1261                                         /* all the rest is strange and should be reported */
1262                                         perror_msg("process_vm_readv");
1263                                         return -1;
1264                         }
1265                 }
1266                 return 0;
1267         }
1268  vm_readv_didnt_work:
1269
1270         if (addr & (sizeof(long) - 1)) {
1271                 /* addr not a multiple of sizeof(long) */
1272                 n = addr & (sizeof(long) - 1);  /* residue */
1273                 addr &= -sizeof(long);          /* aligned address */
1274                 errno = 0;
1275                 u.val = ptrace(PTRACE_PEEKDATA, pid, (char *)addr, 0);
1276                 switch (errno) {
1277                         case 0:
1278                                 break;
1279                         case ESRCH: case EINVAL:
1280                                 /* these could be seen if the process is gone */
1281                                 return -1;
1282                         case EFAULT: case EIO: case EPERM:
1283                                 /* address space is inaccessible */
1284                                 return -1;
1285                         default:
1286                                 /* all the rest is strange and should be reported */
1287                                 perror_msg("umovestr: PTRACE_PEEKDATA pid:%d @0x%lx",
1288                                             pid, addr);
1289                                 return -1;
1290                 }
1291                 m = MIN(sizeof(long) - n, len);
1292                 memcpy(laddr, &u.x[n], m);
1293                 while (n & (sizeof(long) - 1))
1294                         if (u.x[n++] == '\0')
1295                                 return 1;
1296                 addr += sizeof(long);
1297                 laddr += m;
1298                 nread += m;
1299                 len -= m;
1300         }
1301
1302         while (len) {
1303                 errno = 0;
1304                 u.val = ptrace(PTRACE_PEEKDATA, pid, (char *)addr, 0);
1305                 switch (errno) {
1306                         case 0:
1307                                 break;
1308                         case ESRCH: case EINVAL:
1309                                 /* these could be seen if the process is gone */
1310                                 return -1;
1311                         case EFAULT: case EIO: case EPERM:
1312                                 /* address space is inaccessible */
1313                                 if (nread) {
1314                                         perror_msg("umovestr: short read (%d < %d) @0x%lx",
1315                                                    nread, nread + len, addr - nread);
1316                                 }
1317                                 return -1;
1318                         default:
1319                                 /* all the rest is strange and should be reported */
1320                                 perror_msg("umovestr: PTRACE_PEEKDATA pid:%d @0x%lx",
1321                                            pid, addr);
1322                                 return -1;
1323                 }
1324                 m = MIN(sizeof(long), len);
1325                 memcpy(laddr, u.x, m);
1326                 /* "If a NUL char exists in this word" */
1327                 if ((u.val - x01010101) & ~u.val & x80808080)
1328                         return 1;
1329                 addr += sizeof(long);
1330                 laddr += m;
1331                 nread += m;
1332                 len -= m;
1333         }
1334         return 0;
1335 }
1336
1337 int
1338 upeek(int pid, long off, long *res)
1339 {
1340         long val;
1341
1342         errno = 0;
1343         val = ptrace(PTRACE_PEEKUSER, (pid_t)pid, (char *) off, 0);
1344         if (val == -1 && errno) {
1345                 if (errno != ESRCH) {
1346                         perror_msg("upeek: PTRACE_PEEKUSER pid:%d @0x%lx)", pid, off);
1347                 }
1348                 return -1;
1349         }
1350         *res = val;
1351         return 0;
1352 }