/* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- */

/*

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library 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

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

 * Boston, MA 02110-1301 USA.

 *

 * Copyright (C) 2009 Novell, Inc.

 * Author: Tambet Ingo (tambet@gmail.com).

 *

 * Copyright (C) 2009 - 2012 Red Hat, Inc.

 * Copyright (C) 2012 Lanedo GmbH

 */

#include "nm-default.h"

#include <string.h>

#include <errno.h>

#include <stdlib.h>

#include "nm-mobile-providers.h"

#define ISO_3166_COUNTRY_CODES ISO_CODES_PREFIX"/share/xml/iso-codes/iso_3166.xml"

#define ISO_CODES_LOCALESDIR ISO_CODES_PREFIX"/share/locale"

/******************************************************************************/

/* Access method type */

G_DEFINE_BOXED_TYPE (NMAMobileAccessMethod,

                     nma_mobile_access_method,

                     nma_mobile_access_method_ref,

                     nma_mobile_access_method_unref)

struct _NMAMobileAccessMethod {

	volatile gint refs;

	char *name;

	/* maps lang (char *) -> name (char *) */

	GHashTable *lcl_names;

	char *username;

	char *password;

	char *gateway;

	GPtrArray *dns; /* GPtrArray of 'char *' */

	/* Only used with 3GPP family type providers */

	char *apn;

	NMAMobileFamily family;

};

static NMAMobileAccessMethod *

access_method_new (void)

{

	NMAMobileAccessMethod *method;

	method = g_slice_new0 (NMAMobileAccessMethod);

	method->refs = 1;

	method->lcl_names = g_hash_table_new_full (g_str_hash, g_str_equal,

	                                           (GDestroyNotify) g_free,

	                                           (GDestroyNotify) g_free);

	return method;

}

NMAMobileAccessMethod *

nma_mobile_access_method_ref (NMAMobileAccessMethod *method)

{

	g_return_val_if_fail (method != NULL, NULL);

	g_return_val_if_fail (method->refs > 0, NULL);

	g_atomic_int_inc (&method->refs);

	return method;

}

void

nma_mobile_access_method_unref (NMAMobileAccessMethod *method)

{

	g_return_if_fail (method != NULL);

	g_return_if_fail (method->refs > 0);

	if (g_atomic_int_dec_and_test (&method->refs)) {

		g_free (method->name);

		g_hash_table_destroy (method->lcl_names);

		g_free (method->username);

		g_free (method->password);

		g_free (method->gateway);

		g_free (method->apn);

		if (method->dns)

			g_ptr_array_unref (method->dns);

		g_slice_free (NMAMobileAccessMethod, method);

	}

}

/**

 * nma_mobile_access_method_get_name:

 *

 * Returns: (transfer none): the name of the method.

 */

const gchar *

nma_mobile_access_method_get_name (NMAMobileAccessMethod *method)

{

	g_return_val_if_fail (method != NULL, NULL);

	return method->name;

}

/**

 * nma_mobile_access_method_get_username:

 *

 * Returns: (transfer none): the username.

 */

const gchar *

nma_mobile_access_method_get_username (NMAMobileAccessMethod *method)

{

	g_return_val_if_fail (method != NULL, NULL);

	return method->username;

}

/**

 * nma_mobile_access_method_get_password:

 *

 * Returns: (transfer none): the password.

 */

const gchar *

nma_mobile_access_method_get_password (NMAMobileAccessMethod *method)

{

	g_return_val_if_fail (method != NULL, NULL);

	return method->password;

}

/**

 * nma_mobile_access_method_get_gateway:

 *

 * Returns: (transfer none): the gateway.

 */

const gchar *

nma_mobile_access_method_get_gateway (NMAMobileAccessMethod *method)

{

	g_return_val_if_fail (method != NULL, NULL);

	return method->gateway;

}

/**

 * nma_mobile_access_method_get_dns:

 *

 * Returns: (transfer none) (array zero-terminated=1) (element-type utf8): the list of DNS.

 */

const gchar **

nma_mobile_access_method_get_dns (NMAMobileAccessMethod *method)

{

	g_return_val_if_fail (method != NULL, NULL);

	return method->dns ? (const gchar **)method->dns->pdata : NULL;

}

