time_utils.c

Go to the documentation of this file.

/*
 * This file is part of liberutils.
 *
 * liberutils is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * liberutils is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

/**
 * Copyright (C) 2009 iRex Technologies B.V.
 * All rights reserved.
 */

#include <string.h>
#include <stdlib.h>
#include <sys/time.h>
#include <assert.h>
#include <unistd.h>
#include <time.h>
#include <glib.h>
//#include <gtk/gtk.h>

#include <curl/curl.h>
#include <curl/types.h>
#include <curl/easy.h>

#include "log.h"
#include "time_utils.h"

#define MINUTES(x) 60*x
#define HOURS(x)   60*60*x

#define DATE_STRING_LENGTH        64

#define TZ_FILES_DIR      "/usr/share/zoneinfo/Etc/"

#define DEFAULT_TIMEZONE_OFFSET   0
#define DEFAULT_TIMEZONE_NAME     "GMT+00:00"
#define DST_FLAG                  "DST"


// Header of timezone files, you can find them in /usr/share/zoneinfo
struct tzhead
{
    char tzh_magic[4];       /* TZ_MAGIC */
    char tzh_reserved[16];   /* reserved for future use */
    char tzh_ttisgmtcnt[4];  /* coded number of trans. time flags */
    char tzh_ttisstdcnt[4];  /* coded number of trans. time flags */
    char tzh_leapcnt[4];     /* coded number of leap seconds */
    char tzh_timecnt[4];     /* coded number of transition times */
    char tzh_typecnt[4];     /* coded number of local time types */
    char tzh_charcnt[4];     /* coded number of abbr. chars */
};


typedef struct {
    char *memory;
    size_t size;
} MemoryStruct;


static void *myrealloc(void *ptr, size_t size)
{
    if (ptr) return realloc(ptr, size);
    else return malloc(size);
}


static size_t writer(void *ptr, size_t size, size_t nmemb, void *data)
{
    size_t realsize = size * nmemb;
    MemoryStruct *mem = (MemoryStruct *)data;

    mem->memory = (char*)myrealloc(mem->memory, mem->size + realsize + 1);
    if (mem->memory) 
    {
        memcpy(&(mem->memory[mem->size]), ptr, realsize);
        mem->size += realsize;
        mem->memory[mem->size] = 0;
    }
    return realsize;
}


time_t get_server_time()
{
    LOGPRINTF("entry");

    MemoryStruct chunk;
    chunk.memory = NULL;
    chunk.size = 0;

    curl_global_init(CURL_GLOBAL_ALL);
    CURL *curl_handle = curl_easy_init();

    curl_easy_setopt(curl_handle, CURLOPT_URL, "http://time.irexnet.com/epoch");
    curl_easy_setopt(curl_handle, CURLOPT_WRITEFUNCTION, writer);
    curl_easy_setopt(curl_handle, CURLOPT_WRITEDATA, (void *)&chunk);
    curl_easy_setopt(curl_handle, CURLOPT_USERAGENT, "libcurl-agent/1.0");

    curl_easy_setopt(curl_handle, CURLOPT_LOW_SPEED_LIMIT, 1);
    curl_easy_setopt(curl_handle, CURLOPT_LOW_SPEED_TIME, 30);
    curl_easy_setopt(curl_handle, CURLOPT_CONNECTTIMEOUT, 30);

    curl_easy_perform(curl_handle);
    curl_easy_cleanup(curl_handle);

    time_t now = 0;
    if (chunk.memory != NULL) now = atoi(chunk.memory);

    if (chunk.memory) free(chunk.memory);
    curl_global_cleanup();

    return now;
}


// returns newly allocated string with current timezone, must be freed by caller
gchar *get_timezone()
{
    LOGPRINTF("entry");

    char actual_tzfile[256];
    memset(actual_tzfile, 0, sizeof(actual_tzfile));
    
    // get timezone reference
    if (readlink(TZ_FILE, actual_tzfile, sizeof(actual_tzfile)) == -1)
    {
        ERRORPRINTF("Can't dereference symlink %s, errno [%d][%s]", TZ_FILE, errno, strerror(errno));
        return NULL;
    }
    
    // check if it exists
    if (!g_file_test(actual_tzfile, G_FILE_TEST_IS_REGULAR))
    {
        ERRORPRINTF("Can't find symlink target %s", actual_tzfile);
        return NULL;
    }
    
    return g_path_get_basename(actual_tzfile);
}


gboolean set_timezone(const char* tzname, gboolean is_dst)
{
    LOGPRINTF("entry");

    char actual_tzfile[256];

    snprintf(actual_tzfile, 256, "%s%s%s", TZ_FILES_DIR, tzname, is_dst ? DST_FLAG : "");
    LOGPRINTF("symlink %s to %s", actual_tzfile, TZ_FILE);
    if (g_file_test(TZ_FILE, G_FILE_TEST_EXISTS) && (unlink(TZ_FILE) != 0))
    {
        ERRORPRINTF("Can't remove %s", TZ_FILE);
        return FALSE;
    }

    if (symlink(actual_tzfile, TZ_FILE) != 0)
    {
        ERRORPRINTF("Can't create symlink from %s to %s", actual_tzfile, TZ_FILE);
        return FALSE;
    }

    return TRUE;    
}


// returns index in the timezone table of given tzname and determines DST (optional)
gint get_timezone_index(const char* tzname, gboolean *dst)
{
    LOGPRINTF("entry");

    gboolean is_dst;
    gint tzindex = -1;
    
    if (tzname == NULL)
    {
        tzname = DEFAULT_TIMEZONE_NAME;
        WARNPRINTF("No timezone given, use default [%s]", tzname);
    }
    
    int tzlength = strlen(tzname);
    is_dst = g_str_has_suffix(tzname, DST_FLAG);
    if (is_dst)
    {
        // ignore DST suffix
        tzlength -= strlen(DST_FLAG);
    }
    
    int i;
    for (i=0; i<TOTAL_TIMEZONES; i++) 
    {
        if (strncmp(tzname, timezones[i].tzname, tzlength) == 0)
        {
            tzindex = i;
            break;
        }
    }

    if (tzindex == -1)
    {
        WARNPRINTF("Can't find zoneinfo for [%s]", tzname);
        tzindex = 12; // default to GMT
        is_dst = FALSE;
    }
    
    if (dst)
    {
        *dst = is_dst;
    }
    
    return tzindex;
}


void set_time_utc(time_t utc_time)
{
    LOGPRINTF("entry");
    
    struct timeval tp;
    gettimeofday(&tp, NULL);
    tp.tv_sec = utc_time;
    settimeofday(&tp, NULL);

    system("/sbin/hwclock -w -u");
}


gboolean set_time_from_server(void) 
{
    LOGPRINTF("entry");
    
    time_t utc_time = get_server_time();
    if (utc_time == 0) {
        ERRORPRINTF("Failed to get server time");
        return FALSE;
    }
    
    set_time_utc(utc_time);
    return TRUE;
}