git.gag.com Git - debian/amanda/blob - common-src/glib-util.c

   1 /*
   2  * Copyright (c) 2005-2008 Zmanda Inc.  All Rights Reserved.
   3  *
   4  * This library is free software; you can redistribute it and/or modify it
   5  * under the terms of the GNU Lesser General Public License version 2.1 as
   6  * published by the Free Software Foundation.
   7  *
   8  * This library is distributed in the hope that it will be useful, but
   9  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  10  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
  11  * License for more details.
  12  *
  13  * You should have received a copy of the GNU Lesser General Public License
  14  * along with this library; if not, write to the Free Software Foundation,
  15  * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA.
  16  *
  17  * Contact information: Zmanda Inc., 465 S Mathlida Ave, Suite 300
  18  * Sunnyvale, CA 94086, USA, or: http://www.zmanda.com
  19  */
  20
  21 /*
  22  * Utilities that aren't quite included in glib
  23  *
  24  * Author: Dustin J. Mitchell <dustin@zmanda.com>, Ian Turner <ian@zmanda.com>
  25  */
  26
  27 #include "amanda.h"
  28 #include "glib-util.h"
  29 #include "conffile.h" /* For find_multiplier. */
  30
  31 #ifdef HAVE_LIBCURL
  32 #include <curl/curl.h>
  33 #endif
  34
  35 void
  36 glib_init(void) {
  37     static gboolean did_glib_init = FALSE;
  38     if (did_glib_init) return;
  39     did_glib_init = TRUE;
  40
  41     /* Initialize glib's type system */
  42     g_type_init();
  43
  44     /* set up libcurl (this must happen before threading
  45      * is initialized) */
  46 #ifdef HAVE_LIBCURL
  47 # ifdef G_THREADS_ENABLED
  48     g_assert(!g_thread_supported());
  49 # endif
  50     g_assert(curl_global_init(CURL_GLOBAL_ALL) == 0);
  51 #endif
  52
  53     /* And set up glib's threads */
  54 #if defined(G_THREADS_ENABLED) && !defined(G_THREADS_IMPL_NONE)
  55     if (g_thread_supported()) {
  56         return;
  57     }
  58     g_thread_init(NULL);
  59 #endif
  60
  61     /* do a version check */
  62 #if GLIB_CHECK_VERSION(2,6,0)
  63     {
  64         const char *glib_err = glib_check_version(GLIB_MAJOR_VERSION,
  65                                                   GLIB_MINOR_VERSION,
  66                                                   GLIB_MICRO_VERSION);
  67         if (glib_err) {
  68             error(_("%s: Amanda was compiled with glib-%d.%d.%d"), glib_err,
  69                     GLIB_MAJOR_VERSION, GLIB_MINOR_VERSION, GLIB_MICRO_VERSION);
  70             exit(1); /* glib_init may be called before error handling is set up */
  71         }
  72     }
  73 #endif
  74 }
  75
  76 typedef enum {
  77     FLAG_STRING_NAME,
  78     FLAG_STRING_SHORT_NAME,
  79     FLAG_STRING_NICK
  80 } FlagString;
  81
  82 static char ** g_flags_to_strv(int value, GType type, FlagString source);
  83
  84 void
  85 _glib_util_foreach_glue(gpointer data, gpointer func)
  86 {
  87     void (*one_arg_fn)(gpointer) = (void (*)(gpointer))func;
  88     one_arg_fn(data);
  89 }
  90
  91 GValue* g_value_unset_init(GValue* value, GType type) {
  92     g_return_val_if_fail(value != NULL, NULL);
  93
  94     if (G_IS_VALUE(value)) {
  95         g_value_unset(value);
  96     }
  97     g_value_init(value, type);
  98     return value;
  99 }
 100
 101 GValue* g_value_unset_copy(const GValue * from, GValue * to) {
 102     g_return_val_if_fail(from != NULL, NULL);
 103     g_return_val_if_fail(to != NULL, NULL);
 104
 105     g_value_unset_init(to, G_VALUE_TYPE(from));
 106     g_value_copy(from, to);
 107     return to;
 108 }
 109
 110 void g_list_free_full(GList * list) {
 111     GList * cur = list;
 112
 113     while (cur != NULL) {
 114         gpointer data = cur->data;
 115         amfree(data);
 116         cur = g_list_next(cur);
 117     }
 118
 119     g_list_free(list);
 120 }
 121
 122 void g_slist_free_full(GSList * list) {
 123     GSList * cur = list;
 124
 125     while (cur != NULL) {
 126         gpointer data = cur->data;
 127         amfree(data);
 128         cur = g_slist_next(cur);
 129     }
 130
 131     g_slist_free(list);
 132 }
 133
 134 void g_queue_free_full(GQueue * queue) {
 135     while (!g_queue_is_empty(queue)) {
 136         gpointer data;
 137         data = g_queue_pop_head(queue);
 138         amfree(data);
 139     }
 140     g_queue_free(queue);
 141 }
 142
 143 void g_ptr_array_free_full(GPtrArray * array) {
 144     size_t i;
 145
 146     for (i = 0; i < array->len; i ++) {
 147         amfree(g_ptr_array_index(array, i));
 148     }
 149     g_ptr_array_free(array, TRUE);
 150 }
 151
 152 gboolean g_value_compare(GValue * a, GValue * b) {
 153     if (a == NULL && b == NULL)
 154         return TRUE;
 155     if (a == NULL || b == NULL)
 156         return FALSE;
 157     if (G_VALUE_TYPE(a) != G_VALUE_TYPE(b))
 158         return FALSE;
 159     if (g_value_fits_pointer(a) && g_value_fits_pointer(b)) {
 160         return g_value_peek_pointer(a) == g_value_peek_pointer(b);
 161     } else {
 162         /* Since there is no builtin comparison function, we resort to
 163            comparing serialized strings. Yuck. */
 164         char * a_str;
 165         char * b_str;
 166         gboolean rval;
 167         a_str = g_strdup_value_contents(a);
 168         b_str = g_strdup_value_contents(b);
 169         rval = (0 == strcmp(a_str, b_str));
 170         amfree(a_str);
 171         amfree(b_str);
 172         return rval;
 173     }
 174
 175     g_assert_not_reached();
 176 }
 177
 178 static gboolean g_value_set_boolean_from_string(GValue * val, char * string) {
 179     if (strcasecmp(string, "true") == 0 ||
 180         strcasecmp(string, "yes") == 0 ||
 181         strcmp(string, "1") == 0) {
 182         g_value_set_boolean(val, TRUE);
 183     } else if (strcasecmp(string, "false") == 0 ||
 184                strcasecmp(string, "no") == 0 ||
 185                strcmp(string, "0") == 0) {
 186         g_value_set_boolean(val, FALSE);
 187     } else {
 188         return FALSE;
 189     }
 190
 191     return TRUE;
 192 }
 193
 194 static gboolean g_value_set_int_from_string(GValue * val, char * string) {
 195     long int strto_result;
 196     char * strto_end;
 197     gint64 multiplier;
 198     strto_result = strtol(string, &strto_end, 0);
 199     multiplier = find_multiplier(strto_end);
 200     if (multiplier == G_MAXINT64) {
 201         if (strto_result >= 0) {
 202             g_value_set_int(val, G_MAXINT);
 203         } else {
 204             g_value_set_int(val, G_MININT);
 205         }
 206         return TRUE;
 207     } else if (*string == '\0' || multiplier == 0
 208                || strto_result < G_MININT / multiplier
 209                || strto_result > G_MAXINT / multiplier) {
 210         return FALSE;
 211     } else {
 212         g_value_set_int(val, (int)(strto_result * multiplier));
 213         return TRUE;
 214     }
 215 }
 216
 217 static gboolean g_value_set_uint_from_string(GValue * val, char * string) {
 218     unsigned long int strto_result;
 219     char * strto_end;
 220     guint64 multiplier;
 221     strto_result = strtoul(string, &strto_end, 0);
 222     multiplier = find_multiplier(strto_end); /* casts */
 223     if (multiplier == G_MAXINT64) {
 224         g_value_set_uint(val, G_MAXUINT);
 225         return TRUE;
 226     } else if (multiplier == 0 || *string == '\0' ||
 227                strto_result > G_MAXUINT / multiplier) {
 228         return FALSE;
 229     } else {
 230         g_value_set_uint(val, (guint)(strto_result * multiplier));
 231         return TRUE;
 232     }
 233 }
 234
 235 static gboolean g_value_set_uint64_from_string(GValue * val, char * string) {
 236     unsigned long long int strto_result;
 237     char * strto_end;
 238     guint64 multiplier;
 239     strto_result = strtoull(string, &strto_end, 0);
 240     multiplier = find_multiplier(strto_end); /* casts */
 241     if (multiplier == G_MAXINT64) {
 242         g_value_set_uint64(val, G_MAXUINT64);
 243         return TRUE;
 244     } else if (multiplier == 0 || *string == '\0' ||
 245         strto_result > G_MAXUINT64 / multiplier) {
 246         return FALSE;
 247     } else {
 248         g_value_set_uint64(val, (guint64)(strto_result * multiplier));
 249         return TRUE;
 250     }
 251 }
 252
 253 /* Flags can contain multiple values. We assume here that values are like
 254  * C identifiers (that is, they match /[A-Za-z_][A-Za-z0-9_]+/), although
 255  * that doesn't seem to be a requirement of GLib. With that assumption in
 256  * mind, we look for the format "FLAG_1 | FLAG_2 | ... | FLAG_N". */
 257 static gboolean g_value_set_flags_from_string(GValue * val, char * string) {
 258     guint value = 0;
 259     char * strtok_saveptr;
 260     char * string_copy;
 261     char * strtok_first_arg;
 262     const char delim[] = " \t,|";
 263     GFlagsClass * flags_class;
 264
 265     flags_class = (GFlagsClass*) g_type_class_ref(G_VALUE_TYPE(val));
 266     g_return_val_if_fail(flags_class != NULL, FALSE);
 267     g_return_val_if_fail(G_IS_FLAGS_CLASS(flags_class), FALSE);
 268
 269     /* Don't let strtok stop on original. */
 270     strtok_first_arg = string_copy = strdup(string);
 271
 272     for (;;) {
 273         GFlagsValue * flag_value;
 274         char * token = strtok_r(strtok_first_arg, delim, &strtok_saveptr);
 275         strtok_first_arg = NULL;
 276
 277         if (token == NULL) {
 278             break;
 279         }
 280
 281         flag_value = g_flags_get_value_by_name(flags_class, token);
 282         if (flag_value == NULL) {
 283             flag_value = g_flags_get_value_by_nick(flags_class, token);
 284         }
 285         if (flag_value == NULL) {
 286             g_fprintf(stderr, _("Invalid flag %s for type %s\n"), token,
 287                     g_type_name(G_VALUE_TYPE(val)));
 288             continue;
 289         }
 290
 291         value |= flag_value->value;
 292     }
 293
 294     amfree(string_copy);
 295
 296     if (value == 0) {
 297         g_fprintf(stderr, _("No valid flags for type %s in string %s\n"),
 298                 g_type_name(G_VALUE_TYPE(val)), string);
 299         return FALSE;
 300     }
 301
 302     g_value_set_flags(val, value);
 303     return TRUE;
 304
 305 }
 306
 307 /* This function really ought not to be part of Amanda. In my (Ian's) opinion,
 308    serialization and deserialization should be a part of the GValue
 309    interface. But it's not, and here we are. */
 310 gboolean g_value_set_from_string(GValue * val, char * string) {
 311     g_return_val_if_fail(val != NULL, FALSE);
 312     g_return_val_if_fail(G_IS_VALUE(val), FALSE);
 313
 314     if (G_VALUE_HOLDS_BOOLEAN(val)) {
 315         return g_value_set_boolean_from_string(val, string);
 316     } else if (G_VALUE_HOLDS_INT(val)) {
 317         return g_value_set_int_from_string(val, string);
 318     } else if (G_VALUE_HOLDS_UINT(val)) {
 319         return g_value_set_uint_from_string(val, string);
 320     } else if (G_VALUE_HOLDS_UINT64(val)) {
 321         return g_value_set_uint64_from_string(val, string);
 322     } else if (G_VALUE_HOLDS_STRING(val)) {
 323         g_value_set_string(val, string);
 324         return TRUE;
 325     } else if (G_VALUE_HOLDS_FLAGS(val)) {
 326         return g_value_set_flags_from_string(val, string);
 327     }
 328
 329     return TRUE;
 330 }
 331
 332 gint
 333 g_compare_strings(
 334     gconstpointer a,
 335     gconstpointer b)
 336 {
 337     return strcmp((char *)a, (char *)b);
 338 }
 339
 340 char * g_strjoinv_and_free(char ** strv, const char * seperator) {
 341     char * rval = g_strjoinv(seperator, strv);
 342     g_strfreev(strv);
 343     return rval;
 344 }
 345
 346 char ** g_flags_name_to_strv(int value, GType type) {
 347     return g_flags_to_strv(value, type, FLAG_STRING_NAME);
 348 }
 349
 350 char ** g_flags_short_name_to_strv(int value, GType type) {
 351     return g_flags_to_strv(value, type, FLAG_STRING_SHORT_NAME);
 352 }
 353
 354 char ** g_flags_nick_to_strv(int value, GType type) {
 355     return g_flags_to_strv(value, type, FLAG_STRING_NICK);
 356 }
 357
 358 static char * get_name_from_value(GFlagsValue * value, FlagString source) {
 359     switch (source) {
 360     case FLAG_STRING_NAME:
 361     case FLAG_STRING_SHORT_NAME:
 362         return strdup(value->value_name);
 363     case FLAG_STRING_NICK:
 364         return strdup(value->value_nick);
 365     default:
 366         return NULL;
 367     }
 368 }
 369
 370 /* If freed and notfreed have a common prefix that is different from freed,
 371    then return that and free freed. Otherwise, return freed. */
 372 static char * find_common_prefix(char * freed, const char * notfreed) {
 373     char * freed_ptr = freed;
 374     const char * notfreed_ptr = notfreed;
 375
 376     if (freed == NULL) {
 377         if (notfreed == NULL) {
 378             return NULL;
 379         } else {
 380             return strdup(notfreed);
 381         }
 382     } else if (notfreed == NULL) {
 383         amfree(freed);
 384         return strdup("");
 385     }
 386
 387     while (*freed_ptr == *notfreed_ptr) {
 388         freed_ptr ++;
 389         notfreed_ptr ++;
 390     }
 391
 392     *freed_ptr = '\0';
 393     return freed;
 394 }
 395
 396 static char ** g_flags_to_strv(int value, GType type,
 397                                FlagString source) {
 398     GPtrArray * rval;
 399     GFlagsValue * flagsvalue;
 400     char * common_prefix = NULL;
 401     int common_prefix_len;
 402     GFlagsClass * class;
 403
 404     g_return_val_if_fail(G_TYPE_IS_FLAGS(type), NULL);
 405     g_return_val_if_fail((class = g_type_class_ref(type)) != NULL, NULL);
 406     g_return_val_if_fail(G_IS_FLAGS_CLASS(class), NULL);
 407
 408     rval = g_ptr_array_new();
 409     for (flagsvalue = class->values;
 410          flagsvalue->value_name != NULL;
 411          flagsvalue ++) {
 412         if (source == FLAG_STRING_SHORT_NAME) {
 413             common_prefix = find_common_prefix(common_prefix,
 414                                                flagsvalue->value_name);
 415         }
 416
 417         if ((flagsvalue->value == 0 && value == 0) ||
 418             (flagsvalue->value != 0 && (value & flagsvalue->value))) {
 419             g_ptr_array_add(rval, get_name_from_value(flagsvalue, source));
 420         }
 421     }
 422
 423     if (source == FLAG_STRING_SHORT_NAME && common_prefix != NULL &&
 424         ((common_prefix_len = strlen(common_prefix))) > 0) {
 425         char * old;
 426         char * new;
 427         guint i;
 428         for (i = 0; i < rval->len; i ++) {
 429             old = g_ptr_array_index(rval, i);
 430             new = strdup(old + common_prefix_len);
 431             g_ptr_array_index(rval, i) = new;
 432             g_free(old);
 433         }
 434     }
 435
 436     g_ptr_array_add(rval, NULL);
 437
 438     amfree(common_prefix);
 439     return (char**)g_ptr_array_free(rval, FALSE);
 440 }
 441
 442 char * g_english_strjoinv(char ** strv, const char * conjunction) {
 443     int length;
 444     char * last;
 445     char * joined;
 446     char * rval;
 447     strv = g_strdupv(strv);
 448
 449     length = g_strv_length(strv);
 450
 451     if (length == 1)
 452         return stralloc(strv[0]);
 453
 454     last = strv[length - 1];
 455     strv[length - 1] = NULL;
 456
 457     joined = g_strjoinv(", ", strv);
 458     rval = g_strdup_printf("%s, %s %s", joined, conjunction, last);
 459
 460     g_free(joined);
 461     g_free(last);
 462     g_strfreev(strv);
 463     return rval;
 464 }
 465
 466 char * g_english_strjoinv_and_free(char ** strv, const char * conjunction) {
 467     char * rval = g_english_strjoinv(strv, conjunction);
 468     g_strfreev(strv);
 469     return rval;
 470 }
 471
 472 #if !(GLIB_CHECK_VERSION(2,6,0))
 473 guint g_strv_length(gchar ** strv) {
 474     int rval = 0;
 475
 476     if (G_UNLIKELY(strv == NULL))
 477         return 0;
 478
 479     while (*strv != NULL) {
 480         rval ++;
 481         strv ++;
 482     }
 483     return rval;
 484 }
 485 #endif /* GLIB_CHECK_VERSION(2.6.0) */
 486
 487 #if !GLIB_CHECK_VERSION(2,4,0)
 488 void
 489 g_ptr_array_foreach (GPtrArray *array,
 490                      GFunc      func,
 491                      gpointer   user_data)
 492 {
 493   guint i;
 494
 495   g_return_if_fail (array);
 496
 497   for (i = 0; i < array->len; i++)
 498     (*func) (array->pdata[i], user_data);
 499 }
 500 #endif
 501
 502 guint
 503 g_str_case_hash(
 504         gconstpointer key)
 505 {
 506     /* modified version of glib's hash function, copyright
 507      * GLib Team and others 1997-2000. */
 508     const char *p = key;
 509     guint h = g_ascii_toupper(*p);
 510
 511     if (h)
 512         for (p += 1; *p != '\0'; p++)
 513             h = (h << 5) - h + g_ascii_toupper(*p);
 514
 515     return h;
 516 }
 517
 518 gboolean
 519 g_str_case_equal(
 520         gconstpointer v1,
 521         gconstpointer v2)
 522 {
 523     return (0 == g_ascii_strcasecmp((char *)v1, (char *)v2));
 524 }