c%2B%2B/socket%2B%2B-1.10/Fork.C

// Fork.C -*- C++ -*- socket library
// Copyright (C) 1992,1993,1994 Gnanasekaran Swaminathan <gs4t@virginia.edu>
// 
// Permission is granted to use at your own risk and distribute this software
// in source and binary forms provided the above copyright
// notice and this paragraph are preserved on all copies.
// This software is provided "as is" with no express or implied warranty.
//
// Version: 17Oct95 1.10

#include <config.h>

#include <iostream.h>
#include <stdio.h> // perror in solaris2.3 is declared here
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <signal.h>
#include <sys/wait.h>

#include <Fork.h>

Fork::ForkProcess* Fork::ForkProcess::list = 0;
Fork::KillForks Fork::killall;

Fork::~Fork ()
{
  if (process->pid <= 0)
    delete process;
}

Fork::KillForks::~KillForks ()
     // First, kill all children whose kill_child flag is set.
     // Second, wait for other children to die.
{
  for (ForkProcess* cur = Fork::ForkProcess::list; cur; cur = cur->next)
    if (cur->kill_child)
      delete cur;

  while (Fork::ForkProcess::list && wait (0) > 0);
}

Fork::ForkProcess::ForkProcess (int kill, int give_reason)
     : kill_child (kill), reason (give_reason), next (0)
{
  if (list == 0) {
    struct sigaction sa;
    sa.sa_handler = funcptr (&Fork::ForkProcess::reaper_nohang);
    sigemptyset (&sa.sa_mask);
    sa.sa_flags = SA_RESTART;
    sigaction (SIGCHLD, &sa, 0);
  }

  pid = fork ();

  if (pid > 0) {
    next = list;
    list = this;
  } else if (pid == 0) {
    // child process. clear list
    ForkProcess* p = list;
    while (p) {
      ForkProcess* nxt = p->next;
      p->pid = 0;
      delete p;
      p = nxt;
    }
    list = 0;

    if (kill_child) {
      struct sigaction sa;
      sa.sa_handler = funcptr (&Fork::ForkProcess::commit_suicide);
      sigemptyset (&sa.sa_mask);
      sa.sa_flags = SA_RESTART;
      sigaction (SIGTERM, &sa, 0);
    }
  }
}

Fork::ForkProcess::~ForkProcess ()
{
  if (pid > 0) {
    if (kill_child)
      kill (pid, SIGTERM);
    reap_child ();

    // I remove myself from list
    if (list == this)
      list = list->next;
    else {
      for (ForkProcess* p = list; p; p = p->next)
        if (p->next == this) {
          p->next = next;
          break;
        }
    }
  }
}

void Fork::ForkProcess::kill_process () const
{
  if (pid > 0) {
    kill (pid, SIGKILL);
    reap_child ();
  }
}

void Fork::ForkProcess::reap_child () const
{
  int status;
  if (pid > 0 && waitpid (pid, &status, 0) == pid && reason)
    infanticide_reason (pid, status);
}

void Fork::ForkProcess::infanticide_reason (pid_t pid, int status)
{
  if (pid <= 0)
    return;

  if (WIFSTOPPED (status))
    cerr << "process " << pid << " gets "
      << SYS_SIGLIST [WSTOPSIG (status)] << endl;
  else if (WIFEXITED (status))
    cerr << "process " << pid << " exited with status "
      << WEXITSTATUS (status) << endl;
  else if (WIFSIGNALED (status))
    cerr << "process " << pid << " got "
      << SYS_SIGLIST [WTERMSIG (status)] << endl;
}

void Fork::ForkProcess::reaper_nohang (int signo)
{
  if (signo != SIGCHLD)
    return;

  int status;
  pid_t wpid;
  if ((wpid = waitpid (-1, &status, WNOHANG)) > 0) {
    ForkProcess* prev = 0;
    ForkProcess* cur  = list;
    while (cur) {
      if (cur->pid == wpid) {
        cur->pid = -1;
        if (prev)
          prev->next = cur->next;
        else
          list = list->next;
        
        if (cur->reason)
          infanticide_reason (wpid, status);

        delete cur;
        break;
      }
      prev = cur;
      cur  = cur->next;
    }
  }
}

void Fork::ForkProcess::commit_suicide (int)
{
  // if this process has any children we kill them.

  ForkProcess* p = list;
  while (p) {
    ForkProcess* next = p->next;
    if (!p->kill_child) // otherwise ForkProcess::~ForkProcess will take care
      kill (p->pid, SIGKILL);
    delete p; // ForkProcess::~ForkProcess will call reap_child ().
    p = next;
  }

  exit (0x0f); 
}