/**

 * nma_mobile_access_method_get_3gpp_apn:

 *

 * Returns: (transfer none): the 3GPP APN.

 */

const gchar *

nma_mobile_access_method_get_3gpp_apn (NMAMobileAccessMethod *method)

{

	g_return_val_if_fail (method != NULL, NULL);

	return method->apn;

}

/**

 * nma_mobile_access_method_get_family:

 *

 * Returns: a #NMAMobileFamily.

 */

NMAMobileFamily

nma_mobile_access_method_get_family (NMAMobileAccessMethod *method)

{

	g_return_val_if_fail (method != NULL, NMA_MOBILE_FAMILY_UNKNOWN);

	return method->family;

}

/******************************************************************************/

/* Mobile provider type */

G_DEFINE_BOXED_TYPE (NMAMobileProvider,

                     nma_mobile_provider,

                     nma_mobile_provider_ref,

                     nma_mobile_provider_unref)

struct _NMAMobileProvider {

	volatile gint refs;

	char *name;

	/* maps lang (char *) -> name (char *) */

	GHashTable *lcl_names;

	GSList *methods; /* GSList of NmaMobileAccessMethod */

	GPtrArray *mcc_mnc;  /* GPtrArray of strings */

	GArray *cdma_sid; /* GArray of guint32 */

};

static NMAMobileProvider *

provider_new (void)

{

	NMAMobileProvider *provider;

	provider = g_slice_new0 (NMAMobileProvider);

	provider->refs = 1;

	provider->lcl_names = g_hash_table_new_full (g_str_hash, g_str_equal,

	                                             (GDestroyNotify) g_free,

	                                             (GDestroyNotify) g_free);

	return provider;

}

NMAMobileProvider *

nma_mobile_provider_ref (NMAMobileProvider *provider)

{

	g_return_val_if_fail (provider != NULL, NULL);

	g_return_val_if_fail (provider->refs > 0, NULL);

	g_atomic_int_inc (&provider->refs);

	return provider;

}

void

nma_mobile_provider_unref (NMAMobileProvider *provider)

{

	if (g_atomic_int_dec_and_test (&provider->refs)) {

		g_free (provider->name);

		g_hash_table_destroy (provider->lcl_names);

		g_slist_free_full (provider->methods, (GDestroyNotify) nma_mobile_access_method_unref);

		if (provider->mcc_mnc)

			g_ptr_array_unref (provider->mcc_mnc);

		if (provider->cdma_sid)

			g_array_unref (provider->cdma_sid);

		g_slice_free (NMAMobileProvider, provider);

	}

}

/**

 * nma_mobile_provider_get_name:

 *

 * Returns: (transfer none): the name of the provider.

 */

const gchar *

nma_mobile_provider_get_name (NMAMobileProvider *provider)

{

	g_return_val_if_fail (provider != NULL, NULL);

	return provider->name;

}

/**

 * nma_mobile_provider_get_methods:

 * @provider: a #NMAMobileProvider

 *

 * Returns: (element-type NMGtk.MobileAccessMethod) (transfer none): the

 *	 list of #NMAMobileAccessMethod this provider exposes.

 */

GSList *

nma_mobile_provider_get_methods (NMAMobileProvider *provider)

{

	g_return_val_if_fail (provider != NULL, NULL);

	return provider->methods;

}

/**

 * nma_mobile_provider_get_3gpp_mcc_mnc:

 * @provider: a #NMAMobileProvider

 *

 * Returns: (transfer none) (array zero-terminated=1) (element-type utf8): a

 *	 list of strings with the MCC and MNC codes this provider exposes.

 */

const gchar **

nma_mobile_provider_get_3gpp_mcc_mnc (NMAMobileProvider *provider)

{

	g_return_val_if_fail (provider != NULL, NULL);

	return provider->mcc_mnc ? (const gchar **)provider->mcc_mnc->pdata : NULL;

}

/**

 * nma_mobile_provider_get_cdma_sid:

 * @provider: a #NMAMobileProvider

 *

 * Returns: (transfer none) (array zero-terminated=1) (element-type guint32): the

 *	 list of CDMA SIDs this provider exposes

 */

const guint32 *

nma_mobile_provider_get_cdma_sid (NMAMobileProvider *provider)

