Пример #1
0
static void *
thread_loop (void *args)
{
  struct thread_pool *pool = args;
  struct work_unit *work;

  while (NULL != (work = async_queue_pop (pool->work_queue, true)))
    {
      if (THREAD_POOL_TERM_SIG == work->func)
        {
          pthread_mutex_lock (&pool->lock);

          if (1 < pool->num_threads)
            thread_pool_push (pool, THREAD_POOL_TERM_SIG, NULL);

          pool->num_threads--;

          pthread_mutex_unlock (&pool->lock);
          free (work);

          return NULL;
        }

      work->func (work->data);

      free (work);
    }

  return NULL;
}
Пример #2
0
static void __client_writer_cb(struct ev_loop *loop, struct tls_user_context_t *context, int revents)
{
    user_session_t *session;
    int fd;
#if DEBUG_ENABLE
    int i = 0;
#endif
    while ((fd = GPOINTER_TO_INT(g_async_queue_try_pop(writer_queue)))) {
        session = get_client_datas_by_socket(fd);
        if (session == NULL) {
            continue;
        }
        if (g_mutex_trylock(session->rw_lock)) {
            ev_io_stop(session->srv_context->loop,
                       &session->client_watcher);
            debug_log_message(VERBOSE_DEBUG, DEBUG_AREA_USER,
                              "sending session to user_workers (%d)",
                              i);
            g_mutex_unlock(session->rw_lock);
            thread_pool_push(nuauthdatas->user_workers, session, NULL);
        }
#if DEBUG_ENABLE
        i++;
#endif
        unlock_client_datas();
    }
}
Пример #3
0
void OnTcpConnected(void* param, socket_t sock, const char* ip, int port)
{
WebSession* session = new WebSession(sock, ip, port);
if(0 != thread_pool_push(g_thdpool, WebSession::Run, session))
{
    printf("thread pool push error[%s.%d].\n", ip, port);
    delete session;
}
}
Пример #4
0
void thread_pool_test(void)
{
	int i, r;
	thread_pool_t pool;
	pool = thread_pool_create(4, 2, 8);

	for(i=0; i<20; i++)
	{
		r = thread_pool_push(pool, worker, &i);
		assert(0 == r);
	}
	
	thread_pool_destroy(pool);
}
Пример #5
0
static void CALLBACK timer_schd_worker(UINT uTimerID, UINT uMsg, DWORD_PTR dwUser, DWORD_PTR dw1, DWORD_PTR dw2)
{
	timer_context_t* ctx;
	ctx = (timer_context_t*)dwUser;
	if(1 != InterlockedIncrement(&ctx->locked))
	{
		InterlockedDecrement(&ctx->locked);
	}
	else
	{
		// one timer only can be call in one thread
		thread_pool_push(g_ctx.pool, timer_thread_worker, ctx);
	}
}
Пример #6
0
void client_activity_cb(struct ev_loop *loop, ev_io *w, int revents)
{
    struct tls_user_context_t *context = (struct tls_user_context_t *) w->data;
    /* get_client_datas_by_socket acquire client datas lock if session is found */
    user_session_t *c_session = get_client_datas_by_socket(w->fd);

    if (! c_session) {
        log_message(WARNING, DEBUG_AREA_USER,
                    "Unable to find session for %d", w->fd);
        return;
    }

    debug_log_message(VERBOSE_DEBUG, DEBUG_AREA_USER,
                      "User activity for \"%s\" (in cb)",
                      c_session->user_name);

    if (c_session->activated) {
        c_session->activated = FALSE;
    }

    ev_io_stop(context->loop, w);

    if (revents & EV_ERROR) {
        log_message(INFO, DEBUG_AREA_USER,
                    "Error on socket %d", w->fd);
        delete_locked_client_by_socket(w->fd);
        unlock_client_datas();
        return;
    }
    if (revents & EV_READ) {
        debug_log_message(VERBOSE_DEBUG, DEBUG_AREA_USER,
                          "Reading needed for user \"%s\"(in cb)",
                          c_session->user_name);
        g_async_queue_push(c_session->workunits_queue, GINT_TO_POINTER(0x1));
        thread_pool_push(nuauthdatas->user_workers, c_session, NULL);
        unlock_client_datas();
        return;
    }
    /* we should not reach this point */
    log_message(WARNING, DEBUG_AREA_USER, "Surprising event from libev: %d",
                revents);
    /* disconnecting session to be sure */
    if (g_mutex_trylock(c_session->rw_lock)) {
        delete_rw_locked_client(c_session);
    } else {
        c_session->pending_disconnect = TRUE;
    }
    unlock_client_datas();
}
Пример #7
0
/**
 * \brief Entry point of the program.
 * \param argc number of arguments.
 * \param argv array of arguments.
 * \return EXIT_SUCCESS or EXIT_FAILURE.
 */
