int
mono_gc_pthread_detach (pthread_t thread)
{
return pthread_detach (thread);
}
static void *_working(void *arg) {
pthread_detach(pthread_self());
__lock;
_connection_num++;
__unlock;
struct connection_info *ci = (struct connection_info *) arg;
ci->is_connected = 0;
struct sockaddr_in server_addr;
bzero(&server_addr, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(ci->port);
if (0 == inet_aton(ci->ip, &server_addr.sin_addr)) {
log_fatal("failed to initialize socket ip");
exit(1);
}
while (ci->is_running) {
int ret = connect(ci->socket, (struct sockaddr *) &server_addr,
sizeof(server_addr));
if (0 == ret) {
ci->callback_funs.on_connected(ci->id);
ci->is_connected = 1;
} else if (0 > ret && EINPROGRESS != errno) {
log_info("failed to connect to destination");
goo_sleep(ci->reconnect_interval, 0);
_fini_socket(ci);
_init_socket(ci);
continue;
}
ci->needs_reconnect = 0;
struct epoll_event events[EPOLL_EVENT_NUM];
int ret_fds = 0;
while (ci->is_running && !ci->needs_reconnect) {
ret_fds = epoll_wait(ci->epoll_container, events, EPOLL_EVENT_NUM,
ci->reconnect_interval);
if (-1 == ret_fds) {
switch (errno) {
case EBADF:
log_fatal("failed to call epoll_wait - EBADF");
exit(1);
case EFAULT:
log_fatal("failed to call epoll_wait - EFAULT");
exit(1);
case EINTR:
continue;
case EINVAL:
log_fatal("failed to call epoll_wait - EINVAL");
exit(1);
default:
log_fatal("failed to call epoll_wait - Unknown");
exit(1);
}
}
int i = 0;
for (; i < ret_fds; i++) {
if ((events[i].events & EPOLLERR) && EINPROGRESS != errno) {
ci->is_connected = 0;
ci->needs_reconnect = 1;
ci->callback_funs.on_error(ci->id, errno, strerror(errno));
goo_sleep(ci->reconnect_interval, 0);
_fini_socket(ci);
_init_socket(ci);
break;
}
if (events[i].events & EPOLLRDHUP) {
ci->is_connected = 0;
ci->needs_reconnect = 1;
ci->callback_funs.on_closed(ci->id);
goo_sleep(ci->reconnect_interval, 0);
_fini_socket(ci);
_init_socket(ci);
break;
}
if (events[i].events & EPOLLOUT) {
if (!ci->is_connected) {
ci->is_connected = 1;
ci->callback_funs.on_connected(ci->id);
continue;
}
}
if (events[i].events & EPOLLIN) {
unsigned char buffer[RECEIVE_BUFFER_SIZE];
int offset = 0;
for (;;) {
unsigned char tmp_buf[512];
int len = recv(events[i].data.fd, tmp_buf, 512, 0);
if (0 < len) { // read data from socket buffer
if (len + offset > RECEIVE_BUFFER_SIZE) {
log_fatal("the socket receiving buffer is too "
"small");
exit(1);
}
memcpy(buffer + offset, tmp_buf, len);
offset += len;
} else if (0 > len) {
if (EAGAIN == errno || EWOULDBLOCK == errno) {
// socket read buffer is empty
if (0 < offset) {
buffer[offset] = 0;
ci->callback_funs.on_received(ci->id,
buffer, offset);
offset = 0;
}
} else {
// error happened
}
break;
} else {
// the socket has been closed
break;
}
}
}
}
}
}
ci->is_connected = 0;
ci->callback_funs.on_closed(ci->id);
_fini_socket(ci);
__lock;
_connection_num--;
__unlock;
ci->tid = 0;
return NULL;
}
/*
* main
*/
int main(int argc, char **argv)
{
int ret = 0;
void *status;
/* Parse arguments */
progname = argv[0];
parse_args(argc, argv);
/* Daemonize */
if (opt_daemon) {
int i;
/*
* fork
* child: setsid, close FD 0, 1, 2, chdir /
* parent: exit (if fork is successful)
*/
ret = daemon(0, 0);
if (ret < 0) {
PERROR("daemon");
goto error;
}
/*
* We are in the child. Make sure all other file
* descriptors are closed, in case we are called with
* more opened file descriptors than the standard ones.
*/
for (i = 3; i < sysconf(_SC_OPEN_MAX); i++) {
(void) close(i);
}
}
/* Set up max poll set size */
lttng_poll_set_max_size();
if (*command_sock_path == '\0') {
switch (opt_type) {
case LTTNG_CONSUMER_KERNEL:
snprintf(command_sock_path, PATH_MAX, DEFAULT_KCONSUMERD_CMD_SOCK_PATH,
DEFAULT_LTTNG_RUNDIR);
break;
case LTTNG_CONSUMER64_UST:
snprintf(command_sock_path, PATH_MAX,
DEFAULT_USTCONSUMERD64_CMD_SOCK_PATH, DEFAULT_LTTNG_RUNDIR);
break;
case LTTNG_CONSUMER32_UST:
snprintf(command_sock_path, PATH_MAX,
DEFAULT_USTCONSUMERD32_CMD_SOCK_PATH, DEFAULT_LTTNG_RUNDIR);
break;
default:
WARN("Unknown consumerd type");
goto error;
}
}
/* Init */
lttng_consumer_init();
if (!getuid()) {
/* Set limit for open files */
set_ulimit();
}
/* create the consumer instance with and assign the callbacks */
ctx = lttng_consumer_create(opt_type, lttng_consumer_read_subbuffer,
NULL, lttng_consumer_on_recv_stream, NULL);
if (ctx == NULL) {
goto error;
}
lttng_consumer_set_command_sock_path(ctx, command_sock_path);
if (*error_sock_path == '\0') {
switch (opt_type) {
case LTTNG_CONSUMER_KERNEL:
snprintf(error_sock_path, PATH_MAX, DEFAULT_KCONSUMERD_ERR_SOCK_PATH,
DEFAULT_LTTNG_RUNDIR);
break;
case LTTNG_CONSUMER64_UST:
snprintf(error_sock_path, PATH_MAX,
DEFAULT_USTCONSUMERD64_ERR_SOCK_PATH, DEFAULT_LTTNG_RUNDIR);
break;
case LTTNG_CONSUMER32_UST:
snprintf(error_sock_path, PATH_MAX,
DEFAULT_USTCONSUMERD32_ERR_SOCK_PATH, DEFAULT_LTTNG_RUNDIR);
break;
default:
WARN("Unknown consumerd type");
goto error;
}
}
if (set_signal_handler() < 0) {
goto error;
}
/* Connect to the socket created by lttng-sessiond to report errors */
DBG("Connecting to error socket %s", error_sock_path);
ret = lttcomm_connect_unix_sock(error_sock_path);
/* not a fatal error, but all communication with lttng-sessiond will fail */
if (ret < 0) {
WARN("Cannot connect to error socket (is lttng-sessiond started?)");
}
lttng_consumer_set_error_sock(ctx, ret);
/*
* For UST consumer, we block RT signals used for periodical metadata flush
* in main and create a dedicated thread to handle these signals.
*/
switch (opt_type) {
case LTTNG_CONSUMER32_UST:
case LTTNG_CONSUMER64_UST:
consumer_signal_init();
break;
default:
break;
}
ctx->type = opt_type;
/* Create thread to manage channels */
ret = pthread_create(&channel_thread, NULL, consumer_thread_channel_poll,
(void *) ctx);
if (ret != 0) {
perror("pthread_create");
goto error;
}
/* Create thread to manage the polling/writing of trace metadata */
ret = pthread_create(&metadata_thread, NULL, consumer_thread_metadata_poll,
(void *) ctx);
if (ret != 0) {
perror("pthread_create");
goto metadata_error;
}
/* Create thread to manage the polling/writing of trace data */
ret = pthread_create(&data_thread, NULL, consumer_thread_data_poll,
(void *) ctx);
if (ret != 0) {
perror("pthread_create");
goto data_error;
}
/* Create the thread to manage the receive of fd */
ret = pthread_create(&sessiond_thread, NULL, consumer_thread_sessiond_poll,
(void *) ctx);
if (ret != 0) {
perror("pthread_create");
goto sessiond_error;
}
switch (opt_type) {
case LTTNG_CONSUMER32_UST:
case LTTNG_CONSUMER64_UST:
/* Create the thread to manage the metadata periodic timers */
ret = pthread_create(&metadata_timer_thread, NULL,
consumer_timer_metadata_thread, (void *) ctx);
if (ret != 0) {
perror("pthread_create");
goto metadata_timer_error;
}
ret = pthread_detach(metadata_timer_thread);
if (ret) {
errno = ret;
perror("pthread_detach");
}
break;
default:
break;
}
metadata_timer_error:
ret = pthread_join(sessiond_thread, &status);
if (ret != 0) {
perror("pthread_join");
goto error;
}
sessiond_error:
ret = pthread_join(data_thread, &status);
if (ret != 0) {
perror("pthread_join");
goto error;
}
data_error:
ret = pthread_join(metadata_thread, &status);
if (ret != 0) {
perror("pthread_join");
goto error;
}
metadata_error:
ret = pthread_join(channel_thread, &status);
if (ret != 0) {
perror("pthread_join");
goto error;
}
if (!ret) {
ret = EXIT_SUCCESS;
lttng_consumer_send_error(ctx, LTTCOMM_CONSUMERD_EXIT_SUCCESS);
goto end;
}
error:
ret = EXIT_FAILURE;
if (ctx) {
lttng_consumer_send_error(ctx, LTTCOMM_CONSUMERD_EXIT_FAILURE);
}
end:
lttng_consumer_destroy(ctx);
lttng_consumer_cleanup();
return ret;
}
void* client_main_thread(void* arg) {
struct client_struct* client = (struct client_struct*)arg;
int skip_sleep;
do {
skip_sleep = 0;
/* GLOBAL READ LOCK */
pthread_rwlock_rdlock(&netopeer_state.global_lock);
switch (client->transport) {
#ifdef NP_SSH
case NC_TRANSPORT_SSH:
skip_sleep += np_ssh_client_transport((struct client_struct_ssh*)client);
skip_sleep += np_ssh_client_netconf_rpc((struct client_struct_ssh*)client);
break;
#endif
#ifdef NP_TLS
case NC_TRANSPORT_TLS:
skip_sleep += np_tls_client_transport((struct client_struct_tls*)client);
skip_sleep += np_tls_client_netconf_rpc((struct client_struct_tls*)client);
break;
#endif
default:
nc_verb_error("%s: internal error (%s:%d)", __func__, __FILE__, __LINE__);
}
/* GLOBAL READ UNLOCK */
pthread_rwlock_unlock(&netopeer_state.global_lock);
if (!skip_sleep) {
/* we did not do anything productive, so let the thread sleep */
usleep(netopeer_options.response_time*1000);
}
} while (!client->to_free);
/* GLOBAL WRITE LOCK */
pthread_rwlock_wrlock(&netopeer_state.global_lock);
np_client_detach(&netopeer_state.clients, client);
/* GLOBAL WRITE UNLOCK */
pthread_rwlock_unlock(&netopeer_state.global_lock);
switch (client->transport) {
#ifdef NP_SSH
case NC_TRANSPORT_SSH:
client_free_ssh((struct client_struct_ssh*)client);
break;
#endif
#ifdef NP_TLS
case NC_TRANSPORT_TLS:
client_free_tls((struct client_struct_tls*)client);
break;
#endif
default:
free(client);
break;
}
#ifdef NP_TLS
np_tls_thread_cleanup();
#endif
pthread_detach(pthread_self());
return NULL;
}
void
SDL_SYS_DetachThread(SDL_Thread * thread)
{
pthread_detach(thread->handle);
}
/*************************************************
Function: phone_monitor_proc
Description: 模拟门前机监视线程
Input:
1.param 参数
Output: 无
Return: BOOLEAN
Others:
*************************************************/
static void* phone_monitor_proc(void *param)
{
// 设置分离线程
pthread_detach(pthread_self());
time_t t0;
//int32 RequestTimes = 3;
int32 ret = FALSE;
static int32 times = 10;
LabChange:
t0 = time(0);
g_Video_Start = 0;
//RequestTimes = 3;
if (MONITOR_REQUEST == g_MonitorInfo.state)
{
g_PreMonitorState = MONITOR_REQUEST;
GuiNotify(g_MonitorInfo.state, g_MonitorInfo.index);
g_MonitorInfo.state = MONITOR_MONITORING; // 模拟门前机直接监视
usleep(1000);
#if 0
// 3次不成功就退出
while (RequestTimes)
{
// 【开启监视接口】索引号传入
//ret = [开启监视接口函数];
if (ret == FALSE)
{
RequestTimes--;
}
else
{
g_MonitorInfo.state = MONITOR_MONITORING;
break;
}
}
if (RequestTimes <= 0)
{
g_MonitorInfo.state = MONITOR_END;
}
#endif
}
t0 = time(0);
if(MONITOR_MONITORING == g_MonitorInfo.state)
{
dprintf(" *************** MONITOR_MONITORING ******************* \n");
g_PreMonitorState = MONITOR_MONITORING;
hw_mk_start();
// [开启视频接口]
ret = media_start_analog_video();
if (ret == -1)
{
g_MonitorInfo.state = MONITOR_END;
g_PreMonitorState = MONITOR_END;
}
else
{
GuiNotify(g_MonitorInfo.state, 0);
g_Video_Start = 1;
g_MonitorInfo.TimeMax = MONITOR_TIME_MAX;
g_MonitorInfo.TimeOut = 0;
g_RemainTime = 0;
}
while (MONITOR_MONITORING == g_MonitorInfo.state)
{
g_MonitorInfo.TimeOut = time(0) - t0;
if (g_MonitorInfo.TimeMax > 0)
{
//剩余时间
g_RemainTime = g_MonitorInfo.TimeMax - g_MonitorInfo.TimeOut;
dprintf("g_RemainTime : %d\n ", g_RemainTime);
if (g_RemainTime <= 0)
{
g_ErrType = MONITOR_MONITORING_TIMEOUT;
g_MonitorInfo.state = MONITOR_END;
break;
}
else
{
//GuiNotify(MONITOR_TIMER, g_RemainTime);
}
times = 10;
while ((times--) > 0 && MONITOR_MONITORING == g_MonitorInfo.state)
{
usleep(100*1000);
}
}
}
}
t0 = time(0);
if(MONITOR_TALKING == g_MonitorInfo.state)
{
dprintf("MONITOR_TALKING == g_MonitorInfo.state \n");
// [监视进入通话接口]
//hw_switch_analog();
hw_mk_talk();
g_PreMonitorState = MONITOR_TALKING;
GuiNotify(g_MonitorInfo.state, 0);
g_MonitorInfo.TimeMax = MONITOR_TALK_TIME_MAX;
g_MonitorInfo.TimeOut = 0;
g_MonitorInfo.HeartTime = 0;
while (MONITOR_TALKING == g_MonitorInfo.state)
{
if (g_MonitorInfo.TimeMax > 0)
{
g_RemainTime = 0;
g_MonitorInfo.TimeOut = time(0) - t0;
g_RemainTime = g_MonitorInfo.TimeMax - g_MonitorInfo.TimeOut;
if (g_RemainTime <= 0)
{
dprintf("monitor timer proc : talking time out\n");
g_ErrType = MONITOR_TALKING_TIMEOUT;
g_MonitorInfo.state = MONITOR_END;
break;
}
else
{
//GuiNotify(MONITOR_TIMER, g_RemainTime);
}
times = 10;
while ((times--) > 0 && MONITOR_TALKING == g_MonitorInfo.state)
{
usleep(100*1000);
}
}
}
}
// 监视下一个情况
if (MONITOR_REQUEST == g_MonitorInfo.state)
{
// [关闭视频接口]
media_stop_analog_video();
goto LabChange;
}
dprintf("monitor proc : AS_MONITOR_END : g_ErrType : %d\n", g_ErrType);
media_stop_analog_video();
g_Video_Start = 0;
hw_switch_digit(); // [关闭监视接口]
sys_set_monitor_state(FALSE);
dprintf("monitor proc end!\n");
g_MonitorInfo.state = MONITOR_END;
g_PreMonitorState = MONITOR_END;
GuiNotify(g_MonitorInfo.state, g_ErrType);
inter_SetThread(&g_MonitorInfo.mThread);
pthread_exit(NULL);
return NULL; // 返回后资源由系统释放
}
static DWORD WINAPI
#else
static void *
#endif
handle_connection(void *arg)
{
ssize_t n;
unsigned long long sum = 0, first_length = 0;
char *buf;
#ifdef _WIN32
HANDLE tid;
#else
pthread_t tid;
#endif
struct socket *conn_sock;
struct timeval start_time, now, diff_time;
double seconds;
unsigned long messages = 0;
unsigned long recv_calls = 0;
unsigned long notifications = 0;
int flags;
struct sockaddr_in addr;
socklen_t len;
union sctp_notification *snp;
struct sctp_paddr_change *spc;
struct timeval note_time;
unsigned int infotype;
struct sctp_recvv_rn rn;
socklen_t infolen = sizeof(struct sctp_recvv_rn);
conn_sock = *(struct socket **)arg;
#ifdef _WIN32
tid = GetCurrentThread();
#else
tid = pthread_self();
pthread_detach(tid);
#endif
buf = malloc(BUFFERSIZE);
flags = 0;
len = (socklen_t)sizeof(struct sockaddr_in);
infotype = 0;
memset(&rn, 0, sizeof(struct sctp_recvv_rn));
n = usrsctp_recvv(conn_sock, buf, BUFFERSIZE, (struct sockaddr *) &addr, &len, (void *)&rn,
&infolen, &infotype, &flags);
gettimeofday(&start_time, NULL);
while (n > 0) {
recv_calls++;
if (flags & MSG_NOTIFICATION) {
notifications++;
gettimeofday(¬e_time, NULL);
printf("notification arrived at %f\n", note_time.tv_sec+(double)note_time.tv_usec/1000000.0);
snp = (union sctp_notification *)buf;
if (snp->sn_header.sn_type==SCTP_PEER_ADDR_CHANGE)
{
spc = &snp->sn_paddr_change;
printf("SCTP_PEER_ADDR_CHANGE: state=%d, error=%d\n",spc->spc_state, spc->spc_error);
}
} else {
if (very_verbose) {
printf("Message received\n");
}
sum += n;
if (flags & MSG_EOR) {
messages++;
if (first_length == 0)
first_length = sum;
}
}
flags = 0;
len = (socklen_t)sizeof(struct sockaddr_in);
infolen = sizeof(struct sctp_recvv_rn);
infotype = 0;
memset(&rn, 0, sizeof(struct sctp_recvv_rn));
n = usrsctp_recvv(conn_sock, (void *) buf, BUFFERSIZE, (struct sockaddr *) &addr, &len, (void *)&rn,
&infolen, &infotype, &flags);
}
if (n < 0)
perror("sctp_recvv");
gettimeofday(&now, NULL);
timersub(&now, &start_time, &diff_time);
seconds = diff_time.tv_sec + (double)diff_time.tv_usec/1000000.0;
printf("%llu, %lu, %lu, %lu, %llu, %f, %f\n",
first_length, messages, recv_calls, notifications, sum, seconds, (double)first_length * (double)messages / seconds);
fflush(stdout);
usrsctp_close(conn_sock);
free(buf);
#ifdef _WIN32
return 0;
#else
return (NULL);
#endif
}
void Thread::OnStop()
{
tid_ = 0;
flag_ = 0;
pthread_detach(pthread_self());
}
/**
* @internal
*
* Stops the valvula thread pool, that was initialized by
* valvula_thread_pool_init.
*
*/
void valvula_thread_pool_exit (ValvulaCtx * ctx)
{
/* get current context */
int iterator;
ValvulaThread * thread;
if (ctx->skip_thread_pool_wait)
return;
valvula_log (VALVULA_LEVEL_DEBUG, "stopping thread pool..");
/* flag the queue to be stoping */
valvula_mutex_lock (&ctx->thread_pool->mutex);
ctx->thread_pool_being_stopped = axl_true;
valvula_mutex_unlock (&ctx->thread_pool->mutex);
/* push beacons to notify eacy thread created to stop */
iterator = 0;
while (iterator < axl_list_length (ctx->thread_pool->threads)) {
valvula_log (VALVULA_LEVEL_DEBUG, "pushing beacon to stop thread from the pool..");
/* push a notifier */
valvula_async_queue_push (ctx->thread_pool->queue, INT_TO_PTR (1));
/* update the iterator */
iterator++;
} /* end if */
/* stop all threads */
if (ctx->skip_thread_pool_wait) {
valvula_log (VALVULA_LEVEL_DEBUG, "found skip thread finish wait");
/* remove all threads */
while (axl_list_length (ctx->thread_pool->threads) > 0) {
/* get reference to the thread to be not waited */
thread = axl_list_get_first (ctx->thread_pool->threads);
/* remove from the list */
axl_list_unlink_first (ctx->thread_pool->threads);
#if defined(AXL_OS_UNIX)
/* flag is as detached */
pthread_detach (*thread);
#endif
/* release object */
axl_free (thread);
}
} /* end if */
axl_list_free (ctx->thread_pool->threads);
axl_list_free (ctx->thread_pool->events);
axl_list_cursor_free (ctx->thread_pool->events_cursor);
axl_list_free (ctx->thread_pool->stopped);
/* unref the queue */
valvula_async_queue_unref (ctx->thread_pool->queue);
/* terminate mutex */
valvula_mutex_destroy (&ctx->thread_pool->mutex);
valvula_mutex_destroy (&(ctx->thread_pool->stopped_mutex));
/* free the node itself */
axl_free (ctx->thread_pool);
ctx->thread_pool = NULL;
valvula_log (VALVULA_LEVEL_DEBUG, "thread pool is stopped..");
return;
}
static void
handle_request( VoodooManager *manager,
VoodooRequestMessage *request )
{
DirectResult ret;
VoodooInstance *instance;
D_MAGIC_ASSERT( manager, VoodooManager );
D_ASSERT( request != NULL );
D_ASSERT( request->header.size >= sizeof(VoodooRequestMessage) );
D_ASSERT( request->header.type == VMSG_REQUEST );
D_DEBUG( "Voodoo/Dispatch: Handling REQUEST message %llu to %u::%u %s%s(%d bytes).\n",
(unsigned long long)request->header.serial, request->instance, request->method,
(request->flags & VREQ_RESPOND) ? "[RESPONDING] " : "",
(request->flags & VREQ_ASYNC) ? "[ASYNC] " : "",
request->header.size );
pthread_mutex_lock( &manager->instances.lock );
instance = direct_hash_lookup( manager->instances.local, request->instance );
if (!instance) {
pthread_mutex_unlock( &manager->instances.lock );
D_ERROR( "Voodoo/Dispatch: "
"Requested instance %u doesn't exist (anymore)!\n", request->instance );
if (request->flags & VREQ_RESPOND)
voodoo_manager_respond( manager, request->header.serial,
DR_NOSUCHINSTANCE, VOODOO_INSTANCE_NONE,
VMBT_NONE );
return;
}
if (request->flags & VREQ_ASYNC) {
pthread_t thread;
DispatchAsyncContext *context;
context = D_MALLOC( sizeof(DispatchAsyncContext) + request->header.size );
if (!context) {
D_WARN( "out of memory" );
pthread_mutex_unlock( &manager->instances.lock );
return;
}
context->manager = manager;
context->instance = instance;
context->request = (VoodooRequestMessage*) (context + 1);
direct_memcpy( context->request, request, request->header.size );
pthread_create( &thread, NULL, dispatch_async_thread, context );
pthread_detach( thread );
}
else {
ret = instance->dispatch( instance->proxy, instance->real, manager, request );
if (ret && (request->flags & VREQ_RESPOND))
voodoo_manager_respond( manager, request->header.serial,
ret, VOODOO_INSTANCE_NONE,
VMBT_NONE );
}
pthread_mutex_unlock( &manager->instances.lock );
}
static void *fuse_do_work(void *data)
{
struct fuse_worker *w = (struct fuse_worker *) data;
struct fuse_mt *mt = w->mt;
while (!fuse_session_exited(mt->se)) {
int isforget = 0;
struct fuse_chan *ch = mt->prevch;
struct fuse_buf fbuf = {
.mem = w->buf,
.size = w->bufsize,
};
int res;
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
res = fuse_session_receive_buf(mt->se, &fbuf, &ch);
pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
if (res == -EINTR)
continue;
if (res <= 0) {
if (res < 0) {
fuse_session_exit(mt->se);
mt->error = -1;
}
break;
}
pthread_mutex_lock(&mt->lock);
if (mt->exit) {
pthread_mutex_unlock(&mt->lock);
return NULL;
}
/*
* This disgusting hack is needed so that zillions of threads
* are not created on a burst of FORGET messages
*/
if (!(fbuf.flags & FUSE_BUF_IS_FD)) {
struct fuse_in_header *in = fbuf.mem;
if (in->opcode == FUSE_FORGET ||
in->opcode == FUSE_BATCH_FORGET)
isforget = 1;
}
if (!isforget)
mt->numavail--;
if (mt->numavail == 0)
fuse_loop_start_thread(mt);
pthread_mutex_unlock(&mt->lock);
fuse_session_process_buf(mt->se, &fbuf, ch);
pthread_mutex_lock(&mt->lock);
if (!isforget)
mt->numavail++;
if (mt->numavail > 10) {
if (mt->exit) {
pthread_mutex_unlock(&mt->lock);
return NULL;
}
list_del_worker(w);
mt->numavail--;
mt->numworker--;
pthread_mutex_unlock(&mt->lock);
pthread_detach(w->thread_id);
free(w->buf);
free(w);
return NULL;
}
pthread_mutex_unlock(&mt->lock);
}
sem_post(&mt->finish);
return NULL;
}
int fuse_start_thread(pthread_t *thread_id, void *(*func)(void *), void *arg)
{
sigset_t oldset;
sigset_t newset;
int res;
pthread_attr_t attr;
char *stack_size;
/* Override default stack size */
pthread_attr_init(&attr);
stack_size = getenv(ENVNAME_THREAD_STACK);
if (stack_size && pthread_attr_setstacksize(&attr, atoi(stack_size)))
fprintf(stderr, "fuse: invalid stack size: %s\n", stack_size);
/* Disallow signal reception in worker threads */
sigemptyset(&newset);
sigaddset(&newset, SIGTERM);
sigaddset(&newset, SIGINT);
sigaddset(&newset, SIGHUP);
sigaddset(&newset, SIGQUIT);
pthread_sigmask(SIG_BLOCK, &newset, &oldset);
res = pthread_create(thread_id, &attr, func, arg);
pthread_sigmask(SIG_SETMASK, &oldset, NULL);
pthread_attr_destroy(&attr);
if (res != 0) {
fprintf(stderr, "fuse: error creating thread: %s\n",
strerror(res));
return -1;
}
return 0;
}
static void *tcp_server_thread(void *p_param)
{
/* local variables definitions */
int j = 0;
int n = 0;
int ret_val = 0;
char data = 0;
fd_list_node *p_fd_list_node = NULL;
pthread_t thread_id = 0;
recv_data_thread_context *p_recv_data_thread_context = NULL;
tcp_server_context *p_tcp_server_context = (tcp_server_context*)p_param;
/* code body */
while (1)
{
ret_val = poll(
p_tcp_server_context->p_poll_fds,
(p_tcp_server_context->listen_addr_num + 1),
(-1));
if (ret_val > 0)
{
for (j = 0; j < p_tcp_server_context->listen_addr_num; j++)
{
if (p_tcp_server_context->p_poll_fds[j].revents & POLLIN)
{
p_fd_list_node = calloc(1, sizeof(*p_fd_list_node));
p_fd_list_node->fd = accept(p_tcp_server_context->p_listen_socket_fd[j], NULL, NULL);
if (0 != pthread_mutex_lock(&(p_tcp_server_context->mutex)))
{
}
else
{
p_fd_list_node->p_next_node = p_tcp_server_context->p_conn_socket_list;
p_tcp_server_context->p_conn_socket_list = p_fd_list_node;
p_recv_data_thread_context = calloc(1, sizeof(*p_recv_data_thread_context));
if (NULL == p_recv_data_thread_context)
{
}
else
{
p_recv_data_thread_context->fd = p_fd_list_node->fd;
p_recv_data_thread_context->index = j;
p_recv_data_thread_context->p_tcp_server_context = p_tcp_server_context;
if (0 == pthread_create(&thread_id, NULL, recv_data_thread, p_recv_data_thread_context))
{
pthread_detach(thread_id);
}
else
{
}
}
pthread_mutex_unlock(&(p_tcp_server_context->mutex));
}
}
}
if (p_tcp_server_context->p_poll_fds[p_tcp_server_context->listen_addr_num].revents & POLLIN)
{
n = recv(p_tcp_server_context->manage_socket_fd[1], &data, sizeof(data), 0);
break;
}
}
else
{
break;
}
}
for (j = 0; j < p_tcp_server_context->listen_addr_num; j++)
{
close(p_tcp_server_context->p_listen_socket_fd[j]);
}
if (0 != pthread_mutex_lock(&(p_tcp_server_context->mutex)))
{
}
else
{
p_tcp_server_context->tcp_server_exit = TRUE;
p_fd_list_node = p_tcp_server_context->p_conn_socket_list;
/* There is no receive data thread */
if (NULL == p_fd_list_node)
{
data = DONE_COMMAND;
send(p_tcp_server_context->manage_socket_fd[1], &data, sizeof(data), 0);
}
else
{
while (NULL != p_fd_list_node)
{
shutdown(p_fd_list_node->fd, SHUT_RD);
p_fd_list_node = p_fd_list_node->p_next_node;
}
}
pthread_mutex_unlock(&(p_tcp_server_context->mutex));
}
return NULL;
}
static void *
np_conn_read_proc(void *a)
{
int i, n, size, msize;
Npsrv *srv;
Npconn *conn;
Nptrans *trans;
Npreq *req;
Npfcall *fc, *fc1;
pthread_detach(pthread_self());
conn = a;
np_conn_incref(conn);
srv = conn->srv;
msize = conn->msize;
fc = np_conn_new_incall(conn);
n = 0;
while (conn->trans && (i = np_trans_read(conn->trans, fc->pkt + n, msize - n)) > 0) {
pthread_mutex_lock(&conn->lock);
if (conn->resetting) {
pthread_cond_wait(&conn->resetdonecond, &conn->lock);
n = 0; /* discard all input */
i = 0;
}
pthread_mutex_unlock(&conn->lock);
n += i;
again:
if (n < 4)
continue;
size = fc->pkt[0] | (fc->pkt[1]<<8) | (fc->pkt[2]<<16) | (fc->pkt[3]<<24);
if (n < size)
continue;
if (!np_deserialize(fc, fc->pkt, conn->dotu))
break;
if (conn->srv->debuglevel) {
fprintf(stderr, "<<< (%p) ", conn);
np_printfcall(stderr, fc, conn->dotu);
fprintf(stderr, "\n");
}
fc1 = np_conn_new_incall(conn);
if (n > size)
memmove(fc1->pkt, fc->pkt + size, n - size);
n -= size;
req = np_req_alloc(conn, fc);
pthread_mutex_lock(&srv->lock);
if (!conn->resetting)
np_srv_add_req(srv, req);
else
np_req_unref(req);
pthread_mutex_unlock(&srv->lock);
fc = fc1;
if (n > 0)
goto again;
}
pthread_mutex_lock(&conn->lock);
trans = conn->trans;
conn->trans = NULL;
np_conn_free_incall(conn, fc, 0);
pthread_mutex_unlock(&conn->lock);
np_srv_remove_conn(conn->srv, conn);
np_conn_reset(conn, 0, 0);
if (trans)
np_trans_destroy(trans);
np_conn_decref(conn);
return NULL;
}
void Thread::detach()
{
pthread_detach(_tid);
}
void cancel_test(void)
{
pthread_t waiter;
void *result;
int status;
/* Test 1: Normal Cancel *********************************************/
/* Start the waiter thread */
printf("cancel_test: Test 1: Normal Cancelation\n");
printf("cancel_test: Starting thread\n");
start_thread(&waiter, 1);
/* Then cancel it. It should be in the pthread_cond_wait now */
printf("cancel_test: Canceling thread\n");
status = pthread_cancel(waiter);
if (status != 0)
{
printf("cancel_test: ERROR pthread_cancel failed, status=%d\n", status);
}
/* Then join to the thread to pick up the result (if we don't do
* we will have a memory leak!)
*/
printf("cancel_test: Joining\n");
status = pthread_join(waiter, &result);
if (status != 0)
{
printf("cancel_test: ERROR pthread_join failed, status=%d\n", status);
}
else
{
printf("cancel_test: waiter exited with result=%p\n", result);
if (result != PTHREAD_CANCELED)
{
printf("cancel_test: ERROR expected result=%p\n", PTHREAD_CANCELED);
}
else
{
printf("cancel_test: PASS thread terminated with PTHREAD_CANCELED\n");
}
}
/* Test 2: Cancel Detached Thread ************************************/
printf("cancel_test: Test 2: Cancelation of detached thread\n");
printf("cancel_test: Re-starting thread\n");
restart_thread(&waiter, 1);
/* Detach the thread */
status = pthread_detach(waiter);
if (status != 0)
{
printf("cancel_test: ERROR pthread_detach, status=%d\n", status);
}
/* Then cancel it. It should be in the pthread_cond_wait now */
printf("cancel_test: Canceling thread\n");
status = pthread_cancel(waiter);
if (status != 0)
{
printf("cancel_test: ERROR pthread_cancel failed, status=%d\n", status);
}
/* Join should now fail */
printf("cancel_test: Joining\n");
status = pthread_join(waiter, &result);
if (status == 0)
{
printf("cancel_test: ERROR pthread_join succeeded\n");
}
else if (status != ESRCH)
{
printf("cancel_test: ERROR pthread_join failed but with wrong status=%d\n", status);
}
else
{
printf("cancel_test: PASS pthread_join failed with status=ESRCH\n");
}
/* Test 3: Non-cancelable threads ************************************/
/* This test currently depends on signals. It doesn't have to and
* could be re-designed so that it does not depend on signals.
*/
#ifndef CONFIG_DISABLE_SIGNALS
printf("cancel_test: Test 3: Non-cancelable threads\n");
printf("cancel_test: Re-starting thread (non-cancelable)\n");
restart_thread(&waiter, 0);
/* Give the thread a chance to run an to set the non-cancelable state.
* This is the dependency on signals:
*/
usleep(200*1000);
/* Then cancel it. It should be in the pthread_cond_wait now. The
* behavior here is non-standard: when the thread is at a cancelation
* point, it should be cancelable, even when cancelation is disable.
*
* The cancelation should succeed, because the cancelation is pending.
*/
printf("cancel_test: Canceling thread\n");
status = pthread_cancel(waiter);
if (status != 0)
{
printf("cancel_test: ERROR pthread_cancel failed, status=%d\n", status);
}
/* Signal the thread. It should wake up and restore the cancelable state.
* When the cancelable state is re-enabled, the thread should be canceled.
*/
status = pthread_mutex_lock(&mutex);
if (status != 0)
{
printf("cancel_test: ERROR pthread_mutex_lock failed, status=%d\n", status);
}
status = pthread_cond_signal(&cond);
if (status != 0)
{
printf("cancel_test: ERROR pthread_cond_signal failed, status=%d\n", status);
}
status = pthread_mutex_unlock(&mutex);
if (status != 0)
{
printf("cancel_test: ERROR pthread_mutex_unlock failed, status=%d\n", status);
}
/* Then join to the thread to pick up the result (if we don't do
* we will have a memory leak!)
*/
printf("cancel_test: Joining\n");
status = pthread_join(waiter, &result);
if (status != 0)
{
printf("cancel_test: ERROR pthread_join failed, status=%d\n", status);
}
else
{
printf("cancel_test: waiter exited with result=%p\n", result);
if (result != PTHREAD_CANCELED)
{
printf("cancel_test: ERROR expected result=%p\n", PTHREAD_CANCELED);
}
else
{
printf("cancel_test: PASS thread terminated with PTHREAD_CANCELED\n");
}
}
#endif
}
/* $begin detach */
void Pthread_detach(pthread_t tid) {
int rc;
if ((rc = pthread_detach(tid)) != 0)
posix_error(rc, "Pthread_detach error");
}
Thread::~Thread()
{
if(isStarted_)
pthread_detach(tid_);
}
static void NPClientDetachConnectThread(void)
{
pthread_create(&connectthread, NULL, NPClientConnectThread, NULL);
pthread_detach(connectthread);
}
/*************************************************
Function: monitor_proc
Description: 监视线程
Input:
1.param 参数
Output: 无
Return: BOOLEAN
Others:
*************************************************/
static void* monitor_proc(void *param)
{
// 设置分离线程
pthread_detach(pthread_self());
time_t t0;
int32 size = 0;
int32 ret = FALSE;
static int32 times = 10;
LabChange:
g_Video_Start = 0;
g_Audio_Start = 0;
monitor_set_media_ifover(FALSE);
ret = media_start_net_video(g_MonitorInfo.address, _RECVONLY);
if (ret == TRUE)
{
dprintf("monitor_proc : monitoring : start net video OK\n");
g_Video_Start = 1;
}
t0 = time(0);
if (MONITOR_REQUEST == g_MonitorInfo.state)
{
g_PreMonitorState = MONITOR_REQUEST;
monitor_fill_destdevno();
GuiNotify(g_MonitorInfo.state, g_MonitorInfo.index);
g_MonitorInfo.TimeOut = 0;
g_MonitorInfo.HeartTime = 0;
while (MONITOR_REQUEST == g_MonitorInfo.state)
{
memset(g_data, 0, sizeof(g_data));
memcpy(g_data, &g_MonitorInfo.LocalVideoPort, 2);
g_MonitorInfo.TimeOut = time(0) - t0;
// 监视请求5s后没有回应退出
if (g_MonitorInfo.TimeOut >= 5)
{
dprintf("monitor_timer_proc : request time out \n");
g_ErrType = MONITOR_REQUEST_TIMEOUT;
g_MonitorInfo.state = MONITOR_END;
break;
}
// 以下每秒发送一次连接请求
if (g_MonitorInfo.DevType == DEVICE_TYPE_DOOR_NET)
{
// 监视网络门前机
uint8 *tmp = NULL;
MAC_TYPE MacType = DOOR1_MAC;
if (g_MonitorInfo.index == 1)
{
MacType = DOOR1_MAC;
}
else
{
MacType = DOOR2_MAC;
}
tmp = storage_get_mac(MacType);
memcpy(g_mac, tmp, 6);
g_data[2] = DEVICE_TYPE_DOOR_NET;
g_data[3] = (uint8)g_MonitorInfo.index;
#ifdef _SEND_SDP_PARAM_
memcpy(&g_data[4], (char *)(&g_venc_parm), 16);
memcpy(&g_data[20], (char *)(&g_audio_parm), 8);
memcpy(&g_data[28], g_mac, 6);
size = 66;
#else
memcpy(&g_data[4], g_mac, 6);
size = 10;
#endif
set_nethead(g_MoniDestDeviceNo, PRIRY_DEFAULT);
net_direct_send(CMD_MONITOR, g_data, size, g_MonitorInfo.address, g_MonitorInfo.port);
}
else
{
#ifdef _TY_STAIR_
if (storage_get_extmode(EXT_MODE_GENERAL_STAIR))
{
g_data[2] = (uint8)g_MonitorInfo.DevType;
g_data[3] = (uint8)g_MonitorInfo.index;
#ifdef _SEND_SDP_PARAM_
memcpy(&g_data[4], (char *)(&g_venc_parm), 16);
memcpy(&g_data[20], (char *)(&g_audio_parm), 8);
size = 66;
#else
size = 4;
#endif
set_nethead(g_MoniDestDeviceNo, PRIRY_DEFAULT);
net_direct_send(CMD_MONITOR, g_data, size, g_MonitorInfo.address, g_MonitorInfo.port);
}
else
#endif
{
g_data[2] = (uint8)g_MonitorInfo.DevType;
g_data[3] = (uint8)g_MonitorInfo.index;
#ifdef _SEND_SDP_PARAM_
memcpy(&g_data[4], (char *)(&g_venc_parm), 16);
memcpy(&g_data[20], (char *)(&g_audio_parm), 8);
size = 66;
#else
size = 4;
#endif
set_nethead(g_MoniDestDeviceNo, PRIRY_DEFAULT);
net_direct_send(CMD_MONITOR, g_data, size, g_MonitorInfo.address, g_MonitorInfo.port);
}
}
// 睡眠时间会影响视频出来快慢
times = 10;
while ((times--) > 0 && MONITOR_REQUEST == g_MonitorInfo.state)
{
usleep(100*1000);
}
}
// 解决链接转监视太快 UI切换失败问题
if (time(0) - t0 < 2)
{
usleep(500*1000);
}
}
t0 = time(0);
if(MONITOR_MONITORING == g_MonitorInfo.state)
{
g_MonitorInfo.TimeMax = MONITOR_TIME_MAX;
g_MonitorInfo.TimeOut = 0;
g_MonitorInfo.HeartTime = 0;
g_RemainTime = 0;
while (MONITOR_MONITORING == g_MonitorInfo.state)
{
g_MonitorInfo.TimeOut = time(0) - t0;
if (g_MonitorInfo.TimeMax > 0)
{
// 剩余时间
g_RemainTime = g_MonitorInfo.TimeMax - g_MonitorInfo.TimeOut;
if (g_RemainTime <= 0)
{
set_nethead(g_MoniDestDeviceNo, PRIRY_DEFAULT);
net_direct_send(CMD_STOP_MONITOR, g_buf, 2, g_MonitorInfo.address, g_MonitorInfo.port);
g_ErrType = MONITOR_MONITORING_TIMEOUT;
g_MonitorInfo.state = MONITOR_END;
break;
}
else
{
GuiNotify(MONITOR_TIMER, g_RemainTime);
set_nethead(g_MoniDestDeviceNo, PRIRY_DEFAULT);
net_direct_send(CMD_MONITOR_HEART, g_buf, 2, g_MonitorInfo.address, g_MonitorInfo.port);
}
if (g_MonitorInfo.HeartTime > HEART_TIMEOUT)
{
g_ErrType = MONITOR_HEART_TIMEOUT;
g_MonitorInfo.state = MONITOR_END;
break;
}
g_MonitorInfo.HeartTime++;
times = 10;
while ((times--) > 0 && (MONITOR_MONITORING == g_MonitorInfo.state))
{
usleep(100*1000);
}
}
}
}
if (MONITOR_TALKING == g_MonitorInfo.state)
{
hw_switch_digit(); // 切换到数字对讲
media_set_talk_volume(g_MonitorInfo.DevType, storage_get_talkvolume());
media_set_mic_volume(storage_get_micvolume());
if (media_start_net_audio(g_MonitorInfo.address))
{
dprintf("media_start_net_audio return ok\n ");
g_Audio_Start = 1;
media_add_audio_sendaddr(g_MonitorInfo.address, g_MonitorInfo.RemoteAudioPort);
// add by chenbh 2016-08-22
media_enable_audio_send();
media_enable_audio_recv();
}
else
{
dprintf(" media_start_net_audio return error\n ");
g_MonitorInfo.state = MONITOR_END;
}
}
t0 = time(0);
if (MONITOR_TALKING == g_MonitorInfo.state)
{
dprintf("MONITOR_TALKING == g_MonitorInfo.state \n");
GuiNotify(g_MonitorInfo.state, 0);
g_PreMonitorState = MONITOR_TALKING;
g_MonitorInfo.TimeMax = MONITOR_TALK_TIME_MAX;
g_MonitorInfo.TimeOut = 0;
g_MonitorInfo.HeartTime = 0;
while (MONITOR_TALKING == g_MonitorInfo.state)
{
if (g_MonitorInfo.TimeMax > 0)
{
g_RemainTime = 0;
g_MonitorInfo.TimeOut = time(0) - t0;
// 剩余时间
//g_RemainTime = g_MonitorInfo.TimeMax - g_MonitorInfo.TimeOut;
if (g_MonitorInfo.TimeOut >= g_MonitorInfo.TimeMax)
{
dprintf("monitor timer proc : talking time out\n");
set_nethead(g_MoniDestDeviceNo, PRIRY_DEFAULT);
net_direct_send(CMD_STOP_MONITOR, g_buf, 2, g_MonitorInfo.address, g_MonitorInfo.port);
g_ErrType = MONITOR_TALKING_TIMEOUT;
g_MonitorInfo.state = MONITOR_END;
break;
}
else
{
g_RemainTime = g_MonitorInfo.TimeMax - g_MonitorInfo.TimeOut;
GuiNotify(MONITOR_TIMER, g_RemainTime);
set_nethead(g_MoniDestDeviceNo, PRIRY_DEFAULT);
net_direct_send(CMD_MONITOR_HEART, g_buf, 2, g_MonitorInfo.address, g_MonitorInfo.port);
}
if (g_MonitorInfo.HeartTime > HEART_TIMEOUT)
{
g_ErrType = MONITOR_HEART_TIMEOUT;
g_MonitorInfo.state = MONITOR_END;
break;
}
g_MonitorInfo.HeartTime++;
times = 10;
while ((times--) > 0 && (MONITOR_TALKING == g_MonitorInfo.state))
{
usleep(100*1000);
}
}
}
}
// 监视下一个情况 得回到监视请求
if (MONITOR_REQUEST == g_MonitorInfo.state)
{
media_stop_net_video(_RECVONLY);
goto LabChange;
}
dprintf("monitor proc : g_PreMonitorState : %d\n", g_PreMonitorState);
if (g_Audio_Start == 1)
{
g_Audio_Start = 0;
media_del_audio_send_addr(g_MonitorInfo.address, MEDIA_AUDIO_PORT);
usleep(10*1000);
media_stop_net_audio();
}
// 关闭视频接口
if (g_Video_Start == 1)
{
g_Video_Start = 0;
media_stop_net_video(_RECVONLY);
}
monitor_set_media_ifover(TRUE);
dprintf("monitor proc : AS_MONITOR_END : g_ErrType : %d\n", g_ErrType);
//sys_set_monitor_state(FALSE);
dprintf("monitor proc end!\n");
g_MonitorInfo.state = MONITOR_END;
g_PreMonitorState = MONITOR_END;
GuiNotify(g_MonitorInfo.state, g_ErrType);
g_ErrType = MONITOR_OK;
sys_set_monitor_state(FALSE);
inter_SetThread(&g_MonitorInfo.mThread);
pthread_exit(NULL);
return NULL; // 返回后资源由系统释放
}
static void NPClientDetachPrepareThread(void)
{
pthread_create(&preparethread, NULL, NPClientPrepareThread, NULL);
pthread_detach(preparethread);
}
void
xpthread_detach (pthread_t thr)
{
xpthread_check_return ("pthread_detach", pthread_detach (thr));
}
int TRI_DetachThread (TRI_thread_t* thread) {
return pthread_detach(*thread);
}
/*
* First of all, creates a transaction;
* then reads the newly created bus path,
* adds a match to the bus to wait until installation is really finished before notifying the user.
* finally, calls InstallFiles method, and processes the bus while finished == 0.
*/
void *install_package(void *str) {
sd_bus_error error = SD_BUS_ERROR_NULL;
sd_bus_message *mess = NULL;
sd_bus *install_bus = NULL;
const char *path;
int r, inhibit_fd = -1, finished = 0;
r = sd_bus_open_system(&install_bus);
if (r < 0) {
print_and_warn(strerror(-r), ERR_LINE);
goto finish;
}
INFO("calling CreateTransaction on bus.");
r = sd_bus_call_method(install_bus,
"org.freedesktop.PackageKit",
"/org/freedesktop/PackageKit",
"org.freedesktop.PackageKit",
"CreateTransaction",
&error,
&mess,
NULL);
if (r < 0) {
print_and_warn(error.message, ERR_LINE);
goto finish;
}
if (config.inhibit) {
inhibit_fd = inhibit_suspend("Package installation...");
}
sd_bus_message_read(mess, "o", &path);
r = sd_bus_add_match(install_bus, NULL, "type='signal',interface='org.freedesktop.PackageKit.Transaction',member='Finished'", match_callback, &finished);
if (r < 0) {
print_and_warn(strerror(-r), ERR_LINE);
goto finish;
}
sd_bus_flush(install_bus);
INFO("calling InstallFiles on bus.");
r = sd_bus_call_method(install_bus,
"org.freedesktop.PackageKit",
path,
"org.freedesktop.PackageKit.Transaction",
"InstallFiles",
&error,
NULL,
"tas",
0,
1,
(char *)str);
if (r < 0) {
print_and_warn(error.message, ERR_LINE);
goto finish;
}
while (!finished) {
r = sd_bus_process(install_bus, NULL);
if (r > 0) {
continue;
}
r = sd_bus_wait(install_bus, (uint64_t) -1);
if (r < 0) {
break;
}
}
finish:
stop_inhibition(inhibit_fd);
close_bus(&error, mess, install_bus);
pthread_detach(pthread_self());
pthread_exit(NULL);
}
Thread::~Thread()
{
pthread_detach(pthId_);
isRunning_ = false;
}
void *jalls_handler(void *thread_ctx_p) {
if (!thread_ctx_p) {
return NULL; //should never happen.
}
struct jalls_thread_context *thread_ctx = NULL;
thread_ctx = thread_ctx_p;
pid_t *pid = NULL;
uid_t *uid = NULL;
int debug = thread_ctx->ctx->debug;
int err = pthread_detach(pthread_self());
if (err < 0) {
if (debug) {
fprintf(stderr, "Failed to detach the thread\n");
}
goto out;
}
while (!should_exit) {
// read protocol version, message type, data length,
// metadata length and possible fd.
uint16_t protocol_version;
uint16_t message_type;
uint64_t data_len;
uint64_t meta_len;
int msg_fd = -1;
struct msghdr msgh;
memset(&msgh, 0, sizeof(msgh));
struct iovec iov[4];
iov[0].iov_base = &protocol_version;
iov[0].iov_len = sizeof(protocol_version);
iov[1].iov_base = &message_type;
iov[1].iov_len = sizeof(message_type);
iov[2].iov_base = &data_len;
iov[2].iov_len = sizeof(data_len);
iov[3].iov_base = &meta_len;
iov[3].iov_len = sizeof(meta_len);
msgh.msg_iov = iov;
msgh.msg_iovlen = 4;
char msg_control_buffer[CMSG_SPACE(sizeof(msg_fd))];
msgh.msg_control = msg_control_buffer;
msgh.msg_controllen = sizeof(msg_control_buffer);
#ifdef SO_PEERCRED
struct ucred cred;
memset(&cred, 0, sizeof(cred));
pid = &cred.pid;
uid = &cred.uid;
*pid = -1;
*uid = 0;
socklen_t cred_len = sizeof(cred);
if (-1 == getsockopt(thread_ctx->fd, SOL_SOCKET, SO_PEERCRED, &cred, &cred_len)) {
if (debug) {
fprintf(stderr, "failed receiving peer crendentials\n");
}
}
#endif
#ifdef SCM_UCRED
ucred_t *cred = NULL;
pid_t tmp_pid = -1;
uid_t tmp_uid = 0;
pid = &tmp_pid;
uid = &tmp_uid;
if (-1 == getpeerucred(thread_ctx->fd, &cred)) {
if (debug) {
fprintf(stderr, "failed receiving peer credentials\n");
}
} else {
tmp_pid = ucred_getpid(cred);
tmp_uid = ucred_geteuid(cred);
ucred_free(cred);
}
#endif
ssize_t bytes_recv = jalls_recvmsg_helper(thread_ctx->fd, &msgh, debug);
if (bytes_recv < 0) {
if (debug) {
fprintf(stderr, "Failed to receive the message header\n");
}
goto out;
}
if (bytes_recv == 0) {
if (debug) {
fprintf(stderr, "The peer has shutdown\n");
}
goto out;
}
//receive fd
struct cmsghdr *cmsg;
cmsg = CMSG_FIRSTHDR(&msgh);
while (cmsg != NULL) {
if (cmsg->cmsg_level == SOL_SOCKET) {
if (cmsg->cmsg_type == SCM_RIGHTS && cmsg->cmsg_len == CMSG_LEN(sizeof(msg_fd))) {
if (message_type != JALLS_JOURNAL_FD_MSG) {
if (debug) {
fprintf(stderr, "received an fd for a message type that was not journal_fd\n");
}
goto out;
}
void *tmp_fd = CMSG_DATA(cmsg);
if (debug && msg_fd != -1) {
fprintf(stderr, "received duplicate ancillary data: overwrote the fd\n");
}
msg_fd = *((int *)tmp_fd);
if (msg_fd < 0) {
if (debug) {
fprintf(stderr, "received an fd < 0\n");
}
goto out;
}
} else {
if (debug) {
fprintf(stderr, "received unrecognized ancillary data\n");
}
goto out;
}
}
cmsg = CMSG_NXTHDR(&msgh, cmsg);
}
thread_ctx->peer_pid = *pid;
thread_ctx->peer_uid = *uid;
if (debug && *pid == -1) {
thread_ctx->peer_pid = 0;
thread_ctx->peer_uid = 0;
fprintf(stderr, "Did not receive credentials\n");
}
if (protocol_version != 1) {
if (debug) {
fprintf(stderr, "received protocol version != 1\n");
}
return NULL;
}
//call appropriate handler
switch (message_type) {
case JALLS_LOG_MSG:
err = jalls_handle_log(thread_ctx, data_len, meta_len);
break;
case JALLS_AUDIT_MSG:
err = jalls_handle_audit(thread_ctx, data_len, meta_len);
break;
case JALLS_JOURNAL_MSG:
err = jalls_handle_journal(thread_ctx, data_len, meta_len);
break;
case JALLS_JOURNAL_FD_MSG:
if (msg_fd < 0) {
if (debug) {
fprintf(stderr, "Message type is journal_fd, but no fd was received\n");
}
goto out;
}
err = jalls_handle_journal_fd(thread_ctx, data_len, meta_len, msg_fd);
break;
default:
if (debug) {
fprintf(stderr, "Message type is not legal.\n");
}
goto out;
}
if (err < 0) {
goto out;
}
}
out:
close(thread_ctx->fd);
free(thread_ctx);
return NULL;
}
int main(int argc, char *argv[])
{
int fd = -1, newfd = -1;
struct sockaddr_in sin;
int serv_port = SERV_PORT;
/* 参数处理*/
if( argc >2 ) {
usage(argv[0]);
exit(EXIT_FAILURE);
}
if(argc == 2) {
serv_port = atoi(argv[1]);
}
/* 1.创建套接字*/
if( (fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
perror("socket");
exit(1);
}
/* 2. 绑定 */
/*2.1 填充sockaddr_in结构体，填充绑定的IP地址和端口号 */
sin.sin_family = AF_INET;
sin.sin_port = htons(SERV_PORT);
#if 0
if(inet_pton(AF_INET,SERV_IP, &sin.sin_addr) != 1) {
perror("inet_pton");
exit(EXIT_FAILURE);
}
#else
sin.sin_addr.s_addr = htonl(INADDR_ANY);
#endif
bzero(sin.sin_zero, 8);
/* 允许地址快速重用 **/
int b_reuse =1;
setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &b_reuse, sizeof(int));
/* 2.2 调用bind()函数去绑定在本地的某个IP地址+端口上*/
if(bind(fd, (struct sockaddr *)&sin, sizeof(sin)) < 0) {
perror("bind");
exit(EXIT_FAILURE);
}
/* 3.把套接字变成被动套接字 */
listen(fd, BACKLOG);
printf("server staring....OK!\n");
/*4. 阻塞等待客户端连接 */
while(1) {
struct sockaddr_in cin;
int clen = sizeof(cin);
pthread_t tid;
struct cli_info *pInfo = NULL;
newfd = accept(fd, (struct sockaddr *)&cin, &clen); /*阻塞等待客户端的连接请求*/
pInfo = (struct cli_info *)malloc(sizeof(struct cli_info));
/* 填充客户端信息的的结构体*/
pInfo->cli_fd = newfd;
memcpy(&pInfo->cin, &cin, sizeof(cin));
//FIXME!!
//...把pInfo加到主线程的客户端信息链表中
pthread_create(&tid, NULL, cli_data_handler, (void *)pInfo);
pthread_detach(tid);
}
close(fd);
return 0;
}
//-----------------------------------------------------------------------------
void* thread_func(void* param)
{
thread_param* th_param = (thread_param*)param;
process_events_and_channel_data_from_plugin(th_param);
pthread_detach(pthread_self());
}
int main(int argc, char *argv[])
{
int fd, sock_server, sock_client;
pthread_t thread;
void *(*handler[4])(void *) =
{
rx_ctrl_handler,
rx_data_handler,
tx_ctrl_handler,
tx_data_handler
};
void *cfg, *sts;
char *end, *name = "/dev/mem";
struct sockaddr_in addr;
uint16_t port;
uint32_t command;
ssize_t result;
int yes = 1;
long number;
errno = 0;
number = (argc == 2) ? strtol(argv[1], &end, 10) : -1;
if(errno != 0 || end == argv[1] || number < 1 || number > 2)
{
printf("Usage: sdr-transceiver 1|2\n");
return EXIT_FAILURE;
}
if((fd = open(name, O_RDWR)) < 0)
{
perror("open");
return EXIT_FAILURE;
}
switch(number)
{
case 1:
port = 1001;
cfg = mmap(NULL, sysconf(_SC_PAGESIZE), PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0x40000000);
sts = mmap(NULL, sysconf(_SC_PAGESIZE), PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0x40001000);
rx_data = mmap(NULL, 2*sysconf(_SC_PAGESIZE), PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0x40002000);
tx_data = mmap(NULL, 2*sysconf(_SC_PAGESIZE), PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0x40004000);
break;
case 2:
port = 1002;
cfg = mmap(NULL, sysconf(_SC_PAGESIZE), PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0x40006000);
sts = mmap(NULL, sysconf(_SC_PAGESIZE), PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0x40007000);
rx_data = mmap(NULL, 2*sysconf(_SC_PAGESIZE), PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0x40008000);
tx_data = mmap(NULL, 2*sysconf(_SC_PAGESIZE), PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0x4000A000);
break;
}
gpio = ((uint16_t *)(cfg + 0));
rx_freq = ((uint32_t *)(cfg + 4));
rx_rate = ((uint32_t *)(cfg + 8));
rx_cntr = ((uint16_t *)(sts + 0));
tx_freq = ((uint32_t *)(cfg + 12));
tx_rate = ((uint32_t *)(cfg + 16));
tx_cntr = ((uint16_t *)(sts + 2));
/* set PTT pin to low */
*gpio = 0;
/* set default rx phase increment */
*rx_freq = (uint32_t)floor(600000/125.0e6*(1<<30)+0.5);
/* set default rx sample rate */
*rx_rate = 625;
/* set default tx phase increment */
*tx_freq = (uint32_t)floor(600000/125.0e6*(1<<30)+0.5);
/* set default tx sample rate */
*tx_rate = 625;
if((sock_server = socket(AF_INET, SOCK_STREAM, 0)) < 0)
{
perror("socket");
return EXIT_FAILURE;
}
setsockopt(sock_server, SOL_SOCKET, SO_REUSEADDR, (void *)&yes , sizeof(yes));
/* setup listening address */
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = htonl(INADDR_ANY);
addr.sin_port = htons(port);
if(bind(sock_server, (struct sockaddr *)&addr, sizeof(addr)) < 0)
{
perror("bind");
return EXIT_FAILURE;
}
listen(sock_server, 1024);
while(1)
{
if((sock_client = accept(sock_server, NULL, NULL)) < 0)
{
perror("accept");
return EXIT_FAILURE;
}
result = recv(sock_client, (char *)&command, 4, MSG_WAITALL);
if(result <= 0 || command > 3 || sock_thread[command] > -1)
{
close(sock_client);
continue;
}
sock_thread[command] = sock_client;
if(pthread_create(&thread, NULL, handler[command], NULL) < 0)
{
perror("pthread_create");
return EXIT_FAILURE;
}
pthread_detach(thread);
}
close(sock_server);
return EXIT_SUCCESS;
}
int
main(int argc, char *argv[])
{
fd_set rfds, wfds;
struct cn_strct *tp, *to;
int rnum, wnum, readsocks;
int i;
struct tm *tm_struct;
/* initialize the masterdate we update only every second */
_Last_loop = time(NULL);
tm_struct = gmtime(&_Last_loop);
strftime( _Master_date, 32, "%a, %d %b %Y %H:%M:%S %Z", tm_struct);
#if DEBUG_VERBOSE == 2
_Conn_count=0;
#endif
#if DEBUG_VERBOSE == 1
printf("STARTED AT: %s\n", _Master_date);
#endif
signal(SIGQUIT, die);
signal(SIGTERM, die);
signal(SIGPIPE, check_sockets);
signal(SIGINT, clean_on_quit);
/* Fill up the initial connection lists; _Free_conns is just a LIFO stack,
* there shall never be a performance issues -> single linked only */
_Free_count=0;
for (i = 0; i < INITIAL_CONNS; i++) {
tp = _Free_conns;
_Free_conns = (struct cn_strct *) calloc(1, sizeof(struct cn_strct));
_Free_conns->data_buf_head =
(char *) calloc (RECV_BUFF_LENGTH, sizeof (char));
_Free_conns->c_next = tp;
_Free_conns->c_prev = NULL;
_Free_conns->q_prev = NULL;
_Free_conns->identifier = _Conn_count++;
_Free_count++;
}
/* create the master listener */
if ((_Master_sock = create_listener(HTTP_PORT)) == -1) {
fprintf(stderr, "ERR: Couldn't bind to port %d\n",
HTTP_PORT);
exit(1);
}
/* set up LIFO queue */
_Queue_tail = _Queue_head = NULL;
_Queue_count = 0;
/* create workers for application */
for(i = 0; i < WORKER_THREADS; i++) {
pthread_create(&_Workers[i], NULL, &run_app_thread, (void *) &i);
}
sleep(1);
for(i = 0; i < WORKER_THREADS; i++) {
pthread_detach( _Workers[i] );
}
#if DEBUG_VERBOSE == 1
printf("%s: listening on port %d (http)\n",
_Server_version, HTTP_PORT);
#endif
/* main loop */
while (1) {
// clean socket lists
FD_ZERO(&rfds);
FD_ZERO(&wfds);
wnum = -1;
// Add master listener to reading sockets
FD_SET(_Master_sock, &rfds);
rnum = _Master_sock;
// Add the established sockets
tp = _Busy_conns;
/* Adding connection to the SocketSets based on state */
while (tp != NULL) {
if (REQSTATE_READ_HEAD == tp->req_state) {
FD_SET(tp->net_socket, &rfds);
rnum = (tp->net_socket > rnum) ? tp->net_socket : rnum;
}
if (REQSTATE_SEND_FILE == tp->req_state) {
FD_SET(tp->net_socket, &wfds);
wnum = (tp->net_socket > wnum) ? tp->net_socket : wnum;
}
tp = tp->c_next;
}
readsocks = select(
(wnum > rnum) ? wnum+1 : rnum+1,
(-1 != rnum) ? &rfds : NULL,
(-1 != wnum) ? &wfds : NULL,
(fd_set *) 0,
NULL
);
// is the main listener in the read set? -> New connection
if (FD_ISSET(_Master_sock, &rfds)) {
handle_new_conn(_Master_sock);
readsocks--;
}
// Handle the established sockets
tp = _Busy_conns;
while (readsocks > 0 && tp != NULL) {
to = tp;
tp = tp->c_next;
if (REQSTATE_READ_HEAD == to->req_state &&
FD_ISSET(to->net_socket, &rfds)) {
readsocks--;
#if DEBUG_VERBOSE == 1
printf("WANNA RECV HEAD\n");
#endif
read_request(to);
}
if (REQSTATE_SEND_FILE == to->req_state &&
FD_ISSET(to->net_socket, &wfds)) {
readsocks--;
#if DEBUG_VERBOSE == 1
printf("WANNA SEND FILE\n");
#endif
send_file(to);
}
}
}
return 0;
}
/*
* The thread start routine for crew threads. Waits in the rngBlkGet()
* call where address of workQEntries are received, then processes work items until requested to shut down.
*
* For none active Receivers/DDRs their cmd will set to -1 , thus they will
* pend immediately.
*
* Author: Greg Brissey
*/
void *worker_routine (void *arg)
{
int status;
WORKQ_ENTRY_ID pWrkQentry;
RCVR_DESC_ID pRcvrDesc;
WORKQINVARIENT_ID pWrkqInvar;
int inQueue;
int processThreadFlag;
char *CntlrId;
RCVR_DESC_ID pAccessWrkDesc = (RCVR_DESC_ID) arg;
if (pAccessWrkDesc == &ProcessThread)
processThreadFlag = 1;
else
processThreadFlag = 0;
CntlrId = pAccessWrkDesc->cntlrId;
DPRINT3(+2,"'%s': threadId: 0x%lx, RCVR_DESC_ID: 0x%lx, starting\n",
CntlrId,pAccessWrkDesc->threadID,pAccessWrkDesc);
pThreadBlockAllSigs(); /* block most signals here */
pthread_detach(pAccessWrkDesc->threadID); /* if thread terminates no need to join it to recover resources */
while (1) {
/* obtain work from the pipe line Q, if non the thread blocks */
rngBlkGet(pAccessWrkDesc->pInputQ, &pWrkQentry,1);
if (!processThreadFlag)
incrActiveCntlrStatus(CntlrId);
pRcvrDesc = (RCVR_DESC_ID) pWrkQentry->pInvar->pRcvrDesc;
DPRINT2(+2,"'%s': Got workQ: 0x%lx\n", pRcvrDesc->cntlrId, pWrkQentry);
inQueue = rngBlkNElem(pRcvrDesc->pInputQ);
DPRINT2(+2,"'%s': work still in Q: %d\n", pRcvrDesc->cntlrId, inQueue);
#define INSTRUMENT
#ifdef INSTRUMENT
if (inQueue > pRcvrDesc->p4Diagnostics->pipeHighWaterMark)
pRcvrDesc->p4Diagnostics->pipeHighWaterMark = inQueue;
#endif
DPRINT2(+2,"'%s': Got workQ: 0x%lx\n", pAccessWrkDesc->cntlrId, pAccessWrkDesc);
DPRINT2(+2,"'%s': work still in Q: %d\n", pAccessWrkDesc->cntlrId, rngBlkNElem(pAccessWrkDesc->pInputQ));
status = (pAccessWrkDesc->pCallbackFunc)(pWrkQentry);
/* if status is not < 0 then send workQ on to next stage
* if status < 0 then there is an error or the function call already
* handled the passing to the next stage and this routine does not need to
*/
DPRINT2(+2,"'%s': CallBack Returned: %d\n", pRcvrDesc->cntlrId, status);
if (status >= 0)
{
DPRINT2(+2,"'%s': Done, Send WorkQ onto Processing Thread: 0x%lx\n",
pRcvrDesc->cntlrId, pRcvrDesc);
rngBlkPut(pAccessWrkDesc->pOutputQ, &pWrkQentry,1);
}
if (!processThreadFlag)
decActiveCntlrStatus(CntlrId);
}
}
