Question

I am getting some perl compile errors trying to convert these unix commands to perl.
The use of single quotes and double quotes is throwing me off (see below: my $curlcmd).

Here’s the working unix commands executed in order:

export CERT=`/dev/bin/util --show dev.testaccnt | awk '{print $2}'`

/usr/bin/curl -c /home/foobar/cookee.txt --certify /dev/key.crt \
     --header "FooBar-Util:'${CERT}'" \
     https://devhost.foobar.com:4443/fs/workflow/data/source/productname?val=Summ

I want to do the same within Perl:

#Build cmd in perl
my $cookie='/home/foobar/cookee.txt';
my $certkey='/dev/key.crt';
my $fsProxyHostPort='devhost.foobar.com:4443';
my $fsPath='workflow/data/source/productname';
my $fsProxyOperation='Summ';
my $fsProxyURL="https://$fsProxyHostPort/fs/$fsPath?val=$fsProxyOperation";

#Get cert
my $cert=qx(/dev/bin/pass-util --show foobar.dev.testaccnt | awk '{print \$2}');

Here’s where I am having trouble executing it:

my $curlcmd = qx(/usr/bin/curl -c $cookie --certify $certkey --header "FooBar-Util:'${" . $cert . "}'". $fsProxyURL);

Can someone show me how to setup these commands in Perl correctly?

Answer 1

In the shell script, you have (in part):

--header "FooBar-Util:'${CERT}'"

This generates something like:

--header FooBar-Util:'data-from-certificate'

where the curl command gets to see those single quotes. To get the same result in Perl, you will need:

my $header = "FooBar-Util:'$cert'";
my $out = qx(/usr/bin/curl -c $cookie --certify $certkey --header $header $fsProxyURL);

Changes:

• Lost the ${ ... } notation.
• Lost the concatenation operations.

In situations where you have problems seeing the argument list sent to a command, I recommend using a program analogous to the shell echo command, but which lists each argument on its own line, rather than as a space-separated set of arguments on a single line. I call my version of this al for ‘argument list’. If you test your commands (for example, the shell version) by prefixing the whole command line with al, you get to see the arguments that curl would see. You can then do the same in Perl to compare the arguments curl sees at the shell with the ones given it by Perl. Then you can fix the problems, typically much more easily.

For debugging with al:

my @lines = qx(al /usr/bin/curl -c $cookie --certify $certkey --header $header $fsProxyURL);
foreach my $line (@lines) { print "$line"; }

---

If you want to write al in Perl:

#!/usr/bin/env perl
foreach my $arg (@ARGV) { print "$arg\n"; }

---

Adventures in Validating an Answer

Fortunately, I usually check what I write as answers – and what is written above is mostly accurate, except for one detail; Perl manages to invoke the shell on the command, and in doing so, the shell cleans out the single-quotes:

my $cert = 'certificate-info';
my $fsProxyURL = 'https://www.example.com/fsProxy';
my $cookie = 'cookie';
my $certkey = 'cert-key';
my $header = "FooBar-Util:'$cert'";
#my @out = qx(al /usr/bin/curl -c $cookie --certify $certkey --header $header $fsProxyURL);
my @cmdargs = ( 'al', '/usr/bin/curl', '-c', $cookie, '--certify', $certkey, '--header', $header, $fsProxyURL);
print "System:\n";
system @cmdargs;
print "\nQX command:\n";
my @lines = qx(@cmdargs);
foreach my $line (@lines) { print "$line"; }

This yields:

System:
/usr/bin/curl
-c
cookie
--certify
cert-key
--header
FooBar-Util:'certificate-info'
https://www.example.com/fsProxy

QX command:
/usr/bin/curl
-c
cookie
--certify
cert-key
--header
FooBar-Util:certificate-info
https://www.example.com/fsProxy

Note the difference in the `FooBar lines!

At this point, you start to wonder what’s the least unclean way to work around this. If you want to use the qx// operator, then you probably do:

my $header = "FooBar-Util:\\'$cert\\'";

This yields the variant outputs (system then qx//):

FooBar-Util:\'certificate-info\'

FooBar-Util:'certificate-info'

So, the qx// notation now gives the single quotes to the executed command, just as in the shell script. This meets the goal, so I’m going to suggest that it is ‘OK’ for you; I’m just not sure that I’d actually adopt it in my own code, but I don’t have a cleaner mechanism on hand. I’d like to be able to use the system plus ‘array of arguments’ mechanism, while still capturing the output, but I haven’t checked whether there’s a sensible (meaning relatively easy) way to do that.

One other passing comment; if any of your arguments contained spaces, you’d have to be excruciatingly careful with what gets passed through the shell. Having the al command available really pays off then. You can’t identify which spaces in echo output are parts of one argument and which are separators provided by echo.