granicus.if.org Git - strace/blob - execve.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-1996 Rick Sladkey <jrs@world.std.com>
   5  * Copyright (c) 1996-1999 Wichert Akkerman <wichert@cistron.nl>
   6  * Copyright (c) 2007 Roland McGrath <roland@redhat.com>
   7  * Copyright (c) 2011-2012 Denys Vlasenko <vda.linux@googlemail.com>
   8  * Copyright (c) 2010-2015 Dmitry V. Levin <ldv@altlinux.org>
   9  * Copyright (c) 2014-2017 The strace developers.
  10  * All rights reserved.
  11  *
  12  * Redistribution and use in source and binary forms, with or without
  13  * modification, are permitted provided that the following conditions
  14  * are met:
  15  * 1. Redistributions of source code must retain the above copyright
  16  *    notice, this list of conditions and the following disclaimer.
  17  * 2. Redistributions in binary form must reproduce the above copyright
  18  *    notice, this list of conditions and the following disclaimer in the
  19  *    documentation and/or other materials provided with the distribution.
  20  * 3. The name of the author may not be used to endorse or promote products
  21  *    derived from this software without specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  24  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  25  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  26  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  27  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  28  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  29  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  30  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  31  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  32  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  33  */
  34
  35 #include "defs.h"
  36
  37 static void
  38 printargv(struct tcb *const tcp, kernel_ulong_t addr)
  39 {
  40         if (!addr || !verbose(tcp)) {
  41                 printaddr(addr);
  42                 return;
  43         }
  44
  45         const char *const start_sep = "[";
  46         const char *sep = start_sep;
  47         const unsigned int wordsize = current_wordsize;
  48         unsigned int n;
  49
  50         for (n = 0; addr; sep = ", ", addr += wordsize, ++n) {
  51                 union {
  52                         unsigned int p32;
  53                         kernel_ulong_t p64;
  54                         char data[sizeof(kernel_ulong_t)];
  55                 } cp;
  56
  57                 if (umoven(tcp, addr, wordsize, cp.data)) {
  58                         if (sep == start_sep)
  59                                 printaddr(addr);
  60                         else
  61                                 tprints(", ???]");
  62                         return;
  63                 }
  64                 if (!(wordsize < sizeof(cp.p64) ? cp.p32 : cp.p64)) {
  65                         if (sep == start_sep)
  66                                 tprints(start_sep);
  67                         break;
  68                 }
  69                 if (abbrev(tcp) && n >= max_strlen) {
  70                         tprintf("%s...", sep);
  71                         break;
  72                 }
  73                 tprints(sep);
  74                 printstr(tcp, wordsize < sizeof(cp.p64) ? cp.p32 : cp.p64);
  75         }
  76         tprints("]");
  77 }
  78
  79 static void
  80 printargc(struct tcb *const tcp, kernel_ulong_t addr)
  81 {
  82         printaddr(addr);
  83
  84         if (!addr || !verbose(tcp))
  85                 return;
  86
  87         bool unterminated = false;
  88         unsigned int count = 0;
  89         char *cp = NULL;
  90
  91         for (; addr; addr += current_wordsize, ++count) {
  92                 if (umoven(tcp, addr, current_wordsize, &cp)) {
  93                         if (!count)
  94                                 return;
  95
  96                         unterminated = true;
  97                         break;
  98                 }
  99                 if (!cp)
 100                         break;
 101         }
 102         tprintf_comment("%u var%s%s",
 103                 count, count == 1 ? "" : "s",
 104                 unterminated ? ", unterminated" : "");
 105 }
 106
 107 static void
 108 decode_execve(struct tcb *tcp, const unsigned int index)
 109 {
 110         printpath(tcp, tcp->u_arg[index + 0]);
 111         tprints(", ");
 112
 113         printargv(tcp, tcp->u_arg[index + 1]);
 114         tprints(", ");
 115
 116         (abbrev(tcp) ? printargc : printargv) (tcp, tcp->u_arg[index + 2]);
 117 }
 118
 119 SYS_FUNC(execve)
 120 {
 121         decode_execve(tcp, 0);
 122
 123         return RVAL_DECODED;
 124 }
 125
 126 SYS_FUNC(execveat)
 127 {
 128         print_dirfd(tcp, tcp->u_arg[0]);
 129         decode_execve(tcp, 1);
 130         tprints(", ");
 131         printflags(at_flags, tcp->u_arg[4], "AT_???");
 132
 133         return RVAL_DECODED;
 134 }
 135
 136 #if defined(SPARC) || defined(SPARC64)
 137 SYS_FUNC(execv)
 138 {
 139         printpath(tcp, tcp->u_arg[0]);
 140         tprints(", ");
 141         printargv(tcp, tcp->u_arg[1]);
 142
 143         return RVAL_DECODED;
 144 }
 145 #endif /* SPARC || SPARC64 */