{

	g_return_val_if_fail (provider != NULL, NULL);

	return provider->cdma_sid ? (const guint32 *)provider->cdma_sid->data : NULL;

}

/******************************************************************************/

/* Country Info type */

G_DEFINE_BOXED_TYPE (NMACountryInfo,

                     nma_country_info,

                     nma_country_info_ref,

                     nma_country_info_unref)

struct _NMACountryInfo {

	volatile gint refs;

	char *country_code;

	char *country_name;

	GSList *providers;

};

static NMACountryInfo *

country_info_new (const char *country_code,

                  const gchar *country_name)

{

	NMACountryInfo *country_info;

	country_info = g_slice_new0 (NMACountryInfo);

	country_info->refs = 1;

	country_info->country_code = g_strdup (country_code);

	country_info->country_name = g_strdup (country_name);

	return country_info;

}

NMACountryInfo *

nma_country_info_ref (NMACountryInfo *country_info)

{

	g_return_val_if_fail (country_info != NULL, NULL);

	g_return_val_if_fail (country_info->refs > 0, NULL);

	g_atomic_int_inc (&country_info->refs);

	return country_info;

}

void

nma_country_info_unref (NMACountryInfo *country_info)

{

	if (g_atomic_int_dec_and_test (&country_info->refs)) {

		g_free (country_info->country_code);

		g_free (country_info->country_name);

		g_slist_free_full (country_info->providers,

		                   (GDestroyNotify) nma_mobile_provider_unref);

		g_slice_free (NMACountryInfo, country_info);

	}

}

/**

 * nma_country_info_get_country_code:

 *

 * Returns: (transfer none): the code of the country.

 */

const gchar *

nma_country_info_get_country_code (NMACountryInfo *country_info)

{

	g_return_val_if_fail (country_info != NULL, NULL);

	return country_info->country_code;

}

/**

 * nma_country_info_get_country_name:

 *

 * Returns: (transfer none): the name of the country.

 */

const gchar *

nma_country_info_get_country_name (NMACountryInfo *country_info)

{

	g_return_val_if_fail (country_info != NULL, NULL);

	return country_info->country_name;

}

/**

 * nma_country_info_get_providers:

 *

 * Returns: (element-type NMGtk.MobileProvider) (transfer none): the

 *	 list of #NMAMobileProvider this country exposes.

 */

GSList *

nma_country_info_get_providers (NMACountryInfo *country_info)

{

	g_return_val_if_fail (country_info != NULL, NULL);

	return country_info->providers;

}

/******************************************************************************/

/* XML Parser for iso_3166.xml */

static void

iso_3166_parser_start_element (GMarkupParseContext *context,

                               const gchar *element_name,

                               const gchar **attribute_names,

                               const gchar **attribute_values,

                               gpointer data,

                               GError **error)

{

	int i;

	const char *country_code = NULL;

	const char *common_name = NULL;

	const char *name = NULL;

	GHashTable *table = (GHashTable *) data;

	if (!strcmp (element_name, "iso_3166_entry")) {

		NMACountryInfo *country_info;

		for (i = 0; attribute_names && attribute_names[i]; i++) {

			if (!strcmp (attribute_names[i], "alpha_2_code"))

				country_code = attribute_values[i];

			else if (!strcmp (attribute_names[i], "common_name"))

				common_name = attribute_values[i];

			else if (!strcmp (attribute_names[i], "name"))

				name = attribute_values[i];

		}

		if (!country_code) {

			g_warning ("%s: missing mandatory 'alpha_2_code' atribute in '%s'"

			           " element.", __func__, element_name);

			return;

		}

		if (!name) {

			g_warning ("%s: missing mandatory 'name' atribute in '%s'"

			           " element.", __func__, element_name);

			return;

		}

		country_info = country_info_new (country_code,

		                                 dgettext ("iso_3166", common_name ? common_name : name));

		g_hash_table_insert (table, g_strdup (country_code), country_info);

	}

}

static const GMarkupParser iso_3166_parser = {

	iso_3166_parser_start_element,

	NULL, /* end element */

	NULL, /* text */

	NULL, /* passthrough */

	NULL  /* error */

};

static GHashTable *

read_country_codes (const gchar *country_codes_file,

                    GCancellable *cancellable,

                    GError **error)

