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