/** * @brief Initialize async module children */ static int child_init(int rank) { int pid; int i; if (rank==PROC_INIT) { if(evapi_init_notify_sockets()<0) { LM_ERR("failed to initialize notify sockets\n"); return -1; } return 0; } if (rank!=PROC_MAIN) { evapi_close_notify_sockets_parent(); return 0; } pid=fork_process(PROC_NOCHLDINIT, "EvAPI Dispatcher", 1); if (pid<0) return -1; /* error */ if(pid==0) { /* child */ /* initialize the config framework */ if (cfg_child_init()) return -1; /* main function for dispatcher */ evapi_close_notify_sockets_child(); if(evapi_run_dispatcher(_evapi_bind_addr, _evapi_bind_port)<0) { LM_ERR("failed to initialize disptacher process\n"); return -1; } } for(i=0; i<_evapi_workers; i++) { pid=fork_process(PROC_RPC, "EvAPI Worker", 1); if (pid<0) return -1; /* error */ if(pid==0) { /* child */ /* initialize the config framework */ if (cfg_child_init()) return -1; /* main function for workers */ if(evapi_run_worker(i+1)<0) { LM_ERR("failed to initialize worker process: %d\n", i); return -1; } } } return 0; }
int jsonrpc_dgram_child_init(int rank) { int i; int pid; if (rank==PROC_MAIN) { if(jsonrpc_dgram_pre_process()!=0) { LM_ERR("pre-fork function failed\n"); return -1; } for(i=0; i<jsonrpc_dgram_workers; i++) { pid=fork_process(PROC_NOCHLDINIT, "JSONRPC-S DATAGRAM", 1); if (pid<0) return -1; /* error */ if(pid==0) { /* child */ /* initialize the config framework */ if (cfg_child_init()) return -1; jsonrpc_dgram_process(i); return 0; } } if(jsonrpc_dgram_post_process()!=0) { LM_ERR("post-fork function failed\n"); return -1; } } return 0; }
int sms_child_init(int rank) { int i, foo; /* only the child 1 will execute this */ if (rank != 1) goto done; /* creates processes for each modem */ for(i=0;i<nr_of_modems;i++) { if ( (foo=fork())<0 ) { LM_ERR("cannot fork \n"); goto error; } if (!foo) { /* initialize the config framework */ if (cfg_child_init()) goto error; modem_process(&(modems[i])); goto done; } } done: return 0; error: return-1; }
static int cpl_child_init(int rank) { pid_t pid; /* don't do anything for main process and TCP manager process */ if (rank==PROC_INIT || rank==PROC_MAIN || rank==PROC_TCP_MAIN) return 0; /* only child 1 will fork the aux process */ if (rank==1) { pid = fork(); if (pid==-1) { LOG(L_CRIT,"ERROR:cpl_child_init(%d): cannot fork: %s!\n", rank, strerror(errno)); goto error; } else if (pid==0) { /* I'm the child */ /* initialize the config framework */ if (cfg_child_init()) goto error; cpl_aux_process( cpl_env.cmd_pipe[0], cpl_env.log_dir); } else { LOG(L_INFO,"INFO:cpl_child_init(%d): I just gave birth to a child!" " I'm a PARENT!!\n",rank); /* I'm the parent -> remember the pid */ aux_process = pid; } } return cpl_db_init(DB_URL, DB_TABLE); error: return -1; }
static int child_init(int rank) { int pid; if (rank!=PROC_INIT) cmd_pipe = pipe_fds[1]; if (rank!=PROC_MAIN) return 0; pid=fork_process(PROC_NOCHLDINIT, "jsonrpc io handler", 1); if (pid<0) { LM_ERR("failed to fork jsonrpc io handler\n"); return -1; /* error */ } if(pid==0){ /* child */ close(pipe_fds[1]); /* initialize the config framework */ if (cfg_child_init()) return -1; return jsonrpc_io_child_process(pipe_fds[0], servers_param); } return 0; }
static int child_init(int rank) { evrexec_task_t *it; int i; int pid; char si_desc[MAX_PT_DESC]; if(_evrexec_list==NULL) return 0; if (rank!=PROC_MAIN) return 0; it = _evrexec_list; while(it) { for(i=0; i<it->workers; i++) { snprintf(si_desc, MAX_PT_DESC, "EVREXEC child=%d exec=%.*s", i, it->ename.len, it->ename.s); pid=fork_process(PROC_RPC, si_desc, 1); if (pid<0) return -1; /* error */ if(pid==0){ /* child */ /* initialize the config framework */ if (cfg_child_init()) return -1; evrexec_process(it, i); } } it = it->next; } return 0; }
/*! This function is called when Kamailio has finished creating all instances of * itself. It is at this point that we want to create our AgentX sub-agent * process, and register a handler for any state changes of our child. */ static int mod_child_init(int rank) { int pid; /* We only want to setup a single process, under the main attendant. */ if(rank != PROC_MAIN) { return 0; } /* Spawn SNMP AgentX process */ pid = fork_process(PROC_NOCHLDINIT, "SNMP AgentX", 1); if(pid < 0) return -1; /* error */ if(pid == 0) { /* child */ /* initialize the config framework */ if(cfg_child_init()) return -1; agentx_child(1); return 0; } /* Spawn a child that will check the system up time. */ spawn_sysUpTime_child(); return 0; }
static int child_init(int rank) { LM_DBG("Initialization of module in child [%d] \n", rank); if ((subscribe_to_reginfo == 1) && (rank == PROC_MAIN)) { LM_DBG("Creating RegInfo Event Processor process\n"); int pid = fork_process(PROC_SIPINIT, "RegInfo Event Processor", 1); if (pid < 0) return -1; //error if (pid == 0) { if (cfg_child_init()) return -1; //error reginfo_event_process(); } } if (rank == PROC_MAIN || rank == PROC_TCP_MAIN) return 0; if (rank == 1) { /* init stats */ //TODO if parameters are modified via cfg framework do i change them? //update_stat( max_expires_stat, default_registrar_cfg.max_expires ); update_stat( max_contacts_stat, default_registrar_cfg.max_contacts ); update_stat( default_expire_stat, default_registrar_cfg.default_expires ); } /* don't do anything for main process and TCP manager process */ if (rank == PROC_MAIN || rank == PROC_TCP_MAIN) return 0; return 0; }
int jsonrpc_fifo_child_init(int rank) { int pid; if(jsonrpc_fifo == NULL) { LM_ERR("invalid fifo file path\n"); } pid=fork_process(PROC_NOCHLDINIT, "JSONRPC-S FIFO", 1); if (pid<0) { return -1; /* error */ } if(pid==0) { /* child */ /* initialize the config framework */ if (cfg_child_init()) return -1; jsonrpc_fifo_process(1); } return 0; }
/** * \brief Forks a separate simple sleep() -&- sync periodic timer * * Forks a very basic periodic timer process, that just sleep()s for * the specified interval and then calls the timer function. * The new "sync timer" process execution start immediately, the sleep() * is called first (so the first call to the timer function will happen * \<interval\> seconds after the call to fork_sync_timer) * @param child_id @see fork_process() * @param desc @see fork_process() * @param make_sock @see fork_process() * @param f timer function/callback * @param param parameter passed to the timer function * @param interval interval in seconds. * @return pid of the new process on success, -1 on error * (doesn't return anything in the child process) */ int fork_sync_timer(int child_id, char* desc, int make_sock, timer_function* f, void* param, int interval) { int pid; ticks_t ts1 = 0; ticks_t ts2 = 0; pid=fork_process(child_id, desc, make_sock); if (pid<0) return -1; if (pid==0){ /* child */ ts2 = interval; if (cfg_child_init()) return -1; for(;;){ if(ts2>0) sleep(ts2); else sleep(1); ts1 = get_ticks(); cfg_update(); f(get_ticks(), param); /* ticks in s for compatibility with old timers */ ts2 = interval - get_ticks() + ts1; } } /* parent */ return pid; }
/** * This function initializes each one of the processes spawn by the server. * the rank is 1 only when the main process is being initialized, so in that * case the function spawns the SEAS process to handle as_events triggered * from the other SER processes (executing the script). * the new process created, then goes into dispatcher_main_loop(), where * it reads() the pipe waiting for events produced by other SER processes. */ static int seas_child_init(int rank) { int pid; /* only the child 1 will execute this */ if (rank != PROC_MAIN){ /* only dispatcher needs to read from the pipe, so close reading fd*/ /*close(read_pipe);*/ return 0; } if ((pid=fork_process(PROC_NOCHLDINIT,"SEAS",0))<0) { LM_ERR("forking failed\n"); return -1; } if (!pid) { /*dispatcher child. we leave writing end open so that new childs spawned * by event dispatcher can also write to pipe.. */ /* initialize the config framework */ if (cfg_child_init()) return -1; /* close(write_pipe); */ return dispatcher_main_loop(); } return 0; }
/** * \brief Forks a separate simple milisecond-sleep() -&- sync periodic timer * * Forks a very basic periodic timer process, that just ms-sleep()s for * the specified interval and then calls the timer function. * The new "sync timer" process execution start immediately, the ms-sleep() * is called first (so the first call to the timer function will happen * \<interval\> seconds after the call to fork_basic_utimer) * @param child_id @see fork_process() * @param desc @see fork_process() * @param make_sock @see fork_process() * @param f timer function/callback * @param param parameter passed to the timer function * @param uinterval interval in mili-seconds. * @return pid of the new process on success, -1 on error * (doesn't return anything in the child process) */ int fork_sync_utimer(int child_id, char* desc, int make_sock, utimer_function* f, void* param, int uinterval) { int pid; ticks_t ts1 = 0; ticks_t ts2 = 0; pid=fork_process(child_id, desc, make_sock); if (pid<0) return -1; if (pid==0){ /* child */ ts2 = uinterval; if (cfg_child_init()) return -1; for(;;){ if(ts2>0) sleep_us(uinterval); else sleep_us(1); ts1 = get_ticks_raw(); cfg_update(); f(TICKS_TO_MS(ts1), param); /* ticks in mili-seconds */ ts2 = uinterval - get_ticks_raw() + ts1; } } /* parent */ return pid; }
/** * Initializes the module in child. */ static int mod_child_init(int rank) { LM_DBG("Initialization of module in child [%d] \n", rank); if (rank == PROC_MAIN) { int pid = fork_process(PROC_SIPINIT, "Rx Event Processor", 1); if (pid < 0) return -1; //error if (pid == 0) { if (cfg_child_init()) return -1; //error cdp_cb_event_process(); } } /* don't do anything for main process and TCP manager process */ if (rank == PROC_MAIN || rank == PROC_TCP_MAIN) { return 0; } lock_get(process_lock); if ((*callback_singleton) == 0) { *callback_singleton = 1; cdpb.AAAAddRequestHandler(callback_cdp_request, NULL); } lock_release(process_lock); return 0; }
/* arm the "slow" timer ( start it) * returns -1 on error * WARNING: use it in the same process as the timer * (the one using pause(); timer_handler()) or * change run_timer to a pointer in shared mem */ int arm_slow_timer() { sigemptyset(&slow_timer_sset); sigaddset(&slow_timer_sset, SLOW_TIMER_SIG); again: if (sigprocmask(SIG_BLOCK, &slow_timer_sset, 0)==-1){ if (errno==EINTR) goto again; LM_ERR("sigprocmask failed: %s [%d]}n", strerror(errno), errno); goto error; } #ifdef __OS_darwin /* workaround for darwin sigwait bug, see slow_timer_main() for more * info (or grep __OS_darwin) */ /* keep in sync wih main.c: sig_usr() - signals we are interested in */ sigaddset(&slow_timer_sset, SIGINT); sigaddset(&slow_timer_sset, SIGTERM); sigaddset(&slow_timer_sset, SIGUSR1); sigaddset(&slow_timer_sset, SIGHUP); sigaddset(&slow_timer_sset, SIGCHLD); sigaddset(&slow_timer_sset, SIGALRM); #endif /* initialize the config framework */ if (cfg_child_init()) goto error; return 0; error: return -1; }
/* arm the timer ( start it) * returns -1 on error * WARNING: use it in the same process as the timer * (the one using pause(); timer_handler()) or * change run_timer to a pointer in shared mem */ int arm_timer() { struct itimerval it; /* init signal generation */ it.it_interval.tv_sec=0; it.it_interval.tv_usec=1000000/TIMER_TICKS_HZ; it.it_value=it.it_interval; /* install the signal handler */ if (set_sig_h(SIGALRM, sig_timer) == SIG_ERR ){ LM_CRIT("SIGALRM signal handler cannot be installed: %s [%d]\n", strerror(errno), errno); return -1; } if (setitimer(ITIMER_REAL, &it, 0) == -1){ LM_CRIT("setitimer failed: %s [%d]\n", strerror(errno), errno); return -1; } if (gettimeofday(&last_time, 0)<0){ LM_ERR("gettimeofday failed: %s [%d]\n", strerror(errno), errno); return -1; } /* initialize the config framework */ if (cfg_child_init()) return -1; return 0; }
/** * \brief Forks a separate simple sleep() -&- sync periodic timer * * Forks a very basic periodic timer process, that just sleep()s for * the specified interval and then calls the timer function. * The new "sync timer" process execution start immediately, the sleep() * is called first (so the first call to the timer function will happen * \<interval\> seconds after the call to fork_sync_timer) * @param child_id @see fork_process() * @param desc @see fork_process() * @param make_sock @see fork_process() * @param f timer function/callback * @param param parameter passed to the timer function * @param interval interval in seconds. * @return pid of the new process on success, -1 on error * (doesn't return anything in the child process) */ int fork_sync_timer(int child_id, char* desc, int make_sock, timer_function* f, void* param, int interval) { int pid; ticks_t ts1 = 0; ticks_t ts2 = 0; pid=fork_process(child_id, desc, make_sock); if (pid<0) return -1; if (pid==0){ /* child */ interval *= 1000; /* miliseconds */ ts2 = interval; if (cfg_child_init()) return -1; for(;;){ if (ts2>interval) sleep_us(1000); /* 1 milisecond sleep to catch up */ else sleep_us(ts2*1000); /* microseconds sleep */ ts1 = get_ticks_raw(); cfg_update(); f(TICKS_TO_S(ts1), param); /* ticks in sec for compatibility with old timers */ /* adjust the next sleep duration */ ts2 = interval - TICKS_TO_MS(get_ticks_raw()) + TICKS_TO_MS(ts1); } } /* parent */ return pid; }
/** * @brief Initialize async module children */ static int child_init(int rank) { int pid; int i; LM_DBG("child initializing async http\n"); if(num_workers<=0) return 0; if (rank==PROC_INIT) { for(i=0; i<num_workers; i++) { LM_DBG("initializing worker notification socket: %d\n", i); if(async_http_init_sockets(&workers[i])<0) { LM_ERR("failed to initialize tasks sockets\n"); return -1; } } return 0; } if(rank>0) { for(i=0; i<num_workers; i++) { close(workers[i].notication_socket[0]); } return 0; } if (rank!=PROC_MAIN) return 0; for(i=0; i<num_workers; i++) { if(async_http_init_worker(i+1, &workers[i])<0) { LM_ERR("failed to initialize worker process: %d\n", i); return -1; } pid=fork_process(PROC_RPC, "Http Worker", 1); if (pid<0) return -1; /* error */ if(pid==0) { /* child */ /* enforce http_reply_parse=yes */ http_reply_parse = 1; /* initialize the config framework */ if (cfg_child_init()) return -1; /* init msg structure for http reply parsing */ ah_reply = pkg_malloc(sizeof(struct sip_msg)); if(!ah_reply) { LM_ERR("failed to allocate pkg memory\n"); return -1; } memset(ah_reply, 0, sizeof(struct sip_msg)); /* main function for workers */ async_http_run_worker(&workers[i]); } } return 0; }
/*! \brief Initialize module for child processes */ static int mi_child_init(int rank) { int pid; if (rank==PROC_TIMER || rank>0 ) { if ( mi_writer_init(read_buf_size, mi_reply_indent)!=0 ) { LM_CRIT("failed to init the reply writer\n"); return -1; } } if (rank==PROC_MAIN) { pid=fork_process(PROC_NOCHLDINIT, "MI FIFO", 1); if (pid<0) return -1; /* error */ if(pid==0){ /* child */ /* initialize the config framework */ if (cfg_child_init()) return -1; fifo_process(1); } } return 0; }
static int child_init(int rank) { int pid; if (rank!=PROC_MAIN) return 0; if(!reg_db_url.s || reg_db_url.len<=0) return 0; pid=fork_process(PROC_TIMER, "TIMER UAC REG", 1); if (pid<0) { LM_ERR("failed to register timer routine as process\n"); return -1; } if (pid==0){ /* child */ /* initialize the config framework */ if (cfg_child_init()) return -1; uac_reg_load_db(); uac_reg_timer(0); for(;;){ /* update the local config framework structures */ cfg_update(); sleep(reg_timer_interval); uac_reg_timer(get_ticks()); } } /* parent */ return 0; }
static int child_init(int rank) { int pid; int k=0; LM_DBG("Initialization of module in child [%d] \n", rank); if (rank == PROC_MAIN) { /* fork notification workers */ for(k=0;k<notification_processes;k++){ pid = fork_process(1001+k,"notification_worker",1); if (pid==-1){ LM_CRIT("init_notification_worker(): Error on fork() for worker!\n"); return 0; } if (pid==0) { if (cfg_child_init()) return 0; notification_event_process(); LM_CRIT("init_notification_worker():: worker_process finished without exit!\n"); exit(-1); } } } if (rank == PROC_MAIN || rank == PROC_TCP_MAIN) return 0; if (rank == 1) { /* init stats */ //TODO if parameters are modified via cfg framework do i change them? update_stat(max_expires_stat, default_registrar_cfg.max_expires); update_stat(max_contacts_stat, default_registrar_cfg.max_contacts); update_stat(default_expire_stat, default_registrar_cfg.default_expires); } /* don't do anything for main process and TCP manager process */ /* don't do anything for main process and TCP manager process */ if (rank == PROC_MAIN || rank == PROC_TCP_MAIN) return 0; /* Init the user data parser */ if (!parser_init(scscf_user_data_dtd, scscf_user_data_xsd)) return -1; lock_get(process_lock); if ((*callback_singleton) == 0) { *callback_singleton = 1; cdpb.AAAAddRequestHandler(callback_cdp_request, NULL); } lock_release(process_lock); return 0; }
int async_task_child_init(int rank) { int pid; int i; if(_async_task_workers<=0) return 0; LM_DBG("child initializing asynk task framework\n"); if (rank==PROC_INIT) { if(async_task_init_sockets()<0) { LM_ERR("failed to initialize tasks sockets\n"); return -1; } return 0; } if(rank>0) { async_task_close_sockets_parent(); return 0; } if (rank!=PROC_MAIN) return 0; for(i=0; i<_async_task_workers; i++) { pid=fork_process(PROC_RPC, "Async Task Worker", 1); if (pid<0) return -1; /* error */ if(pid==0) { /* child */ /* initialize the config framework */ if (cfg_child_init()) return -1; /* main function for workers */ if(async_task_run(i+1)<0) { LM_ERR("failed to initialize task worker process: %d\n", i); return -1; } } } return 0; }
/** * \brief Forks a separate simple sleep() periodic timer * * Forks a very basic periodic timer process, that just sleep()s for * the specified interval and then calls the timer function. * The new "basic timer" process execution start immediately, the sleep() * is called first (so the first call to the timer function will happen * \<interval\> seconds after the call to fork_basic_timer) * @param child_id @see fork_process() * @param desc @see fork_process() * @param make_sock @see fork_process() * @param f timer function/callback * @param param parameter passed to the timer function * @param interval interval in seconds. * @return pid of the new process on success, -1 on error * (doesn't return anything in the child process) */ int fork_basic_timer(int child_id, char* desc, int make_sock, timer_function* f, void* param, int interval) { int pid; pid=fork_process(child_id, desc, make_sock); if (pid<0) return -1; if (pid==0){ /* child */ if (cfg_child_init()) return -1; for(;;){ sleep(interval); cfg_update(); f(get_ticks(), param); /* ticks in s for compatibility with old timers */ } } /* parent */ return pid; }
/** * initialize child processes */ static int child_init(int rank) { int pid; if (rank==PROC_MAIN) { pid=fork_process(PROC_NOCHLDINIT, "XMPP Manager", 1); if (pid<0) return -1; /* error */ if(pid==0){ /* child */ /* initialize the config framework */ if (cfg_child_init()) return -1; xmpp_process(1); } } return 0; }
static int mi_child_init(int rank) { int i; int pid; if (rank==PROC_TIMER || rank>0 ) { if(mi_datagram_writer_init( DATAGRAM_SOCK_BUF_SIZE , mi_reply_indent )!= 0) { LM_CRIT("failed to initiate mi_datagram_writer\n"); return -1; } } if (rank==PROC_MAIN) { if(pre_datagram_process()!=0) { LM_ERR("pre-fork function failed\n"); return -1; } for(i=0; i<mi_procs[0].no; i++) { pid=fork_process(PROC_NOCHLDINIT, "MI DATAGRAM", 1); if (pid<0) return -1; /* error */ if(pid==0) { /* child */ /* initialize the config framework */ if (cfg_child_init()) return -1; datagram_process(i); return 0; } } if(post_datagram_process()!=0) { LM_ERR("post-fork function failed\n"); return -1; } } return 0; }
/** * \brief Forks a separate simple milisecond-sleep() periodic timer * * Forks a very basic periodic timer process, that just ms-sleep()s for * the specified interval and then calls the timer function. * The new "basic timer" process execution start immediately, the ms-sleep() * is called first (so the first call to the timer function will happen * \<interval\> seconds after the call to fork_basic_utimer) * @param child_id @see fork_process() * @param desc @see fork_process() * @param make_sock @see fork_process() * @param f timer function/callback * @param param parameter passed to the timer function * @param uinterval interval in mili-seconds. * @return pid of the new process on success, -1 on error * (doesn't return anything in the child process) */ int fork_basic_utimer(int child_id, char* desc, int make_sock, utimer_function* f, void* param, int uinterval) { int pid; ticks_t ts; pid=fork_process(child_id, desc, make_sock); if (pid<0) return -1; if (pid==0){ /* child */ if (cfg_child_init()) return -1; for(;;){ sleep_us(uinterval); cfg_update(); ts = get_ticks_raw(); f(TICKS_TO_MS(ts), param); /* ticks in mili-seconds */ } } /* parent */ return pid; }
/** * Start the CDiameterPeer operations. * It forks all the processes required. * @param blocking - if this is set, use the calling processes for the timer and never * return; else fork a new one for the timer and return * @returns 1 on success, 0 on error, never if blocking */ int diameter_peer_start(int blocking) { int pid; int k=0; peer *p; /* fork workers */ for(k=0;k<config->workers;k++){ pid = fork_process(1001+k,"cdp_worker",1); if (pid==-1){ LM_CRIT("init_diameter_peer(): Error on fork() for worker!\n"); return 0; } if (pid==0) { srandom(time(0)*k); snprintf(pt[process_no].desc, MAX_PT_DESC,"cdp worker child=%d", k ); if (cfg_child_init()) return 0; worker_process(k); LM_CRIT("init_diameter_peer(): worker_process finished without exit!\n"); exit(-1); }else{ dp_add_pid(pid); } } /* init the fd_exchange pipes */ receiver_init(NULL); for(p = peer_list->head,k=0;p;p=p->next,k++) receiver_init(p); /* fork receiver for unknown peers */ pid = fork_process(1001+k,"cdp_receiver_peer_unkown",1); if (pid==-1){ LM_CRIT("init_diameter_peer(): Error on fork() for unknown peer receiver!\n"); return 0; } if (pid==0) { srandom(time(0)*k); snprintf(pt[process_no].desc, MAX_PT_DESC, "cdp receiver peer unknown"); if (cfg_child_init()) return 0; receiver_process(NULL); LM_CRIT("init_diameter_peer(): receiver_process finished without exit!\n"); exit(-1); }else{ dp_add_pid(pid); } /* fork receivers for each pre-configured peers */ lock_get(peer_list_lock); for(p = peer_list->head,k=-1;p;p = p->next,k--){ pid = fork_process(1001+k,"cdp_receiver_peer",1); if (pid==-1){ LM_CRIT("init_diameter_peer(): Error on fork() for peer receiver!\n"); return 0; } if (pid==0) { srandom(time(0)*k); snprintf(pt[process_no].desc, MAX_PT_DESC, "cdp_receiver_peer=%.*s", p->fqdn.len,p->fqdn.s ); if (cfg_child_init()) return 0; receiver_process(p); LM_CRIT("init_diameter_peer(): receiver_process finished without exit!\n"); exit(-1); }else{ dp_add_pid(pid); } } lock_release(peer_list_lock); /* Fork the acceptor process (after receivers, so it inherits all the right sockets) */ pid = fork_process(1000,"cdp_acceptor",1); if (pid==-1){ LM_CRIT("init_diameter_peer(): Error on fork() for acceptor!\n"); return 0; } if (pid==0) { if (cfg_child_init()) return 0; acceptor_process(config); LM_CRIT("init_diameter_peer(): acceptor_process finished without exit!\n"); exit(-1); }else{ dp_add_pid(pid); } /* fork/become timer */ if (blocking) { dp_add_pid(getpid()); if (cfg_child_init()) return 0; timer_process(1); } else{ pid = fork_process(1001,"cdp_timer",1); if (pid==-1){ LM_CRIT("init_diameter_peer(): Error on fork() for timer!\n"); return 0; } if (pid==0) { if (cfg_child_init()) return 0; timer_process(0); LM_CRIT("init_diameter_peer(): timer_process finished without exit!\n"); exit(-1); }else{ dp_add_pid(pid); } } return 1; }
/* * Initialize children */ static int child_init(int rank) { int i, j, mpid, cpid; DBG("XJAB:child_init: initializing child <%d>\n", rank); /* Rank 0 is main process now - 1 is the first child (janakj) */ if(rank == 1) { #ifdef HAVE_IHTTP /** register iHTTP callbacks -- go forward in any case*/ ihb.reg_f("xjab", "XMPP Gateway", IH_MENU_YES, xjab_mod_info, NULL); ihb.reg_f("xjabc", "XMPP connections", IH_MENU_YES, xjab_connections, NULL); #endif if((mpid=fork())<0 ) { LOG(L_ERR, "XJAB:child_init:error - cannot launch worker's" " manager\n"); return -1; } if(mpid == 0) { /** launching the workers */ for(i=0;i<nrw;i++) { if ( (cpid=fork())<0 ) { LOG(L_ERR,"XJAB:child_init:error - cannot launch worker\n"); return -1; } if (cpid == 0) { for(j=0;j<nrw;j++) if(j!=i) close(pipes[j][0]); close(pipes[i][1]); if(xj_wlist_set_pid(jwl, getpid(), i) < 0) { LOG(L_ERR, "XJAB:child_init:error setting worker's" " pid\n"); return -1; } /* initialize the config framework */ if (cfg_child_init()) return -1; ctx = db_ctx("jabber"); if (ctx == NULL) goto dberror; if (db_add_db(ctx, db_url) < 0) goto dberror; if (db_connect(ctx) < 0) goto dberror; cmd = db_cmd(DB_GET, ctx, db_table, db_cols, db_params, NULL); if (!cmd) goto dberror; xj_worker_process(jwl,jaddress,jport,i, cmd); db_cmd_free(cmd); db_ctx_free(ctx); ctx = NULL; /* destroy the local config */ cfg_child_destroy(); exit(0); } } mpid = getpid(); /* initialize the config framework */ if (cfg_child_init()) return -1; while(1) { sleep(check_time); /* update the local config */ cfg_update(); xjab_check_workers(mpid); } } } //if(pipes) //{ // for(i=0;i<nrw;i++) // close(pipes[i][0]); //} return 0; dberror: if (cmd) db_cmd_free(cmd); cmd = NULL; if (ctx) db_ctx_free(ctx); ctx = NULL; return -1; }
void tcp_receive_loop(int unix_sock) { /* init */ tcpmain_sock=unix_sock; /* init com. socket */ if (init_io_wait(&io_w, get_max_open_fds(), tcp_poll_method)<0) goto error; tcp_reader_prev_ticks=get_ticks_raw(); if (init_local_timer(&tcp_reader_ltimer, get_ticks_raw())!=0) goto error; /* add the unix socket */ if (io_watch_add(&io_w, tcpmain_sock, POLLIN, F_TCPMAIN, 0)<0){ LM_CRIT("failed to add socket to the fd list\n"); goto error; } /* initialize the config framework */ if (cfg_child_init()) goto error; /* main loop */ switch(io_w.poll_method){ case POLL_POLL: while(1){ io_wait_loop_poll(&io_w, TCP_CHILD_SELECT_TIMEOUT, 0); tcp_reader_timer_run(); } break; #ifdef HAVE_SELECT case POLL_SELECT: while(1){ io_wait_loop_select(&io_w, TCP_CHILD_SELECT_TIMEOUT, 0); tcp_reader_timer_run(); } break; #endif #ifdef HAVE_SIGIO_RT case POLL_SIGIO_RT: while(1){ io_wait_loop_sigio_rt(&io_w, TCP_CHILD_SELECT_TIMEOUT); tcp_reader_timer_run(); } break; #endif #ifdef HAVE_EPOLL case POLL_EPOLL_LT: while(1){ io_wait_loop_epoll(&io_w, TCP_CHILD_SELECT_TIMEOUT, 0); tcp_reader_timer_run(); } break; case POLL_EPOLL_ET: while(1){ io_wait_loop_epoll(&io_w, TCP_CHILD_SELECT_TIMEOUT, 1); tcp_reader_timer_run(); } break; #endif #ifdef HAVE_KQUEUE case POLL_KQUEUE: while(1){ io_wait_loop_kqueue(&io_w, TCP_CHILD_SELECT_TIMEOUT, 0); tcp_reader_timer_run(); } break; #endif #ifdef HAVE_DEVPOLL case POLL_DEVPOLL: while(1){ io_wait_loop_devpoll(&io_w, TCP_CHILD_SELECT_TIMEOUT, 0); tcp_reader_timer_run(); } break; #endif default: LM_CRIT("no support for poll method %s (%d)\n", poll_method_name(io_w.poll_method), io_w.poll_method); goto error; } error: destroy_io_wait(&io_w); LM_CRIT("exiting..."); exit(-1); }
static int mod_child_init(int rank) { int pid; int i; kz_amqp_zone_ptr g; kz_amqp_server_ptr s; fire_init_event(rank); if (rank==PROC_INIT || rank==PROC_TCP_MAIN) return 0; // if (rank>PROC_MAIN) // kz_cmd_pipe = kz_cmd_pipe_fds[1]; if (rank==PROC_MAIN) { /* pid=fork_process(PROC_NOCHLDINIT, "AMQP Timer", 0); if (pid<0) return -1; if(pid==0){ return(kz_amqp_timeout_proc()); } */ for(i=0; i < dbk_consumer_workers; i++) { pid=fork_process(i+1, "AMQP Consumer Worker", 1); if (pid<0) return -1; /* error */ if(pid==0){ if (cfg_child_init()) return -1; close(kz_worker_pipes_fds[i*2+1]); return(kz_amqp_consumer_worker_proc(kz_worker_pipes_fds[i*2])); } } for (g = kz_amqp_get_zones(); g != NULL; g = g->next) { int w = (g == kz_amqp_get_primary_zone() ? dbk_consumer_processes : 1); for(i=0; i < w; i++) { for (s = g->servers->head; s != NULL; s = s->next) { pid=fork_process(PROC_NOCHLDINIT, "AMQP Consumer", 0); if (pid<0) return -1; /* error */ if(pid==0){ if (cfg_child_init()) return -1; return(kz_amqp_consumer_proc(s)); } } } } pid=fork_process(PROC_NOCHLDINIT, "AMQP Publisher", 1); if (pid<0) return -1; /* error */ if(pid==0){ if (cfg_child_init()) return -1; close(kz_cmd_pipe_fds[1]); kz_amqp_publisher_proc(kz_cmd_pipe_fds[0]); } return 0; } if(dbk_pua_mode == 1) { if (kz_pa_dbf.init==0) { LM_CRIT("child_init: database not bound\n"); return -1; } kz_pa_db = kz_pa_dbf.init(&kz_db_url); if (!kz_pa_db) { LM_ERR("child %d: unsuccessful connecting to database\n", rank); return -1; } if (kz_pa_dbf.use_table(kz_pa_db, &kz_presentity_table) < 0) { LM_ERR( "child %d:unsuccessful use_table presentity_table\n", rank); return -1; } LM_DBG("child %d: Database connection opened successfully\n", rank); } return 0; }