granicus.if.org Git - strace/blob - dirent.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) 2005-2015 Dmitry V. Levin <ldv@altlinux.org>
   7  * Copyright (c) 2014-2017 The strace developers.
   8  * All rights reserved.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  * 3. The name of the author may not be used to endorse or promote products
  19  *    derived from this software without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  22  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  23  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  24  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  25  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  26  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  27  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  28  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  29  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  30  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31  */
  32
  33 #include "defs.h"
  34
  35 #include DEF_MPERS_TYPE(kernel_dirent)
  36
  37 #include MPERS_DEFS
  38
  39 #define D_NAME_LEN_MAX 256
  40
  41 static void
  42 print_old_dirent(struct tcb *const tcp, const kernel_ulong_t addr)
  43 {
  44         kernel_dirent d;
  45
  46         if (umove_or_printaddr(tcp, addr, &d))
  47                 return;
  48
  49         tprintf("{d_ino=%llu, d_off=%llu, d_reclen=%u, d_name=",
  50                 zero_extend_signed_to_ull(d.d_ino),
  51                 zero_extend_signed_to_ull(d.d_off), d.d_reclen);
  52         if (d.d_reclen > D_NAME_LEN_MAX)
  53                 d.d_reclen = D_NAME_LEN_MAX;
  54         printpathn(tcp, addr + offsetof(kernel_dirent, d_name), d.d_reclen);
  55         tprints("}");
  56 }
  57
  58 SYS_FUNC(readdir)
  59 {
  60         if (entering(tcp)) {
  61                 printfd(tcp, tcp->u_arg[0]);
  62                 tprints(", ");
  63         } else {
  64                 if (tcp->u_rval == 0)
  65                         printaddr(tcp->u_arg[1]);
  66                 else
  67                         print_old_dirent(tcp, tcp->u_arg[1]);
  68                 /* Not much point in printing this out, it is always 1. */
  69                 if (tcp->u_arg[2] != 1)
  70                         tprintf(", %" PRI_klu, tcp->u_arg[2]);
  71         }
  72         return 0;
  73 }
  74
  75 SYS_FUNC(getdents)
  76 {
  77         unsigned int i, len, dents = 0;
  78         unsigned char *buf;
  79
  80         if (entering(tcp)) {
  81                 printfd(tcp, tcp->u_arg[0]);
  82                 return 0;
  83         }
  84
  85         const unsigned int count = tcp->u_arg[2];
  86
  87         if (syserror(tcp) || !verbose(tcp)) {
  88                 tprints(", ");
  89                 printaddr(tcp->u_arg[1]);
  90                 tprintf(", %u", count);
  91                 return 0;
  92         }
  93
  94         /* Beware of insanely large or too small values in tcp->u_rval */
  95         if (tcp->u_rval > 1024*1024)
  96                 len = 1024*1024;
  97         else if (tcp->u_rval < (int) sizeof(kernel_dirent))
  98                 len = 0;
  99         else
 100                 len = tcp->u_rval;
 101
 102         if (len) {
 103                 buf = malloc(len);
 104                 if (!buf || umoven(tcp, tcp->u_arg[1], len, buf) < 0) {
 105                         tprints(", ");
 106                         printaddr(tcp->u_arg[1]);
 107                         tprintf(", %u", count);
 108                         free(buf);
 109                         return 0;
 110                 }
 111         } else {
 112                 buf = NULL;
 113         }
 114
 115         tprints(",");
 116         if (!abbrev(tcp))
 117                 tprints(" [");
 118         for (i = 0; len && i <= len - sizeof(kernel_dirent); ) {
 119                 kernel_dirent *d = (kernel_dirent *) &buf[i];
 120
 121                 if (!abbrev(tcp)) {
 122                         int oob = d->d_reclen < sizeof(kernel_dirent) ||
 123                                   i + d->d_reclen - 1 >= len;
 124                         int d_name_len = oob ? len - i : d->d_reclen;
 125                         d_name_len -= offsetof(kernel_dirent, d_name) + 1;
 126                         if (d_name_len > D_NAME_LEN_MAX)
 127                                 d_name_len = D_NAME_LEN_MAX;
 128
 129                         tprintf("%s{d_ino=%llu, d_off=%llu, d_reclen=%u"
 130                                 ", d_name=", i ? ", " : "",
 131                                 zero_extend_signed_to_ull(d->d_ino),
 132                                 zero_extend_signed_to_ull(d->d_off),
 133                                 d->d_reclen);
 134
 135                         print_quoted_cstring(d->d_name, d_name_len);
 136
 137                         tprints(", d_type=");
 138                         if (oob)
 139                                 tprints("?");
 140                         else
 141                                 printxval(dirent_types, buf[i + d->d_reclen - 1], "DT_???");
 142                         tprints("}");
 143                 }
 144                 dents++;
 145                 if (d->d_reclen < sizeof(kernel_dirent)) {
 146                         tprints_comment("d_reclen < sizeof(struct dirent)");
 147                         break;
 148                 }
 149                 i += d->d_reclen;
 150         }
 151         if (!abbrev(tcp))
 152                 tprints("]");
 153         else
 154                 tprintf_comment("%u entries", dents);
 155         tprintf(", %u", count);
 156         free(buf);
 157         return 0;
 158 }