2 * Copyright (c) 2005-2008 Zmanda Inc. All Rights Reserved.
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.
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.
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.
17 * Contact information: Zmanda Inc., 465 S Mathlida Ave, Suite 300
18 * Sunnyvale, CA 94086, USA, or: http://www.zmanda.com
22 * Utilities that aren't quite included in glib
24 * Author: Dustin J. Mitchell <dustin@zmanda.com>, Ian Turner <ian@zmanda.com>
28 #include "glib-util.h"
29 #include "conffile.h" /* For find_multiplier. */
32 #include <curl/curl.h>
37 static gboolean did_glib_init = FALSE;
38 if (did_glib_init) return;
41 /* Initialize glib's type system */
44 /* set up libcurl (this must happen before threading
47 # ifdef G_THREADS_ENABLED
48 g_assert(!g_thread_supported());
50 g_assert(curl_global_init(CURL_GLOBAL_ALL) == 0);
53 /* And set up glib's threads */
54 #if defined(G_THREADS_ENABLED) && !defined(G_THREADS_IMPL_NONE)
55 if (g_thread_supported()) {
61 /* do a version check */
62 #if GLIB_CHECK_VERSION(2,6,0)
64 const char *glib_err = glib_check_version(GLIB_MAJOR_VERSION,
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 */
78 FLAG_STRING_SHORT_NAME,
82 static char ** g_flags_to_strv(int value, GType type, FlagString source);
85 _glib_util_foreach_glue(gpointer data, gpointer func)
87 void (*one_arg_fn)(gpointer) = (void (*)(gpointer))func;
91 GValue* g_value_unset_init(GValue* value, GType type) {
92 g_return_val_if_fail(value != NULL, NULL);
94 if (G_IS_VALUE(value)) {
97 g_value_init(value, type);
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);
105 g_value_unset_init(to, G_VALUE_TYPE(from));
106 g_value_copy(from, to);
110 void g_list_free_full(GList * list) {
113 while (cur != NULL) {
114 gpointer data = cur->data;
116 cur = g_list_next(cur);
122 void g_slist_free_full(GSList * list) {
125 while (cur != NULL) {
126 gpointer data = cur->data;
128 cur = g_slist_next(cur);
134 void g_queue_free_full(GQueue * queue) {
135 while (!g_queue_is_empty(queue)) {
137 data = g_queue_pop_head(queue);
143 void g_ptr_array_free_full(GPtrArray * array) {
146 for (i = 0; i < array->len; i ++) {
147 amfree(g_ptr_array_index(array, i));
149 g_ptr_array_free(array, TRUE);
152 gboolean g_value_compare(GValue * a, GValue * b) {
153 if (a == NULL && b == NULL)
155 if (a == NULL || b == NULL)
157 if (G_VALUE_TYPE(a) != G_VALUE_TYPE(b))
159 if (g_value_fits_pointer(a) && g_value_fits_pointer(b)) {
160 return g_value_peek_pointer(a) == g_value_peek_pointer(b);
162 /* Since there is no builtin comparison function, we resort to
163 comparing serialized strings. Yuck. */
167 a_str = g_strdup_value_contents(a);
168 b_str = g_strdup_value_contents(b);
169 rval = (0 == strcmp(a_str, b_str));
175 g_assert_not_reached();
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);
194 static gboolean g_value_set_int_from_string(GValue * val, char * string) {
195 long int strto_result;
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);
204 g_value_set_int(val, G_MININT);
207 } else if (*string == '\0' || multiplier == 0
208 || strto_result < G_MININT / multiplier
209 || strto_result > G_MAXINT / multiplier) {
212 g_value_set_int(val, (int)(strto_result * multiplier));
217 static gboolean g_value_set_uint_from_string(GValue * val, char * string) {
218 unsigned long int strto_result;
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);
226 } else if (multiplier == 0 || *string == '\0' ||
227 strto_result > G_MAXUINT / multiplier) {
230 g_value_set_uint(val, (guint)(strto_result * multiplier));
235 static gboolean g_value_set_uint64_from_string(GValue * val, char * string) {
236 unsigned long long int strto_result;
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);
244 } else if (multiplier == 0 || *string == '\0' ||
245 strto_result > G_MAXUINT64 / multiplier) {
248 g_value_set_uint64(val, (guint64)(strto_result * multiplier));
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) {
259 char * strtok_saveptr;
261 char * strtok_first_arg;
262 const char delim[] = " \t,|";
263 GFlagsClass * flags_class;
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);
269 /* Don't let strtok stop on original. */
270 strtok_first_arg = string_copy = strdup(string);
273 GFlagsValue * flag_value;
274 char * token = strtok_r(strtok_first_arg, delim, &strtok_saveptr);
275 strtok_first_arg = NULL;
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);
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)));
291 value |= flag_value->value;
297 g_fprintf(stderr, _("No valid flags for type %s in string %s\n"),
298 g_type_name(G_VALUE_TYPE(val)), string);
302 g_value_set_flags(val, value);
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);
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);
325 } else if (G_VALUE_HOLDS_FLAGS(val)) {
326 return g_value_set_flags_from_string(val, string);
337 return strcmp((char *)a, (char *)b);
340 char * g_strjoinv_and_free(char ** strv, const char * seperator) {
341 char * rval = g_strjoinv(seperator, strv);
346 char ** g_flags_name_to_strv(int value, GType type) {
347 return g_flags_to_strv(value, type, FLAG_STRING_NAME);
350 char ** g_flags_short_name_to_strv(int value, GType type) {
351 return g_flags_to_strv(value, type, FLAG_STRING_SHORT_NAME);
354 char ** g_flags_nick_to_strv(int value, GType type) {
355 return g_flags_to_strv(value, type, FLAG_STRING_NICK);
358 static char * get_name_from_value(GFlagsValue * value, FlagString 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);
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;
377 if (notfreed == NULL) {
380 return strdup(notfreed);
382 } else if (notfreed == NULL) {
387 while (*freed_ptr == *notfreed_ptr) {
396 static char ** g_flags_to_strv(int value, GType type,
399 GFlagsValue * flagsvalue;
400 char * common_prefix = NULL;
401 int common_prefix_len;
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);
408 rval = g_ptr_array_new();
409 for (flagsvalue = class->values;
410 flagsvalue->value_name != NULL;
412 if (source == FLAG_STRING_SHORT_NAME) {
413 common_prefix = find_common_prefix(common_prefix,
414 flagsvalue->value_name);
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));
423 if (source == FLAG_STRING_SHORT_NAME && common_prefix != NULL &&
424 ((common_prefix_len = strlen(common_prefix))) > 0) {
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;
436 g_ptr_array_add(rval, NULL);
438 amfree(common_prefix);
439 return (char**)g_ptr_array_free(rval, FALSE);
442 char * g_english_strjoinv(char ** strv, const char * conjunction) {
447 strv = g_strdupv(strv);
449 length = g_strv_length(strv);
452 return stralloc(strv[0]);
454 last = strv[length - 1];
455 strv[length - 1] = NULL;
457 joined = g_strjoinv(", ", strv);
458 rval = g_strdup_printf("%s, %s %s", joined, conjunction, last);
466 char * g_english_strjoinv_and_free(char ** strv, const char * conjunction) {
467 char * rval = g_english_strjoinv(strv, conjunction);
472 #if !(GLIB_CHECK_VERSION(2,6,0))
473 guint g_strv_length(gchar ** strv) {
476 if (G_UNLIKELY(strv == NULL))
479 while (*strv != NULL) {
485 #endif /* GLIB_CHECK_VERSION(2.6.0) */
487 #if !GLIB_CHECK_VERSION(2,4,0)
489 g_ptr_array_foreach (GPtrArray *array,
495 g_return_if_fail (array);
497 for (i = 0; i < array->len; i++)
498 (*func) (array->pdata[i], user_data);
506 /* modified version of glib's hash function, copyright
507 * GLib Team and others 1997-2000. */
509 guint h = g_ascii_toupper(*p);
512 for (p += 1; *p != '\0'; p++)
513 h = (h << 5) - h + g_ascii_toupper(*p);
523 return (0 == g_ascii_strcasecmp((char *)v1, (char *)v2));