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  * 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
  36 static void
  37 printargv(struct tcb *tcp, long addr)
  38 {
  39         if (!addr || !verbose(tcp)) {
  40                 printaddr(addr);
  41                 return;
  42         }
  43
  44         const char *const start_sep = "[";
  45         const char *sep = start_sep;
  46         const unsigned int wordsize = current_wordsize;
  47         unsigned int n;
  48
  49         for (n = 0; addr; sep = ", ", addr += wordsize, ++n) {
  50                 union {
  51                         unsigned int p32;
  52                         unsigned long p64;
  53                         char data[sizeof(long)];
  54                 } cp;
  55
  56                 if (umoven(tcp, addr, wordsize, cp.data)) {
  57                         if (sep == start_sep)
  58                                 printaddr(addr);
  59                         else
  60                                 tprints(", ???]");
  61                         return;
  62                 }
  63                 if (!(wordsize < sizeof(cp.p64) ? cp.p32 : cp.p64)) {
  64                         if (sep == start_sep)
  65                                 tprints(start_sep);
  66                         break;
  67                 }
  68                 if (abbrev(tcp) && n >= max_strlen) {
  69                         tprintf("%s...", sep);
  70                         break;
  71                 }
  72                 tprints(sep);
  73                 printstr(tcp, wordsize < sizeof(cp.p64) ? cp.p32 : cp.p64, -1);
  74         }
  75         tprints("]");
  76 }
  77
  78 static void
  79 printargc(struct tcb *tcp, long addr)
  80 {
  81         if (!addr || !verbose(tcp)) {
  82                 printaddr(addr);
  83                 return;
  84         }
  85
  86         bool unterminated = false;
  87         unsigned int count = 0;
  88         char *cp = NULL;
  89
  90         for (; addr; addr += current_wordsize, ++count) {
  91                 if (umoven(tcp, addr, current_wordsize, &cp)) {
  92                         if (count) {
  93                                 unterminated = true;
  94                                 break;
  95                         }
  96                         printaddr(addr);
  97                         return;
  98                 }
  99                 if (!cp)
 100                         break;
 101         }
 102         tprintf("[/* %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 */