So I want to create a shell script that ultimately exec's a command, after doing something like, say, setting an environment variable first:
#!/bin/sh export MY_VAR=MY_VAL exec my_command $*
(The point of using `exec my_command` rather than plain `my_command` is to not leave a /bin/sh process waiting for my_command that shows up in pstree and makes my_command not see its "real" parent process and so on.)
Simple enough, except it doesn't work. If you run the script with `script "a b" c`, my_command's arguments will be a b c (that's three arguments instead of the original two).
(Update - as pointed out in the comments, "$@" instead of $* works fine, and is perfectly sufficient for my example where all the script does is setting an env var. "$@" isn't enough if you need to fiddle with the arguments - if you need to do that, read on, otherwise just use "$@".)
A common workaround seems to be, you iterate over the arguments and you quote them and then eval:
#!/bin/sh export MY_VAR=MY_VAL args= for arg in "$@"; do args="$args '$arg'" done eval exec my_command $args
Not so simple, but works better: "a b" c will indeed be passed to my_command as "a b" c.
However, it doesn't work if the arguments contain single quotes. If you pass "'a'" (that's double quote, single quote, the character a, single quote, double quote), my_command will get plain a. If you pass "'a b'" (double, single, a, space, b, single, double), my_command will get two arguments, a b, instead of one, 'a b'.
What to do? One potential workaround is escaping quotes: replacing ' with \', etc. Perhaps someone with sufficiently thorough understanding of the Unix shell could pull it off; personally, I wouldn't trust myself to take care of all the special cases, or even to fully enumerate them.
So instead, what works for me (or so I hope) is, instead of creating a string of values by concatenating arguments, I make a string of references to the arguments using the variables $1, $2, etc. How many of those are needed - is the last one $3 or $7? Ah, we can use $# to figure that out:
#!/bin/sh export MY_VAR=MY_VAL nargs=$# args= while [ $nargs -gt 0 ] do args="\"\$$nargs\" $args" nargs=`expr $nargs - 1` done eval exec my_command $args
This handsome code generates, given three arguments, the string "$1" "$2" "$3", and then evals it to get the three argument values, which apparently can't cause quoting complications that are dependent on the actual argument values. With five arguments, the string "$1" "$2" "$3" "$4" "$5" is generated, and so on. (You'd use more code if you wanted to mangle some of the arguments, which is the sole reason to do this sort of things as opposed to using "$@".)
If you're good at Unix and you know a less "\"\$$ugly\" $way" to do this, and/or a more correct one, do tell.
(Why am I writing shell scripts in the first place, you ask? There are reasons for this too, and reasons for the reasons; there always are.)
Update 2: according to a comment, $1-$9 work in sh, but $10 and up do not; they do work in bash, which is what you actually get when you ask for /bin/sh on some systems but not others.
I really ought to try harder to stay away from shell scripting. I mean, I know I shouldn't, but I keep coming back. I'm like those tribesmen around the world who can't resist the urge to drink alcohol and having genes making alcohol particularly addictive and bad for their health. I clearly don't have the genetic makeup that would make *sh reasonably harmless for me.