Hi all,
I am currently developing a C program on AIX 4.0 that interacts with a
proprietary communication protocol server. The program involves
establishing sessions, receiving data and writing data to Oracle
database.
I am forking a child process to write the data to the database. The
problem I face is that the forked child processes do not terminate after

the function is executed. But once the parent terminates, all the child
processes terminates.

The attached code is a copy of the mechanism used in the actual code.
Can anyone tell me why the child processes do not terminate ?

Code begins here :
#include <stdio.h>
#include <signal.h>
#include <sys/errno.h>
#include <unistd.h>
int main()
{
 int i=0;
 pid_t pid;
 while (1)
 {
  if (i==10)
   exit(0);
  pid = fork();
  if (pid == 0)
  {
   print_val();
   exit(0);
  }
  i++;
  sleep(3);
 }

Thanks for your help,
Sajid.

Nope, if you ask the question here, read the answer here.

This question is off topic for comp.lang.c, which discusses the
standard C programming language and not specific operating
system issues.  The header file uistd.h is not part of standard
C, neither is pid_t, fork, or sleep.  These are specific to UNIX
and UNIX like operating systems.

I would suggest you post this question to comp.unix.aix, or a
one of the comp.unix.* groups.

Please read the article "--- Welcome to comp.lang.c!  Please
read this first" which is posted frequently to this group by
Billy Chambless so that in the future you will know what
subjects are on and off topic here.

Jack

I say adopt the child process, not abort() it.

I'm at home, so I say anything I please.

The main problem is that you neglected to wait() on the children;
so long as their parent exists, terminated children remain in a "zombie" state so that there is a place to keep their exit
status, which is made available to the wait()er.
When they have been "orphaned", i.e. their parent has terminated, they are inherited by a "reaper" process (traditionally part
of init, PID#1), which quickly lays them to rest by wait()ing on them.
In cases where the parent does not find it convenient to wait on the children, a useful trick is to make them grandchildren
instead, with the intermediate child process immediately dying; as just described, that means that the children will be
immediately inherited by PID#1, so when they terminate they won't be zombies for more than an instant.
        if ((pid=fork())==0)
                // child process
                if ((pid=fork())>0)
                        _exit(0);       // child suicides after spawning
                else if (pid<0)      // error
                        handle_failure_to_fork(pid);
                else { // pid==0        // grandchild
                        do_slave_processing();
                        _exit(0);       // status sent to PID#1
                }
        else    // parent process
                if (pid<0)   // error
                        handle_failure_to_fork();
                else    // wait for (immediate) suicide of child
                        while (waitpid(pid,&status,0)<0 && errno==EINTR)
                                ;       // wait interrupted by signal, try again