void
check_servers(void)
{
/* For each server, check the following, in order:
*
* - Connection status. Skip the rest if unresolved
* - Ping timeout. Skip the rest detected
* - Reconnect attempt. Skip the rest if successful
* - Socket input. Consume all input
* */
/* TODO: there's probably a better order to check these */
server *s;
if ((s = server_head) == NULL)
return;
time_t t = time(NULL);
do {
if (check_connect(s))
continue;
if (check_latency(s, t))
continue;
if (check_reconnect(s, t))
continue;
check_socket(s, t);
} while ((s = s->next) != server_head);
}
// Force remote JVM to start Attach listener.
// HotSpot will start Attach listener in response to SIGQUIT if it sees .attach_pid file
static int start_attach_mechanism(int pid) {
char path[128];
sprintf(path, "/proc/%d/cwd/.attach_pid%d", pid, pid);
int fd = creat(path, 0660);
if (fd == -1) {
sprintf(path, "/tmp/.attach_pid%d", pid);
fd = creat(path, 0660);
if (fd == -1) {
return 0;
}
}
close(fd);
kill(pid, SIGQUIT);
int result;
struct timespec ts = {0, 100000000};
int retry = 0;
do {
nanosleep(&ts, NULL);
result = check_socket(pid);
} while (!result && ++retry < 10);
unlink(path);
return result;
}
int main(int argc, char** argv) {
if (argc < 3) {
printf("Usage: jattach <pid> <cmd> <args> ...\n");
return 1;
}
int pid = atoi(argv[1]);
if (!check_socket(pid) && !start_attach_mechanism(pid)) {
printf("Could not start attach mechanism\n");
return 1;
}
int fd = connect_socket(pid);
if (fd == -1) {
printf("Could not connect to socket\n");
return 1;
}
printf("Connected to remote JVM\n");
write_command(fd, argc - 2, argv + 2);
printf("Response code = ");
read_response(fd);
printf("\n");
close(fd);
return 0;
}
static void wireless_sec_mode(RESULT * result, RESULT * arg1)
{
char *dev = R2S(arg1);
if (check_socket() != 0)
return;
save_result(result, dev, KEY_SEC_MODE, get_sec_mode(dev, KEY_SEC_MODE));
}
static void wireless_sensitivity(RESULT * result, RESULT * arg1)
{
char *dev = R2S(arg1);
if (check_socket() != 0)
return;
save_result(result, dev, KEY_SENS, get_sens(dev, KEY_SENS));
}
static void wireless_essid(RESULT * result, RESULT * arg1)
{
char *dev = R2S(arg1);
if (check_socket() != 0)
return;
save_result(result, dev, KEY_ESSID, get_essid(dev, KEY_ESSID));
}
static void wireless_bitrate(RESULT * result, RESULT * arg1)
{
char *dev = R2S(arg1);
if (check_socket() != 0)
return;
save_result(result, dev, KEY_BIT_RATE, get_bitrate(dev, KEY_BIT_RATE));
}
static void wireless_frequency(RESULT * result, RESULT * arg1)
{
char *dev = R2S(arg1);
if (check_socket() != 0)
return;
save_result(result, dev, KEY_FREQUENCY, get_frequency(dev, KEY_FREQUENCY));
}
static void wireless_protocol(RESULT * result, RESULT * arg1)
{
char *dev = R2S(arg1);
if (check_socket() != 0)
return;
save_result(result, dev, KEY_PROTO, get_ifname(NULL, dev));
}
static void wireless_level(RESULT * result, RESULT * arg1)
{
char *dev = R2S(arg1);
if (check_socket() != 0)
return;
save_result(result, dev, KEY_LEVEL, get_stats(dev, KEY_LEVEL));
}
static void wireless_quality(RESULT * result, RESULT * arg1)
{
char *dev = R2S(arg1);
if (check_socket() != 0)
return;
save_result(result, dev, KEY_QUALITY, get_stats(dev, KEY_QUALITY));
}
static void wireless_noise(RESULT * result, RESULT * arg1)
{
char *dev = R2S(arg1);
if (check_socket() != 0)
return;
save_result(result, dev, KEY_NOISE, get_stats(dev, KEY_NOISE));
}
int TCP_Socket::receive(void * const &data, const Uint16 &num_bytes) {
int retval = check_socket();
if(retval) {
retval = SDLNet_TCP_Recv(sock, data, num_bytes);
if(retval <= 0)
throw Socket_Closed();
}
return retval;
}
int socket_is_ready(Socket_T S) {
ASSERT(S);
switch(S->type) {
case SOCK_STREAM:
return check_socket(S->socket);
case SOCK_DGRAM:
return check_udp_socket(S->socket);
default:
break;
}
return FALSE;
}
int nl6621_gizwits_entry(void)
{
int ret = 0;
UINT8 prioUser = TCPIP_THREAD_PRIO + 1;
/* Print GAgent version */
print_version();
log_info("Entry gizwits initialize(time:%d(s); %d(ms)).\n",
nl6621_GetTime_S(), nl6621_GetTime_MS());
init_system_task();
sys_status.status = SYS_STATUS_WIFI_STOP;
sys_status.onboarding = SYS_STATUS_ONBOARDING_FAILED;
sys_thread_new("SysStatusThread", SysStatusThread, NULL, NST_TEST_APP_TASK_STK_SIZE, prioUser++);
/* Initialize the system timer
**/
GAgent_TimerInit();
nl6621_Timer_Creat(GAGENT_TIMER_S_1,
GAGENT_TIMER_US, nl6621_timer_handle); /* 1S */
#if HEART_BEAT_DEBUG_MACRO
GAgent_Timer_Init();
#endif
/* initialize GAgent resource */
GAgent_Init();
OSTimeDly(100);
/* After module network create finish, setup soft timer to process the RESET task.
* */
GAgent_ResetTask();
/*
* Create network task thread. Include UDP server, UDP Broadcast, TCP server, TCP
* login cloud task thread.
* */
sys_thread_new("UdpServerThread", UdpServerThread, NULL, NST_TEST_APP_TASK_STK_SIZE, prioUser++);
sys_thread_new("DevDiscoverThread", DevDiscoverThread, NULL, NST_TEST_APP_TASK_STK_SIZE, prioUser++);/*ota DevDiscoverThread*/
sys_thread_new("UdpBCTThread", UdpBCTThread, NULL, NST_TEST_APP_TASK_STK_SIZE, prioUser++);
sys_thread_new("TcpServerThread", TcpServerThread, NULL, NST_TEST_APP_TASK_STK_SIZE, prioUser++);
sys_thread_new("TcpCloudThread", TcpCloudThread, NULL, NST_TEST_APP_TASK_STK_SIZE * 4, prioUser++);
/* support NTP protocol */
sys_thread_new("RTCThread", NTPThread, NULL, NST_TEST_APP_TASK_STK_SIZE, prioUser++);
log_info("Try to connect wifi...[%08x]\n", g_stGAgentConfigData.flag);
/*power save enable,soft ps mode, mcu keep running, open/close radio power dynamically*/
// InfListenIntervalSet(255, 1);
#ifdef POWERSAVE_SUPPORT
ret = InfPowerSaveSet(PS_MODE_SOFT);
printf("InfPowerSaveSet : %d\n",ret);
#endif
while (1) {
GAgent_TimerRun();
check_socket();
check_system_reset();
OSTimeDly(10);
}
}
int main(int argc, char **argv)
{
task_waiter_t lock;
pid_t pid1, pid2, pid3, pid0 = getpid();
int status = -1, sk;
test_init(argc, argv);
task_waiter_init(&lock);
sk = create_socket(0);
if (sk < 0)
return 1;
pid1 = fork();
if (pid1 < 0) {
pr_perror("fork");
return -1;
}
if (pid1 == 0) {
close(sk);
unshare(CLONE_NEWNET);
sk = create_socket(1);
if (sk < 0)
return 1;
pid3 = fork();
if (pid3 < 0) {
pr_perror("fork");
return 1;
}
if (pid3 == 0) {
char ns[] = "/proc/0123456789/ns/net";
int fd;
snprintf(ns, sizeof(ns), "/proc/%d/ns/net", pid0);
fd = open(ns, O_RDONLY);
if (fd < 0)
return 1;
if (setns(fd, 0))
return 1;
close(fd);
task_waiter_complete(&lock, 3);
test_waitsig();
if (check_socket(0, true))
return 1;
if (check_socket(2, false))
return 1;
if (check_socket(1, false))
return 1;
return 0;
}
/* This socket will be alive in the 3 process */
close(sk);
task_waiter_complete(&lock, 1);
test_waitsig();
if (check_socket(1, true))
return 1;
kill(pid3, SIGTERM);
waitpid(pid3, &status, 0);
if (status) {
fail();
return 1;
}
return 0;
}
pid2 = fork();
if (pid2 < 0) {
pr_perror("fork");
return -1;
}
if (pid2 == 0) {
unshare(CLONE_NEWNET);
sk = create_socket(2);
if (sk < 0)
return 1;
task_waiter_complete(&lock, 2);
test_waitsig();
if (check_socket(0, false))
return 1;
if (check_socket(1, false))
return 1;
if (check_socket(2, true))
return 1;
return 0;
}
close(sk);
task_waiter_wait4(&lock, 1);
task_waiter_wait4(&lock, 2);
task_waiter_wait4(&lock, 3);
test_daemon();
test_waitsig();
kill(pid1, SIGTERM);
waitpid(pid1, &status, 0);
if (status) {
fail();
return 1;
}
kill(pid2, SIGTERM);
status = -1;
waitpid(pid2, &status, 0);
if (status) {
fail();
return 1;
}
pass();
return 0;
}
void
main_loop()
/* main loop - get the time to sleep until next job execution,
* sleep, and then test all jobs and execute if needed. */
{
time_t save; /* time remaining until next save */
time_t stime; /* time to sleep until next job
* execution */
#ifdef HAVE_GETTIMEOFDAY
struct timeval tv; /* we use usec field to get more precision */
#endif
#ifdef FCRONDYN
int retcode = 0;
#endif
debug("Entering main loop");
now = time(NULL);
synchronize_dir(".", is_system_startup());
/* synchronize save with jobs execution */
save = now + save_time;
if (serial_num > 0 || once)
stime = first_sleep;
else if ((stime = time_to_sleep(save)) < first_sleep)
/* force first execution after first_sleep sec : execution of jobs
* during system boot time is not what we want */
stime = first_sleep;
debug("initial sleep time : %ld", stime);
for (;;) {
#ifdef HAVE_GETTIMEOFDAY
#ifdef FCRONDYN
gettimeofday(&tv, NULL);
tv.tv_sec = (stime > 1) ? stime - 1 : 0;
/* we set tv_usec to slightly more than necessary so as
* we don't wake up too early, in which case we would
* have to sleep again for some time */
tv.tv_usec = 1001000 - tv.tv_usec;
/* On some systems (BSD, etc), tv_usec cannot be greater than 999999 */
if (tv.tv_usec > 999999)
tv.tv_usec = 999999;
/* note: read_set is set in socket.c */
if ((retcode = select(set_max_fd + 1, &read_set, NULL, NULL, &tv)) < 0
&& errno != EINTR)
die_e("select returned %d", errno);
#else
if (stime > 1)
sleep(stime - 1);
gettimeofday(&tv, NULL);
/* we set tv_usec to slightly more than necessary to avoid
* infinite loop */
usleep(1001000 - tv.tv_usec);
#endif /* FCRONDYN */
#else
sleep(stime);
#endif /* HAVE_GETTIMEOFDAY */
now = time(NULL);
check_signal();
debug("\n");
test_jobs();
while (serial_num > 0 && serial_running < serial_max_running)
run_serial_job();
if (once) {
explain("Running with option once : exiting ... ");
xexit(EXIT_OK);
}
if (save <= now) {
save = now + save_time;
/* save all files */
save_file(NULL);
}
#ifdef FCRONDYN
/* check if there's a new connection, a new command to answer, etc ... */
/* we do that *after* other checks, to avoid Denial Of Service attacks */
check_socket(retcode);
#endif
stime = check_lavg(save);
debug("next sleep time : %ld", stime);
check_signal();
}
}
