Need C++ or Java please

http://linux.die.net/man/3/exec

fork() creates a new process by duplicating the calling process. The new process, referred to as the child, is an exact duplicate of the calling process, referred to as the parent

#include <unistd.h>

pid_t fork(void);

The exec() family of functions replaces the current process image with a new process image. The functions described in this manual page are front-ends for execve(2). (See the manual page for execve(2) for further details about the replacement of the current process image.)

The exec() family of functions include execl, execlp, execle, execv, execvp, and execvpe to execute a file.

The ANSI prototype for execl() is: 

int execl(const char *path, const char *arg0,..., const char *argn, 0) 

http://www.cems.uwe.ac.uk/~irjohnso/coursenotes/lrc/system/pc/pc4.htm

    #inciude <stdio.h>

    #inciude <unistd.h>

	main()
	{
		execl("/bin/ls", "ls", "-l", 0); 
		printf("Can only get here on error\n");
	}

The first parameter to execl() in this example is the full pathname to the ls command. This is the file whose contents will be run, provided the process has execute permission on the file. The rest of the execl() parameters provide the strings to which the argv array elements in the new program will point. In this example, it means that the ls program will see the string ls pointed to by its argv[0], and the string -l pointed to by itsargv[1]. In addition to making all these parameters available to the new program, the exec() calls also pass a value for the variable:
	extern char **environ;
This variable has the same format as the 
argv
 variable except that the items passed via 
environ
 are the values in the environment of the process (like any exported shell variables), rather than the command line parameters. In the case of execl(), the value of the 
environ
 variable in the new program will be a copy of the value of this variable in the calling process.
The execl() version of exec() is fine in the circumstances where you can ex-plicitly list all of the parameters, as in the previous example. Now suppose you want to write a program that doesn't just run ls, but will run any program you wish, and pass it any number of appropriate command line parameters. Obviously, execl() won't do the job.
The example program below, which implements this requirement, shows, however, that the system call execv() will perform as required:
	#inciude <stdio.h>
	main(int argc, char **argv)
	{
		if (argc==1)
		{
			printf("Usage: run <command> [<paraneters>]\n"); 
			exit(1)
		}
		execv(argv[l], &argv[1)); 
		printf("Sorry...   couldn't run that!\n");
	}
The prototype for execv() shows that it only takes two parameters, the first is the full pathname to the command to execute and the second is the 
argv
 value you want to pass into the new program. In the previous example this value was derived from the 
argv
 value passed into the run command, so that the run command can take the command line parameter values you pass it and just pass them on.
	int execl(pathname, argo, ..., argn, 0); 
	int execv(pathname, argv);
	int execlp(cmdname, arg0, ..., argn, 0); 
	int execvp(cmdname, argv);
	int execle(patbname, arg0, ..., arga, 0, envp);
	int execve(pathname, argv, envp);
	char *pathname, *cmdname;
	char *arg0, ..., *argn;
	char **argv, **envp;






pipe() creates a pipe, a unidirectional data channel that can be used for interprocess communication. The array pipefd is used to return two file descriptors referring to the ends of the pipe. pipefd[0] refers to the read end of the pipe. pipefd[1] refers to the write end of the pipe. Data written to the write end of the pipe is buffered by the kernel until it is read from the read end of the pipe
#include <unistd.h>
int pipe(int pipefd[2]);
#define _GNU_SOURCE             /* See 
feature_test_macros
(7) */#include
<fcntl.h>              /* Obtain O_* constant definitions */#include <unistd.h>
int pipe2(int pipefd[2], int flags);


read() attempts to read up to count bytes from file descriptor fd into the buffer starting at buf.
#include <unistd.h>
ssize_t read(int fd, void *buf, size_t count);


write() writes up to count bytes from the buffer pointed buf to the file referred to by the file descriptor fd.
#include <unistd.h>
ssize_t write(int fd, const void *buf, size_t count);


close() closes a file descriptor, so that it no longer refers to any file and may be reused. Any record locks (see 
fcntl

(2)) held on the file it was associated with, and owned by the process, are removed (regardless of the file descriptor that was used to obtain the lock).
If fd is the last file descriptor referring to the underlying open file description (see

open


(2)), the resources associated with the open file description are freed; if the descriptor was the last reference to a file which has been removed using 

unlink


(2) the file is deleted.
#include <unistd.h>
int close(int fd);





Sample Program 1


/****************************************************************
 *
 *    Example: to demonstrate fork() and execl() and system calls
 *
 ***************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/wait.h>
int main( int argc, char *argv[], char *env[] )
{
   pid_t my_pid, parent_pid, child_pid;
   int status;
/* get and print my pid and my parent's pid. */
   my_pid = getpid();    parent_pid = getppid();
   printf("\n Parent: my pid is %d\n\n", my_pid);
   printf("Parent: my parent's pid is %d\n\n", parent_pid);
/* print error message if fork() fails */
   if((child_pid = fork()) < 0 )
   {
      perror("fork failure");
      exit(1);
   }
