Shell Scripting：使用\\ $引用变量

Question

I've just started learning about shell scripting and have been trying to workout what's going on in this script: http://dev.cloudtrax.com/wiki/ng-cs-ip-logging

Specifically, I can't wrap my head around a couple of lines that use "\\$foo" for example:

[ -z "\\$plug_event" ] && return

Everything I've read and learned about shell scripting has me believing that "\\$plug_event" would evaluate as a string whose value is $plug_event . This would mean that the above test would always return a 1 (ie the test was false), right? If so, what's the point?

I've found plenty on quotes around variables but so far I haven't been able to find a single example of this kind of usage. Is it just a typo? Unfortunately I'm nowhere near experienced enough to tell the difference yet.

All help is much appreciated, and a link to a relevant document would certainly suffice.

Cheers, Kyle

Answer 1

The reason for escaping all the $ s is that those lines are part of here-docs

The command cat > /etc/ip_logging.sh << EOF will output all of following text into /etc/ip_logging.sh until it hits EOF , and not to evaluate the variables in the current script, the $ has to be escaped.

Alternatively, and to make the code easier to read, putting the terminating string in single quotes will disable variable substitution in the heredoc:

cat > /etc/ip_logging.sh << 'EOF'
    [ -z "$plug_event" ]
    #other stuff
EOF

will have same result, sans the escaped $ and other shell special characters

Answer 2

The test:

[ -z "\$plug_event" ]

is pointless. The string is never zero length; the return after it is never executed.

Whoever wrote that code did not understand what they were doing ... unless there are extenuating circumstances such as it is part of a here-doc which is then treated specially.

But, standing on its own, the statement is pointless.

...look at the code...

# create iptables script on the fly
cat > /etc/ip_logging.sh << EOF
#!/bin/sh

. /etc/functions.sh

install_rule() {
        config_get plug_event "\$1" plug_event

        [ -z "\$plug_event" ] && return

        pub_ip=\$(uci get dhcp.pub.ipaddr)
        pub_mask=\$(uci get dhcp.pub.netmask)

        priv_ip=\$(uci get dhcp.priv.ipaddr)
        priv_mask=\$(uci get dhcp.priv.netmask)

        iptables -I POSTROUTING -t nat -o br-\$1 -s \$pub_ip/\$pub_mask -j LOG --log-level debug --log-prefix "iplog: "
        iptables -I POSTROUTING -t nat -o br-\$1 -s \$priv_ip/\$priv_mask -j LOG --log-level debug --log-prefix "iplog: "
}

config_load network
config_foreach install_rule interface
EOF

Someone did know more or less what they are up to; they are writing a script in a here-doc and need the parameters expanded when the script that's being generated is executed, not when it is created. They could have simplified life by using:

# create iptables script on the fly
cat > /etc/ip_logging.sh << 'EOF'

The quotes around the end marker mean that no expansions are done in the here-doc, so all the backslashes could go.

The bash manual is your friend. Shell parameter expansion is one relevant section, but it covers actual expansions, not suppressed expansions.