/**

  * GMyth Library

  *

  * @file gmyth/gmyth_util.c

  * 

  * @brief <p> This component provides utility functions 

  * 	(dealing with dates, time, string formatting, etc.).

  * 

  * Copyright (C) 2006 INdT - Instituto Nokia de Tecnologia.

  * @author Hallyson Luiz de Morais Melo <hallyson.melo@indt.org.br>

  * @author Rosfran Borges <rosfran.borges@indt.org.br>

  *

  * 

  * This program is free software; you can redistribute it and/or modify

  * it under the terms of the GNU Lesser General Public License as published by

  * the Free Software Foundation; either version 2 of the License, or

  * (at your option) any later version.

  *

  * This program 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 Lesser General Public License

  * along with this program; if not, write to the Free Software

  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

  */

 #ifdef HAVE_CONFIG_H

 #include "config.h"

 #endif

 #define _XOPEN_SOURCE

 #define _XOPEN_SOURCE_EXTENDED

 #define __USE_MISC

 #include <glib.h>

 #include <glib/gprintf.h>

 #include <time.h>

 #include <sys/time.h>

 #include <sys/timex.h>

 #include "gmyth_socket.h"

 #include "gmyth_recorder.h"

 #include "gmyth_common.h"

 #include "gmyth_debug.h"

 #include "gmyth_util.h"

 #if !GLIB_CHECK_VERSION (2, 10, 0)

 gchar          *g_time_val_to_iso8601(GTimeVal * time_);

 gboolean        g_time_val_from_iso8601(const gchar * iso_date,

                                         GTimeVal * time_);

 void            g_date_set_time_val(GDate * date, GTimeVal * timeval);

 #endif

 /** Converts a time_t struct in a GString at ISO standard format 

  * (e.g. 2006-07-20T09:56:41).

  * 

  * The returned GString memory should be deallocated from 

  * the calling function.

  *

  * @param time_value the time value to be converted

  * @return GString* the converted isoformat string 

  */

 GString        *

 gmyth_util_time_to_isoformat(time_t time_value)

 {

     struct tm       tm_time;

     GString        *result;

     if (localtime_r(&time_value, &tm_time) == NULL) {

         gmyth_debug("gmyth_util_time_to_isoformat convertion error!\n");

         return NULL;

     }

     result = g_string_sized_new(20);

     g_string_printf(result, "%04d-%02d-%02dT%02d:%02d:%02d",

                     tm_time.tm_year + 1900, tm_time.tm_mon + 1,

                     tm_time.tm_mday, tm_time.tm_hour, tm_time.tm_min,

                     tm_time.tm_sec);

     gmyth_debug("Result (ISO 8601) = %s", result->str);

     return result;

 }

 /** Converts a time_t struct in a GString at ISO standard format 

  * (e.g. 2006-07-20T09:56:41).

  * 

  * The returned GString memory should be deallocated from 

  * the calling function.

  *

  * @param time_value the GTimeValue to be converted

  * @return GString* the converted isoformat string 

  */

 gchar*

 gmyth_util_time_to_isoformat_from_time_val_fmt(const gchar * fmt_string,

                                                const GTimeVal * time_val)

 {

     gchar          *result = NULL;

     struct tm      *tm_time = NULL;

     time_t          time;

     gint            buffer_len = 0;

     g_return_val_if_fail(fmt_string != NULL, NULL);

     g_return_val_if_fail(time_val != NULL, NULL);

     time = time_val->tv_sec;    // + (gint)( time_val->tv_usec /

     // G_USEC_PER_SEC );

     tm_time = g_malloc0(sizeof(struct tm));

     if (NULL == localtime_r(&time, tm_time)) {

         gmyth_debug("gmyth_util_time_to_isoformat convertion error!\n");

     } else {

         /*

          * we first check the return of strftime to allocate a buffer of

          * the correct size 

          */

         buffer_len = strftime(NULL, SSIZE_MAX, fmt_string, tm_time);

         if (buffer_len > 0) {

             result = g_malloc0(buffer_len + 1);

             if (result == NULL) {

                 gmyth_debug

                     ("gmyth_util_time_to_isoformat convertion error!\n");

                 return NULL;

             }

             strftime(result, buffer_len + 1, fmt_string, tm_time);

             gmyth_debug("Dateline (ISO result): %s", result);

         }

     }                           /* if */

     gmyth_debug("Result (strftime) = %s", result);

     // strptime( result, "%Y-%m-%dT%H:%M:%SZ", tm_time ); 

     // strftime( result, strlen(result), fmt_string, tm_time );

     g_free(tm_time);

     gmyth_debug("Result (ISO 8601) = %s", result);

     return result;

 }

 /** Converts a time_t struct in a GString at ISO standard format 

  * (e.g. 2006-07-20 09:56:41).

  * 

  * The returned GString memory should be deallocated from 

  * the calling function.

  *

  * @param time_value the GTimeValue to be converted

  * @return GString* the converted isoformat string 

  */

 gchar          *

 gmyth_util_time_to_isoformat_from_time_val(const GTimeVal * time)

 {

     gchar          *result =

         gmyth_util_time_to_isoformat_from_time_val_fmt("%Y-%m-%d %H:%M:%S",

                                                        time);

     // result[10] = ' ';

     // result[ strlen(result) - 1] = '\0';

     return result;

 }

 /** Converts a time_t struct in a GString at ISO standard format 2 

  * (e.g. 2006-07-20T09:56:41).

  * 

  * The returned GString memory should be deallocated from 

  * the calling function.

  *

  * @param time_value the GTimeValue to be converted

  * @return GString* the converted isoformat string 

  */

 gchar          *

 gmyth_util_time_to_mythformat_from_time_val(const GTimeVal * time)

 {

     gchar          *result =

         gmyth_util_time_to_isoformat_from_time_val_fmt("%Y-%m-%dT%H:%M:%S",

                                                        time);

     return result;

 }

 /** Converts a time_t struct in a GString at ISO standard format 

  * (e.g. 2006-07-20T09:56:41).

  * 

  * The returned GString memory should be deallocated from 

  * the calling function.

  *

  * @param time_value the GTimeValue to be converted

  * @return GString* the converted isoformat string 

  */

 gchar          *

 gmyth_util_time_to_string_only_date(const GTimeVal * time)

 {

     gchar          *result =

         gmyth_util_time_to_isoformat_from_time_val_fmt("%Y-%m-%d", time);

     // result[10] = ' ';

     // result[ strlen(result) - 1] = '\0';

     return result;

 }

 /** Converts a time_t struct in a GString at ISO standard format 

  * (e.g. 2006-07-20T09:56:41).

  * 

  * The returned GString memory should be deallocated from 

  * the calling function.

  *

  * @param time_value the GTimeValue to be converted

  * @return GString* the converted isoformat string 

  */

 gchar          *

 gmyth_util_time_to_string_only_time(const GTimeVal * time)

 {

     gchar          *result =

         gmyth_util_time_to_isoformat_from_time_val_fmt("%H:%M:%S", time);

     // result[10] = ' ';

     // result[ strlen(result) - 1] = '\0';

     return result;

 }

 /** Converts a time_t struct in a GString to the following 

  * format (e.g. 2006-07-20 09:56:41).

  * 

  * The returned GString memory should be deallocated from 

  * the calling function.

  *

  * @param time_value the time value to be converted

  * @return GString* the converted string 

  */

 GString        *

 gmyth_util_time_to_string(time_t time_value)

 {

     GString        *result = gmyth_util_time_to_isoformat(time_value);

     result->str[10] = ' ';

     result->str[strlen(result->str) - 1] = '\0';

     return result;

 }

 /** Converts a time_t struct in a GString to the following 

  * format (e.g. 2006-07-20 09:56:41).

  * 

  * The returned GString memory should be deallocated from 

  * the calling function.

  *

  * @param time_value the time value to be converted

  * @return GString* the converted string 

  */

 gchar*

 gmyth_util_time_to_string_from_time_val(const GTimeVal * time_val)

 {

     gchar *result =

         gmyth_util_time_to_isoformat_from_time_val_fmt("%Y-%m-%d %H:%M:%S",

                                                        time_val);

     // result[10] = ' ';

     return result;

 }

 /** Converts a GString in the following format 

  * (e.g. 2006-07-20 09:56:41) to a time_t struct.

  * 

  * @param time_str the string to be converted

  * @return time_t the time converted value

  */

 time_t

 gmyth_util_string_to_time(GString * time_str)

 {

     gint            year,

                     month,

                     day,

                     hour,

                     min,

                     sec;

     gmyth_debug("[%s] time_str = %s. [%s]", __FUNCTION__,

                 time_str !=

                 NULL ? time_str->str : "[time string is NULL!]",

                 time_str->str);

     if (sscanf(time_str->str, "%04d-%02d-%02d %02d:%02d:%02d",

                &year, &month, &day, &hour, &min, &sec) < 3) {

         gmyth_debug("GMythUtil: isoformat_to_time converter error!\n");

         return 0;

     }

     struct tm      *tm_time = g_malloc0(sizeof(struct tm));

     tm_time->tm_year = year - 1900;

     tm_time->tm_mon = month - 1;

     tm_time->tm_mday = day;

     tm_time->tm_hour = hour;

     tm_time->tm_min = min;

     tm_time->tm_sec = sec;

     return mktime(tm_time);

 }

 /** Converts a GString in the following format 

  * (e.g. 2006-07-20 09:56:41) to a time_t struct.

  * 

  * @param time_str the string to be converted

  * @return time_t the time converted value

  */

 struct tm      *

 gmyth_util_time_val_to_date(const GTimeVal * time)

 {

     struct tm      *date = g_malloc0(sizeof(struct tm));

     time_t          time_micros = time->tv_sec; // + (gint)( time->tv_usec 

                                                 // 

     // 

     // / G_USEC_PER_SEC );

     if (NULL == date) {

         gmyth_debug

             ("GMythUtil: GDate *gmyth_util_time_val_to_date (GTimeVal* time) - converter error!\n");

         return NULL;

     }

     if (NULL == localtime_r(&time_micros, date)) {

         gmyth_debug("gmyth_util_time_to_isoformat convertion error!\n");

         return NULL;

     }

     gmyth_debug("Converted from GTimeVal == %s to GDate", asctime(date));

     return date;

 }

 /** Converts a GString in the following format 

  * (e.g. 2006-07-20 09:56:41) to a time_t struct.

  * 

  * @param time_str the string to be converted

  * @return time_t the time converted value

  */

 GTimeVal       *

 gmyth_util_string_to_time_val_fmt(const gchar * fmt_string,

                                   const gchar * time_str)

 {

     GTimeVal       *time = g_new0(GTimeVal, 1);

     struct tm      *tm_time = NULL;

     time_t          time_micros;

     gchar          *result;

     gmyth_debug("[%s] time_str = %s. [%s]", time_str, time_str != NULL ?

                 time_str : "[time string is NULL!]", time_str);

     if (NULL == time_str) {

         gmyth_debug("GMythUtil: isoformat_to_time converter error!\n");

         return NULL;

     }

     tm_time = g_malloc0(sizeof(struct tm));

     /*

      * we first check the return of strftime to allocate a buffer of the

      * correct size 

      */

     result = strptime(time_str, "%Y-%m-%dT%H:%M:%S", tm_time);

     if (NULL == result) {

         /*

          * we first check the return of strftime to allocate a buffer of

          * the correct size 

          */

         result = strptime(time_str, "%Y-%m-%dT%H:%M:%SZ", tm_time);

         if (NULL == result) {

             /*

              * we first check the return of strftime to allocate a buffer

              * of the correct size 

              */

             result = strptime(time_str, "%Y-%m-%d %H:%M:%S", tm_time);

             if (NULL == result) {

                 result = strptime(time_str, "%Y-%m-%dT%H:%M", tm_time);

                 if (NULL == result) {

                     gmyth_debug("Dateline (ISO result): %s", result);

                     g_free(tm_time);

                     return NULL;

                     // goto done; 

                 }

             }

         }

     }

     time_micros = mktime(tm_time);

     time->tv_sec = time_micros; // + (gint)( time_val->tv_usec /

     // G_USEC_PER_SEC );

     gmyth_debug("After mktime call... = %s", asctime(tm_time));

     g_free(tm_time);

     return time;

 }

 /** Converts a GString in the following format 

  * (e.g. 2006-07-20 09:56:41) to a time_t struct.

  * 

  * @param time_str the string to be converted

  * @return time_t the time converted value

  */

 GTimeVal       *

 gmyth_util_string_to_time_val(const gchar * time_str)

 {

     GTimeVal       *time =

         gmyth_util_string_to_time_val_fmt("%Y-%m-%d %H:%M:%S", time_str);

     return time;

 }

 /** 

  * Checks if the given remote file exists.

  * 

  * @param backend_info The GMythBackendInfo instance.

  * @param filename The file name of the remote file.

  * 

  * @return <code>true</code>, if the remote file exists.

  */

 gboolean

 gmyth_util_file_exists(GMythBackendInfo * backend_info,

                        const gchar * filename)

 {

     GMythSocket    *socket;

     gboolean        res = FALSE;

     gmyth_debug("Check if file %s exists", filename);

     g_return_val_if_fail(backend_info != NULL, FALSE);

     g_return_val_if_fail(filename != NULL, FALSE);

     socket = gmyth_backend_info_get_connected_socket (backend_info);

     if (socket != NULL) {

         res = gmyth_util_file_exists_from_socket (socket, filename);

         g_object_unref(socket);

     }

     return res;

 }

 gboolean

 gmyth_util_file_exists_from_socket (GMythSocket *sock, 

                                     const gchar *filename)

 {

     gboolean res = FALSE;

     GString *path;

     GMythProgramInfo *program;

     program = gmyth_program_info_new();

     program->pathname = g_string_new(filename);

     path = gmyth_util_check_file_from_socket (sock, program);

     if (path) {

         res = TRUE;

         g_string_free(path, TRUE);

     }

     g_object_unref(program);

     return res;

 }

 GString *

 gmyth_util_check_file_from_socket (GMythSocket *sock,

                                    GMythProgramInfo *program)

 {

     GString *res;

     gint length;

     GMythStringList *slist;

     slist = gmyth_string_list_new();

     gmyth_string_list_append_char_array(slist, "QUERY_CHECKFILE");

     if (gmyth_socket_get_protocol_version(sock) >= 32)

 	gmyth_string_list_append_int(slist, 1);

     gmyth_program_info_to_string_list(program, slist);

     length = gmyth_socket_sendreceive_stringlist (sock, slist);

     if (length > 1 && gmyth_string_list_get_int(slist, 0) == 1)

         res = gmyth_string_list_get_string(slist, 1);

     else

         res = NULL;

     g_object_unref(slist);

     return res;

 }

 gboolean

 gmyth_util_get_backend_details (GMythSocket *sock, GMythBackendDetails **details)

 {

     gboolean res = FALSE;

     gint length = 0;

     GMythStringList *slist;

     slist = gmyth_string_list_new();

     gmyth_string_list_append_char_array(slist, "QUERY_FREE_SPACE");

     length = gmyth_socket_sendreceive_stringlist (sock, slist);

     if (length >= 8) {

         *details = g_new0 (GMythBackendDetails, 1);

         (*details)->total_space = gmyth_string_list_get_uint64 (slist, 4) * 1024;

         (*details)->used_space = gmyth_string_list_get_uint64 (slist, 6) * 1024;

         res = TRUE;

     }

     g_object_unref(slist);

     return res;

 }

 void

 gmyth_util_backend_details_free (GMythBackendDetails *details)

 {

     g_free (details);

 }

 /** 

  * Checks if the given remote file exists, and gets its remote directory.

  * 

  * @param backend_info The GMythBackendInfo instance.

  * @param filename The file name of the remote file.

  * @param current_dir String pointer to the directory where the remote file is stored.

  * 

  * @return <code>true</code>, if the remote file exists.

  */

 gboolean

 gmyth_util_file_exists_and_get_remote_dir(GMythBackendInfo * backend_info,

                                           const gchar * filename,

                                           gchar ** current_dir)

 {

     GMythSocket    *socket;

     gboolean        res;

     *current_dir = NULL;

     socket = gmyth_socket_new();

     res = gmyth_socket_connect_to_backend(socket, backend_info->hostname,

                                           backend_info->port, TRUE);

     if (res == TRUE) {

         GMythProgramInfo *program;

 	GString *path;

         program = gmyth_program_info_new();

         program->pathname = g_string_new(filename);

         path = gmyth_util_check_file_from_socket (socket, program);

         res = !!path;

         if (path)

             *current_dir = g_string_free(path, FALSE);

         if (*current_dir != NULL)

             gmyth_debug("Current directory = %s.", (*current_dir != NULL)

                         ? *current_dir : "[directory not found]");

         g_object_unref(program);

         gmyth_socket_close_connection(socket);

     }

     g_object_unref(socket);

     return res;

 }

 /** 

  * Creates a file name to a possible existing remote file,

  * based on some fields of the LiveTV/recorded program info.

  * 

  * @param chan_id The channel ID number.

  * @param start_time The start time of the recording.

  * 

  * @return The string representing the file name.

  */

 gchar          *

 gmyth_util_create_filename(const gint chan_id, const GTimeVal * start_time)

 {

     gchar          *basename = NULL;

     g_return_val_if_fail(start_time != NULL, NULL);

     gchar          *isodate =

         gmyth_util_time_to_isoformat_from_time_val_fmt("%Y%m%d%H%M%S",

                                                        start_time);

     basename = g_strdup_printf("%d_%s", chan_id, isodate);

     gmyth_debug("Basename (from chan_id and start_time): %s", basename);

     if (isodate)

         g_free(isodate);

     return basename;

 }

 /** 

  * Gets the channel list.

  * 

  * @param backend_info The GMythBackendInfo instance.

  * 

  * @return a pointer to a GList with all the channels.

  */

 GList*

 gmyth_util_get_channel_list(GMythBackendInfo * backend_info)

 {

     GMythRecorder  *recorder;

     GList          *channel_list = NULL;

     gboolean        res = FALSE;

     gmyth_debug("Gets channel list.");

     g_return_val_if_fail(backend_info != NULL, FALSE);

     recorder =

         gmyth_recorder_new(1,

                            g_string_new(gmyth_backend_info_get_hostname

                                         (backend_info)),

                            gmyth_backend_info_get_port(backend_info));

     res = gmyth_recorder_setup(recorder);

     if (res == TRUE) {

         // GList* channel_list = gmyth_recorder_get_channel_list( recorder 

         // 

         // 

         // ); 

         gmyth_debug("Yeah, got channel list!!!");

         GList          *ch = NULL;

         GMythChannelInfo *channel_info = NULL;

         for (ch = gmyth_recorder_get_channel_list(recorder); ch != NULL;) {

             channel_info = g_malloc0(sizeof(GMythChannelInfo));

             channel_info->channel_ID = 0;

             channel_info->channel_num =

                 g_string_new(g_strdup((gchar *) ch->data));

             channel_info->channel_name = g_string_new("");

             gmyth_debug("Printing channel info... (%s)",

                         channel_info->channel_num->str);

             channel_list =

                 g_list_append(channel_list,

                               g_memdup(channel_info,

                                        sizeof(GMythChannelInfo)));

             ch = g_list_next(ch);

             if (channel_info != NULL)

                 g_free(channel_info);

         }

     } /* if */

     else {

         gmyth_debug("No, couldn't get the channel list!!!");

     }

     gmyth_debug("Got %d channels!!!", g_list_length(channel_list));

     g_object_unref(recorder);

     return channel_list;

 }

 /** 

  * Gets all the recordings from remote encoder.

  * 

  * @param backend_info The GMythBackendInfo instance.

  * 

  * @return The program info's listage.

  */

 GSList         *

 gmyth_util_get_all_recordings(GMythBackendInfo * backend_info)

 {

     GSList         *program_list = NULL;

     GMythSocket    *socket;

     gboolean        res;

     socket = gmyth_socket_new();

     res = gmyth_socket_connect_to_backend(socket, backend_info->hostname,

                                           backend_info->port, TRUE);

     if (res == TRUE) {

         GMythStringList *slist = gmyth_string_list_new();

         guint           pos = 0;

         gmyth_string_list_append_char_array(slist,

                                             "QUERY_RECORDINGS Play");

         gmyth_socket_sendreceive_stringlist(socket, slist);

         if (slist != NULL && (gmyth_string_list_length(slist) > 0)) {

             GMythProgramInfo *program = NULL;

             gmyth_debug("OK! Got the program list [size=%d].",

                         gmyth_string_list_length(slist));

             do {

                 program =

                     gmyth_program_info_from_string_list_from_pos(slist,

                                                                  pos);

                 if (program != NULL) {

                     pos += 41;

                     program_list = g_slist_append(program_list, program);

                 } else

                     break;

             }

             while (gmyth_string_list_length(slist) > pos);

         }

         /*

          * if 

          */

         g_object_unref(slist);

         gmyth_socket_close_connection(socket);

     }

     g_object_unref(socket);

     return program_list;

 }

 /** 

  * Checks if the given remote file exists, and gets its remote directory.

  * 

  * @param backend_info The GMythBackendInfo instance.

  * @param channel The channel name of the program info.

  * 

  * @return The requested program info.

  */

 GMythProgramInfo *

 gmyth_util_get_recording_from_channel(GMythBackendInfo * backend_info,

                                       const gchar * channel)

 {

     GSList         *program_list = NULL;

     GMythProgramInfo *program = NULL;

     program_list = gmyth_util_get_all_recordings(backend_info);

     if (program_list != NULL && g_slist_length(program_list) > 0) {

         GMythProgramInfo *program = NULL;

         guint           pos = 0;

         gmyth_debug("OK! Got the program list [size=%d].",

                     g_slist_length(program_list));

         while (pos < g_slist_length(program_list)) {

             program =

                 (GMythProgramInfo *) g_slist_nth_data(program_list, pos);

             if (program != NULL && program->channame != NULL &&

                 g_ascii_strncasecmp(program->channame->str, channel,

                                     strlen(channel)) == 0) {

                 break;

             }

             ++pos;

         }                       /* while */

     }

     /*

      * if 

      */

     return program;

 }

 GSList *

 gmyth_util_get_all_pending(GMythBackendInfo * backend_info,

                            gboolean * conflicts)

 {

     GSList         *program_list = NULL;

     GMythSocket    *socket;

     gboolean        res;

     socket = gmyth_socket_new();

     res = gmyth_socket_connect_to_backend(socket, backend_info->hostname,

                                           backend_info->port, TRUE);

     if (res) {

         GMythStringList *slist = gmyth_string_list_new();

         int              pos, lines, count;

         gmyth_string_list_append_char_array(slist, "QUERY_GETALLPENDING");

         gmyth_socket_sendreceive_stringlist(socket, slist);

         if (gmyth_string_list_length(slist) > 1) {

             GMythProgramInfo *program;

             *conflicts = gmyth_string_list_get_int(slist, 0);

             count = gmyth_string_list_get_int(slist, 1);

             lines = (gmyth_string_list_length(slist) - 2) / count;

             for(pos = 2; pos < 2 + count * lines; pos += lines) {

                 program =

                   gmyth_program_info_from_string_list_from_pos(slist, pos);

                 if (program)

                     program_list = g_slist_prepend(program_list, program);

             }

         }

         g_object_unref(slist);

         gmyth_socket_close_connection(socket);

     }

     g_object_unref(socket);

     return g_slist_reverse(program_list);

 }

 #if !GLIB_CHECK_VERSION (2, 10, 0)

 /*

  * Hacked from glib 2.10 <gtime.c> 

  */

 static          time_t

 mktime_utc(struct tm *tm)

 {

     time_t          retval;

 #ifndef HAVE_TIMEGM

     static const gint days_before[] = {

         0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334

     };

 #endif

 #ifndef HAVE_TIMEGM

     if (tm->tm_mon < 0 || tm->tm_mon > 11)

         return (time_t) - 1;

     retval = (tm->tm_year - 70) * 365;

     retval += (tm->tm_year - 68) / 4;

     retval += days_before[tm->tm_mon] + tm->tm_mday - 1;

     if (tm->tm_year % 4 == 0 && tm->tm_mon < 2)

         retval -= 1;

     retval =

         ((((retval * 24) + tm->tm_hour) * 60) + tm->tm_min) * 60 +

         tm->tm_sec;

 #else

     retval = timegm(tm);

 #endif                          /* !HAVE_TIMEGM */

     return retval;

 }

 gboolean

 g_time_val_from_iso8601(const gchar * iso_date, GTimeVal * time_)

 {

     struct tm       tm;

     long            val;

     g_return_val_if_fail(iso_date != NULL, FALSE);

     g_return_val_if_fail(time_ != NULL, FALSE);

     val = strtoul(iso_date, (char **) &iso_date, 10);

     if (*iso_date == '-') {

         /*

          * YYYY-MM-DD 

          */

         tm.tm_year = val - 1900;

         iso_date++;

         tm.tm_mon = strtoul(iso_date, (char **) &iso_date, 10) - 1;

         if (*iso_date++ != '-')

             return FALSE;

         tm.tm_mday = strtoul(iso_date, (char **) &iso_date, 10);

     } else {

         /*

          * YYYYMMDD 

          */

         tm.tm_mday = val % 100;

         tm.tm_mon = (val % 10000) / 100 - 1;

         tm.tm_year = val / 10000 - 1900;

     }

     if (*iso_date++ != 'T')

         return FALSE;

     val = strtoul(iso_date, (char **) &iso_date, 10);

     if (*iso_date == ':') {

         /*

          * hh:mm:ss 

          */

         tm.tm_hour = val;

         iso_date++;

         tm.tm_min = strtoul(iso_date, (char **) &iso_date, 10);

         if (*iso_date++ != ':')

             return FALSE;

         tm.tm_sec = strtoul(iso_date, (char **) &iso_date, 10);

     } else {

         /*

          * hhmmss 

          */

         tm.tm_sec = val % 100;

         tm.tm_min = (val % 10000) / 100;

         tm.tm_hour = val / 10000;

     }

     time_->tv_sec = mktime_utc(&tm);

     time_->tv_usec = 1;

     if (*iso_date == '.')

         time_->tv_usec = strtoul(iso_date + 1, (char **) &iso_date, 10);

     if (*iso_date == '+' || *iso_date == '-') {

         gint            sign = (*iso_date == '+') ? -1 : 1;

         val = 60 * strtoul(iso_date + 1, (char **) &iso_date, 10);

         if (*iso_date == ':')

             val = 60 * val + strtoul(iso_date + 1, NULL, 10);

         else

             val = 60 * (val / 100) + (val % 100);

         time_->tv_sec += (time_t) (val * sign);

     }

     return TRUE;

 }

 gchar          *

 g_time_val_to_iso8601(GTimeVal * time_)

 {

     gchar          *retval;

     g_return_val_if_fail(time_->tv_usec >= 0

                          && time_->tv_usec < G_USEC_PER_SEC, NULL);

 #define ISO_8601_LEN    21

 #define ISO_8601_FORMAT "%Y-%m-%dT%H:%M:%SZ"

     retval = g_new0(gchar, ISO_8601_LEN + 1);

     strftime(retval, ISO_8601_LEN, ISO_8601_FORMAT,

              gmtime(&(time_->tv_sec)));

     return retval;

 }

 /*

  * Hacked from glib 2.10 <gdate.c> 

  */

 void

 g_date_set_time_t(GDate * date, time_t timet)

 {

     struct tm       tm;

     g_return_if_fail(date != NULL);

 #ifdef HAVE_LOCALTIME_R

     localtime_r(&timet, &tm);

 #else

     {

         struct tm      *ptm = localtime(&timet);

         if (ptm == NULL) {

             /*

              * Happens at least in Microsoft's C library if you pass a

              * negative time_t. Use 2000-01-01 as default date. 

              */

 #ifndef G_DISABLE_CHECKS

             g_return_if_fail_warning(G_LOG_DOMAIN, "g_date_set_time",

                                      "ptm != NULL");

 #endif

             tm.tm_mon = 0;

             tm.tm_mday = 1;

             tm.tm_year = 100;

         } else

             memcpy((void *) &tm, (void *) ptm, sizeof(struct tm));

     }

 #endif

     date->julian = FALSE;

     date->month = tm.tm_mon + 1;

     date->day = tm.tm_mday;

     date->year = tm.tm_year + 1900;

     g_return_if_fail(g_date_valid_dmy(date->day, date->month, date->year));

     date->dmy = TRUE;

 }

 void

 g_date_set_time_val(GDate * date, GTimeVal * timeval)

 {

     g_date_set_time_t(date, (time_t) timeval->tv_sec);

 }

 #endif