/* fork() == 0 for child process */
   if(child_pid == 0)
   {  printf("\nChild: I am a new-born process!\n\n");
      my_pid = getpid();    parent_pid = getppid();
      printf("Child: my pid is: %d\n\n", my_pid);
      printf("Child: my parent's pid is: %d\n\n", parent_pid);
      printf("Child: I will sleep 3 seconds and then execute - date - command \n\n");
      sleep(3); 
      printf("Child: Now, I woke up and am executing date command \n\n");
      execl("/bin/date", "date", 0, 0);
      perror("execl() failure!\n\n");
      printf("This print is after execl() and should not have been executed if execl were successful! \n\n");
      _exit(1);
   }
/*
 * parent process
 */
   else
   {
      printf("\nParent: I created a child process.\n\n");
      printf("Parent: my child's pid is: %d\n\n", child_pid);
      system("ps -acefl | grep ercal");  printf("\n \n");
      wait(&status); /* can use wait(NULL) since exit status
                        from child is not used. */
      printf("\n Parent: my child is dead. I am going to leave.\n \n ");
   }
   return 0;
}







Sample Program 2



Execution 

> gcc –o proc proc.c
> gcc –o fibo fibo.c
> gcc –o pipe pipe.c
> ./proc 


proc.c

#include <stdio.h>
#include <sys/shm.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
int main(){
   pid_t pid;
   int segment_id; //allocate the memory
   char *shared_memory; //pointer to memory
   const int size = 4096;
   segment_id = shmget(IPC_PRIVATE, size, S_IRUSR | S_IWUSR);
   shared_memory = (char *) shmat(segment_id, NULL, 0);
   pid = fork();
   if(pid < 0) { //error
                fprintf(stderr, "Fork failed");
                return 1;
   }
   else if(pid == 0){ //child process
                char *child_shared_memory;
                child_shared_memory = (char *) shmat(segment_id,NULL,0);    
                                                                //attach mem
                sprintf(child_shared_memory, "Hello parent process!"); 
                                                    //write to the shared mem 
                shmdt(child_shared_memory);
                execl("./pipe", "pipe", "3", 0);  /* to call pipe program */
                execl("./fibo", "fibo", "12", 0); /* to call fibo program */
   }
   else {//parent process
                wait(NULL);
                printf("Child process completed.\n");
                printf("The child process has written to the shared memory.\n
                It has    said: %s\n", shared_memory); //read from shared mem
                shmdt(shared_memory);
                shmctl(segment_id, IPC_RMID, NULL);
   }
   return 0;
} 


fibo.c

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#include <string.h>
int fibo(int num);
int main(int argc, char *argv[]) {
   if (argc != 2) {
      fprintf(stderr, "argc %d \n", argc);
      fprintf(stderr, "argv[0]: %s >\n", argv[0]);
      fprintf(stderr, "argv[1]: %s >\n", argv[1]);
      fprintf(stderr, "Usage: %s <string>\n", argv[0]);
      exit(EXIT_FAILURE);
   }
   int num = atoi(argv[1]);
   printf( "%d'th Fibonacci number is %d\n", num, fibo(num));
   exit(EXIT_SUCCESS);
} /* end of main */ 
int fibo(int num) {
   if (num > 0) {
      if (num <=2) {
         return 1;
      } else {
         return fibo(num-1) + fibo(num-2);
      }
   } else {
      return -1;
   }
} /* end of fibo() */






pipe.c

#include <stdio.h>
#include <stdlib.h>
#include <sys/shm.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <unistd.h>
#include <string.h>
int segmentId;
char *sharedMemory;
int main(int argc, char *argv[]) {
   int pipefd[2];
   pid_t cpid;
   char buf;
   if (argc != 2) {
      fprintf(stderr, "argc %d \n", argc);
      fprintf(stderr, "argv[0]: %s >\n", argv[0]);
      fprintf(stderr, "argv[1]: %s >\n", argv[1]);
      fprintf(stderr, "Usage: %s <string>\n", argv[0]);
      exit(EXIT_FAILURE);
   }
   if (pipe(pipefd) == -1) {
      perror("pipe");
      exit(EXIT_FAILURE);
   }
   cpid = fork();
   if (cpid == -1) {
      perror("fork");
      exit(EXIT_FAILURE);
   }
   if (cpid == 0) { /* Child reads from pipe */
      close(pipefd[1]); /* Close unused write end */
      while (read(pipefd[0], &buf, 1) > 0)
         write(STDOUT_FILENO, &buf, 1);
      write(STDOUT_FILENO, "\n", 1); 
      _exit(EXIT_SUCCESS);
   } else {         /* Parent writes argv[1] to pipe */
      close(pipefd[0]); /* Close unsed read end */
      write(pipefd[1], argv[1], strlen(argv[1]));
      close(pipefd[1]);    /* Reader will see EOF */
      wait (NULL);         /* Wait for child */
      exit(EXIT_SUCCESS);
   }
}