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 uint64_t 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 uint64_t val1 = *(const uint64_t *) a;
 136         const uint64_t 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 uint64_t val)
 142 {
 143         const struct xlat *e =
 144                 bsearch((const void*) &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 uint64_t 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("%#" PRIx64 " /* %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, uint64_t 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("|%#" PRIx64, 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, uint64_t 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, "%#" PRIx64, flags);
 353         }
 354
 355         return outstr;
 356 }
 357
 358 int
 359 printflags64(const struct xlat *xlat, uint64_t 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%#" PRIx64, sep, flags);
 382                         n++;
 383                 }
 384         } else {
 385                 if (flags) {
 386                         tprintf("%#" PRIx64, 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 inode =
 516                                 strtoul(path + socket_prefix_len, NULL, 10);
 517
 518                         if (!print_sockaddr_by_inode_cached(inode)) {
 519                                 char buf[256];
 520                                 const char *proto =
 521                                         getfdproto(tcp, fd, buf, sizeof(buf));
 522                                 if (!print_sockaddr_by_inode(inode, proto))
 523                                         tprints(path);
 524                         }
 525                 } else {
 526                         print_quoted_string(path, path_len,
 527                                             QUOTE_OMIT_LEADING_TRAILING_QUOTES);
 528                 }
 529                 tprints(">");
 530         } else
 531                 tprintf("%d", fd);
 532 }
 533
 534 /*
 535  * Quote string `instr' of length `size'
 536  * Write up to (3 + `size' * 4) bytes to `outstr' buffer.
 537  *
 538  * If QUOTE_0_TERMINATED `style' flag is set,
 539  * treat `instr' as a NUL-terminated string,
 540  * checking up to (`size' + 1) bytes of `instr'.
 541  *
 542  * If QUOTE_OMIT_LEADING_TRAILING_QUOTES `style' flag is set,
 543  * do not add leading and trailing quoting symbols.
 544  *
 545  * Returns 0 if QUOTE_0_TERMINATED is set and NUL was seen, 1 otherwise.
 546  * Note that if QUOTE_0_TERMINATED is not set, always returns 1.
 547  */
 548 int
 549 string_quote(const char *instr, char *outstr, const unsigned int size,
 550              const unsigned int style)
 551 {
 552         const unsigned char *ustr = (const unsigned char *) instr;
 553         char *s = outstr;
 554         unsigned int i;
 555         int usehex, c, eol;
 556
 557         if (style & QUOTE_0_TERMINATED)
 558                 eol = '\0';
 559         else
 560                 eol = 0x100; /* this can never match a char */
 561
 562         usehex = 0;
 563         if (xflag > 1)
 564                 usehex = 1;
 565         else if (xflag) {
 566                 /* Check for presence of symbol which require
 567                    to hex-quote the whole string. */
 568                 for (i = 0; i < size; ++i) {
 569                         c = ustr[i];
 570                         /* Check for NUL-terminated string. */
 571                         if (c == eol)
 572                                 break;
 573
 574                         /* Force hex unless c is printable or whitespace */
 575                         if (c > 0x7e) {
 576                                 usehex = 1;
 577                                 break;
 578                         }
 579                         /* In ASCII isspace is only these chars: "\t\n\v\f\r".
 580                          * They happen to have ASCII codes 9,10,11,12,13.
 581                          */
 582                         if (c < ' ' && (unsigned)(c - 9) >= 5) {
 583                                 usehex = 1;
 584                                 break;
 585                         }
 586                 }
 587         }
 588
 589         if (!(style & QUOTE_OMIT_LEADING_TRAILING_QUOTES))
 590                 *s++ = '\"';
 591
 592         if (usehex) {
 593                 /* Hex-quote the whole string. */
 594                 for (i = 0; i < size; ++i) {
 595                         c = ustr[i];
 596                         /* Check for NUL-terminated string. */
 597                         if (c == eol)
 598                                 goto asciz_ended;
 599                         *s++ = '\\';
 600                         *s++ = 'x';
 601                         *s++ = "0123456789abcdef"[c >> 4];
 602                         *s++ = "0123456789abcdef"[c & 0xf];
 603                 }
 604         } else {
 605                 for (i = 0; i < size; ++i) {
 606                         c = ustr[i];
 607                         /* Check for NUL-terminated string. */
 608                         if (c == eol)
 609                                 goto asciz_ended;
 610                         switch (c) {
 611                                 case '\"': case '\\':
 612                                         *s++ = '\\';
 613                                         *s++ = c;
 614                                         break;
 615                                 case '\f':
 616                                         *s++ = '\\';
 617                                         *s++ = 'f';
 618                                         break;
 619                                 case '\n':
 620                                         *s++ = '\\';
 621                                         *s++ = 'n';
 622                                         break;
 623                                 case '\r':
 624                                         *s++ = '\\';
 625                                         *s++ = 'r';
 626                                         break;
 627                                 case '\t':
 628                                         *s++ = '\\';
 629                                         *s++ = 't';
 630                                         break;
 631                                 case '\v':
 632                                         *s++ = '\\';
 633                                         *s++ = 'v';
 634                                         break;
 635                                 default:
 636                                         if (c >= ' ' && c <= 0x7e)
 637                                                 *s++ = c;
 638                                         else {
 639                                                 /* Print \octal */
 640                                                 *s++ = '\\';
 641                                                 if (i + 1 < size
 642                                                     && ustr[i + 1] >= '0'
 643                                                     && ustr[i + 1] <= '9'
 644                                                 ) {
 645                                                         /* Print \ooo */
 646                                                         *s++ = '0' + (c >> 6);
 647                                                         *s++ = '0' + ((c >> 3) & 0x7);
 648                                                 } else {
 649                                                         /* Print \[[o]o]o */
 650                                                         if ((c >> 3) != 0) {
 651                                                                 if ((c >> 6) != 0)
 652                                                                         *s++ = '0' + (c >> 6);
 653                                                                 *s++ = '0' + ((c >> 3) & 0x7);
 654                                                         }
 655                                                 }
 656                                                 *s++ = '0' + (c & 0x7);
 657                                         }
 658                                         break;
 659                         }
 660                 }
 661         }
 662
 663         if (!(style & QUOTE_OMIT_LEADING_TRAILING_QUOTES))
 664                 *s++ = '\"';
 665         *s = '\0';
 666
 667         /* Return zero if we printed entire ASCIZ string (didn't truncate it) */
 668         if (style & QUOTE_0_TERMINATED && ustr[i] == '\0') {
 669                 /* We didn't see NUL yet (otherwise we'd jump to 'asciz_ended')
 670                  * but next char is NUL.
 671                  */
 672                 return 0;
 673         }
 674
 675         return 1;
 676
 677  asciz_ended:
 678         if (!(style & QUOTE_OMIT_LEADING_TRAILING_QUOTES))
 679                 *s++ = '\"';
 680         *s = '\0';
 681         /* Return zero: we printed entire ASCIZ string (didn't truncate it) */
 682         return 0;
 683 }
 684
 685 #ifndef ALLOCA_CUTOFF
 686 # define ALLOCA_CUTOFF  4032
 687 #endif
 688 #define use_alloca(n) ((n) <= ALLOCA_CUTOFF)
 689
 690 /*
 691  * Quote string `str' of length `size' and print the result.
 692  *
 693  * If QUOTE_0_TERMINATED `style' flag is set,
 694  * treat `str' as a NUL-terminated string and
 695  * quote at most (`size' - 1) bytes.
 696  *
 697  * If QUOTE_OMIT_LEADING_TRAILING_QUOTES `style' flag is set,
 698  * do not add leading and trailing quoting symbols.
 699  *
 700  * Returns 0 if QUOTE_0_TERMINATED is set and NUL was seen, 1 otherwise.
 701  * Note that if QUOTE_0_TERMINATED is not set, always returns 1.
 702  */
 703 int
 704 print_quoted_string(const char *str, unsigned int size,
 705                     const unsigned int style)
 706 {
 707         char *buf;
 708         char *outstr;
 709         unsigned int alloc_size;
 710         int rc;
 711
 712         if (size && style & QUOTE_0_TERMINATED)
 713                 --size;
 714
 715         alloc_size = 4 * size;
 716         if (alloc_size / 4 != size) {
 717                 error_msg("Out of memory");
 718                 tprints("???");
 719                 return -1;
 720         }
 721         alloc_size += 1 + (style & QUOTE_OMIT_LEADING_TRAILING_QUOTES ? 0 : 2);
 722
 723         if (use_alloca(alloc_size)) {
 724                 outstr = alloca(alloc_size);
 725                 buf = NULL;
 726         } else {
 727                 outstr = buf = malloc(alloc_size);
 728                 if (!buf) {
 729                         error_msg("Out of memory");
 730                         tprints("???");
 731                         return -1;
 732                 }
 733         }
 734
 735         rc = string_quote(str, outstr, size, style);
 736         tprints(outstr);
 737
 738         free(buf);
 739         return rc;
 740 }
 741
 742 /*
 743  * Print path string specified by address `addr' and length `n'.
 744  * If path length exceeds `n', append `...' to the output.
 745  */
 746 void
 747 printpathn(struct tcb *tcp, long addr, unsigned int n)
 748 {
 749         char path[PATH_MAX + 1];
 750         int nul_seen;
 751
 752         if (!addr) {
 753                 tprints("NULL");
 754                 return;
 755         }
 756
 757         /* Cap path length to the path buffer size */
 758         if (n > sizeof path - 1)
 759                 n = sizeof path - 1;
 760
 761         /* Fetch one byte more to find out whether path length > n. */
 762         nul_seen = umovestr(tcp, addr, n + 1, path);
 763         if (nul_seen < 0)
 764                 tprintf("%#lx", addr);
 765         else {
 766                 path[n++] = '\0';
 767                 print_quoted_string(path, n, QUOTE_0_TERMINATED);
 768                 if (!nul_seen)
 769                         tprints("...");
 770         }
 771 }
 772
 773 void
 774 printpath(struct tcb *tcp, long addr)
 775 {
 776         /* Size must correspond to char path[] size in printpathn */
 777         printpathn(tcp, addr, PATH_MAX);
 778 }
 779
 780 /*
 781  * Print string specified by address `addr' and length `len'.
 782  * If `len' < 0, treat the string as a NUL-terminated string.
 783  * If string length exceeds `max_strlen', append `...' to the output.
 784  */
 785 void
 786 printstr(struct tcb *tcp, long addr, long len)
 787 {
 788         static char *str = NULL;
 789         static char *outstr;
 790         unsigned int size;
 791         unsigned int style;
 792         int ellipsis;
 793
 794         if (!addr) {
 795                 tprints("NULL");
 796                 return;
 797         }
 798         /* Allocate static buffers if they are not allocated yet. */
 799         if (!str) {
 800                 unsigned int outstr_size = 4 * max_strlen + /*for quotes and NUL:*/ 3;
 801
 802                 if (outstr_size / 4 != max_strlen)
 803                         die_out_of_memory();
 804                 str = xmalloc(max_strlen + 1);
 805                 outstr = xmalloc(outstr_size);
 806         }
 807
 808         size = max_strlen;
 809         if (len == -1) {
 810                 /*
 811                  * Treat as a NUL-terminated string: fetch one byte more
 812                  * because string_quote may look one byte ahead.
 813                  */
 814                 if (umovestr(tcp, addr, size + 1, str) < 0) {
 815                         tprintf("%#lx", addr);
 816                         return;
 817                 }
 818                 style = QUOTE_0_TERMINATED;
 819         }
 820         else {
 821                 if (size > (unsigned long)len)
 822                         size = (unsigned long)len;
 823                 if (umoven(tcp, addr, size, str) < 0) {
 824                         tprintf("%#lx", addr);
 825                         return;
 826                 }
 827                 style = 0;
 828         }
 829
 830         /* If string_quote didn't see NUL and (it was supposed to be ASCIZ str
 831          * or we were requested to print more than -s NUM chars)...
 832          */
 833         ellipsis = (string_quote(str, outstr, size, style) &&
 834                         (len < 0 || (unsigned long) len > max_strlen));
 835
 836         tprints(outstr);
 837         if (ellipsis)
 838                 tprints("...");
 839 }
 840
 841 void
 842 dumpiov_upto(struct tcb *tcp, int len, long addr, unsigned long data_size)
 843 {
 844 #if SUPPORTED_PERSONALITIES > 1
 845         union {
 846                 struct { uint32_t base; uint32_t len; } *iov32;
 847                 struct { uint64_t base; uint64_t len; } *iov64;
 848         } iovu;
 849 #define iov iovu.iov64
 850 #define sizeof_iov \
 851         (current_wordsize == 4 ? sizeof(*iovu.iov32) : sizeof(*iovu.iov64))
 852 #define iov_iov_base(i) \
 853         (current_wordsize == 4 ? (uint64_t) iovu.iov32[i].base : iovu.iov64[i].base)
 854 #define iov_iov_len(i) \
 855         (current_wordsize == 4 ? (uint64_t) iovu.iov32[i].len : iovu.iov64[i].len)
 856 #else
 857         struct iovec *iov;
 858 #define sizeof_iov sizeof(*iov)
 859 #define iov_iov_base(i) iov[i].iov_base
 860 #define iov_iov_len(i) iov[i].iov_len
 861 #endif
 862         int i;
 863         unsigned size;
 864
 865         size = sizeof_iov * len;
 866         /* Assuming no sane program has millions of iovs */
 867         if ((unsigned)len > 1024*1024 /* insane or negative size? */
 868             || (iov = malloc(size)) == NULL) {
 869                 error_msg("Out of memory");
 870                 return;
 871         }
 872         if (umoven(tcp, addr, size, iov) >= 0) {
 873                 for (i = 0; i < len; i++) {
 874                         unsigned long iov_len = iov_iov_len(i);
 875                         if (iov_len > data_size)
 876                                 iov_len = data_size;
 877                         if (!iov_len)
 878                                 break;
 879                         data_size -= iov_len;
 880                         /* include the buffer number to make it easy to
 881                          * match up the trace with the source */
 882                         tprintf(" * %lu bytes in buffer %d\n", iov_len, i);
 883                         dumpstr(tcp, (long) iov_iov_base(i), iov_len);
 884                 }
 885         }
 886         free(iov);
 887 #undef sizeof_iov
 888 #undef iov_iov_base
 889 #undef iov_iov_len
 890 #undef iov
 891 }
 892
 893 void
 894 dumpstr(struct tcb *tcp, long addr, int len)
 895 {
 896         static int strsize = -1;
 897         static unsigned char *str;
 898
 899         char outbuf[
 900                 (
 901                         (sizeof(
 902                         "xx xx xx xx xx xx xx xx  xx xx xx xx xx xx xx xx  "
 903                         "1234567890123456") + /*in case I'm off by few:*/ 4)
 904                 /*align to 8 to make memset easier:*/ + 7) & -8
 905         ];
 906         const unsigned char *src;
 907         int i;
 908
 909         memset(outbuf, ' ', sizeof(outbuf));
 910
 911         if (strsize < len + 16) {
 912                 free(str);
 913                 str = malloc(len + 16);
 914                 if (!str) {
 915                         strsize = -1;
 916                         error_msg("Out of memory");
 917                         return;
 918                 }
 919                 strsize = len + 16;
 920         }
 921
 922         if (umoven(tcp, addr, len, str) < 0)
 923                 return;
 924
 925         /* Space-pad to 16 bytes */
 926         i = len;
 927         while (i & 0xf)
 928                 str[i++] = ' ';
 929
 930         i = 0;
 931         src = str;
 932         while (i < len) {
 933                 char *dst = outbuf;
 934                 /* Hex dump */
 935                 do {
 936                         if (i < len) {
 937                                 *dst++ = "0123456789abcdef"[*src >> 4];
 938                                 *dst++ = "0123456789abcdef"[*src & 0xf];
 939                         }
 940                         else {
 941                                 *dst++ = ' ';
 942                                 *dst++ = ' ';
 943                         }
 944                         dst++; /* space is there by memset */
 945                         i++;
 946                         if ((i & 7) == 0)
 947                                 dst++; /* space is there by memset */
 948                         src++;
 949                 } while (i & 0xf);
 950                 /* ASCII dump */
 951                 i -= 16;
 952                 src -= 16;
 953                 do {
 954                         if (*src >= ' ' && *src < 0x7f)
 955                                 *dst++ = *src;
 956                         else
 957                                 *dst++ = '.';
 958                         src++;
 959                 } while (++i & 0xf);
 960                 *dst = '\0';
 961                 tprintf(" | %05x  %s |\n", i - 16, outbuf);
 962         }
 963 }
 964
 965 #ifdef HAVE_PROCESS_VM_READV
 966 /* C library supports this, but the kernel might not. */
 967 static bool process_vm_readv_not_supported = 0;
 968 #else
 969
 970 /* Need to do this since process_vm_readv() is not yet available in libc.
 971  * When libc is be updated, only "static bool process_vm_readv_not_supported"
 972  * line should remain.
 973  */
 974 #if !defined(__NR_process_vm_readv)
 975 # if defined(I386)
 976 #  define __NR_process_vm_readv  347
 977 # elif defined(X86_64)
 978 #  define __NR_process_vm_readv  310
 979 # elif defined(POWERPC)
 980 #  define __NR_process_vm_readv  351
 981 # endif
 982 #endif
 983
 984 #if defined(__NR_process_vm_readv)
 985 static bool process_vm_readv_not_supported = 0;
 986 /* Have to avoid duplicating with the C library headers. */
 987 static ssize_t strace_process_vm_readv(pid_t pid,
 988                  const struct iovec *lvec,
 989                  unsigned long liovcnt,
 990                  const struct iovec *rvec,
 991                  unsigned long riovcnt,
 992                  unsigned long flags)
 993 {
 994         return syscall(__NR_process_vm_readv, (long)pid, lvec, liovcnt, rvec, riovcnt, flags);
 995 }
 996 #define process_vm_readv strace_process_vm_readv
 997 #else
 998 static bool process_vm_readv_not_supported = 1;
 999 # define process_vm_readv(...) (errno = ENOSYS, -1)