{

	GHashTable *table = NULL;

	GMarkupParseContext *ctx;

	char *buf;

	gsize buf_len;

	/* Set domain to iso_3166 for country name translation */

	bindtextdomain ("iso_3166", ISO_CODES_LOCALESDIR);

	bind_textdomain_codeset ("iso_3166", "UTF-8");

	if (!g_file_get_contents (country_codes_file, &buf, &buf_len, error)) {

		g_prefix_error (error,

		                "Failed to load '%s' from 'iso-codes': ",

		                country_codes_file);

		return NULL;

	}

	table = g_hash_table_new_full (g_str_hash,

	                               g_str_equal,

	                               g_free,

	                               (GDestroyNotify)nma_country_info_unref);

	ctx = g_markup_parse_context_new (&iso_3166_parser, 0, table, NULL);

	if (!g_markup_parse_context_parse (ctx, buf, buf_len, error)) {

		g_prefix_error (error,

		                "Failed to parse '%s' from 'iso-codes': ",

		                country_codes_file);

		g_hash_table_destroy (table);

		return NULL;

	}

	g_markup_parse_context_free (ctx);

	g_free (buf);

	return table;

}

/******************************************************************************/

/* XML Parser for serviceproviders.xml */

typedef enum {

	PARSER_TOPLEVEL = 0,

	PARSER_COUNTRY,

	PARSER_PROVIDER,

	PARSER_METHOD_GSM,

	PARSER_METHOD_GSM_APN,

	PARSER_METHOD_CDMA,

	PARSER_ERROR

} MobileContextState;

typedef struct {

	GHashTable *table;

	char *current_country;

	GSList *current_providers;

	NMAMobileProvider *current_provider;

	NMAMobileAccessMethod *current_method;

	char *text_buffer;

	MobileContextState state;

} MobileParser;

static void

provider_list_free (gpointer data)

{

	GSList *list = (GSList *) data;

	while (list) {

		nma_mobile_provider_unref ((NMAMobileProvider *) list->data);

		list = g_slist_delete_link (list, list);

	}

}

static void

parser_toplevel_start (MobileParser *parser,

                       const char *name,

                       const char **attribute_names,

                       const char **attribute_values)

{

	int i;

	if (!strcmp (name, "serviceproviders")) {

		for (i = 0; attribute_names && attribute_names[i]; i++) {

			if (!strcmp (attribute_names[i], "format")) {

				if (strcmp (attribute_values[i], "2.0")) {

					g_warning ("%s: mobile broadband provider database format '%s'"

					           " not supported.", __func__, attribute_values[i]);

					parser->state = PARSER_ERROR;

					break;

				}

			}

		}

	} else if (!strcmp (name, "country")) {

		for (i = 0; attribute_names && attribute_names[i]; i++) {

			if (!strcmp (attribute_names[i], "code")) {

				char *country_code;

				NMACountryInfo *country_info;

				country_code = g_ascii_strup (attribute_values[i], -1);

				country_info = g_hash_table_lookup (parser->table, country_code);

				/* Ensure we have a country provider for this country code */

				if (!country_info) {

					g_warning ("%s: adding providers for unknown country '%s'", __func__, country_code);

					country_info = country_info_new (country_code, NULL);

					g_hash_table_insert (parser->table, country_code, country_info);

				}

				parser->current_country = country_code;

				parser->state = PARSER_COUNTRY;

				break;

			}

		}

	}

}

static void

parser_country_start (MobileParser *parser,

                      const char *name,

                      const char **attribute_names,

                      const char **attribute_values)

{

	if (!strcmp (name, "provider")) {

		parser->state = PARSER_PROVIDER;

		parser->current_provider = provider_new ();

	}

}

static void

parser_provider_start (MobileParser *parser,

                       const char *name,

                       const char **attribute_names,

                       const char **attribute_values)

{

	if (!strcmp (name, "gsm"))

		parser->state = PARSER_METHOD_GSM;

	else if (!strcmp (name, "cdma")) {

		parser->state = PARSER_METHOD_CDMA;

		parser->current_method = access_method_new ();

	}

}

static void

parser_gsm_start (MobileParser *parser,

                  const char *name,

                  const char **attribute_names,

                  const char **attribute_values)

