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

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