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  * SPDX-License-Identifier: LGPL-2.1-or-later
  13  */
  14
  15 #include "defs.h"
  16
  17 static void
  18 printargv(struct tcb *const tcp, kernel_ulong_t addr)
  19 {
  20         if (!addr || !verbose(tcp)) {
  21                 printaddr(addr);
  22                 return;
  23         }
  24
  25         const char *const start_sep = "[";
  26         const char *sep = start_sep;
  27         const unsigned int wordsize = current_wordsize;
  28         unsigned int n;
  29
  30         for (n = 0; addr; sep = ", ", addr += wordsize, ++n) {
  31                 union {
  32                         unsigned int p32;
  33                         kernel_ulong_t p64;
  34                         char data[sizeof(kernel_ulong_t)];
  35                 } cp;
  36
  37                 if (umoven(tcp, addr, wordsize, cp.data)) {
  38                         if (sep == start_sep)
  39                                 printaddr(addr);
  40                         else {
  41                                 tprints(", ...");
  42                                 printaddr_comment(addr);
  43                                 tprints("]");
  44                         }
  45                         return;
  46                 }
  47                 if (!(wordsize < sizeof(cp.p64) ? cp.p32 : cp.p64)) {
  48                         if (sep == start_sep)
  49                                 tprints(start_sep);
  50                         break;
  51                 }
  52                 if (abbrev(tcp) && n >= max_strlen) {
  53                         tprintf("%s...", sep);
  54                         break;
  55                 }
  56                 tprints(sep);
  57                 printstr(tcp, wordsize < sizeof(cp.p64) ? cp.p32 : cp.p64);
  58         }
  59         tprints("]");
  60 }
  61
  62 static void
  63 printargc(struct tcb *const tcp, kernel_ulong_t addr)
  64 {
  65         printaddr(addr);
  66
  67         if (!addr || !verbose(tcp))
  68                 return;
  69
  70         bool unterminated = false;
  71         unsigned int count = 0;
  72         char *cp = NULL;
  73
  74         for (; addr; addr += current_wordsize, ++count) {
  75                 if (umoven(tcp, addr, current_wordsize, &cp)) {
  76                         if (!count)
  77                                 return;
  78
  79                         unterminated = true;
  80                         break;
  81                 }
  82                 if (!cp)
  83                         break;
  84         }
  85         tprintf_comment("%u var%s%s",
  86                 count, count == 1 ? "" : "s",
  87                 unterminated ? ", unterminated" : "");
  88 }
  89
  90 static void
  91 decode_execve(struct tcb *tcp, const unsigned int index)
  92 {
  93         printpath(tcp, tcp->u_arg[index + 0]);
  94         tprints(", ");
  95
  96         printargv(tcp, tcp->u_arg[index + 1]);
  97         tprints(", ");
  98
  99         (abbrev(tcp) ? printargc : printargv) (tcp, tcp->u_arg[index + 2]);
 100 }
 101
 102 SYS_FUNC(execve)
 103 {
 104         decode_execve(tcp, 0);
 105
 106         return RVAL_DECODED;
 107 }
 108
 109 SYS_FUNC(execveat)
 110 {
 111         print_dirfd(tcp, tcp->u_arg[0]);
 112         decode_execve(tcp, 1);
 113         tprints(", ");
 114         printflags(at_flags, tcp->u_arg[4], "AT_???");
 115
 116         return RVAL_DECODED;
 117 }
 118
 119 #if defined(SPARC) || defined(SPARC64)
 120 SYS_FUNC(execv)
 121 {
 122         printpath(tcp, tcp->u_arg[0]);
 123         tprints(", ");
 124         printargv(tcp, tcp->u_arg[1]);
 125
 126         return RVAL_DECODED;
 127 }
 128 #endif /* SPARC || SPARC64 */