l4/pkg/valgrind/src/valgrind-3.6.0-svn/coregrind/m_commandline.c

   1
   2 /*--------------------------------------------------------------------*/
   3 /*--- Command line handling.                       m_commandline.c ---*/
   4 /*--------------------------------------------------------------------*/
   5
   6 /*
   7    This file is part of Valgrind, a dynamic binary instrumentation
   8    framework.
   9
  10    Copyright (C) 2000-2010 Julian Seward
  11       jseward@acm.org
  12
  13    This program is free software; you can redistribute it and/or
  14    modify it under the terms of the GNU General Public License as
  15    published by the Free Software Foundation; either version 2 of the
  16    License, or (at your option) any later version.
  17
  18    This program is distributed in the hope that it will be useful, but
  19    WITHOUT ANY WARRANTY; without even the implied warranty of
  20    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  21    General Public License for more details.
  22
  23    You should have received a copy of the GNU General Public License
  24    along with this program; if not, write to the Free Software
  25    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  26    02111-1307, USA.
  27
  28    The GNU General Public License is contained in the file COPYING.
  29 */
  30
  31 #include "pub_core_basics.h"
  32 #include "pub_core_vki.h"
  33 #include "pub_core_libcassert.h"
  34 #include "pub_core_libcbase.h"
  35 #include "pub_core_libcfile.h"
  36 #include "pub_core_libcprint.h"
  37 #include "pub_core_libcproc.h"
  38 #include "pub_core_mallocfree.h"
  39 #include "pub_core_xarray.h"
  40 #include "pub_core_clientstate.h"
  41 #include "pub_core_commandline.h" /* self */
  42
  43
  44 /* Add a string to an expandable array of strings. */
  45
  46 static void add_string ( XArray* /* of HChar* */xa, HChar* str )
  47 {
  48    (void) VG_(addToXA)( xa, (void*)(&str) );
  49 }
  50
  51
  52 /* Read the contents of .valgrindrc in 'dir' into malloc'd memory. */
  53 // Note that we deliberately don't free the malloc'd memory.  See
  54 // comment at call site.
  55
  56 static HChar* read_dot_valgrindrc ( HChar* dir )
  57 {
  58    Int    n;
  59    SysRes fd;
  60    struct vg_stat stat_buf;
  61    HChar* f_clo = NULL;
  62    HChar  filename[VKI_PATH_MAX];
  63
  64    VG_(snprintf)(filename, VKI_PATH_MAX, "%s/.valgrindrc",
  65                            ( NULL == dir ? "" : dir ) );
  66    fd = VG_(open)(filename, 0, VKI_S_IRUSR);
  67    if ( !sr_isError(fd) ) {
  68       Int res = VG_(fstat)( sr_Res(fd), &stat_buf );
  69       // Ignore if not owned by current user or world writeable (CVE-2008-4865)
  70       if (!res && stat_buf.uid == VG_(geteuid)()
  71           && (!(stat_buf.mode & VKI_S_IWOTH))) {
  72          if ( stat_buf.size > 0 ) {
  73             f_clo = VG_(malloc)("commandline.rdv.1", stat_buf.size+1);
  74             vg_assert(f_clo);
  75             n = VG_(read)(sr_Res(fd), f_clo, stat_buf.size);
  76             if (n == -1) n = 0;
  77             vg_assert(n >= 0 && n <= stat_buf.size+1);
  78             f_clo[n] = '\0';
  79          }
  80       }
  81       else
  82          VG_(message)(Vg_UserMsg,
  83                "%s was not read as it is world writeable or not owned by the "
  84                "current user\n", filename);
  85
  86       VG_(close)(sr_Res(fd));
  87    }
  88    return f_clo;
  89 }
  90
  91
  92 // Add args from a string into VG_(args_for_valgrind), splitting the
  93 // string at whitespace and adding each component as a separate arg.
  94
  95 static void add_args_from_string ( HChar* s )
  96 {
  97    HChar* tmp;
  98    HChar* cp = s;
  99    vg_assert(cp);
 100    while (True) {
 101       // We have alternating sequences: blanks, non-blanks, blanks...
 102       // copy the non-blanks sequences, and add terminating '\0'
 103       while (VG_(isspace)(*cp)) cp++;
 104       if (*cp == 0) break;
 105       tmp = cp;
 106       while ( !VG_(isspace)(*cp) && *cp != 0 ) cp++;
 107       if ( *cp != 0 ) *cp++ = '\0';       // terminate if not the last
 108       add_string( VG_(args_for_valgrind), tmp );
 109    }
 110 }
 111
 112
 113 /* Split up the args presented by the launcher to m_main.main(), and
 114    park them in VG_(args_for_client) and VG_(args_for_valgrind).
 115
 116    The resulting arg list is the concatenation of the following:
 117    - contents of ~/.valgrindrc
 118    - contents of $VALGRIND_OPTS
 119    - contents of ./.valgrindrc
 120    - args from the command line
 121    in the stated order.
 122
 123    VG_(args_for_valgrind_noexecpass) is set to be the number of items
 124    in the first three categories.  They are not passed to child invokations
 125    at exec, whereas the last group is.
 126
 127    If the last group contains --command-line-only=yes, then the
 128    first three groups are left empty.
 129
 130    Scheme: first examine the last group (the supplied argc/argv).
 131    It should look like this.
 132
 133       args-for-v  exe_name  args-for-c
 134
 135    args-for-v are taken until either they don't start with '-' or
 136    a "--" is seen.
 137
 138    The exe name and args-for-c are recorded without further ado.
 139    Note that args-for-c[0] is the first real arg for the client, not
 140    its executable name.
 141
 142    args-for-v are then copied into tmp_xarray.
 143
 144    if args-for-v does not include --command-line-only=yes:
 145       contents of ~/.valgrindrc, $VALGRIND_OPTS and ./.valgrindrc
 146       are copied into VG_(args_for_valgrind).
 147    else
 148       VG_(args_for_valgrind) is made empty.
 149
 150    Finally, tmp_xarray is copied onto the end of VG_(args_for_valgrind).
 151 */
 152
 153 void VG_(split_up_argv)( Int argc, HChar** argv )
 154 {
 155           Int  i;
 156           Bool augment = True;
 157    static Bool already_called = False;
 158
 159    XArray* /* of HChar* */ tmp_xarray;
 160
 161    /* This function should be called once, at startup, and then never
 162       again. */
 163    vg_assert(!already_called);
 164    already_called = True;
 165
 166    tmp_xarray = VG_(newXA)( VG_(malloc), "commandline.sua.1",
 167                             VG_(free), sizeof(HChar*) );
 168    vg_assert(tmp_xarray);
 169
 170    vg_assert( ! VG_(args_for_valgrind) );
 171    VG_(args_for_valgrind)
 172       = VG_(newXA)( VG_(malloc), "commandline.sua.2",
 173                     VG_(free), sizeof(HChar*) );
 174    vg_assert( VG_(args_for_valgrind) );
 175
 176    vg_assert( ! VG_(args_for_client) );
 177    VG_(args_for_client)
 178       = VG_(newXA)( VG_(malloc), "commandline.sua.3",
 179                     VG_(free), sizeof(HChar*) );
 180    vg_assert( VG_(args_for_client) );
 181
 182    /* Collect up the args-for-V. */
 183    i = 1; /* skip the exe (stage2) name. */
 184    for (; i < argc; i++) {
 185       vg_assert(argv[i]);
 186       if (0 == VG_(strcmp)(argv[i], "--")) {
 187          i++;
 188          break;
 189       }
 190       if (0 == VG_(strcmp)(argv[i], "--command-line-only=yes"))
 191          augment = False;
 192       if (argv[i][0] != '-')
 193         break;
 194       add_string( tmp_xarray, argv[i] );
 195    }
 196
 197    /* Should now be looking at the exe name. */
 198    if (i < argc) {
 199       vg_assert(argv[i]);
 200       VG_(args_the_exename) = argv[i];
 201       i++;
 202    }
 203
 204    /* The rest are args for the client. */
 205    for (; i < argc; i++) {
 206       vg_assert(argv[i]);
 207       add_string( VG_(args_for_client), argv[i] );
 208    }
 209
 210    /* Get extra args from ~/.valgrindrc, $VALGRIND_OPTS and
 211       ./.valgrindrc into VG_(args_for_valgrind). */
 212    if (augment) {
 213       // read_dot_valgrindrc() allocates the return value with
 214       // VG_(malloc)().  We do not free f1_clo and f2_clo as they get
 215       // put into VG_(args_for_valgrind) and so must persist.
 216       HChar* home    = VG_(getenv)("HOME");
 217       HChar* f1_clo  = home ? read_dot_valgrindrc( home ) : NULL;
 218       HChar* env_clo = VG_(strdup)( "commandline.sua.4",
 219                                     VG_(getenv)(VALGRIND_OPTS) );
 220       HChar* f2_clo  = NULL;
 221
 222       // Don't read ./.valgrindrc if "." is the same as "$HOME", else its
 223       // contents will be applied twice. (bug #142488)
 224       if (home) {
 225          HChar cwd[VKI_PATH_MAX+1];
 226          Bool  cwd_ok = VG_(get_startup_wd)(cwd, VKI_PATH_MAX);
 227          f2_clo = ( (cwd_ok && VG_STREQ(home, cwd))
 228                        ? NULL : read_dot_valgrindrc(".") );
 229       }
 230
 231       if (f1_clo)  add_args_from_string( f1_clo );
 232       if (env_clo) add_args_from_string( env_clo );
 233       if (f2_clo)  add_args_from_string( f2_clo );
 234    }
 235
 236    /* .. and record how many extras we got. */
 237    VG_(args_for_valgrind_noexecpass)
 238       = VG_(sizeXA)( VG_(args_for_valgrind) );
 239
 240    /* Finally, copy tmp_xarray onto the end. */
 241    for (i = 0; i < VG_(sizeXA)( tmp_xarray ); i++)
 242       add_string( VG_(args_for_valgrind),
 243                   * (HChar**)VG_(indexXA)( tmp_xarray, i ) );
 244
 245    VG_(deleteXA)( tmp_xarray );
 246 }
 247
 248 /*--------------------------------------------------------------------*/
 249 /*--- end                                                          ---*/
 250 /*--------------------------------------------------------------------*/