int main(int argc, char** argv)
{
  const size_t tasks_size = 20;
  thread_pool th = NULL;
  struct thread_pool_task tasks[tasks_size];

  (void)argc;
  (void)argv;

  fprintf(stdout, "Begin\n");
  th = thread_pool_new(10);
  fprintf(stdout, "Thread pool: %p\n", (void*)th);

  if(!th)
  {
    fprintf(stderr, "Failed to create pool errno=%d\n",
        errno);
    exit(EXIT_FAILURE);
  }

  for(unsigned int i = 0 ; i < tasks_size ; i++)
  {
    tasks[i].data = (void*)(uintptr_t)i;
    tasks[i].run = fcn_run;
    tasks[i].cleanup = fcn_cleanup;

    if(thread_pool_push(th, &tasks[i]) != 0)
    {
      fprintf(stderr, "Failed to add task %u\n", i);
    }
  }

  thread_pool_start(th);
  sleep(1);

  fprintf(stdout, "Stop stuff\n");
  thread_pool_stop(th);
  fprintf(stdout, "Free stuff\n");
  thread_pool_free(&th);
  fprintf(stdout, "OK\n");

  fprintf(stdout, "End\n");

  return EXIT_SUCCESS;
}
Пример #8
0
bool
thread_pool_barrier_wait (struct thread_pool *pool)
{
  size_t max_threads = pool->num_threads;
  loomlib_barrier_t* barrier;

  pthread_mutex_lock (&pool->lock);

  loomlib_barrier_init (barrier, NULL, pool->num_threads + 1);

  while (max_threads--)
    thread_pool_push (pool, barrier_thread, &barrier);

  loomlib_barrier_wait (barrier);
  loomlib_barrier_destroy (barrier);

  pthread_mutex_unlock (&pool->lock);

  return true;
}
Пример #9
0
Файл: main.c Проект: ireader/sdk
int main(int argc, char* argv[])
{
	char c;
	int cpu = system_getcpucount();
	socket_t server;
	aio_socket_t aioserver;

	memset(s_buffer, 'A', sizeof(s_buffer)-1);

	aio_socket_init(cpu);
	s_thpool = thread_pool_create(cpu, cpu, cpu*2);

	while(cpu > 0)
	{
		thread_pool_push(s_thpool, AIOWorker, NULL);
		--cpu;
	}

	server = Listen(50000);
	aioserver = aio_socket_create(server, 1);
	aio_socket_accept(aioserver, OnAccept, aioserver);

	printf("server listen at: %d\n", 50000);
	for(c = getchar(); 'q' != c; c = getchar())
	{
		switch(c)
		{
		case 'c': // close socket
			aio_socket_destroy(aioserver);
			break;

		default:
			printf("unknown command.\nc : close socket\n");
		}
	}

	aio_socket_destroy(aioserver);
	thread_pool_destroy(s_thpool);
	aio_socket_clean();
	return 0;
}
Пример #10
0
int main(int argc, char* argv[])
{
#if defined(OS_LINUX)
    /* ignore pipe signal */
    struct sigaction sa;
    sa.sa_handler = SIG_IGN;
    sigaction(SIGCHLD, &sa, 0);
    sigaction(SIGPIPE, &sa, 0);
#endif

    int port = 554;
    for(int i=1; i<argc; i++)
    {
        if(streq(argv[i], "--port") && i+1<argc)
        {
            port = atoi(argv[++i]);
        }
    }

    size_t cpu = system_getcpucount();
    g_thpool = thread_pool_create(cpu, cpu, cpu*4);

    aio_socket_init(cpu * 2);
    for(size_t i=0; i<cpu * 2; i++)
        thread_pool_push(g_thpool, AioWorker, NULL); // start worker

    // start server
    StartTcpServer(NULL, port);
    StartUdpServer(NULL, port);

    for(int c = getchar(); 'q' != c ; c = getchar())
    {
    }

    aio_socket_destroy(s_tcp);
    aio_socket_clean();
    thread_pool_destroy(g_thpool);
    return 0;
}
Пример #11
0
FixedPostingList *
fixed_index_multithreaded_multiphrase_get (const FixedIndex *findex,
        ThreadPool *pool,
        GList *phrases)
{
    FixedPostingList *base_list, *succ_list, *tmp_list;
    tp_arg_t *arg;
    GList *phrase_cell;
    guint idx;

    g_return_val_if_fail(findex, NULL);
    g_return_val_if_fail(pool, NULL);
    g_return_val_if_fail(phrases, NULL);

    for(phrase_cell = phrases; phrase_cell != NULL; phrase_cell = phrase_cell->next) {
        arg = g_malloc(sizeof(tp_arg_t));
        arg->findex = findex;
        arg->phrase = phrase_cell->data;
        arg->list = NULL;
        thread_pool_push(pool, arg);
    }

    arg = thread_pool_pop(pool);
    base_list = arg->list;
    g_free(arg);

    for (idx = 1; idx < g_list_length(phrases); idx++) {
        arg = thread_pool_pop(pool);
        succ_list = arg->list;
        tmp_list = fixed_posting_list_doc_intersect(base_list, succ_list);
        fixed_posting_list_free(base_list);
        fixed_posting_list_free(succ_list);
        g_free(arg);
        base_list = tmp_list;
    }

    return base_list;
}
Пример #12
0
int sys_thread_pool_push(sys_thread_pool_proc proc, void *param)
{
	return thread_pool_push(g_pool, proc, param);
}
Пример #13
0
bool
thread_pool_terminate (struct thread_pool *pool)
{
  return thread_pool_push (pool, THREAD_POOL_TERM_SIG, NULL);
}
Пример #14
0
/**
 * Function called on new client connection:
 *    - Call accept()
 *    - Drop client if there are to much clients or if NuAuth is in reload
 *    - Create a client_connection structure
 *    - Add client to ::pre_client_list
 *    - Add client to ::tls_sasl_worker queue (see sasl_worker())
 *
 * \return If an error occurs returns 1, else returns 0.
 */
