#include <sys/sysinfo.h>
#include <stdio.h>
#include <stdlib.h>

int main(int s_argc, char **s_argv)
{
    struct sysinfo s_sysinfo_local;

    (void)s_argc;
    (void)s_argv;

    if(sysinfo((struct sysinfo *)(&s_sysinfo_local)) == 0) {
        (void)fprintf(stdout, "uptime is %ld sec\n",
(long)s_sysinfo_local.uptime);
    }

    return(EXIT_SUCCESS);
}

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main(int s_argc, char **s_argv)
{
    time_t s_time_local;

    if(time((time_t *)(&s_time_local)) != ((time_t)(-1))) {
        struct tm s_tm_local;

        (void)memcpy((void *)(&s_tm_local), localtime((time_t
*)(&s_time_local)), sizeof(struct tm));
        (void)fprintf(stdout, "지역시간: %d/%d/%d %02d:%02d:%02d\n",
s_tm_local.tm_year + 19000, s_tm_local.tm_mon + 1, s_tm_local.tm_mday,
s_tm_local.tm_hour, s_tm_local.tm_min, s_tm_local.tm_sec);

        (void)memcpy((void *)(&s_tm_local), gmtime((time_t
*)(&s_time_local)), sizeof(struct tm));
        (void)fprintf(stdout, "그리니치 표준시: %d/%d/%d %02d:%02d:%
02d\n", s_tm_local.tm_year + 19000, s_tm_local.tm_mon + 1,
s_tm_local.tm_mday, s_tm_local.tm_hour, s_tm_local.tm_min,
s_tm_local.tm_sec);

    }

    return(EXIT_SUCCESS);
}

#include <time.h>

...

struct tm s_set_tm_local;
time_t s_set_time_local;

(void)memset((void *)(&s_set_tm_local), 0, sizeof(s_set_tm_local));
s_set_tm_local.tm_year = <년도> - 1900;
s_set_tm_local.tm_mon = <월> - 1;
s_set_tm_local.tm_mday = <일>;
s_set_tm_local.tm_hour = <시>;
s_set_tm_local.tm_min = <분>;
s_set_tm_local.tm_sec = <초>;
s_set_tm_local.tm_isdst = <일광절약시간 적용유무>;
#if defined(_BSD_SOURCE)
s_set_tm_local.tm_gmtoff = <UTC로부터 지역시간대의 시간>; /* -timezone */
s_set_tm_local.tm_zone = <지역시간대 이름>; /* tzname[ s_set_tm_local.tm_isdst ] */
#endif
s_set_time_local = mktime((struct tm *)(&s_set_tm_local)); /* struct tm구조체형식을 time_t 형식으로 변환해주며 tm구조체를 일부 보정하는 기능이 포함되어 있습니다. */

if(stime((time_t *)(&s_set_time_local)) == 0) {
    /* 설정완료 */
}

...

int s_tz_index;
struct tm s_tm_local;
time_t s_time[2]; /* [0]=standard time, [1]=daylight time */
long s_delta_zone;
long s_timezone;
long s_altzone;
#if defined(_WIN32) /* windows의 경우 */
char s_tzname_local[2][ TZNAME_MAX ];
size_t s_tzname_size;
#endif
const char *s_tzname[2];

#if defined(_WIN32) /* windows의 경우 */
_tzset();
#else
tzset();
#endif

for(s_tz_index = 0;s_tz_index < 2;s_tz_index++) {
#if defined(_WIN32) /* windows의 경우 */
    (void)_get_tzname(
        (size_t *)(&s_tzname_size),
        (char *)memeset((void *)(&s_tzname_local[s_tz_index]), 0, sizeof(s_tzname_local[s_tz_index])),
        sizeof(s_tzname_local[s_tz_index]),
        s_tz_index
    );
    s_tzname[s_tz_index] = (const char *)(&s_tzname_local[s_tz_index]);
#else
    s_tzname[s_tz_index] = tzname[s_tz_index];
#endif    

    (void)memset((void *)(&s_tm_local), 0, sizeof(s_tm_local));

    s_tm_local.tm_year = 2012 - 1900;
    s_tm_local.tm_mon = 8 - 1;
    s_tm_local.tm_mday = 4;
    s_tm_local.tm_hour = 1;
    s_tm_local.tm_min = 30;
    s_tm_local.tm_sec = 0;
    s_tm_local.tm_isdst = s_tz_index;

    s_time[s_tz_index] = mktime((struct tm *)(&s_tm_local));
}

/* 일광절약시간에 의한 시간차 (일광절약시간이 사용된다면 통상적으로 3600초가 나옵니다.) */
s_delta_zone = (long)(((long)s_time[0]) - ((long)s_time[1]));

/* 지역시간대로부터 UTC와의 시간차 (대한민국의 경우 -32400 초 [ -9시간 ]) */
#if defined(_WIN32) /* windows의 경우 */
_get_timezone(&s_timezone);
#else
s_timezone = timemzone;
#endif

/* 일광절약시간을 함께 포함한 지역시간대로부터 UTC와의 시간차  */
s_altzone = s_timezone - s_delta_zone;

/* 지역시간대 및 일광절약 표기 */
(void)printf("%s%ld%s%ld\n", s_tzname[0], s_timezone, s_tzname[1], s_altzone);

/* UTC로부터의 시간차 표기 */
(void)printf("PST%ldPDT%ld    (UTC%ld)\n", -s_timezone, -s_altzone, -s_timezone);

