c++ - Way to know if Linux command exists before executing it - c++

Question

I'd like to write a function that generate gz file. The function will only be operational on Linux so I'd like to use gzip command (just execute external command).
So far I have this:
bool generate_gz( const String& path )
{
bool res = false;
// LINUX
#ifndef __WXMSW__
if( !gzip_command_exists())
cout << "cannot compress file. 'gzip' command is not available.\n";
else
res = (0 == execute_command(String::Format("gzip %s", path.c_str())));
// WINDOWS
#else
// do nothing - result will be false
#endif
return res;
}
bool gzip_command_exists()
{
// TBD
}
Question
Is there a way to implement gzip_command_exists()? If so, does it have to involve running ( or trying to run) gzip command?

Answer 1

The simplest is to execute via system() : "which gzip" and see the exit code of the system call:
RETURN VALUE
The value returned is -1 on error (e.g. fork(2) failed), and the return status of the command otherwise. This latter return status
is in
the format specified in wait(2). Thus, the exit code of the command will be WEXITSTATUS(status). In case /bin/sh could not be
executed,
the exit status will be that of a command that does exit(127).
What to look for:
:~$ which gzip
/bin/gzip
:~$ echo $?
0
:~$ which gzip11
:~$ echo $?
1

Answer 2

If you do not want to spawn an external command, you can use the stat function to check if a file exists and if it is executable on a POSIX system.
It you do not want to hard code the path to gzip it is slightly more complicated. You will have to obtain the PATH environment variable, split it on colons, and then check each path for gzip. Again the name and format of path variables are POSIX specific. Check getenv function to read the path, and you could use strtok to split it.
It is questionable if it is worth checking, though, vs. just trying to run it and handling any errors.

Answer 3

You could use popen(3) to read the output of /usr/bin/which gzip (and you could also use it to compress on the fly by write-popen-ing a gzip > file.gz command). you could also have: FILE* pgzipv = popen("gzip --version", "r"); and fgets the first line then pclose....
You could consider using getenv("PATH") then making a loop on it with an access test to each constructed path obtained by appending /gzip to each element in the PATH, etc... You could also fork then execvp using gzip --version with stdout and stderr suitably redirected, etc..
Notice that both popen(3) and system(3) would fail when asked to execute a non-existing program (since they both fork(2) a /bin/sh shell with -c). So you don't need to test the existence of gzip and you always need to test the success of system or popen (which can fail for many reasons, see below for fork failure, and the documentation for other failures).
To be picky, checking that gzip exists is useless: it [the file /bin/gzip] could (unlikely) have been removed between your check -e.g. with access as below or with popen as above- and your later invocation of system or popen; so your first check for gzip don't bring anything.
On most Linux systems, gzip is generally available at /bin/gzip (and in practice gzip is always installed);
this is required by the file system hierarchy standard (which says that if gzip is installed it should be at that file path). Then you could just use access(2) e.g. with code like
#define GZIP_PATH "/bin/gzip" /* per FSH, see www.pathname.com/fhs */
if (access(GZIP_PATH, X_OK)) { perror(GZIP_PATH); exit(EXIT_FAILURE); };
At last, you don't need at all to fork a gzip process to gzip-compress a file. You could (and you should) simply use a library like zlib (which is required according to the Linux Standard Base as libz.so.1); you want its gzopen, gzwrite, gzprintf, gzputs, gzclose etc .... functions! That would be faster (no need to fork(2) any external process) and more reliable (no dependency on some external program like gzip; would work even if fork is not possible because limits have been reached - see setrlimit(2) with RLIMIT_NPROC and ulimit builtin of bash(1))
See also Advanced Linux Programming