void child_main(ci_socket sockfd)
{
int claddrlen = sizeof(ci_sockaddr_t);
ci_thread_t thread;
int i, retcode, haschild = 1, jobs_in_queue = 0;
int pid = 0;
char op;
HANDLE hStdin;
DWORD dwRead;
// child_signals();
// pid=getpid();
hStdin = GetStdHandle(STD_INPUT_HANDLE);
if ((hStdin == INVALID_HANDLE_VALUE))
ExitProcess(1);
ci_thread_mutex_init(&threads_list_mtx);
ci_thread_mutex_init(&counters_mtx);
ci_thread_cond_init(&free_server_cond);
threads_list =
(server_decl_t **) malloc((START_SERVERS + 1) *
sizeof(server_decl_t *));
con_queue = init_queue(START_SERVERS);
for (i = 0; i < START_SERVERS; i++) {
if ((threads_list[i] = newthread(con_queue)) == NULL) {
exit(-1); // FATAL error.....
}
retcode = ci_thread_create(&thread,
(void *(*)(void *)) thread_main,
(void *) threads_list[i]);
}
threads_list[START_SERVERS] = NULL;
ci_debug_printf(1, "Threads created ....\n");
retcode = ci_thread_create(&worker_thread,
(void *(*)(void *)) worker_main,
(void *) (sockfd));
//Listen for events from main server better..............
while (ReadFile(hStdin, &op, 1, &dwRead, NULL)) {
printf("Operation Read: %c\n", op);
if (op == 'q')
goto end_child_main;
}
ci_thread_join(worker_thread);
end_child_main:
cancel_all_threads();
exit_normaly();
}
struct ldap_connections_pool *ldap_pool_create(char *server, int port, char *user, char *password)
{
struct ldap_connections_pool *pool;
ci_thread_mutex_lock(&ldap_connections_pool_mtx);
pool = search_ldap_pools(server, port,
(user != NULL? user : ""),
(password != NULL? password : ""));
if(pool) {
ci_thread_mutex_unlock(&ldap_connections_pool_mtx);
return pool;
}
pool = malloc(sizeof(struct ldap_connections_pool));
if(!pool) {
ci_thread_mutex_unlock(&ldap_connections_pool_mtx);
return NULL;
}
strncpy(pool->server, server, CI_MAXHOSTNAMELEN);
pool->server[CI_MAXHOSTNAMELEN]='\0';
pool->port = port;
pool->ldapversion = LDAP_VERSION3;
pool->next = NULL;
if(user) {
strncpy(pool->user,user,256);
pool->user[255] = '\0';
}
else
pool->user[0] = '\0';
if(password) {
strncpy(pool->password,password,256);
pool->password[255] = '\0';
}
else
pool->password[0] = '\0';
pool->connections = 0;
pool->inactive = NULL;
pool->used = NULL;
snprintf(pool->ldap_uri,1024,"%s://%s:%d","ldap",pool->server,pool->port);
pool->ldap_uri[1023] = '\0';
ci_thread_mutex_init(&pool->mutex);
#ifdef LDAP_MAX_CONNECTIONS
pool->max_connections = 0;
ci_thread_cond_init(&pool->pool_cond);
#endif
add_ldap_pool(pool);
ci_thread_mutex_unlock(&ldap_connections_pool_mtx);
return pool;
}
int postInitImageClassificationService(void)
{
uint16_t category;
ci_thread_rwlock_init(&imageclassify_rwlock);
ci_thread_rwlock_wrlock(&imageclassify_rwlock);
/*Initialize object pools*/
IMAGEDETECTED_POOL = ci_object_pool_register("image_detected_t", sizeof(image_detected_t) * num_image_categories);
if(IMAGEDETECTED_POOL < 0) {
ci_debug_printf(1, " srvclassify_init_service: error registering object_pool image_detected_t\n");
ci_thread_rwlock_unlock(&imageclassify_rwlock);
return CI_ERROR;
}
IMAGEDETECTEDCOUNT_POOL = ci_object_pool_register("image_detected_count_t", sizeof(image_detected_count_t) * num_image_categories);
if(IMAGEDETECTEDCOUNT_POOL < 0) {
ci_debug_printf(1, " srvclassify_init_service: error registering object_pool image_detected_count_t\n");
ci_object_pool_unregister(IMAGEDETECTED_POOL);
ci_thread_rwlock_unlock(&imageclassify_rwlock);
return CI_ERROR;
}
if(num_image_categories)
{
for(category = 0; category < num_image_categories; category++)
{
if(ci_thread_mutex_init(&imageCategories[category].mutex) != 0)
{
ci_debug_printf(1, "srv_classify_image: Couldn't init category mutex\n");
}
if(ci_thread_cond_init(&imageCategories[category].cond) != 0)
{
ci_debug_printf(1, "srv_classify_image: Couldn't init category condition lock variable\n");
}
}
}
ci_thread_rwlock_unlock(&imageclassify_rwlock);
return CI_OK;
}
struct connections_queue *init_queue(int size){
int ret;
struct connections_queue *q;
if((q=(struct connections_queue *)malloc(sizeof(struct connections_queue)))==NULL)
return NULL;
ret=ci_thread_mutex_init(&(q->queue_mtx));
( ret==0&& (ret=ci_thread_mutex_init(&(q->cond_mtx))));
(ret==0 && (ret=ci_thread_cond_init(&(q->queue_cond))));
if(ret==0 && (q->connections=(ci_connection_t *)malloc(size*sizeof(ci_connection_t)))!=NULL){
q->size=size;
q->used=0;
return q;
}
//else memory allocation failed or mutex/cond init failed
if(q->connections)
free(q->connections);
free(q);
return NULL;
}
void child_main(int sockfd, int pipefd)
{
ci_thread_t thread;
int i, ret;
signal(SIGTERM, SIG_IGN); /*Ignore parent requests to kill us untill we are up and running */
ci_thread_mutex_init(&threads_list_mtx);
ci_thread_mutex_init(&counters_mtx);
ci_thread_cond_init(&free_server_cond);
ci_stat_attach_mem(child_data->stats, child_data->stats_size, NULL);
threads_list =
(server_decl_t **) malloc((CONF.THREADS_PER_CHILD + 1) *
sizeof(server_decl_t *));
con_queue = init_queue(CONF.THREADS_PER_CHILD);
for (i = 0; i < CONF.THREADS_PER_CHILD; i++) {
if ((threads_list[i] = newthread(con_queue)) == NULL) {
exit(-1); // FATAL error.....
}
ret =
ci_thread_create(&thread, (void *(*)(void *)) thread_main,
(void *) threads_list[i]);
threads_list[i]->srv_pthread = thread;
}
threads_list[CONF.THREADS_PER_CHILD] = NULL;
/*Now start the listener thread.... */
ret = ci_thread_create(&thread, (void *(*)(void *)) listener_thread,
(void *) &sockfd);
listener_thread_id = thread;
/*set srand for child......*/
srand(((unsigned int)time(NULL)) + (unsigned int)getpid());
/*I suppose that all my threads are up now. We can setup our signal handlers */
child_signals();
/* A signal from parent may comes while we are starting.
Listener will not accept any request in this case, (it checks on
the beggining of the accept loop for parent commands) so we can
shutdown imediatelly even if the parent said gracefuly.*/
if (child_data->father_said)
child_data->to_be_killed = IMMEDIATELY;
/*start child commands may have non thread safe code but the worker threads
does not serving requests yet.*/
commands_execute_start_child();
/*Signal listener to start accepting requests.*/
int doStart = 0;
do {
ci_thread_mutex_lock(&counters_mtx);
doStart = listener_running;
ci_thread_mutex_unlock(&counters_mtx);
if (!doStart)
ci_usleep(5);
} while(!doStart);
ci_thread_cond_signal(&free_server_cond);
while (!child_data->to_be_killed) {
char buf[512];
int bytes;
if ((ret = ci_wait_for_data(pipefd, 1, wait_for_read)) > 0) { /*data input */
bytes = ci_read_nonblock(pipefd, buf, 511);
if (bytes == 0) {
ci_debug_printf(1,
"Parent closed the pipe connection! Going to term immediately!\n");
child_data->to_be_killed = IMMEDIATELY;
} else {
buf[bytes] = '\0';
handle_child_process_commands(buf);
}
}
else if (ret < 0) {
ci_debug_printf(1,
"An error occured while waiting for commands from parent. Terminating!\n");
child_data->to_be_killed = IMMEDIATELY;
}
if (!listener_running && !child_data->to_be_killed) {
ci_debug_printf(1,
"Ohh!! something happened to listener thread! Terminating\n");
child_data->to_be_killed = GRACEFULLY;
}
commands_exec_scheduled();
}
ci_debug_printf(5, "Child :%d going down :%s\n", getpid(),
child_data->to_be_killed == IMMEDIATELY?
"IMMEDIATELY" : "GRACEFULLY");
cancel_all_threads();
commands_execute_stop_child();
exit_normaly();
}
void child_main(int sockfd){
ci_connection_t conn;
int claddrlen=sizeof(struct sockaddr_in);
ci_thread_t thread;
char clientname[300];
int i,retcode,haschild=1,jobs_in_queue=0;
int pid=0;
child_signals();
pid=getpid();
ci_thread_mutex_init(&threads_list_mtx);
ci_thread_mutex_init(&counters_mtx);
ci_thread_cond_init(&free_server_cond);
threads_list=(server_decl_t **)malloc((START_SERVERS+1)*sizeof(server_decl_t *));
con_queue=init_queue(START_SERVERS);
for(i=0;i<START_SERVERS;i++){
if((threads_list[i]=newthread(con_queue))==NULL){
exit(-1);// FATAL error.....
}
retcode=ci_thread_create(&thread,(void *(*)(void *))thread_main,(void *)threads_list[i]);
}
threads_list[START_SERVERS]=NULL;
for(;;){ //Global for
if(!ci_proc_mutex_lock(&accept_mutex)){
if(errno==EINTR){
debug_printf(5,"EINTR received\n");
if(child_data->to_be_killed)
goto end_child_main;
continue;
}
}
child_data->idle=0;
debug_printf(7,"Child %d getting requests now ...\n",pid);
do{//Getting requests while we have free servers.....
do{
errno = 0;
if(((conn.fd = accept(sockfd, (struct sockaddr *)&(conn.claddr), &claddrlen)) == -1) && errno != EINTR){
debug_printf(1,"error accept .... %d\nExiting server ....\n",errno);
exit(-1); //For the moment .......
goto end_child_main ;
}
if(errno==EINTR && child_data->to_be_killed)
goto end_child_main;
}while(errno==EINTR);
getsockname(conn.fd,(struct sockaddr *)&(conn.srvaddr),&claddrlen);
icap_socket_opts(sockfd);
if((jobs_in_queue=put_to_queue(con_queue,&conn))==0){
debug_printf(1,"ERROR!!!!!!NO AVAILABLE SERVERS!!!!!!!!!\n");
child_data->to_be_killed=GRACEFULLY;
debug_printf(1,"Jobs in Queue:%d,Free servers:%d, Used Servers :%d, Requests %d\n",
jobs_in_queue,
child_data->freeservers,child_data->usedservers,child_data->requests);
goto end_child_main;
}
ci_thread_mutex_lock(&counters_mtx);
haschild=(child_data->freeservers?1:0);
ci_thread_mutex_unlock(&counters_mtx);
(child_data->connections)++; //NUM of Requests....
}while(haschild);
child_data->idle=1;
ci_proc_mutex_unlock(&accept_mutex);
ci_thread_mutex_lock(&counters_mtx);
if(child_data->freeservers==0){
debug_printf(7,"Child %d waiting for a thread to accept more connections ...\n",pid);
ci_thread_cond_wait(&free_server_cond,&counters_mtx);
}
ci_thread_mutex_unlock(&counters_mtx);
}
end_child_main:
cancel_all_threads();
exit_normaly();
}
