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

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