Run a program from within a program

Match                    All                  Any                 word(s).	If you have any questions or comments, please visit us on the Forums.
FAQ > How do I... (Level 2) > Run a program from within a program
This item was added on: 2003/02/07 There are various ways to run another program from within your own. Most of the good ones are compiler dependant, so best research your help files before going too far  In all the example code below you'll find some sample output. In the cases where a child program has been invoked, this source was used to make that child: #include <stdio.h> int main(int argc, char *argv[] ) { int i = 0; printf("I am the child\n"); while (--argc) printf ("Arg %d %s\n", ++i, *++argv); return 0; } Now, we'll start with a simple example of system(). OPTION 1 - system() Prototype: int system (const char * s); This function executes a command specified in s, and returns after the command has been completed. A few reasons not to use this method are: The child program is uninterruptible from the parent program. This means that you cannot stop the program you have started. If it takes 5 hours to complete, that's how long your program will wait  You cannot communicate or share variables with the child process For various security reasons, its unsafe and may leave your system open to exploitation. In system terms, its relatively slow. Having said that, it is easy to use, and these things have their place. Here is a example of how to use it. /* * This example assumes the program you want to execute * is called child.exe, and resides in the same * directory as this program */ #include <stdlib.h> #include <stdio.h> #include <string.h> int main() { char child1[] = "child.exe"; char child2[BUFSIZ]; /* * Execute by passing the name directly */ system ("child.exe"); /* * Execute by passing an array name */ system (child1); /* * Build a buffer, and execute the commands within it */ strcpy (child2, "child.exe"); strcat (child2, " -aparm -b"); printf ("Executing %s\n", child2); system (child2); return 0; } /* * Program output: I am the child I am the child Executing child.exe -aparm -b I am the child Arg 1 -aparm Arg 2 -b * */ OPTION 2 - spawn There a family of functions collectively known as spawn. These are: #include <process.h> int spawnl( mode, path, arg0, arg1..., argn, NULL ); int spawnle( mode, path, arg0, arg1..., argn, NULL, envp); int spawnlp( mode, file, arg0, arg1..., argn, NULL ); int spawnlpe( mode, file, arg0, arg1..., argn, NULL, envp); int spawnv( mode, path, argv ); int spawnve( mode, path, argv, envp ); int spawnvp( mode, file, argv ); int spawnvpe( mode, file, argv, envp ); int mode; /* mode for parent */ const char *path; /* file name incl. path */ const char *file; /* file name */ const char *arg0,..., *argn; /* arguments */ char *const argv[]; /* array of arguments */ char *const envp[]; /* environment strings */ These functions create and execute a new child process, named by path or file (depending on the form of the function used). The value of mode determines how the program is loaded, and how the parent program will behave after the child program is initiated. P_WAIT The child program is loaded into memory and executed, and then the parent program resumes execution.  P_NOWAIT Causes the parent program to execute concurrently with the new child process.  P_NOWAITO  Causes the parent program to execute concurrently with the new child process. The wait() function cannot be used to obtain the exit code. P_OVERLAY The child program replaces the parent program in memory and is executed. No return is made to the parent program. The various forms of the spawn functions are: The l form : These contain an argument list, terminated by a NULL pointer. The argument arg0 should point to a filename that is associated with the child program. The v form : These contain a pointer to an argument vector. The value in argv[0] should point to a filename that is associated with the child program. The last member of argv must be a NULL pointer. The value of argv cannot be NULL, but argv[0] can be a NULL pointer if no argument strings are passed.  The p form : These use paths listed in the PATH environment variable to locate the program to be loaded, provided certain conditions are met. The e form : These pass a pointer to a new environment for the child program. The argument envp is an array of character pointers to null-terminated strings. The array of pointers is terminated by a NULL pointer. The value of envp cannot be NULL, but envp[0] can be a NULL pointer, if no environment strings are passed. #include <stdio.h> #include <process.h> int main(void) { puts("Spawning child with spawnl"); spawnl( P_WAIT, "child.exe", "child.exe", "Using spawnl", "Arg1", "Arg2", NULL ); return 0; } /* * Program output: Spawning child with spawnl I am the child Arg 1 Using Arg 2 spawnl Arg 3 Arg1 Arg 4 Arg2 * */ #include <stdio.h> #include <process.h> int main(void) { char *my_args[4]; my_args[0] = "child.exe"; my_args[1] = "arg1"; my_args[2] = "arg2"; my_args[3] = NULL; puts("Spawning child with spawnv"); spawnv( P_WAIT, "child.exe", my_args); return 0; } /* * Program output: Spawning child with spawnv I am the child Arg 1 arg1 Arg 2 arg2 * */ OPTION 3 - fork/exec Using a combination of fork and exec, you can duplicate your running program in memory, then turn the second copy into another program altogether. Prototypes: #include <sys/types.h> #include <unistd.h> pid_t fork( void ); The exec family consists of: #include <unistd.h> int execl( path, arg0, arg1..., argn, NULL ); int execle( path, arg0, arg1..., argn, NULL, envp ); int execlp( file, arg0, arg1..., argn, NULL ); int execlpe( file, arg0, arg1..., argn, NULL, envp ); int execv( path, argv ); int execve( path, argv, envp ); int execvp( file, argv ); int execvpe( file, argv, envp ); const char *path; /* file name incl. path */ const char *file; /* file name */ const char *arg0,..., *argn; /* arguments */ char *const argv[]; /* array of arguments */ char *const envp[]; /* environment strings */ These have the same forms to the spawn functions (l, v, p and e). #include <stdio.h> #include <stdlib.h> #include <sys/types.h> #include <unistd.h> int main(void) { char *my_args[5]; pid_t pid; my_args[0] = "child.exe"; my_args[1] = "arg1"; my_args[2] = "arg2"; my_args[3] = NULL; puts ("fork()ing"); switch ((pid = fork())) { case -1: /* Fork() has failed */ perror ("fork"); break; case 0: /* This is processed by the child */ execv ("child.exe", my_args); puts("Uh oh! If this prints, execv() must have failed"); exit(EXIT_FAILURE); break; default: /* This is processed by the parent */ puts ("This is a message from the parent"); break; } puts ("End of parent program"); return 0; } /* * Program output: fork()ing This is a message from the parent End of parent program I am the child Arg 1 arg1 Arg 2 arg2 * */ Further options Windows options: (Credit: Sunlight) Use one of the _spawn functions, or CreateProcess, or ShellExecute. Which one you use depends on what you want to do. _spawn is simplest (and most portable), CreateProcess gives you the most control, ShellExecute gives you the most flexibility (starts documents as well as files, for example). Here are some examples of Windows versions, compliments of Fordy. Using CreateProcess() #include <windows.h> int main(void) { char szPath[] = "C:\\WINDOWS\\system32\\Calc.exe"; PROCESS_INFORMATION pif; //Gives info on the thread and.. //..process for the new process STARTUPINFO si; //Defines how to start the program ZeroMemory(&si,sizeof(si)); //Zero the STARTUPINFO struct si.cb = sizeof(si); //Must set size of structure BOOL bRet = CreateProcess( szPath, //Path to executable file NULL, //Command string - not needed here NULL, //Process handle not inherited NULL, //Thread handle not inherited FALSE, //No inheritance of handles 0, //No special flags NULL, //Same environment block as this prog NULL, //Current directory - no separate path &si, //Pointer to STARTUPINFO &pif); //Pointer to PROCESS_INFORMATION if(bRet == FALSE) { MessageBox(HWND_DESKTOP,"Unable to start program","",MB_OK); return 1; } CloseHandle(pif.hProcess); //Close handle to process CloseHandle(pif.hThread); //Close handle to thread return 0; } Using ShellExecute() #include <windows.h> //You need shell32.lib for this one int main(void) { char szPath[] = "C:\\WINDOWS\\system32\\Calc.exe"; HINSTANCE hRet = ShellExecute( HWND_DESKTOP, //Parent window "open", //Operation to perform szPath, //Path to program NULL, //Parameters NULL, //Default directory SW_SHOW); //How to open /* The function returns a HINSTANCE (not really useful in this case) So therefore, to test its result, we cast it to a LONG. Any value over 32 represents success! */ if((LONG)hRet <= 32) { MessageBox(HWND_DESKTOP,"Unable to start program","",MB_OK); return 1; } return 0; }