int tls_user_accept(struct tls_user_context_t *context)
{
    struct sockaddr_storage sockaddr;
    struct sockaddr_in *sockaddr4 = (struct sockaddr_in *) &sockaddr;
    struct sockaddr_in6 *sockaddr6 = (struct sockaddr_in6 *) &sockaddr;
    struct in6_addr addr;
    unsigned int len_inet = sizeof sockaddr;
    struct client_connection *current_client_conn;
    struct pre_client_elt *new_pre_client;
    int socket;
    gint option_value;
    unsigned short sport;
    char address[INET6_ADDRSTRLEN];

    current_client_conn = g_new0(struct client_connection, 1);

    current_client_conn->nussl = nussl_session_accept(context->nussl);
    if ( ! current_client_conn->nussl ) {
        /* can be triggered by EAGAIN on non blocking accept socket */
        g_free(current_client_conn);
        return 1;
    }

    if (nussl_session_getpeer(current_client_conn->nussl, (struct sockaddr *) &sockaddr, &len_inet) != NUSSL_OK)
    {
        log_message(WARNING, DEBUG_AREA_MAIN | DEBUG_AREA_USER,
                    "New client connection failed during nussl_session_getpeer(): %s", nussl_get_error(context->nussl));
        g_free(current_client_conn);
        return 1;
    }

    socket = nussl_session_get_fd(current_client_conn->nussl);

    /* if system is in reload: drop new client */
    if (nuauthdatas->need_reload) {
        shutdown(socket, SHUT_RDWR);
        close(socket);
        return 0;
    }

    /* Extract client address (convert it to IPv6 if it's IPv4) */
    /* if (sockaddr.ss_family == AF_INET) { -> same as tls_nufw.c */
    if (sockaddr6->sin6_family == AF_INET) {
        ipv4_to_ipv6(sockaddr4->sin_addr, &addr);
        sport = ntohs(sockaddr4->sin_port);
    } else {
        addr = sockaddr6->sin6_addr;
        sport = ntohs(sockaddr6->sin6_port);
    }

    format_ipv6(&addr, address, sizeof(address), NULL);
    log_message(DEBUG, DEBUG_AREA_MAIN | DEBUG_AREA_USER,
                "nuauth: user connection attempt from %s\n",
                address);

    if (get_number_of_clients() >= context->nuauth_tls_max_clients) {
        log_message(WARNING, DEBUG_AREA_MAIN | DEBUG_AREA_USER,
                    "too many clients (%d configured)",
                    context->nuauth_tls_max_clients);
        shutdown(socket, SHUT_RDWR);
        close(socket);
        return 1;
    }

    current_client_conn->socket = socket;
    current_client_conn->addr = addr;
    current_client_conn->sport = sport;
    current_client_conn->str_addr = g_strdup(address);
    current_client_conn->srv_context = context;

    /* Set KEEP ALIVE on connection */
    option_value = 1;
    setsockopt(socket,
               SOL_SOCKET, SO_KEEPALIVE,
               &option_value, sizeof(option_value));

    /* give the connection to a separate thread */
    /*  add element to pre_client
       create pre_client_elt */
    new_pre_client = g_new0(struct pre_client_elt, 1);
    new_pre_client->socket = socket;
    new_pre_client->validity =
        time(NULL) + context->nuauth_auth_nego_timeout;

    g_static_mutex_lock(&pre_client_list_mutex);
    pre_client_list = g_slist_prepend(pre_client_list, new_pre_client);
    g_static_mutex_unlock(&pre_client_list_mutex);

    thread_pool_push(nuauthdatas->tls_sasl_worker,
                     current_client_conn, NULL);
    return 0;
}
Пример #15
0
/**
 * Thread which process addresses on tls push queue (tls_push_queue member
 * of ::nuauthdatas) which need an authentication.
 *
 * Lock is only needed when modifications are done, because when this thread
 * work (push mode) it's the only one who can modify the hash.
 *
 * Use a switch:
 *   - #WARN_MESSAGE: call warn_clients() (and may call ip_authentication_workers())
 *   - #INSERT_MESSAGE: call add_client()
 */
