pt.c

Go to the documentation of this file.

/*
 * $Id: pt.c 4815 2008-09-03 16:42:04Z henningw $
 *
 * Copyright (C) 2007 Voice Sistem SRL
 * 
 * This file is part of Kamailio, a free SIP server.
 *
 * Kamailio is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version
 *
 * Kamailio is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License 
 * along with this program; if not, write to the Free Software 
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * History:
 * --------
 * 2007-06-07 - created to contain process handling functions (bogdan)
 */

/*!
 * \file
 * \brief Server process related functions and datastructures
 */


#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include "mem/shm_mem.h"
#include "socket_info.h"
#include "sr_module.h"
#include "dprint.h"
#include "timer.h"
#include "pt.h"


/*! array with children pids, 0= main proc,
 * alloc'ed in shared mem if possible */
struct process_table *pt=0;

/*! variable keeping the number of created processes READONLY!! */
unsigned int counted_processes = 0;


/*!
 * \brief Initialize multi process support
 */
int init_multi_proc_support(void)
{
   unsigned short proc_no;
   struct socket_info* si;
   #ifdef USE_TCP
   unsigned int i;
   #endif

   proc_no = 0;

   /* count how many processes we will have in core */
   if (dont_fork) {
      /* only one UDP listener */
      proc_no = 1;
   } else {
      #ifdef USE_SCTP
      /* SCTP listeners */
      for (si=sctp_listen; si; si=si->next)
         proc_no+=children_no;
      #endif
      /* UDP listeners */
      for (si=udp_listen; si; si=si->next)
         proc_no+=children_no;
      #ifdef USE_TCP
      proc_no += ((!tcp_disable)?( 1/* tcp main */ + tcp_children_no ):0);
      #endif
      /* attendent */
      proc_no++;
   }
   /* timer processes */
   proc_no += count_timer_procs();

   /* count the processes requested by modules */
   proc_no += count_module_procs();

   /* allocate the PID table */
   pt = shm_malloc(sizeof(struct process_table)*proc_no);
   if (pt==0){
      LM_ERR("out of memory\n");
      return -1;
   }
   memset(pt, 0, sizeof(struct process_table)*proc_no);

   #ifdef USE_TCP
   for( i=0 ; i<proc_no ; i++ ) {
      pt[i].unix_sock = -1;
      pt[i].idx = -1;
   }
   #endif

   /* set the pid for the starter process */
   set_proc_attrs("starter");

   counted_processes = proc_no;

   return 0;
}


/*!
 * \brief Set the process attributes
 */
void set_proc_attrs( char *fmt, ...)
{
   va_list ap;

   /* description */
   va_start(ap, fmt);
   vsnprintf( pt[process_no].desc, MAX_PT_DESC, fmt, ap);
   va_end(ap);

   /* pid */
   pt[process_no].pid=getpid();
}



/*!
 * \brief Wrapper around fork, do some initializations
 *
 * \note This function is to be called only by the main process!
 */
pid_t internal_fork(char *proc_desc)
{
   #define CHILD_COUNTER_STOP  656565656
   static int process_counter = 1;
   pid_t pid;
   unsigned int seed;
   #ifdef USE_TCP
   int sockfd[2];
   #endif

   if (process_counter==CHILD_COUNTER_STOP) {
      LM_CRIT("buggy call from non-main process!!!");
      return -1;
   }

   seed = rand();

   LM_DBG("forking new process \"%s\"\n",proc_desc);

   #ifdef USE_TCP
   if(!tcp_disable){
      if (socketpair(AF_UNIX, SOCK_STREAM, 0, sockfd)<0){
         LM_ERR("socketpair failed: %s\n", strerror(errno));
         return -1;
      }
   }
   #endif

   if ( (pid=fork())<0 ){
      LM_CRIT("cannot fork \"%s\" process\n",proc_desc);
      return -1;
   }

   if (pid==0){
      /* child process */
      is_main = 0; /* a child is not main process */
      /* set uid and pid */
      process_no = process_counter;
      pt[process_no].pid = getpid();
      process_counter = CHILD_COUNTER_STOP;
      /* each children need a unique seed */
      seed_child(seed);
      /* set attributes */
      set_proc_attrs(proc_desc);
      /* set TCP communication */
      #ifdef USE_TCP
      if (!tcp_disable){
         close(sockfd[0]);
         unix_tcp_sock=sockfd[1];
         pt[process_no].unix_sock=sockfd[0];
      }
      #endif
      return 0;
   }else{
      /* parent process */
      pt[process_counter].pid = pid;
      #ifdef USE_TCP
      if (!tcp_disable) {
         close(sockfd[1]);
         /* set the fd also in parent to be eliminate any
          * races between the parent and child */
         pt[process_counter].unix_sock=sockfd[0];
      }
      #endif
      process_counter++;
      return pid;
   }
}

---