diff libpurple/protocols/novell/nmfield.c @ 15373:5fe8042783c1

Rename gtk/ and libgaim/ to pidgin/ and libpurple/

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libpurple/protocols/novell/nmfield.c	Sat Jan 20 02:32:10 2007 +0000
@@ -0,0 +1,366 @@
+/*
+ * nmfield.c
+ *
+ * Copyright (c) 2004 Novell, Inc. All Rights Reserved.
+ *
+ * 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; version 2 of the License.
+ *
+ * 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., 59 Temple Place, Suite 330, Boston, MA	02111-1307	USA
+ *
+ */
+
+#include <string.h>
+#include <stdio.h>
+#include "nmfield.h"
+
+/* Free a field value and tag */
+static void _free_field(NMField * field);
+
+/* Free a field value */
+static void _free_field_value(NMField * field);
+
+/* Make a deep copy of the field */
+static void _copy_field(NMField * dest, NMField * src);
+
+/* Make a deep copy of the field's value */
+static void _copy_field_value(NMField * dest, NMField * src);
+
+/* Create a string from a value -- for debugging */
+static char *_value_to_string(NMField * field);
+
+static NMField *
+_add_blank_field(NMField *fields, guint32 count)
+{
+	guint32 new_len;
+
+	if (fields == NULL) {
+		fields = g_new0(NMField, 10);
+		fields->len = 10;
+	} else {
+		if (fields->len < count + 2) {
+			new_len = count + 10;
+			fields = g_realloc(fields, new_len * sizeof(NMField));
+			fields->len = new_len;
+		}
+	}
+	return fields;
+}
+
+NMField *
+nm_field_add_number(NMField * fields, const char *tag, guint32 size, guint8 method,
+					guint8 flags, guint32 value, guint8 type)
+{
+	guint32 count;
+	NMField *field;
+
+	count = nm_count_fields(fields);
+	fields = _add_blank_field(fields, count);
+
+	field = &(fields[count]);
+	field->tag = g_strdup(tag);
+	field->size = size;
+	field->method = method;
+	field->flags = flags;
+	field->value = value;
+	field->type = type;
+
+	/* Null terminate the field array */
+	field = &((fields)[count + 1]);
+	field->tag = NULL;
+	field->value = 0;
+	field->ptr_value = NULL;
+
+	return fields;
+}
+
+NMField *
+nm_field_add_pointer(NMField * fields, const char *tag, guint32 size, guint8 method,
+					 guint8 flags, gpointer value, guint8 type)
+{
+	guint32 count;
+	NMField *field = NULL;
+
+	count = nm_count_fields(fields);
+	fields = _add_blank_field(fields, count);
+
+	field = &(fields[count]);
+	field->tag = g_strdup(tag);
+	field->size = size;
+	field->method = method;
+	field->flags = flags;
+	field->ptr_value = value;
+	field->type = type;
+
+	/* Null terminate the field array */
+	field = &((fields)[count + 1]);
+	field->tag = NULL;
+	field->value = 0;
+	field->ptr_value = NULL;
+
+	return fields;
+}
+
+guint32
+nm_count_fields(NMField * fields)
+{
+	guint32 count = 0;
+
+	if (fields) {
+		while (fields->tag != NULL) {
+			count++;
+			fields++;
+		}
+	}
+
+	return count;
+}
+
+void
+nm_free_fields(NMField ** fields)
+{
+	NMField *field = NULL;
+
+	if ((fields == NULL) || (*fields == NULL))
+		return;
+
+	field = *fields;
+
+	while (field->tag != NULL) {
+		_free_field(field);
+		field++;
+	}
+
+	g_free(*fields);
+	*fields = NULL;
+}
+
+
+static void
+_free_field(NMField * field)
+{
+	if (field == NULL)
+		return;
+
+	_free_field_value(field);
+	g_free(field->tag);
+}
+
+static void
+_free_field_value(NMField * field)
+{
+	if (field == NULL)
+		return;
+
+	switch (field->type) {
+		case NMFIELD_TYPE_BINARY:
+		case NMFIELD_TYPE_UTF8:
+		case NMFIELD_TYPE_DN:
+			if (field->ptr_value != NULL) {
+				g_free(field->ptr_value);
+			}
+			break;
+
+		case NMFIELD_TYPE_ARRAY:
+		case NMFIELD_TYPE_MV:
+			nm_free_fields((NMField **)&field->ptr_value);
+			break;
+
+		default:
+			break;
+	}
+
+	field->size = 0;
+	field->ptr_value = NULL;
+}
+
+NMField *
+nm_locate_field(char *tag, NMField * fields)
+{
+	NMField *ret_fields = NULL;
+
+	if ((fields == NULL) || (tag == NULL)) {
+		return NULL;
+	}
+
+	while (fields->tag != NULL) {
+		if (g_ascii_strcasecmp(fields->tag, tag) == 0) {
+			ret_fields = fields;
+			break;
+		}
+		fields++;
+	}
+
+	return ret_fields;
+}
+
+NMField *
+nm_copy_field_array(NMField * src)
+{
+	NMField *ptr = NULL;
+	NMField *dest = NULL;
+	int count;
+
+	if (src != NULL) {
+		count = nm_count_fields(src) + 1;
+		dest = g_new0(NMField, count);
+		dest->len = count;
+		ptr = dest;
+		while (src->tag != NULL) {
+			_copy_field(ptr, src);
+			ptr++;
+			src++;
+		}
+	}
+
+	return dest;
+}
+
+static void
+_copy_field(NMField * dest, NMField * src)
+{
+	dest->type = src->type;
+	dest->flags = src->flags;
+	dest->method = src->method;
+	dest->tag = g_strdup(src->tag);
+	_copy_field_value(dest, src);
+}
+
+static void
+_copy_field_value(NMField * dest, NMField * src)
+{
+	dest->type = src->type;
+	switch (dest->type) {
+		case NMFIELD_TYPE_UTF8:
+		case NMFIELD_TYPE_DN:
+			if (src->size == 0 && src->ptr_value != NULL) {
+				src->size = strlen((char *) src->ptr_value) + 1;
+			}
+			/* fall through */
+		case NMFIELD_TYPE_BINARY:
+			if (src->size != 0 && src->ptr_value != NULL) {
+				dest->ptr_value = g_new0(char, src->size);
+				memcpy(dest->ptr_value, src->ptr_value, src->size);
+			}
+			break;
+
+		case NMFIELD_TYPE_ARRAY:
+		case NMFIELD_TYPE_MV:
+			dest->ptr_value = nm_copy_field_array((NMField *)src->ptr_value);
+			break;
+
+		default:
+			/* numeric value */
+			dest->value = src->value;
+			break;
+	}
+
+	dest->size = src->size;
+}
+
+void
+nm_remove_field(NMField * field)
+{
+	NMField *tmp;
+	guint32 len;
+
+	if ((field != NULL) && (field->tag != NULL)) {
+		_free_field(field);
+
+		/* Move fields down */
+		tmp = field + 1;
+		while (1) {
+			/* Don't overwrite the size of the array */
+			len = field->len;
+
+			*field = *tmp;
+
+			field->len = len;
+
+			if (tmp->tag == NULL)
+				break;
+
+			field++;
+			tmp++;
+		}
+	}
+}
+
+void
+nm_print_fields(NMField * fields)
+{
+	char *str = NULL;
+	NMField *field = fields;
+
+	if (fields == NULL)
+		return;
+
+	while (field->tag != NULL) {
+		if (field->type == NMFIELD_TYPE_ARRAY || field->type == NMFIELD_TYPE_MV) {
+			printf("Subarray START: %s Method = %d\n", field->tag, field->method);
+			nm_print_fields((NMField *) field->ptr_value);
+			printf("Subarray END: %s\n", field->tag);
+		} else {
+			str = _value_to_string(field);
+			printf("Tag=%s;Value=%s\n", field->tag, str);
+			g_free(str);
+			str = NULL;
+		}
+		field++;
+	}
+
+}
+
+static char *
+_value_to_string(NMField * field)
+{
+	char *value = NULL;
+
+	if (field == NULL)
+		return NULL;
+
+	/* This is a single value attribute */
+	if (((field->type == NMFIELD_TYPE_UTF8) ||
+		 (field->type == NMFIELD_TYPE_DN)) && (field->ptr_value != NULL)) {
+		value = g_strdup((const char *) field->ptr_value);
+	} else if (field->type == NMFIELD_TYPE_BINARY && field->ptr_value != NULL) {
+		value = g_new0(char, field->size);
+		memcpy(value, (const char *) field->ptr_value, field->size);
+	} else if (field->type == NMFIELD_TYPE_BOOL) {
+		if (field->value) {
+			value = g_strdup(NM_FIELD_TRUE);
+		} else {
+			value = g_strdup(NM_FIELD_FALSE);
+		}
+	} else {
+		/* assume it is a number */
+		value = g_new0(char, 20);
+
+		switch (field->type) {
+		case NMFIELD_TYPE_BYTE:
+		case NMFIELD_TYPE_WORD:
+		case NMFIELD_TYPE_DWORD:
+			value = g_strdup_printf("%ld", (long) field->value);
+			break;
+
+		case NMFIELD_TYPE_UBYTE:
+		case NMFIELD_TYPE_UWORD:
+		case NMFIELD_TYPE_UDWORD:
+			value = g_strdup_printf("%lu", (unsigned long) field->value);
+			break;
+		}
+	}
+
+	if (value == NULL)
+		value = g_strdup("NULL");
+
+	return value;
+}