1000 #endif
1001
1002 #endif /* end of hack */
1003
1004 static ssize_t
1005 vm_read_mem(pid_t pid, void *laddr, long raddr, size_t len)
1006 {
1007         const struct iovec local = {
1008                 .iov_base = laddr,
1009                 .iov_len = len
1010         };
1011         const struct iovec remote = {
1012                 .iov_base = (void *) raddr,
1013                 .iov_len = len
1014         };
1015
1016         return process_vm_readv(pid, &local, 1, &remote, 1, 0);
1017 }
1018
1019 /*
1020  * move `len' bytes of data from process `pid'
1021  * at address `addr' to our space at `our_addr'
1022  */
1023 int
1024 umoven(struct tcb *tcp, long addr, unsigned int len, void *our_addr)
1025 {
1026         char *laddr = our_addr;
1027         int pid = tcp->pid;
1028         unsigned int n, m, nread;
1029         union {
1030                 long val;
1031                 char x[sizeof(long)];
1032         } u;
1033
1034 #if SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4
1035         if (current_wordsize < sizeof(addr))
1036                 addr &= (1ul << 8 * current_wordsize) - 1;
1037 #endif
1038
1039         if (!process_vm_readv_not_supported) {
1040                 int r = vm_read_mem(pid, laddr, addr, len);
1041                 if ((unsigned int) r == len)
1042                         return 0;
1043                 if (r >= 0) {
1044                         error_msg("umoven: short read (%u < %u) @0x%lx",
1045                                   (unsigned int) r, len, addr);
1046                         return -1;
1047                 }
1048                 switch (errno) {
1049                         case ENOSYS:
1050                                 process_vm_readv_not_supported = 1;
1051                                 break;
1052                         case EPERM:
1053                                 /* operation not permitted, try PTRACE_PEEKDATA */
1054                                 break;
1055                         case ESRCH:
1056                                 /* the process is gone */
1057                                 return -1;
1058                         case EFAULT: case EIO:
1059                                 /* address space is inaccessible */
1060                                 return -1;
1061                         default:
1062                                 /* all the rest is strange and should be reported */
1063                                 perror_msg("process_vm_readv");
1064                                 return -1;
1065                 }
1066         }
1067
1068         nread = 0;
1069         if (addr & (sizeof(long) - 1)) {
1070                 /* addr not a multiple of sizeof(long) */
1071                 n = addr & (sizeof(long) - 1);  /* residue */
1072                 addr &= -sizeof(long);          /* aligned address */
1073                 errno = 0;
1074                 u.val = ptrace(PTRACE_PEEKDATA, pid, (char *) addr, 0);
1075                 switch (errno) {
1076                         case 0:
1077                                 break;
1078                         case ESRCH: case EINVAL:
1079                                 /* these could be seen if the process is gone */
1080                                 return -1;
1081                         case EFAULT: case EIO: case EPERM:
1082                                 /* address space is inaccessible */
1083                                 return -1;
1084                         default:
1085                                 /* all the rest is strange and should be reported */
1086                                 perror_msg("umoven: PTRACE_PEEKDATA pid:%d @0x%lx",
1087                                             pid, addr);
1088                                 return -1;
1089                 }
1090                 m = MIN(sizeof(long) - n, len);
1091                 memcpy(laddr, &u.x[n], m);
1092                 addr += sizeof(long);
1093                 laddr += m;
1094                 nread += m;
1095                 len -= m;
1096         }
1097         while (len) {
1098                 errno = 0;
1099                 u.val = ptrace(PTRACE_PEEKDATA, pid, (char *) addr, 0);
1100                 switch (errno) {
1101                         case 0:
1102                                 break;
1103                         case ESRCH: case EINVAL:
1104                                 /* these could be seen if the process is gone */
1105                                 return -1;
1106                         case EFAULT: case EIO: case EPERM:
1107                                 /* address space is inaccessible */
1108                                 if (nread) {
1109                                         perror_msg("umoven: short read (%u < %u) @0x%lx",
1110                                                    nread, nread + len, addr - nread);
1111                                 }
1112                                 return -1;
1113                         default:
1114                                 /* all the rest is strange and should be reported */
1115                                 perror_msg("umoven: PTRACE_PEEKDATA pid:%d @0x%lx",
1116                                             pid, addr);
1117                                 return -1;
1118                 }
1119                 m = MIN(sizeof(long), len);
1120                 memcpy(laddr, u.x, m);
1121                 addr += sizeof(long);
1122                 laddr += m;
1123                 nread += m;
1124                 len -= m;
1125         }
1126
1127         return 0;
1128 }
1129
1130 int
1131 umoven_or_printaddr(struct tcb *tcp, const long addr, const unsigned int len,
1132                     void *our_addr)
1133 {
1134         if (!addr) {
1135                 tprints("NULL");
1136                 return -1;
1137         }
1138         if (!verbose(tcp) || (exiting(tcp) && syserror(tcp)) ||
1139             umoven(tcp, addr, len, our_addr) < 0) {
1140                 tprintf("%#lx", addr);
1141                 return -1;
1142         }
1143         return 0;
1144 }
1145
1146 /*
1147  * Like `umove' but make the additional effort of looking
1148  * for a terminating zero byte.
1149  *
1150  * Returns < 0 on error, > 0 if NUL was seen,
1151  * (TODO if useful: return count of bytes including NUL),
1152  * else 0 if len bytes were read but no NUL byte seen.
1153  *
1154  * Note: there is no guarantee we won't overwrite some bytes
1155  * in laddr[] _after_ terminating NUL (but, of course,
1156  * we never write past laddr[len-1]).
1157  */
1158 int
1159 umovestr(struct tcb *tcp, long addr, unsigned int len, char *laddr)
1160 {
1161 #if SIZEOF_LONG == 4
1162         const unsigned long x01010101 = 0x01010101ul;
1163         const unsigned long x80808080 = 0x80808080ul;
1164 #elif SIZEOF_LONG == 8
1165         const unsigned long x01010101 = 0x0101010101010101ul;
1166         const unsigned long x80808080 = 0x8080808080808080ul;
1167 #else
1168 # error SIZEOF_LONG > 8
1169 #endif
1170
1171         int pid = tcp->pid;
1172         unsigned int n, m, nread;
1173         union {
1174                 unsigned long val;
1175                 char x[sizeof(long)];
1176         } u;
1177
1178 #if SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4
1179         if (current_wordsize < sizeof(addr))
1180                 addr &= (1ul << 8 * current_wordsize) - 1;
1181 #endif
1182
1183         nread = 0;
1184         if (!process_vm_readv_not_supported) {
1185                 const size_t page_size = get_pagesize();
1186                 const size_t page_mask = page_size - 1;
1187
1188                 while (len > 0) {
1189                         unsigned int chunk_len;
1190                         unsigned int end_in_page;
1191
1192                         /*
1193                          * Don't cross pages, otherwise we can get EFAULT
1194                          * and fail to notice that terminating NUL lies
1195                          * in the existing (first) page.
1196                          */
1197                         chunk_len = len > page_size ? page_size : len;
1198                         end_in_page = (addr + chunk_len) & page_mask;
1199                         if (chunk_len > end_in_page) /* crosses to the next page */
1200                                 chunk_len -= end_in_page;
1201
1202                         int r = vm_read_mem(pid, laddr, addr, chunk_len);
1203                         if (r > 0) {
1204                                 if (memchr(laddr, '\0', r))
1205                                         return 1;
1206                                 addr += r;
1207                                 laddr += r;
1208                                 nread += r;
1209                                 len -= r;
1210                                 continue;
1211                         }
1212                         switch (errno) {
1213                                 case ENOSYS:
1214                                         process_vm_readv_not_supported = 1;
1215                                         goto vm_readv_didnt_work;
1216                                 case ESRCH:
1217                                         /* the process is gone */
1218                                         return -1;
1219                                 case EPERM:
1220                                         /* operation not permitted, try PTRACE_PEEKDATA */
1221                                         if (!nread)
1222                                                 goto vm_readv_didnt_work;
1223                                         /* fall through */
1224                                 case EFAULT: case EIO:
1225                                         /* address space is inaccessible */
1226                                         if (nread) {
1227                                                 perror_msg("umovestr: short read (%d < %d) @0x%lx",
1228                                                            nread, nread + len, addr - nread);
1229                                         }
1230                                         return -1;
1231                                 default:
1232                                         /* all the rest is strange and should be reported */
1233                                         perror_msg("process_vm_readv");
1234                                         return -1;
1235                         }
1236                 }
1237                 return 0;
1238         }
1239  vm_readv_didnt_work:
1240
1241         if (addr & (sizeof(long) - 1)) {
1242                 /* addr not a multiple of sizeof(long) */
1243                 n = addr & (sizeof(long) - 1);  /* residue */
1244                 addr &= -sizeof(long);          /* aligned address */
1245                 errno = 0;
1246                 u.val = ptrace(PTRACE_PEEKDATA, pid, (char *)addr, 0);
1247                 switch (errno) {
1248                         case 0:
1249                                 break;
1250                         case ESRCH: case EINVAL:
1251                                 /* these could be seen if the process is gone */
1252                                 return -1;
1253                         case EFAULT: case EIO: case EPERM:
1254                                 /* address space is inaccessible */
1255                                 return -1;
1256                         default:
1257                                 /* all the rest is strange and should be reported */
1258                                 perror_msg("umovestr: PTRACE_PEEKDATA pid:%d @0x%lx",
1259                                             pid, addr);
1260                                 return -1;
1261                 }
1262                 m = MIN(sizeof(long) - n, len);
1263                 memcpy(laddr, &u.x[n], m);
1264                 while (n & (sizeof(long) - 1))
1265                         if (u.x[n++] == '\0')
1266                                 return 1;
1267                 addr += sizeof(long);
1268                 laddr += m;
1269                 nread += m;
1270                 len -= m;
1271         }
1272
1273         while (len) {
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                                 if (nread) {
1285                                         perror_msg("umovestr: short read (%d < %d) @0x%lx",
1286                                                    nread, nread + len, addr - nread);
1287                                 }
1288                                 return -1;
1289                         default:
1290                                 /* all the rest is strange and should be reported */
1291                                 perror_msg("umovestr: PTRACE_PEEKDATA pid:%d @0x%lx",
1292                                            pid, addr);
1293                                 return -1;
1294                 }
1295                 m = MIN(sizeof(long), len);
1296                 memcpy(laddr, u.x, m);
1297                 /* "If a NUL char exists in this word" */
1298                 if ((u.val - x01010101) & ~u.val & x80808080)
1299                         return 1;
1300                 addr += sizeof(long);
1301                 laddr += m;
1302                 nread += m;
1303                 len -= m;
1304         }
1305         return 0;
1306 }
1307
1308 /*
1309  * Iteratively fetch and print up to nmemb elements of elem_size size
1310  * from the array that starts at tracee's address start_addr.
1311  *
1312  * Array elements are being fetched to the address specified by elem_buf.
1313  *
1314  * The fetcher callback function specified by umoven_func should follow
1315  * the same semantics as umoven_or_printaddr function.
1316  *
1317  * The printer callback function specified by print_func is expected
1318  * to print something; if it returns false, no more iterations will be made.
1319  *
1320  * The pointer specified by opaque_data is passed to each invocation
1321  * of print_func callback function.
1322  *
1323  * This function prints:
1324  * - "NULL", if start_addr is NULL;
1325  * - "[]", if nmemb is 0;
1326  * - start_addr, if nmemb * elem_size overflows or wraps around;
1327  * - nothing, if the first element cannot be fetched
1328  *   (if umoven_func returns non-zero), but it is assumed that
1329  *   umoven_func has printed the address it failed to fetch data from;
1330  * - elements of the array, delimited by ", ", with the array itself
1331  *   enclosed with [] brackets.
1332  *
1333  * If abbrev(tcp) is true, then
1334  * - the maximum number of elements printed equals to max_strlen;
1335  * - "..." is printed instead of max_strlen+1 element
1336  *   and no more iterations will be made.
1337  *
1338  * This function returns true only if
1339  * - umoven_func has been called at least once AND
1340  * - umoven_func has not returned false.
1341  */
1342 bool
1343 print_array(struct tcb *tcp,
1344             const unsigned long start_addr,
1345             const size_t nmemb,
1346             void *const elem_buf,
1347             const size_t elem_size,
1348             int (*const umoven_func)(struct tcb *,
1349                                      long,
1350                                      unsigned int,
1351                                      void *),
1352             bool (*const print_func)(struct tcb *,
1353                                      void *elem_buf,
1354                                      size_t elem_size,
1355                                      void *opaque_data),
1356             void *const opaque_data)
1357 {
1358         if (!start_addr) {
1359                 tprints("NULL");
1360                 return false;
1361         }
1362
1363         if (!nmemb) {
1364                 tprints("[]");
1365                 return false;
1366         }
1367
1368         const size_t size = nmemb * elem_size;
1369         const unsigned long end_addr = start_addr + size;
1370
1371         if (end_addr <= start_addr || size / elem_size != nmemb) {
1372                 printaddr(start_addr);
1373                 return false;
1374         }
1375
1376         const unsigned long abbrev_end =
1377                 (abbrev(tcp) && max_strlen < nmemb) ?
1378                         start_addr + elem_size * max_strlen : end_addr;
1379         unsigned long cur;
1380
1381         for (cur = start_addr; cur < end_addr; cur += elem_size) {
1382                 if (cur != start_addr)
1383                         tprints(", ");
1384
1385                 if (umoven_func(tcp, cur, elem_size, elem_buf))
1386                         break;
1387
1388                 if (cur == start_addr)
1389                         tprints("[");
1390
1391                 if (cur >= abbrev_end) {
1392                         tprints("...");
1393                         cur = end_addr;
1394                         break;
1395                 }
1396
1397                 if (!print_func(tcp, elem_buf, elem_size, opaque_data)) {
1398                         cur = end_addr;
1399                         break;
1400                 }
1401         }
1402         if (cur != start_addr)
1403                 tprints("]");
1404
1405         return cur >= end_addr;
1406 }