unsigned long long int mz_get_cpu_clock(void)
{
    unsigned long long int s_qword;

    __asm__ volatile(
        "rdtsc\n\t" : "=A"(s_qword)
    );

    return(s_qword);
}

/*
  Copyright (C) JAEHYUK CHO
  All rights reserved.
  Code by JaeHyuk Cho <mailto:minzkn@minzkn.com>
*/

#include <sys/types.h>
#include <sys/time.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <time.h>
#include <unistd.h>
#include <errno.h>

#include <pthread.h>

#define def_mztimer_realtime_signal SIGRTMIN
    
static long g_mztimer_interval_usec;

static void mztimer_handler(int s_signal, siginfo_t *s_siginfo, void *s_user_context)
{
    static unsigned int s_tick = 0;
    timer_t *s_timer_id_ptr;
    int s_overrun_count;

    (void)s_signal;
    (void)s_siginfo;
    (void)s_user_context;

    s_timer_id_ptr = (timer_t *)s_siginfo->si_value.sival_ptr;
    s_overrun_count = timer_getoverrun(*s_timer_id_ptr);
    if(s_overrun_count == (-1)) {
        s_overrun_count = 0;
    }

    (void)fprintf(stdout, "tick=%u, overrun_count=%d", s_tick, s_overrun_count);

#if 1L /* DEBUG: compare with system time */
    do {
        static unsigned long long s_start_time_usec = 0ull;
        unsigned long long s_current_time_usec;
        struct timeval s_timeval;
        unsigned long long s_duration_usec, s_diff_usec;

        s_duration_usec = s_tick * g_mztimer_interval_usec;

        (void)gettimeofday(&s_timeval, NULL);
        s_current_time_usec = (s_timeval.tv_sec * 1000000) + s_timeval.tv_usec;
        if(s_start_time_usec == 0ull) {
            s_start_time_usec = s_current_time_usec;
        }
        s_current_time_usec -= s_start_time_usec;

	if(s_duration_usec > s_current_time_usec) {
	    s_diff_usec = s_duration_usec - s_current_time_usec;
	}
	else {
	    s_diff_usec = s_current_time_usec - s_duration_usec;
	}

        fprintf(stdout, ", real=%llu.%03llu, diff=%llu.%llu",
            s_current_time_usec / 1000ull,
            s_current_time_usec % 1000ull,
            s_diff_usec / 1000ull,
            s_diff_usec % 1000ull);
    }while(0);
#endif

    (void)fprintf(stdout, "\n");

    s_tick += 1 + s_overrun_count;
}
  
static void *mztimer_thread(void *s_argument)
{
    static timer_t s_timer_id;
    struct sigevent s_sigevent;
    struct itimerspec s_itimerspec;
    sigset_t s_mask;
    struct sigaction s_sigaction;
    clockid_t s_clock_id = CLOCK_REALTIME;

    /* establish handler for timer signal */
    s_sigaction.sa_flags = SA_SIGINFO;
    s_sigaction.sa_sigaction = mztimer_handler;
    sigemptyset(&s_sigaction.sa_mask);
    if(sigaction(def_mztimer_realtime_signal, &s_sigaction, NULL) == (-1)) {
        return(NULL);
    }

    /* block timer signal temporarily */
    sigemptyset(&s_mask);
    sigaddset(&s_mask, def_mztimer_realtime_signal);
    if(sigprocmask(SIG_SETMASK, &s_mask, NULL) == (-1)) {
        return(NULL);
    }

    /* create timer */
    s_sigevent.sigev_notify = SIGEV_SIGNAL;
    s_sigevent.sigev_signo = def_mztimer_realtime_signal;
    s_sigevent.sigev_value.sival_ptr = &s_timer_id;
    if(timer_create(s_clock_id, &s_sigevent, &s_timer_id) == (-1)) {
        return(NULL);
    }

    /* start the timer */
    s_itimerspec.it_value.tv_sec = g_mztimer_interval_usec / 1000000l;
    s_itimerspec.it_value.tv_nsec = (g_mztimer_interval_usec % 1000000l) * 1000l;
    s_itimerspec.it_interval.tv_sec = s_itimerspec.it_value.tv_sec;
    s_itimerspec.it_interval.tv_nsec = s_itimerspec.it_value.tv_nsec;
    if(timer_settime(s_timer_id, 0, &s_itimerspec, NULL) == (-1)) {
        return(NULL);
    }
   
    /* unlock the timer signal */
    if(sigprocmask(SIG_UNBLOCK, &s_mask, NULL) == (-1)) {
        return(NULL);
    }

    for(;;) {
        pause();
    }

    return(NULL);
}

int mztimer_start(long s_interval_usec)
{
    pthread_t s_thread_handle;
    sigset_t s_mask;

    g_mztimer_interval_usec = s_interval_usec;

    if(pthread_create(&s_thread_handle, NULL, mztimer_thread, NULL) == (-1)) {
        return(-1);
    }
    (void)pthread_detach(s_thread_handle);
    
    sigemptyset(&s_mask);
    sigaddset(&s_mask, def_mztimer_realtime_signal);
    (void)sigprocmask(SIG_BLOCK, &s_mask, NULL);

    return(0);
}

int main(void)
{
    (void)mztimer_start(1000l);

    for(;;) {
        
        sleep(1);
	
	(void)fprintf(stdout, "\x1b[1;33msleep loop\x1b[0m\n");
    }
    

    return(EXIT_SUCCESS);
}

/* End of source *