src/bg.c File Reference

#include "main.h"
#include <signal.h>
#include "bg.h"

Include dependency graph for bg.c:

Go to the source code of this file.

Data Structures
struct	bg_comm_t
struct	bg_t
Enumerations
enum	bg_state_t { BG_NONE = 0, BG_SPLIT, BG_PARENT }
Functions
static void	bg_do_detach (pid_t p)
void	bg_prepare_split (void)
static void	bg_send_pidfile (void)
void	bg_send_quit (bg_quit_t q)
void	bg_do_split (void)
Variables
char	pid_file []
static bg_t	bg = { 0 }

---

Enumeration Type Documentation

enum bg_state_t

Enumerator:

BG_NONE
BG_SPLIT
BG_PARENT

Definition at line 82 of file bg.c.

             {
  BG_NONE = 0,         /* No forking has taken place yet.                */
  BG_SPLIT,            /* I'm the newly forked process.                  */
  BG_PARENT            /* I'm the original process.                      */
} bg_state_t;

---

Function Documentation

static void bg_do_detach

(

pid_t

p

)

[static]

Definition at line 102 of file bg.c.

References EGG_NOWRITE, NULL, and pid_file.

Referenced by bg_do_split(), and bg_prepare_split().

{
  FILE *fp;

  /* Need to attempt to write pid now, not later. */
  unlink(pid_file);
  fp = fopen(pid_file, "w");
  if (fp != NULL) {
    fprintf(fp, "%u\n", p);
    if (fflush(fp)) {
      /* Kill bot incase a botchk is run from crond. */
      printf(EGG_NOWRITE, pid_file);
      printf("  Try freeing some disk space\n");
      fclose(fp);
      unlink(pid_file);
      exit(1);
    }
    fclose(fp);
  } else
    printf(EGG_NOWRITE, pid_file);
  printf("Launched into the background  (pid: %d)\n\n", p);
#ifdef HAVE_SETPGID
  setpgid(p, p);
#endif
  exit(0);
}

Here is the caller graph for this function:

void bg_do_split

(

void

)

Definition at line 230 of file bg.c.

References bg_do_detach(), BG_QUIT, bg_send_quit(), fatal, and fork_before_tcl().

Referenced by main().

{
  if (fork_before_tcl()) {
    /* Tell our parent process to go away now, as we don't need it anymore. */
    bg_send_quit(BG_QUIT);

  } else {
    /* Split off a new process. */
    int xx = fork();

    if (xx == -1)
      fatal("CANNOT FORK PROCESS.", 0);
    if (xx != 0)
      bg_do_detach(xx);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void bg_prepare_split

(

void

)

Definition at line 129 of file bg.c.

References bg_do_detach(), BG_PARENT, BG_SPLIT, bg_t::child_pid, bg_comm_t::comm_data, bg_t::comm_recv, bg_t::comm_send, bg_comm_t::comm_type, fatal, fork_before_tcl(), pid_file, bg_t::state, and bg_comm_t::transferpf.

Referenced by main().

{
  pid_t p;
  bg_comm_t message;

  if (!fork_before_tcl())
    return;

  /* Create a pipe between parent and split process, fork to create a
   * parent and a split process and wait for messages on the pipe. */
  {
    int comm_pair[2];

    if (pipe(comm_pair) < 0)
      fatal("CANNOT OPEN PIPE.", 0);

    bg.comm_recv = comm_pair[0];
    bg.comm_send = comm_pair[1];
  }

  p = fork();
  if (p == -1)
    fatal("CANNOT FORK PROCESS.", 0);
  if (p == 0) {
    bg.state = BG_SPLIT;
    return;
  } else {
    bg.child_pid = p;
    bg.state = BG_PARENT;
  }

  while (read(bg.comm_recv, &message, sizeof(message)) > 0) {
    switch (message.comm_type) {
    case BG_COMM_QUIT:
      bg_do_detach(p);
      break;
    case BG_COMM_ABORT:
      exit(1);
      break;
    case BG_COMM_TRANSFERPF:
      /* Now transferring file from split process.
       */
      if (message.comm_data.transferpf.len >= 40)
        message.comm_data.transferpf.len = 40 - 1;
      /* Next message contains data. */
      if (read(bg.comm_recv, pid_file, message.comm_data.transferpf.len) <= 0)
        goto error;
      pid_file[message.comm_data.transferpf.len] = 0;
      break;
    }
  }

error:
  /* We only reach this point in case of an error.
   */
  fatal("COMMUNICATION THROUGH PIPE BROKE.", 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void bg_send_pidfile

(

void

)

[static]

Definition at line 191 of file bg.c.

References bg_comm_t::comm_data, bg_t::comm_send, bg_comm_t::comm_type, fatal, pid_file, and bg_comm_t::transferpf.

Referenced by bg_send_quit().

{
  bg_comm_t message;

  message.comm_type = BG_COMM_TRANSFERPF;
  message.comm_data.transferpf.len = strlen(pid_file);

  /* Send type message. */
  if (write(bg.comm_send, &message, sizeof(message)) < 0)
    goto error;
  /* Send data. */
  if (write(bg.comm_send, pid_file, message.comm_data.transferpf.len) < 0)
    goto error;
  return;
error:
  fatal("COMMUNICATION THROUGH PIPE BROKE.", 0);
}

Here is the caller graph for this function:

void bg_send_quit

(

bg_quit_t

q

)

Definition at line 209 of file bg.c.

References BG_PARENT, BG_QUIT, bg_send_pidfile(), BG_SPLIT, bg_t::child_pid, bg_t::comm_send, bg_comm_t::comm_type, fatal, fork_before_tcl(), and bg_t::state.

Referenced by bg_do_split(), do_arg(), fatal(), got_bus(), got_segv(), and main().

{
  if (!fork_before_tcl())
    return;

  if (bg.state == BG_PARENT) {
    kill(bg.child_pid, SIGKILL);
  } else if (bg.state == BG_SPLIT) {
    bg_comm_t message;

    if (q == BG_QUIT) {
      bg_send_pidfile();
      message.comm_type = BG_COMM_QUIT;
    } else
      message.comm_type = BG_COMM_ABORT;
    /* Send message. */
    if (write(bg.comm_send, &message, sizeof(message)) < 0)
      fatal("COMMUNICATION THROUGH PIPE BROKE.", 0);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

Variable Documentation

bg_t bg = { 0 } [static]

Definition at line 95 of file bg.c.

char pid_file[]

Definition at line 112 of file main.c.

Referenced by bg_do_detach(), bg_prepare_split(), bg_send_pidfile(), fatal(), and main().