HGKeeper

/* purple

* Purple is the legal property of its developers, whose names are too numerous

* to list here. Please refer to the COPYRIGHT file distributed with this

* source distribution.

* Rewritten from scratch during Google Summer of Code 2012

* by Tomek Wasilczyk (http://www.wasilczyk.pl).

* Previously implemented by:

* - Arkadiusz Miskiewicz <misiek@pld.org.pl> - first implementation (2001);

* - Bartosz Oler <bartosz@bzimage.us> - reimplemented during GSoC 2005;

* - Krzysztof Klinikowski <grommasher@gmail.com> - some parts (2009-2011).

* This program 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.

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

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

* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA

#include "utils.h"

#include "gg.h"

#include <debug.h>

uin_t ggp_str_to_uin(const char *str)

{

char *endptr;

uin_t uin;

if (!str || str[0] < '0' || str[0] > '9')

return 0;

errno = 0;

uin = strtoul(str, &endptr, 10);

if (errno == ERANGE || endptr[0] != '\0')

return 0;

return uin;

}

const char * ggp_uin_to_str(uin_t uin)

{

static char buff[GGP_UIN_LEN_MAX + 1];

g_snprintf(buff, GGP_UIN_LEN_MAX + 1, "%u", uin);

return buff;

}

uin_t ggp_get_my_uin(PurpleConnection *gc)

{

g_return_val_if_fail(gc != NULL, 0);

return ggp_str_to_uin(purple_account_get_username(

purple_connection_get_account(gc)));

}

static gchar * ggp_convert(const gchar *src, const char *srcenc,

const char *dstenc)

{

gchar *dst;

GError *err = NULL;

if (src == NULL)

return NULL;

dst = g_convert_with_fallback(src, strlen(src), dstenc, srcenc, "?",

NULL, NULL, &err);

if (err != NULL) {

purple_debug_error("gg", "error converting from %s to %s: %s\n",

srcenc, dstenc, err->message);

g_error_free(err);

}

if (dst == NULL)

dst = g_strdup(src);

return dst;

}

gchar * ggp_convert_to_cp1250(const gchar *src)

{

return ggp_convert(src, "UTF-8", "CP1250");

}

gchar * ggp_convert_from_cp1250(const gchar *src)

{

return ggp_convert(src, "CP1250", "UTF-8");

}

gboolean ggp_password_validate(const gchar *password)

{

const int len = strlen(password);

if (len < 6 || len > 15)

return FALSE;

return g_regex_match_simple("^[ a-zA-Z0-9~`!@#$%^&*()_+=[\\]{};':\",./?"

"<>\\\\|-]+$", password, 0, 0);

}

gchar * ggp_utf8_strndup(const gchar *str, gsize n)

{

size_t raw_len;

gchar *end_ptr;

if (str == NULL)

return NULL;

raw_len = strlen(str);

if (raw_len <= n)

return g_strdup(str);

end_ptr = g_utf8_offset_to_pointer(str, g_utf8_pointer_to_offset(str, &str[n]));

raw_len = end_ptr - str;

if (raw_len > n) {

end_ptr = g_utf8_prev_char(end_ptr);

raw_len = end_ptr - str;

}

g_assert(raw_len <= n);

return g_strndup(str, raw_len);

}

GSList * ggp_list_copy_to_slist_deep(GList *list, GCopyFunc func,

gpointer user_data)

{

GSList *new_list = NULL;

GList *it;

it = g_list_first(list);

while (it) {

new_list = g_slist_append(new_list, func(it->data, user_data));

it = g_list_next(it);

}

return new_list;

}

GList * ggp_strsplit_list(const gchar *string, const gchar *delimiter,

gint max_tokens)

{

gchar **splitted, **it;

GList *list = NULL;

it = splitted = g_strsplit(string, delimiter, max_tokens);

while (*it) {

list = g_list_append(list, *it);

it++;

}

g_free(splitted);

return list;

}

gchar * ggp_strjoin_list(const gchar *separator, GList *list)

{

gchar **str_array;

gchar *joined;

gint list_len, i;

GList *it;

list_len = g_list_length(list);

str_array = g_new(gchar*, list_len + 1);

it = g_list_first(list);

i = 0;

while (it) {

str_array[i++] = it->data;

it = g_list_next(it);

}

str_array[i] = NULL;

joined = g_strjoinv(separator, str_array);

g_free(str_array);

return joined;

}

const gchar * ggp_ipv4_to_str(uint32_t raw_ip)

{

static gchar buff[INET_ADDRSTRLEN];

buff[0] = '\0';

g_snprintf(buff, sizeof(buff), "%d.%d.%d.%d",

((raw_ip >> 0) & 0xFF),

((raw_ip >> 8) & 0xFF),

((raw_ip >> 16) & 0xFF),

((raw_ip >> 24) & 0xFF));

return buff;

}

GList * ggp_list_truncate(GList *list, guint length, GDestroyNotify free_func)

{

while (g_list_length(list) > length) {

GList *last = g_list_last(list);

free_func(last->data);

list = g_list_delete_link(list, last);

}

return list;

}

gchar * ggp_free_if_equal(gchar *str, const gchar *pattern)

{

if (g_strcmp0(str, pattern) == 0) {

g_free(str);

return NULL;

}

return str;

}

const gchar * ggp_date_strftime(const gchar *format, time_t date)

{

GDate g_date;

static gchar buff[30];

g_date_set_time_t(&g_date, date);

if (0 == g_date_strftime(buff, sizeof(buff), format, &g_date))

return NULL;

return buff;

}

time_t ggp_date_from_iso8601(const gchar *str)

{

GTimeVal g_timeval;

if (!str)

return 0;

if (!g_time_val_from_iso8601(str, &g_timeval))

return 0;

return g_timeval.tv_sec;

}

uint64_t * ggp_uint64dup(uint64_t val)

{

uint64_t *ptr = g_new(uint64_t, 1);

*ptr = val;

return ptr;

}

gint ggp_int64_compare(gconstpointer _a, gconstpointer _b)

{

const int64_t *ap = _a, *bp = _b;

const int64_t a = *ap, b = *bp;

if (a == b)

return 0;

if (a < b)

return -1;

else

return 1;

}

JsonParser * ggp_json_parse(const gchar *data)

{

JsonParser *parser;

parser = json_parser_new();

if (json_parser_load_from_data(parser, data, -1, NULL))

return parser;

if (purple_debug_is_unsafe())

purple_debug_warning("gg", "Invalid JSON: %s\n", data);

return NULL;

}

pidgin/pidgin