Casting Command Line Arguments?

Question

i have a command line executable program that accepts a configuration file as it's one argument for launch. the configuration file contains only 2 lines of code:

#ConfigFile.cfg
name=geoffrey
city=montreal

currently, the wrapper program that i'm building for this command line executable program writes the configuration file to disk and than sends that written file as the argument to launch the program on the command line.

> myProgram.exe configFile.cfg

is it possible to cast these configuration file entries as the configuration file, allowing me to bypass having to write the configuration file to disk but still allow the program to run as if it's reading from a configuration file?

perhaps something like the following:

> myProgram.exe configFile.cfg(name=geoffrey) configFile.cfg(city=montreal)

Answer 1

If you don't control the source for the program you're wrapping, and it doesn't already provide a facility to receive input in another way, you're going to find it difficult at best.

One possibility would be to intercept the file open and access calls used by the program though this is a horrible way to do it.

It would probably involve injecting your own runtime libraries containing (for C) fopen, fclose, fread and so on, between the program and the real libraries (such as using LD_LIBRARY_PATH or something similar), and that's assuming it's not statically linked. Not something for the faint of heart.

If you're worried about people being able to see your file, there's plenty of ways to avoid that, such as by creating it with rwx------ permissions in a similarly protected directory (assuming UNIX-like OS). That's probably safer than using command line arguments which any joker logged in could find out with a ps command.

If you just don't want the hassle of creating a file, I think you'll find the hassle of avoiding it is going to be so much more.

Depending on what you're really after, it wouldn't take much to put together a program that accepted arguments, wrote them to a temporary file, called the real program with that temporary file name, then deleted the file.

It would still be being written to disk, but that would no longer be the responsibility of your wrapper program. Something along the lines of (a bit rough, but you should get the idea):

#include <stdio.h>
#define PROG "myProgram"
int main (int argCount, char *argVal[]) {
    char *tmpFSpec;
    FILE *fHndl;
    int i;
    char *cmdBuff;

    tmpFSpec = getTempFSpec(); // need to provide this.

    cmdBuff = malloc (sizeof(PROG) + 1 + strlen (tmpFSpec) + 1);
    if (cmdBuff == NULL) {
        // handle error.
        return 1;
    }

    fHndl = fopen (tmpFSpec, "w");
    if (fHndl == NULL) {
        // handle error.
        free (cmdBuff);
        return 1;
    }

    for (i = 1; i < argCount; i++)
        fprintf (fHndl, "%s\n", argVal[i]);

    sprintf (cmdBuff, "%s %s", PROG, tmpFSpec);
    system (cmdBuff);

    return 0;
}