// 获取一次数据以供发送
void GetData()
{
Uint8 *data;
while(TRUE)
{
/* Wait 10 sets of data from ADS1298_ISR(). */
Semaphore_pend(semDRDY, BIOS_WAIT_FOREVER);
// 获取缓冲区地址
data = dataPool;
// 切换数据池
if(dataPool == *DataPool1)
{
dataPool = *DataPool2;
}
else
{
dataPool = *DataPool2;
}
retrieve_data(data);
Data2Send = AllData[8-Channel_No];
signal_process();
//发送单通道数据，触发发送事件
Event_post(eventServer, Event_Id_01);
}
}
int kill(int pid, int sig)
{
if(current->proc->flags & PROC_FLAG_DEBUG)
{
debug("[info]KILL(%d, %d)\n", pid, sig);
}
/* debug("KILL(%d, %d)", pid, sig); */
if(pid <= 0)
{
errno = ESRCH;
return -1;
}
if(sig > NUM_SIGNALS)
{
errno = EINVAL;
return -1;
}
if(!get_process(pid))
{
errno = ESRCH;
return -1;
}
signal_process(pid, sig);
return 0;
}
/* Utility process to kill off a fork job when necessary */
int
kill_fork(samrthread_t *ptr) {
int rval;
rval = signal_process(ptr->pid, NULL, SIGTERM);
return (rval);
}
/*
* Cancel a SAM-FS job by killing the process specified
*/
int
destroy_process(
ctx_t *ctx, /* ARGSUSED */
pid_t pid,
proctype_t ptype)
{
char *pname = NULL;
Trace(TR_MISC, "destroying process with pid: %ld and type: %d",
pid, ptype);
switch (ptype) {
case PTYPE_PROC_JOBS_BEGIN:
pname = NULL;
break;
case PTYPE_OTHER_JOB:
pname = NULL;
break;
case PTYPE_PROC_JOB:
pname = NULL;
break;
default:
if (ptype >= PTYPE_PROC_JOB || ptype < 0) {
pname = NULL;
} else {
pname = proc_type_names[ptype];
}
break;
}
if (pname == NULL) {
samerrno = SE_INVALID_PROCESS_TYPE;
snprintf(samerrmsg, MAX_MSG_LEN, GetCustMsg(samerrno), ptype);
goto err;
}
/* now kill the process */
if (signal_process(pid, pname, SIGKILL) != 0) {
samerrno = SE_KILL_FAILED;
snprintf(samerrmsg, MAX_MSG_LEN, GetCustMsg(samerrno), pid, "");
strlcat(samerrmsg, strerror(errno), MAX_MSG_LEN);
goto err;
}
Trace(TR_MISC, "destroyed process");
return (0);
err:
Trace(TR_ERR, "destroying process failed %s", samerrmsg);
return (-1);
}
int
main(int argc, char *argv[]) {
int rc;
uv_loop_t *loop;
parse_opts(argc, argv);
#if !defined(_WIN32)
if (xsignal) {
return signal_process(xsignal, pidfile);
}
#endif
if (!password || !server_addr_buf) {
print_usage(argv[0]);
return 1;
}
init();
#if !defined(_WIN32)
if (daemon_mode) {
if (daemonize()) {
return 1;
}
if (already_running(pidfile)) {
logger_stderr("xsocks already running.");
return 1;
}
}
#endif
loop = uv_default_loop();
rc = resolve_addr(local_addr, &bind_addr);
if (rc) {
logger_stderr("invalid local address");
return 1;
}
rc = resolve_addr(server_addr_buf, &server_addr);
if (rc) {
logger_stderr("invalid server address");
return 1;
}
udprelay_init();
if (concurrency <= 1) {
struct server_context ctx;
ctx.udprelay = 1;
ctx.udp_fd = create_socket(SOCK_DGRAM, 0);
ctx.local_addr = &bind_addr;
ctx.server_addr = &server_addr;
uv_tcp_init(loop, &ctx.tcp);
rc = uv_tcp_bind(&ctx.tcp, &bind_addr, 0);
if (rc) {
logger_stderr("bind error: %s", uv_strerror(rc));
return 1;
}
rc = uv_listen((uv_stream_t*)&ctx.tcp, 128, client_accept_cb);
if (rc == 0) {
logger_log(LOG_INFO, "listening on %s", local_addr);
#if !defined(_WIN32)
setup_signal(loop, signal_cb, &ctx);
#endif
udprelay_start(loop, &ctx);
uv_run(loop, UV_RUN_DEFAULT);
close_loop(loop);
} else {
logger_stderr("listen error: %s", uv_strerror(rc));
}
} else {
#if !defined(_WIN32)
struct server_context *servers = calloc(concurrency, sizeof(servers[0]));
for (int i = 0; i < concurrency; i++) {
struct server_context *ctx = servers + i;
ctx->index = i;
ctx->tcp_fd = create_socket(SOCK_STREAM, 1);
ctx->udp_fd = create_socket(SOCK_DGRAM, 1);
ctx->udprelay = 1;
ctx->accept_cb = client_accept_cb;
ctx->local_addr = &bind_addr;
ctx->server_addr = &server_addr;
rc = uv_sem_init(&ctx->semaphore, 0);
rc = uv_thread_create(&ctx->thread_id, consumer_start, ctx);
}
logger_log(LOG_INFO, "listening on %s", local_addr);
setup_signal(loop, signal_cb, servers);
uv_run(loop, UV_RUN_DEFAULT);
close_loop(loop);
for (int i = 0; i < concurrency; i++) {
uv_sem_wait(&servers[i].semaphore);
}
free(servers);
#else
logger_stderr("don't support multithreading.");
return 1;
#endif
}
udprelay_destroy();
#if !defined(_WIN32)
if (daemon_mode) {
delete_pidfile(pidfile);
}
#endif
logger_exit();
return 0;
}
int
main(int argc, char* argv[])
{
char *procd_address = NULL;
myDistro->Init(argc, argv);
if (argc < 2) {
fprintf(stderr,
"Usage: %s <options w/arguments> <command> [<arg> ...]\n",
argv[0]);
list_commands();
return 1;
}
config();
Termlog = 1;
dprintf_config("TOOL", get_param_functions());
int cmd_argc = argc - 1;
char** cmd_argv = argv + 1;
// Process the first set of options.
while(cmd_argv[0] != NULL && cmd_argv[0][0] == '-')
{
if (strcmp(cmd_argv[0], "-A") == MATCH) {
cmd_argc--;
cmd_argv++;
if (cmd_argc == 0) {
fprintf(stderr, "error: -A needs an argument\n");
list_commands();
return 1;
}
// store the argument to -A as the file we'll use.
procd_address = cmd_argv[0];
cmd_argc--;
cmd_argv++;
continue;
} else if (strcmp(cmd_argv[0], "-h") == MATCH) {
cmd_argc--;
cmd_argv++;
fprintf(stderr,
"Usage: %s <options w/arguments> <command> [<arg> ...]\n",
argv[0]);
list_commands();
return 1;
continue;
}
// This is the failure case if we manage to pass all checks above.
fprintf(stderr, "error: Don't understand option %s\n", cmd_argv[0]);
list_commands();
return 1;
}
// If there are no command line arguments left, then there is no
// command specified after the options, which is a failure.
if (cmd_argc == 0) {
fprintf(stderr,
"Please specify a command.\n"
"Usage: %s <options w/arguments> <command> [<arg> ...]\n",
argv[0]);
list_commands();
return 1;
}
// If a procd address wasn't specified on the command line, see if we
// have an entry in a config file to use.
if (procd_address == NULL) {
procd_address = param("PROCD_ADDRESS");
if (procd_address == NULL) {
fprintf(stderr, "error: PROCD_ADDRESS not defined\n");
return 1;
}
}
ProcFamilyClient pfc;
if (!pfc.initialize(procd_address)) {
fprintf(stderr, "error: failed to initialize ProcD client\n");
return 1;
}
// Process this single command we should be performing
if (strcasecmp(cmd_argv[0], "REGISTER_FAMILY") == 0) {
return register_family(pfc, cmd_argc, cmd_argv);
}
else if (strcasecmp(cmd_argv[0], "TRACK_BY_ASSOCIATED_GID") == 0) {
return track_by_associated_gid(pfc, cmd_argc, cmd_argv);
}
else if (strcasecmp(cmd_argv[0], "TRACK_BY_ASSOCIATED_CGROUP") == 0) {
return track_by_associated_cgroup(pfc, cmd_argc, cmd_argv);
}
else if (strcasecmp(cmd_argv[0], "GET_USAGE") == 0) {
return get_usage(pfc, cmd_argc, cmd_argv);
}
else if (strcasecmp(cmd_argv[0], "DUMP") == 0) {
return dump(pfc, cmd_argc, cmd_argv);
}
else if (strcasecmp(cmd_argv[0], "LIST") == 0) {
return list(pfc, cmd_argc, cmd_argv);
}
else if (strcasecmp(cmd_argv[0], "SIGNAL_PROCESS") == 0) {
return signal_process(pfc, cmd_argc, cmd_argv);
}
else if (strcasecmp(cmd_argv[0], "SUSPEND_FAMILY") == 0) {
return suspend_family(pfc, cmd_argc, cmd_argv);
}
else if (strcasecmp(cmd_argv[0], "CONTINUE_FAMILY") == 0) {
return continue_family(pfc, cmd_argc, cmd_argv);
}
else if (strcasecmp(cmd_argv[0], "KILL_FAMILY") == 0) {
return kill_family(pfc, cmd_argc, cmd_argv);
}
else if (strcasecmp(cmd_argv[0], "UNREGISTER_FAMILY") == 0) {
return unregister_family(pfc, cmd_argc, cmd_argv);
}
else if (strcasecmp(cmd_argv[0], "SNAPSHOT") == 0) {
return snapshot(pfc, cmd_argc, cmd_argv);
}
else if (strcasecmp(cmd_argv[0], "QUIT") == 0) {
return quit(pfc, cmd_argc, cmd_argv);
}
else {
fprintf(stderr, "error: invalid command: %s\n", cmd_argv[0]);
list_commands();
return 1;
}
}
int
main(int argc, char *argv[]) {
int rc;
uv_loop_t *loop;
struct sockaddr bind_addr;
parse_opts(argc, argv);
if (xsignal) {
return signal_process(xsignal, pidfile);
}
if (!tunnel_mode || !dest_addr || !password) {
print_usage(argv[0]);
return 1;
}
if (init()) {
return 1;
}
if (daemon_mode) {
if (daemonize()) {
return 1;
}
if (already_running(pidfile)) {
logger_stderr("xtunnel already running.");
return 1;
}
}
loop = uv_default_loop();
rc = resolve_addr(source_addr, &bind_addr);
if (rc) {
logger_stderr("invalid local address");
return 1;
}
rc = resolve_addr(dest_addr, &target_addr);
if (rc) {
logger_stderr("invalid target address");
return 1;
}
if (concurrency <= 1) {
struct server_context ctx;
uv_tcp_init(loop, &ctx.tcp);
rc = uv_tcp_bind(&ctx.tcp, &bind_addr, 0);
if (rc) {
logger_stderr("bind error: %s", uv_strerror(rc));
return 1;
}
rc = uv_listen((uv_stream_t*)&ctx.tcp, SOMAXCONN, source_accept_cb);
if (rc == 0) {
logger_log(LOG_INFO, "listening on %s", source_addr);
setup_signal(loop, signal_cb, &ctx);
uv_run(loop, UV_RUN_DEFAULT);
close_loop(loop);
} else {
logger_stderr("listen error: %s", uv_strerror(rc));
}
} else {
struct server_context *servers = calloc(concurrency, sizeof(servers[0]));
for (int i = 0; i < concurrency; i++) {
struct server_context *ctx = servers + i;
ctx->index = i;
ctx->tcp_fd = create_socket(SOCK_STREAM, 1);
ctx->accept_cb = source_accept_cb;
ctx->nameserver_num = -1;
ctx->local_addr = &bind_addr;
rc = uv_sem_init(&ctx->semaphore, 0);
rc = uv_thread_create(&ctx->thread_id, consumer_start, ctx);
}
logger_log(LOG_INFO, "listening on %s", source_addr);
setup_signal(loop, signal_cb, servers);
uv_run(loop, UV_RUN_DEFAULT);
close_loop(loop);
for (int i = 0; i < concurrency; i++) {
uv_sem_wait(&servers[i].semaphore);
}
free(servers);
}
if (daemon_mode) {
delete_pidfile(pidfile);
}
return 0;
}