void *push_worker(GMutex * mutex)
{
    struct msg_addr_set *global_msg = g_new0(struct msg_addr_set, 1);
    struct nu_srv_message *msg = g_new0(struct nu_srv_message, 1);
    struct internal_message *message;
    GTimeVal tv;

    msg->type = SRV_REQUIRED_PACKET;
    msg->option = 0;
    msg->length = htons(4);
    global_msg->msg = msg;

    g_async_queue_ref(nuauthdatas->tls_push_queue);

    /* wait for message */
    while (g_mutex_trylock(mutex)) {
        g_mutex_unlock(mutex);

        /* wait a message during POP_DELAY */
        g_get_current_time(&tv);
        g_time_val_add(&tv, POP_DELAY);
        message =
            g_async_queue_timed_pop(nuauthdatas->tls_push_queue,
                                    &tv);
        if (message == NULL)
            continue;

        switch (message->type) {
        case WARN_MESSAGE:
            global_msg->addr =
                (((auth_pckt_t *) message->datas)->header).saddr;
            global_msg->found = FALSE;
            /* search in client array */
            warn_clients(global_msg, NULL, NULL);
            /* do we have found something */
            if (!ipv6_equal(&global_msg->addr, &in6addr_any)) {
                if (global_msg->found == FALSE) {
                    /* if we do ip authentication send request to pool */
                    if (nuauthconf->
                            do_ip_authentication) {
                        thread_pool_push
                        (nuauthdatas->
                         ip_authentication_workers,
                         message->datas, NULL);
                    } else {
                        g_free(message->datas);
                    }
                } else {
                    /* free header */
                    g_free(message->datas);
                }
            }
            break;

        case INSERT_MESSAGE:
        {
            struct tls_insert_data *data = message->datas;
            if (data->data) {
                add_client(data->socket,
                           data->data);
            }
            g_free(data);
        }
        break;
        default:
            g_message("lost");
        }
        g_free(message);
    }

    g_free(msg);
    g_free(global_msg);
    g_async_queue_unref(nuauthdatas->tls_push_queue);
    return NULL;
}
Пример #16
0
int gurls( FILE* fin, uint32_t threads )
{
    struct thread_pool *pool;
    uint32_t i;
    char url[1024];
    char saftey_ext[5] = "txt\0";

    /* validate threads */
    threads = threads > 30 ? 30 :
              threads == 0 ? 5  :
              threads;

    pool = thread_pool_new( threads );
    if( !pool ) {
        return -1;
    }

    /* initialize curl */
    curl_global_init( CURL_GLOBAL_ALL );

    for( i = 0; fgets(url, 1024, fin) ; i++ )
    {
        gurl_url_t* u;
        char* aux;

        if( *url == '\n' || *url == '\0' ) {
            break;
        }

        if( !is_url(url) ) {
            i--;
            continue;
        }

        /* create url object */
        u = malloc( sizeof(gurl_url_t) );
        if( !u ) {
            break;
        }

        /* remove trailing newline */
        for( aux = url; aux-url < 1024 && *aux != '\n' && *aux != '\0'; aux++ );
        *aux = '\0';

        /* fill up url object */
        strncpy( u->url, url, 1024 );
        aux = get_extension( url );
        if( !aux )
            aux = saftey_ext;
        snprintf( u->filename, 1024, "file-%010d.%s", i, aux );

        thread_pool_push( pool, gurl_url_download, u );
    }

    /* send term signal to children */
    thread_pool_terminate( pool );

    /* cleanup */
    thread_pool_free( pool );
    curl_global_cleanup();
    return 0;
}