{

	if (!strcmp (name, "network-id")) {

		const char *mcc = NULL, *mnc = NULL;

		int i;

		for (i = 0; attribute_names && attribute_names[i]; i++) {

			if (!strcmp (attribute_names[i], "mcc"))

				mcc = attribute_values[i];

			else if (!strcmp (attribute_names[i], "mnc"))

				mnc = attribute_values[i];

			if (mcc && strlen (mcc) && mnc && strlen (mnc)) {

				gchar *mccmnc;

				if (!parser->current_provider->mcc_mnc)

					parser->current_provider->mcc_mnc = g_ptr_array_new_full (2, g_free);

				mccmnc = g_strdup_printf ("%s%s", mcc, mnc);

				g_ptr_array_add (parser->current_provider->mcc_mnc, mccmnc);

				break;

			}

		}

	} else if (!strcmp (name, "apn")) {

		int i;

		for (i = 0; attribute_names && attribute_names[i]; i++) {

			if (!strcmp (attribute_names[i], "value")) {

				parser->state = PARSER_METHOD_GSM_APN;

				parser->current_method = access_method_new ();

				parser->current_method->apn = g_strstrip (g_strdup (attribute_values[i]));

				break;

			}

		}

	}

}

static void

parser_cdma_start (MobileParser *parser,

                   const char *name,

                   const char **attribute_names,

                   const char **attribute_values)

{

	if (!strcmp (name, "sid")) {

		int i;

		for (i = 0; attribute_names && attribute_names[i]; i++) {

			if (!strcmp (attribute_names[i], "value")) {

				guint32 tmp;

				errno = 0;

				tmp = (guint32) strtoul (attribute_values[i], NULL, 10);

				if (errno == 0 && tmp > 0) {

					if (!parser->current_provider->cdma_sid)

						parser->current_provider->cdma_sid = g_array_sized_new (TRUE, FALSE, sizeof (guint32), 2);

					g_array_append_val (parser->current_provider->cdma_sid, tmp);

				}

				break;

			}

		}

	}

}

static void

mobile_parser_start_element (GMarkupParseContext *context,

                             const gchar *element_name,

                             const gchar **attribute_names,

                             const gchar **attribute_values,

                             gpointer data,

                             GError **error)

{

	MobileParser *parser = (MobileParser *) data;

	if (parser->text_buffer) {

		g_free (parser->text_buffer);

		parser->text_buffer = NULL;

	}

	switch (parser->state) {

	case PARSER_TOPLEVEL:

		parser_toplevel_start (parser, element_name, attribute_names, attribute_values);

		break;

	case PARSER_COUNTRY:

		parser_country_start (parser, element_name, attribute_names, attribute_values);

		break;

	case PARSER_PROVIDER:

		parser_provider_start (parser, element_name, attribute_names, attribute_values);

		break;

	case PARSER_METHOD_GSM:

		parser_gsm_start (parser, element_name, attribute_names, attribute_values);

		break;

	case PARSER_METHOD_CDMA:

		parser_cdma_start (parser, element_name, attribute_names, attribute_values);

		break;

	default:

		break;

	}

}

static void

parser_country_end (MobileParser *parser,

                    const char *name)

{

	if (!strcmp (name, "country")) {

		NMACountryInfo *country_info;

		country_info = g_hash_table_lookup (parser->table, parser->current_country);

		g_assert (country_info);

		/* Store providers for this country */

		country_info->providers = parser->current_providers;

		g_free (parser->current_country);

		parser->current_country = NULL;

		parser->current_providers = NULL;

		g_free (parser->text_buffer);

		parser->text_buffer = NULL;

		parser->state = PARSER_TOPLEVEL;

	}

}

static void

parser_provider_end (MobileParser *parser,

                     const char *name)

{

	if (!strcmp (name, "name")) {

		if (!parser->current_provider->name) {

			/* Use the first one. */

			parser->current_provider->name = parser->text_buffer;

			parser->text_buffer = NULL;

		}

	} else if (!strcmp (name, "provider")) {

		if (parser->current_provider->mcc_mnc)

			g_ptr_array_add (parser->current_provider->mcc_mnc, NULL);

		parser->current_provider->methods = g_slist_reverse (parser->current_provider->methods);

		parser->current_providers = g_slist_prepend (parser->current_providers, parser->current_provider);

		parser->current_provider = NULL;

		g_free (parser->text_buffer);

		parser->text_buffer = NULL;

		parser->state = PARSER_COUNTRY;

	}

}

