int sys_stime( int* tptr ) { if ( tptr == NULL ) { return -EINVAL; } set_system_time( ( time_t* )tptr ); return 0; }
// Apply Time Zone // called on recovery start or when changing time zone in menu // on recovery start, it will read and set t_zone.value, t_zone_offset.value and use_dst_time.value values // when called from time zone menu, it will only write and apply t_zone.value // system time is set when calling set_system_time() static void apply_time_zone() { // called on recovery start, read values and apply time // read user config for t_zone.value in UTC hours offset char value[PROPERTY_VALUE_MAX]; t_zone.value = 8; t_zone_offset.value = 0; use_dst_time.value = 0; set_system_time(); }
void RTC1_COUNTER_STOP() { rtc1_counter = NRF_RTC1->COUNTER; set_system_time( get_system_time() + rtc1_counter/8); NRF_RTC1->TASKS_CLEAR = 1; NVIC_DisableIRQ(RTC1_IRQn); NRF_RTC1->EVTENCLR = RTC_EVTEN_COMPARE0_Msk; NRF_RTC1->INTENCLR = RTC_INTENSET_COMPARE0_Msk; NRF_RTC1->TASKS_STOP = 1; }
time_t SNTP_ProcessPacket(uint8_t packet[], uint16_t length) { if(length != sizeof(SNTP_Header_t)) return 0; SNTP_Header_t* SNTP = (SNTP_Header_t *)packet; if ((SNTP->VersionMode & 0x3F) != SNTP_VERSIONMODESERVER || (SNTP->VersionMode & 0xC0) == 0xC0 || (SNTP->TransmitTimestampSec == 0 && SNTP->TransmitTimestampSub == 0)) return 0; TCNT1 = frac2timer(be32_to_cpu(SNTP->TransmitTimestampSub)); time_t newTime = be32_to_cpu(SNTP->TransmitTimestampSec) - NTP_OFFSET; set_system_time(newTime); return newTime; }
int do_srvr_interface(UBUF *ubp, int first) { int htyp, hlen, clen, ilen, eflag, bflag, odr, nego_seq, end; long int tim; time_t time, stime = 0; BYTE buf[MAX_NODE_PSIZE+1], *ip; BYTE *fmw; QUEUE *q; PKBH *pkbh; PKBUC *pkbuc; PKBUI *pkbui; SV_D20("do_srvr_interface(1)...\n"); sigset(SIGINT, sig_int); sigset(SIGPIPE, sig_pipe); if (first) { if (srvr_write_nego_packet(ubp, gtway_start) < 0) { /* GTWAY_START */ ubp_flush(ubp); return(-1); } } for (nego_seq = eflag = bflag = 0; !eflag && nego_seq < 3; nego_seq++) { switch(nego_seq) { case 0: if (srvr_write_nego_packet(ubp, req_to_rcv2) < 0) /* REQ_TO_RCV2 */ eflag++; break; case 1: if (!Srvr_gwtm_frq || (Srvr_conn_cnt % Srvr_gwtm_frq && !first)) continue; // skip time request phase if (srvr_write_nego_packet(ubp, req_to_time) < 0){/* REQ_TO_TIME */ eflag++; break; // proc the response at out of switch } if (srvr_write_nego_packet(ubp, req_to_cntd) < 0) /* REQ_TO_CNTD */ eflag++; break; // proc the response at out of switch case 2: if (Srvr_gwst_frq && (Srvr_conn_cnt % Srvr_gwst_frq) == 0) { if (srvr_write_dta_of_gtwy(ubp) < 0) { eflag++; break; } } for (odr = 1; !eflag && odr <= MAX_UORDER; odr++) { /* upwards */ if (!(q = q_by_order(odr))) continue; while(!eflag && (pkbh = q_delete(q))) { if (!(q->flag & Q_IMAGE)) { pkbuc = (PKBUC *)pkbh; SV_D23("\n---> %.2x,%.2x,%.2x\n", pkbuc->b_type, pkbuc->h_mlen, pkbuc->h_mlen+SRVU_HEADLN_CMD); if ((*srvr_ubp_write)(ubp, pkbuc->b_gwid, pkbuc->h_mlen + SRVU_HEADLN_CMD) > 0) { q->tsend++; q->tfail = 0; SV_D12("gtwy-->srvr : %s[%.2x]\n", get_pdu_name(pkbuc->b_type), pkbuc->b_type); Mfree(pkbuc); } else { if (++(pkbuc->h_nretry) > q->maxrt) { q->taway++; L01("do_srvr_interface(9): send: CMDTA_PACKT(%.2x) away.\n", pkbuc->b_type); SV_D01("do_srvr_interface(9): send: CMDTA_PACKT(%.2x) away.\n", pkbuc->b_type); Mfree(pkbuc); } else { q->tfail++; q_insert_bak((PKBH *)pkbuc, q); L01("do_srvr_interface(9): send: CMDTA_PACKT(%.2x) fail.\n", pkbuc->b_type); SV_D01("do_srvr_interface(9): send: CMDTA_PACKT(%.2x) fail.\n", pkbuc->b_type); } eflag++; } } else { pkbui = (PKBUI *)pkbh; SV_D23("\n---> %.2x,%.8x,%.8x\n", pkbui->b_type, pkbui->h_mlen, pkbui->h_mlen+SRVU_HEADLN_IMG); if ((*srvr_ubp_write)(ubp, pkbui->b_gwid, pkbui->h_mlen + SRVU_HEADLN_IMG) > 0) { q->tsend++; q->tfail = 0; SV_D12("gtwy-->srvr : %s[%.2x]\n", get_pdu_name(pkbui->b_type), pkbui->b_type); Mfree(pkbui); if (srvr_write_nego_packet(ubp, req_to_cntd) < 0) eflag++; } else { L03("do_srvr_interface(B): send: IMAGE_PACKT(%.2x):%.8x,%d: fail.\n", pkbui->b_type, pkbui->h_mlen-NDEU_HEADLN_IMG-2, pkbui->h_mlen-NDEU_HEADLN_IMG-2); SV_D03("do_srvr_interface(B): send: IMAGE_PACKT(%.2x):%.8x,%d: fail.\n", pkbui->b_type, pkbui->h_mlen-NDEU_HEADLN_IMG-2, pkbui->h_mlen-NDEU_HEADLN_IMG-2); if (++(pkbui->h_nretry) > q->maxrt) { q->taway++; L01("do_srvr_interface(B): send: CMDTA_PACKT(%.2x) away.\n", pkbui->b_type); SV_D01("do_srvr_interface(B): send: CMDTA_PACKT(%.2x) away.\n", pkbui->b_type); Mfree(pkbui); } else { q->tfail++; q_insert_bak((PKBH *)pkbui, q); L01("do_srvr_interface(B_2): send: CMDTA_PACKT(%.2x) fail.\n", pkbui->b_type); SV_D01("do_srvr_interface(B_2): send: CMDTA_PACKT(%.2x) fail.\n", pkbui->b_type); } eflag++; } } } // end while } // end for } // end switch for (end = 0; nego_seq < 2 && !end && !eflag; ) { if ((htyp = srvr_packet_head_peek(ubp, &hlen)) < 0) { eflag++; break; /* hlen : ln(1) --> sizeof binary body */ } SV_D12("gtwy<--srvr : %s[%.2x]\n", get_pdu_name(htyp), htyp); if (htyp != DN_NORM_FMW && htyp != DN_GTWY_FMW) { if ((clen = srvr_dncmd_packet_read(ubp, buf, hlen, htyp)) <= 0) { eflag++; break; /* clen = id(1)+length(1)+address(2)+data(n)+escs */ } } else { // length == 4 byte fmw = (BYTE *)Malloc(MAX_FIRMW_SIZE); if ((clen = srvr_dnfmw_packet_read(ubp, fmw, hlen)) <= 0) { Mfree(fmw); /* clen = did(1)+data(n) = 1 + hlen */ eflag++; break; } } switch(htyp) { case DN_NORM_CMD: srvr_enque_dncmd(htyp, hlen, clen, buf); continue; case DN_NORM_FMW: srvr_enque_dnfmw(htyp, hlen, clen, fmw); Mfree(fmw); continue; case DN_GTWY_FMW: if (srvr_enfuse_gtwy(htyp, hlen, clen, fmw) < 0) eflag++; else bflag++; Mfree(fmw); continue; case SET_GW_TIME: SV_D20("time = "); SV_MDH(buf + SRVD_ADROFF_CMD, 4); tim = get_bin_p2_n(buf + SRVD_ADROFF_CMD); /* should be SRVD_DTAOFF_CMD */ SV_D21("fd Set OK...[%d]\n", tim); set_system_time(tim); continue; case REQ_GW_STAT: if (srvr_write_dta_of_gtwy(ubp) < 0) eflag++; end++; break; case END_OF_SND2: end++; break; default : L01("do_srvr_interface(9) : recv: unknown type(%.2x)\n", htyp); SV_D01("do_srvr_interface(9) : recv: unknown type(%.2x)\n", htyp); end++; eflag++; } // end switch } // end for } // end for Srvr_conn_cnt++; SV_D01("Srvr_conn_cnt = %d\n", Srvr_conn_cnt); if (!eflag) { srvr_write_nego_packet(ubp, end_of_snd3); /* END_OF_SND3 */ if (bflag){ if(Cdma_uart_use) { cdma_disc_tcpip(ubp); cdma_disc_circuit(ubp); } else { close(ubp->ufd); if(Cdsk_pppd_use) { wakeup_pppd(PPPD_CTRL_PWROFF); } } sleep(3); SV_D00("do_srvr_interface(A) : Restart Egtwy..\n"); srvr_reboot_gtwy(); /* no rturn */ } } ubp_flush(ubp); if (!eflag) return(1); else return(-1); }
static bool timeout_test (void) { bool status = true; SYNCH_QUEUE mq; MyTask task1; task1.create_reactor (); task1.start (1); TestHandler test_handler (task1.get_reactor (), mq); // The reactor of taks1 that uses a hrtimer will trigger a timeout in // 5 seconds which will enqueue a message block in the queue. At the // same moment we calculate a timeout for the dequeue operation for // 3 seconds in the future. Than we set the system time 4 seconds back. // The condition should timeout because the queue is empty and the trigger // only fires after the condition has timed out. // Next we start another dequeue for 3 seconds in the future which should // return before timing out because by then the trigger should have fired. // In case of using regular system time policy for message queue and // dequeue timeouts the first dequeue would not have timed out because // between calculating the timeout and starting the dequeue the system time // shifted back 4 sec causing the trigger to fire before the timeout elapsed. // In case timeshifting does not work because of priority problems or such // the test should succeed. if (!test_handler.trigger_in (ACE_Time_Value (5, 0))) ACE_ERROR_RETURN ((LM_ERROR, "(%P|%t) Unable to schedule trigger.\n"), false); if (!mq.is_empty ()) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("New queue is not empty!\n"))); status = false; } else { ACE_Message_Block *b = 0; ACE_Time_Value_T<ACE_Monotonic_Time_Policy> tv; tv = (tv.now () + ACE_Time_Value (3,0)); // Now (monotonic time) + 3 sec // shift back in time 4 sec set_system_time (ACE_OS::gettimeofday () - ACE_Time_Value (4, 0)); if (mq.dequeue_head (b, &tv) != -1) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Dequeued before timeout elapsed!\n"))); status = false; } else if (errno != EWOULDBLOCK) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("Dequeue timeout should be EWOULDBLOCK, got"))); status = false; } else { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("First dequeue timed out: OK\n"))); tv = (tv.now () + ACE_Time_Value (3,0)); // Now (monotonic time) + 3 sec if (mq.dequeue_head (b, &tv) != -1) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Second dequeue succeeded: OK\n"))); delete b; } else { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Second dequeue timed out!\n"))); status = false; } } // restore time set_system_time (ACE_OS::gettimeofday () + ACE_Time_Value (4, 0)); } ACE_DEBUG((LM_INFO, "(%P|%t) Asking worker thread to finish.\n")); task1.stop (); ACE_Thread_Manager::instance ()->wait (); return status; }
int run_main (int argc, ACE_TCHAR *argv[]) { ACE_START_TEST (ACE_TEXT ("Monotonic_Manual_Event_Test")); #if defined (ACE_HAS_THREADS) ACE_Manual_Event_T<ACE_Monotonic_Time_Policy> monotonic_event (0); ACE_Manual_Event systime_event (0); ACE_Time_Value_T<ACE_Monotonic_Time_Policy> tm_mono; ACE_Time_Value tm_sys; parse_args (argc, argv); //FUZZ: disable check_for_lack_ACE_OS ACE_Time_Value wait (7, 0); // Wait 7 sec //FUZZ: enable check_for_lack_ACE_OS if (use_monotonic) { evt = &monotonic_event; tm_mono = tm_mono.now () + wait; initial_timeout = &tm_mono; } else { evt = &systime_event; tm_sys = ACE_OS::gettimeofday () + wait; initial_timeout = &tm_sys; } // shift forward in time 3 sec; this will mess up timeouts if // monotonic timer is not used ACE_Time_Value tv_shift (3, 0); set_system_time (ACE_OS::gettimeofday () + tv_shift); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("spawning workers - initial timeout till %#T\n"), initial_timeout)); if (ACE_Thread_Manager::instance ()->spawn_n (static_cast<size_t> (n_workers), ACE_THR_FUNC (worker), 0, THR_NEW_LWP) == -1) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("spawn_n")), 1); // gives all workers chance to start ACE_OS::sleep (5); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("finished waiting for workers to start\n"))); // restore time (workers will already have failed without monotonic timer) set_system_time (ACE_OS::gettimeofday () - tv_shift); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("sending pulse ()\n"))); // Release the all workers. if (evt->pulse () == -1) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("pulse")), 1); // Wait 2 sec ACE_OS::sleep (2); //FUZZ: disable check_for_lack_ACE_OS ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("sending signal ()\n"))); //FUZZ: enable check_for_lack_ACE_OS // Signal if (evt->signal () == -1) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("signal")), 1); ACE_Thread_Manager::instance ()->wait (); #else ACE_UNUSED_ARG (argc); ACE_UNUSED_ARG (argv); ACE_ERROR ((LM_INFO, ACE_TEXT ("Threads not supported on this platform\n"))); #endif /* ACE_HAS_THREADS */ ACE_END_TEST; return test_result; }
int run_main (int , ACE_TCHAR *[]) { ACE_START_TEST (ACE_TEXT ("Monotonic_Task_Test")); int status = 0; # if defined (ACE_HAS_THREADS) MyTask my_task; if (my_task.start () == 0) { // shift back in time 4 sec; this would mess up timeouts if // monotonic timer was not used ACE_Time_Value tv_shift (4, 0); set_system_time (ACE_OS::gettimeofday () - tv_shift); if (my_task.put_message () == 0) { // task should now have finished dequeueing and started waiting for stop signal // wait (2sec) on thread manager should timeout // use the time policy aware gettimeofday() // method of the task to get current time ACE_Time_Value_T<ACE_Monotonic_Time_Policy> tv (my_task.gettimeofday ()); tv += ACE_Time_Value (2, 0); // shift another 3 sec back in time; without monotonic timer support in // thread manager this would mess up the timed wait tv_shift += ACE_Time_Value (3, 0); set_system_time (ACE_OS::gettimeofday () - ACE_Time_Value (3,0)); if (my_task.thr_mgr ()->wait (&tv) == 0) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Thread manager did not time out\n"))); status = 1; } else { ACE_Time_Value_T<ACE_Monotonic_Time_Policy> tv_now (my_task.gettimeofday ()); ACE_DEBUG ((LM_INFO, ACE_TEXT ("Thread manager timed out at %#T\n"), &tv_now)); } } else status = 1; // ok, now stop task if (my_task.stop () != 0) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Failed to stop task\n"))); status = 1; } // restore time set_system_time (ACE_OS::gettimeofday () + tv_shift); } else status = 1; # endif /* ACE_HAS_THREADS */ ACE_END_TEST; return status; }