void Fork::suicide_signal (int signo)
     // commit suicide at the signal signo
{
  struct sigaction sa;
  sa.sa_handler = funcptr (&Fork::ForkProcess::commit_suicide);
  sigemptyset (&sa.sa_mask);
  sa.sa_flags = 0;
  if (sigaction (signo, &sa, 0) == -1)
    perror ("Fork: Cannot commit suicide with the specified signal");
}
Revision:	1.2
Committed:	Mon Jun 10 14:10:43 2002 UTC (22 years, 5 months ago) by tdb
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.1:	+0 -0 lines
State:	*FILE REMOVED*
Log Message:	Tidy up of files. These are all old things that are not only no longer used but are also probably useless to anyone other than us. This saves checking them out all the time, and makes the "cms/source" tree contain only current stuff. They'll still exist in the attic's though :)
#	User	Rev	Content
1	ab11	1.1	// Fork.C -- C++ -- socket library
2			// Copyright (C) 1992,1993,1994 Gnanasekaran Swaminathan <gs4t@virginia.edu>
3			//
4			// Permission is granted to use at your own risk and distribute this software
5			// in source and binary forms provided the above copyright
6			// notice and this paragraph are preserved on all copies.
7			// This software is provided "as is" with no express or implied warranty.
8			//
9			// Version: 17Oct95 1.10
10
11			#include <config.h>
12
13			#include <iostream.h>
14			#include <stdio.h> // perror in solaris2.3 is declared here
15			#include <stdlib.h>
16			#include <unistd.h>
17			#include <errno.h>
18			#include <signal.h>
19			#include <sys/wait.h>
20
21			#include <Fork.h>
22
23			Fork::ForkProcess* Fork::ForkProcess::list = 0;
24			Fork::KillForks Fork::killall;
25
26			Fork::~Fork ()
27			{
28			if (process->pid <= 0)
29			delete process;
30			}
31
32			Fork::KillForks::~KillForks ()
33			// First, kill all children whose kill_child flag is set.
34			// Second, wait for other children to die.
35			{
36			for (ForkProcess* cur = Fork::ForkProcess::list; cur; cur = cur->next)
37			if (cur->kill_child)
38			delete cur;
39
40			while (Fork::ForkProcess::list && wait (0) > 0);
41			}
42
43			Fork::ForkProcess::ForkProcess (int kill, int give_reason)
44			: kill_child (kill), reason (give_reason), next (0)
45			{
46			if (list == 0) {
47			struct sigaction sa;
48			sa.sa_handler = funcptr (&Fork::ForkProcess::reaper_nohang);
49			sigemptyset (&sa.sa_mask);
50			sa.sa_flags = SA_RESTART;
51			sigaction (SIGCHLD, &sa, 0);
52			}
53
54			pid = fork ();
55
56			if (pid > 0) {
57			next = list;
58			list = this;
59			} else if (pid == 0) {
60			// child process. clear list
61			ForkProcess* p = list;
62			while (p) {
63			ForkProcess* nxt = p->next;
64			p->pid = 0;
65			delete p;
66			p = nxt;
67			}
68			list = 0;
69
70			if (kill_child) {
71			struct sigaction sa;
72			sa.sa_handler = funcptr (&Fork::ForkProcess::commit_suicide);
73			sigemptyset (&sa.sa_mask);
74			sa.sa_flags = SA_RESTART;
75			sigaction (SIGTERM, &sa, 0);
76			}
77			}
78			}
79
80			Fork::ForkProcess::~ForkProcess ()
81			{
82			if (pid > 0) {
83			if (kill_child)
84			kill (pid, SIGTERM);
85			reap_child ();
86
87			// I remove myself from list
88			if (list == this)
89			list = list->next;
90			else {
91			for (ForkProcess* p = list; p; p = p->next)
92			if (p->next == this) {
93			p->next = next;
94			break;
95			}
96			}
97			}
98			}
99
100			void Fork::ForkProcess::kill_process () const
101			{
102			if (pid > 0) {
103			kill (pid, SIGKILL);
104			reap_child ();
105			}
106			}
107
108			void Fork::ForkProcess::reap_child () const
109			{
110			int status;
111			if (pid > 0 && waitpid (pid, &status, 0) == pid && reason)
112			infanticide_reason (pid, status);
113			}
114
115			void Fork::ForkProcess::infanticide_reason (pid_t pid, int status)
116			{
117			if (pid <= 0)
118			return;
119
120			if (WIFSTOPPED (status))
121			cerr << "process " << pid << " gets "
122			<< SYS_SIGLIST [WSTOPSIG (status)] << endl;
123			else if (WIFEXITED (status))
124			cerr << "process " << pid << " exited with status "
125			<< WEXITSTATUS (status) << endl;
126			else if (WIFSIGNALED (status))
127			cerr << "process " << pid << " got "
128			<< SYS_SIGLIST [WTERMSIG (status)] << endl;
129			}
130
131			void Fork::ForkProcess::reaper_nohang (int signo)
132			{
133			if (signo != SIGCHLD)
134			return;
135
136			int status;
137			pid_t wpid;
138			if ((wpid = waitpid (-1, &status, WNOHANG)) > 0) {
139			ForkProcess* prev = 0;
140			ForkProcess* cur = list;
141			while (cur) {
142			if (cur->pid == wpid) {
143			cur->pid = -1;
144			if (prev)
145			prev->next = cur->next;
146			else
147			list = list->next;
148
149			if (cur->reason)
150			infanticide_reason (wpid, status);
151
152			delete cur;
153			break;
154			}
155			prev = cur;
156			cur = cur->next;
157			}
158			}
159			}
160
161			void Fork::ForkProcess::commit_suicide (int)
162			{
163			// if this process has any children we kill them.
164
165			ForkProcess* p = list;
166			while (p) {
167			ForkProcess* next = p->next;
168			if (!p->kill_child) // otherwise ForkProcess::~ForkProcess will take care
169			kill (p->pid, SIGKILL);
170			delete p; // ForkProcess::~ForkProcess will call reap_child ().
171			p = next;
172			}
173
174			exit (0x0f);
175			}
176
177			void Fork::suicide_signal (int signo)
178			// commit suicide at the signal signo
179			{
180			struct sigaction sa;
181			sa.sa_handler = funcptr (&Fork::ForkProcess::commit_suicide);
182			sigemptyset (&sa.sa_mask);
183			sa.sa_flags = 0;
184			if (sigaction (signo, &sa, 0) == -1)
185			perror ("Fork: Cannot commit suicide with the specified signal");
186			}