static void

parser_gsm_end (MobileParser *parser,

                const char *name)

{

	if (!strcmp (name, "gsm")) {

		g_free (parser->text_buffer);

		parser->text_buffer = NULL;

		parser->state = PARSER_PROVIDER;

	}

}

static void

parser_gsm_apn_end (MobileParser *parser,

                    const char *name)

{

	if (!strcmp (name, "name")) {

		if (!parser->current_method->name) {

			/* Use the first one. */

			parser->current_method->name = parser->text_buffer;

			parser->text_buffer = NULL;

		}

	} else if (!strcmp (name, "username")) {

		parser->current_method->username = parser->text_buffer;

		parser->text_buffer = NULL;

	} else if (!strcmp (name, "password")) {

		parser->current_method->password = parser->text_buffer;

		parser->text_buffer = NULL;

	} else if (!strcmp (name, "dns")) {

		if (!parser->current_method->dns)

			parser->current_method->dns = g_ptr_array_new_full (2, g_free);

		g_ptr_array_add (parser->current_method->dns, parser->text_buffer);

		parser->text_buffer = NULL;

	} else if (!strcmp (name, "gateway")) {

		parser->current_method->gateway = parser->text_buffer;

		parser->text_buffer = NULL;

	} else if (!strcmp (name, "apn")) {

		parser->current_method->family = NMA_MOBILE_FAMILY_3GPP;

		if (!parser->current_method->name)

			parser->current_method->name = g_strdup (_("Default"));

		if (parser->current_method->dns)

			g_ptr_array_add (parser->current_method->dns, NULL);

		parser->current_provider->methods = g_slist_prepend (parser->current_provider->methods,

		                                                     parser->current_method);

		parser->current_method = NULL;

		g_free (parser->text_buffer);

		parser->text_buffer = NULL;

		parser->state = PARSER_METHOD_GSM;

	}

}

static void

parser_cdma_end (MobileParser *parser,

                 const char *name)

{

	if (!strcmp (name, "username")) {

		parser->current_method->username = parser->text_buffer;

		parser->text_buffer = NULL;

	} else if (!strcmp (name, "password")) {

		parser->current_method->password = parser->text_buffer;

		parser->text_buffer = NULL;

	} else if (!strcmp (name, "dns")) {

		if (!parser->current_method->dns)

			parser->current_method->dns = g_ptr_array_new_full (2, g_free);

		g_ptr_array_add (parser->current_method->dns, parser->text_buffer);

		parser->text_buffer = NULL;

	} else if (!strcmp (name, "gateway")) {

		parser->current_method->gateway = parser->text_buffer;

		parser->text_buffer = NULL;

	} else if (!strcmp (name, "cdma")) {

		parser->current_method->family = NMA_MOBILE_FAMILY_CDMA;

		if (!parser->current_method->name)

			parser->current_method->name = g_strdup (parser->current_provider->name);

		if (parser->current_method->dns)

			g_ptr_array_add (parser->current_method->dns, NULL);

		parser->current_provider->methods = g_slist_prepend (parser->current_provider->methods,

		                                                     parser->current_method);

		parser->current_method = NULL;

		g_free (parser->text_buffer);

		parser->text_buffer = NULL;

		parser->state = PARSER_PROVIDER;

	}

}

static void

mobile_parser_end_element (GMarkupParseContext *context,

                           const gchar *element_name,

                           gpointer data,

                           GError **error)

{

	MobileParser *parser = (MobileParser *) data;

	switch (parser->state) {

	case PARSER_COUNTRY:

		parser_country_end (parser, element_name);

		break;

	case PARSER_PROVIDER:

		parser_provider_end (parser, element_name);

		break;

	case PARSER_METHOD_GSM:

		parser_gsm_end (parser, element_name);

		break;

	case PARSER_METHOD_GSM_APN:

		parser_gsm_apn_end (parser, element_name);

		break;

	case PARSER_METHOD_CDMA:

		parser_cdma_end (parser, element_name);

		break;

	default:

		break;

	}

}

static void