/*
 *
 *  Connection Manager
 *
 *  Copyright (C) 2007-2013  Intel Corporation. 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 version 2 as
 *  published by the Free Software Foundation.
 *
 *  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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <errno.h>
#include <stdlib.h>

#include <gweb/gweb.h>

#include "connman.h"

#define STATUS_URL_IPV4  "http://ipv4.connman.net/online/status.html"
#define STATUS_URL_IPV6  "http://ipv6.connman.net/online/status.html"

#define STATUS_URL_GOOGLE  "http://clients3.google.com/generate_204"

struct connman_wispr_message {
	bool has_error;
	const char *current_element;
	int message_type;
	int response_code;
	char *login_url;
	char *abort_login_url;
	char *logoff_url;
	char *access_procedure;
	char *access_location;
	char *location_name;
};

enum connman_wispr_result {
	CONNMAN_WISPR_RESULT_UNKNOWN = 0,
	CONNMAN_WISPR_RESULT_LOGIN   = 1,
	CONNMAN_WISPR_RESULT_ONLINE  = 2,
	CONNMAN_WISPR_RESULT_FAILED  = 3,
};

struct wispr_route {
	char *address;
	int if_index;
};

struct connman_wispr_portal_context {
	struct connman_service *service;
	enum connman_ipconfig_type type;
	struct connman_wispr_portal *wispr_portal;

	/* Portal/WISPr common */
	GWeb *web;
	unsigned int token;
	guint request_id;

	const char *status_url;

	char *redirect_url;

	/* WISPr specific */
	GWebParser *wispr_parser;
	struct connman_wispr_message wispr_msg;

	char *wispr_username;
	char *wispr_password;
	char *wispr_formdata;

	enum connman_wispr_result wispr_result;

	GSList *route_list;

	guint timeout;
	guint oc_timeout; /* online check timeout */
	enum connman_wispr_server wispr_server;
	GWebResultFunc wispr_result_func;
};

struct connman_wispr_portal {
	struct connman_wispr_portal_context *ipv4_context;
	struct connman_wispr_portal_context *ipv6_context;
};

static bool wispr_portal_web_result_connman(GWebResult *result, gpointer user_data);
static bool wispr_portal_web_result_google(GWebResult *result, gpointer user_data);
static int wispr_portal_detect(struct connman_wispr_portal_context *wp_context);
static gboolean wispr_schedule_pendings(gpointer user_data);

static GHashTable *wispr_portal_list = NULL;
GSList *wispr_pending=NULL;
guint wispr_pending_timeout=0;


static void connman_wispr_message_init(struct connman_wispr_message *msg)
{
	DBG("");

	msg->has_error = false;
	msg->current_element = NULL;

	msg->message_type = -1;
	msg->response_code = -1;

	g_free(msg->login_url);
	msg->login_url = NULL;

	g_free(msg->abort_login_url);
	msg->abort_login_url = NULL;

	g_free(msg->logoff_url);
	msg->logoff_url = NULL;

	g_free(msg->access_procedure);
	msg->access_procedure = NULL;

	g_free(msg->access_location);
	msg->access_location = NULL;

	g_free(msg->location_name);
	msg->location_name = NULL;
}

static void free_wispr_routes(struct connman_wispr_portal_context *wp_context)
{
	while (wp_context->route_list) {
		struct wispr_route *route = wp_context->route_list->data;

		DBG("free route to %s if %d type %d", route->address,
				route->if_index, wp_context->type);

		switch (wp_context->type) {
		case CONNMAN_IPCONFIG_TYPE_IPV4:
			connman_inet_del_host_route(route->if_index,
					route->address);
			break;
		case CONNMAN_IPCONFIG_TYPE_IPV6:
			connman_inet_del_ipv6_host_route(route->if_index,
					route->address);
			break;
		case CONNMAN_IPCONFIG_TYPE_UNKNOWN:
		case CONNMAN_IPCONFIG_TYPE_ALL:
			break;
		}

		g_free(route->address);
		g_free(route);

		wp_context->route_list =
			g_slist_delete_link(wp_context->route_list,
					wp_context->route_list);
	}
}

#define ONLINE_CHECK_MAX_SECONDS 10

static void free_connman_wispr_portal_context(
		struct connman_wispr_portal_context *wp_context)
{
	DBG("context %p", wp_context);

	if (!wp_context)
		return;

	if (wp_context->wispr_portal) {
		if (wp_context->wispr_portal->ipv4_context == wp_context)
			wp_context->wispr_portal->ipv4_context = NULL;

		if (wp_context->wispr_portal->ipv6_context == wp_context)
			wp_context->wispr_portal->ipv6_context = NULL;
	}

	if (wp_context->token > 0)
		connman_proxy_lookup_cancel(wp_context->token);

	if (wp_context->request_id > 0)
		g_web_cancel_request(wp_context->web, wp_context->request_id);

	if (wp_context->timeout > 0)
		g_source_remove(wp_context->timeout);

	if (wp_context->oc_timeout > 0)
		g_source_remove(wp_context->oc_timeout);

	if (wp_context->web)
		g_web_unref(wp_context->web);

	g_free(wp_context->redirect_url);

	if (wp_context->wispr_parser)
		g_web_parser_unref(wp_context->wispr_parser);

	connman_wispr_message_init(&wp_context->wispr_msg);

	g_free(wp_context->wispr_username);
	g_free(wp_context->wispr_password);
	g_free(wp_context->wispr_formdata);

	free_wispr_routes(wp_context);

	g_free(wp_context);
}

static struct connman_wispr_portal_context *create_wispr_portal_context(void)
{
	return g_try_new0(struct connman_wispr_portal_context, 1);
}

static void wispr_stop(
		struct connman_wispr_portal_context *wp_context,
		int check_result, bool retry_pending)
{
	struct connman_service *service;
	enum connman_ipconfig_type type;

	DBG("context %p", wp_context);

	if (!wp_context)
		return;

	service = wp_context->service;
	type = wp_context->type;

	free_connman_wispr_portal_context(wp_context);

	if (((check_result == ONLINE_CHECK_FAIL) || (check_result == ONLINE_CHECK_DNS_FAIL)) &&
		(__connman_service_ipconfig_get_state(service, type) == CONNMAN_SERVICE_STATE_ONLINE)) {
		/* old state is online, but check failed */
		__connman_service_ipconfig_indicate_state(service, CONNMAN_SERVICE_STATE_READY, type);
	}

	if (check_result != ONLINE_CHECK_NO_RESULT) {
		__connman_service_online_check_stopped(service, wp_context, type, check_result);
	} else {
		OC_PRINT("check for context %p will use future result", wp_context);
	}

	if (retry_pending && wispr_pending) {
		DBG("setup timer to retry pending checks");
		if (wispr_pending_timeout)
			g_source_remove(wispr_pending_timeout);
		wispr_pending_timeout = g_timeout_add_seconds(0, wispr_schedule_pendings, NULL);
	}
}

/*
	Online check is independent of what default routing is set to. The independency is done by inserting
	one 	specific routing entry for the pair of target server ip address and routing interface. But if there are
	two simultaneous requests on different interface and check same online server. They will try to
	insert two routing entries with same destination ip. It will be a race which leads to unreliable check
	results. This check here is to guarantee there is only one request at a time for specific type (ipv4 vs ipv6)
	per interface.
*/
static bool wispr_allow_check(struct connman_wispr_portal *wispr_portal, enum connman_ipconfig_type type)
{
	GHashTableIter iter;
	gpointer key, value;

	DBG("wispr_portal %p", wispr_portal);

	g_hash_table_iter_init(&iter, wispr_portal_list);

	while (g_hash_table_iter_next(&iter, &key, &value)) {
		struct connman_wispr_portal *portal = value;

		/* Allow multiple checks on same interface */
		if (wispr_portal == portal)
			continue;

		if (((type == CONNMAN_IPCONFIG_TYPE_IPV4) && portal->ipv4_context) ||
			((type == CONNMAN_IPCONFIG_TYPE_IPV6) && portal->ipv6_context))
			return false;
	}

	return true;
}

static gboolean wispr_oc_timeout(gpointer user_data)
{
	struct connman_wispr_portal_context *wp_context = user_data;

	DBG("wp_context %p", wp_context);

	if (!wp_context)
		return false;

	wp_context->timeout = 0;

	wispr_stop(wp_context, ONLINE_CHECK_FAIL, true);

	return false;
}

static int wispr_start(struct connman_wispr_portal_context *wp_context, bool queue_only)
{
	DBG("wp_context %p", wp_context);

	if (!wp_context)
		return -ENOMEM;

	/* check if other interfaces are checking same type now */
	if (queue_only || !wispr_allow_check(wp_context->wispr_portal, wp_context->type)) {
		DBG("%s, put (%p %d) in pending queue", queue_only ? "Queue only" : "Cannot issue check now",
			wp_context->service, wp_context->type);
		connman_service_ref(wp_context->service);
		wispr_pending = g_slist_append(wispr_pending, wp_context);
		return 0;
	}

	/* If there is already an existing context, we wipe this new request */
	if (wp_context->type == CONNMAN_IPCONFIG_TYPE_IPV4) {
		if (wp_context->wispr_portal->ipv4_context) {
			OC_PRINT("new ipv4 check context %p, ongoing %p",
				wp_context, wp_context->wispr_portal->ipv4_context);
			return -EALREADY;
		}
		wp_context->wispr_portal->ipv4_context = wp_context;
	} else if (wp_context->type == CONNMAN_IPCONFIG_TYPE_IPV6) {
		if (wp_context->wispr_portal->ipv6_context) {
			OC_PRINT("new ipv6 check context %p, ongoing %p",
				wp_context, wp_context->wispr_portal->ipv6_context);
			return -EALREADY;
		}
		wp_context->wispr_portal->ipv6_context = wp_context;
	} else {
		OC_PRINT("invalid type %d", wp_context->type);
		return -EINVAL;
	}

	__connman_service_online_check_started(wp_context->service, wp_context, wp_context->type);

	if (wp_context->oc_timeout) {
		OC_PRINT("Ongoing check???");
		g_source_remove(wp_context->oc_timeout);
	}
	wp_context->oc_timeout = g_timeout_add_seconds(ONLINE_CHECK_MAX_SECONDS, wispr_oc_timeout, wp_context);

	return wispr_portal_detect(wp_context);
}

static gboolean wispr_schedule_pendings(gpointer user_data)
{
	GSList *last_list = NULL, *list;

	DBG("wispr_pending %p", wispr_pending);

	wispr_pending_timeout = 0;

	if (!wispr_pending)
		return false;

	last_list = g_slist_last(wispr_pending);
	while ((list = wispr_pending)) {
		struct connman_wispr_portal_context *context = list->data;

		if (context) {
			bool free_wp_context = true;
			int refcount = -1, check_result = ONLINE_CHECK_FAIL;
			if (context->service) {
				refcount = __connman_service_get_refcount(context->service) - 1;
				connman_service_unref(context->service);
				if (refcount > 0) {
					int ret = wispr_start(context, false);
					if (ret == 0)
						free_wp_context = false;
					else if (ret == -EALREADY)
						check_result = ONLINE_CHECK_NO_RESULT; // silent free context without notifying calller
				}
			}
			if (free_wp_context) {
				DBG("service %p, refcount %d, free context %p check_result %d",
					context->service, refcount, context, check_result);
				wispr_stop(context, check_result, false);
			}
		}

		wispr_pending = g_slist_delete_link(wispr_pending, list);

		if (list == last_list)
			break;
	}

	DBG("retry done");

	return false;
}

static void wispr_cleanup_pendings(gpointer user_data)
{
	GSList *next_list, *list;
	struct connman_service *service = (struct connman_service *)user_data;

	DBG("wispr_pending %p", wispr_pending);

	list = wispr_pending;
	while (list) {
		struct connman_wispr_portal_context *context = list->data;
		bool delete_list = false;

		next_list = g_slist_next(list);

		if (context) {
			if (!service || (service == context->service)) {
				if (context->service)
					connman_service_unref(context->service);
				wispr_stop(context, ONLINE_CHECK_FAIL, false);
				delete_list = true;
			}
		} else {
			delete_list = true;
		}

		if (delete_list)
			wispr_pending = g_slist_delete_link(wispr_pending, list);

		list = next_list;
	}

	DBG("remove done");
}

static void free_connman_wispr_portal(gpointer data)
{
	struct connman_wispr_portal *wispr_portal = data;

	DBG("");

	if (!wispr_portal)
		return;

	wispr_stop(wispr_portal->ipv4_context, ONLINE_CHECK_FAIL, false);
	wispr_stop(wispr_portal->ipv6_context, ONLINE_CHECK_FAIL, true);

	g_free(wispr_portal);
}

static const char *message_type_to_string(int message_type)
{
	switch (message_type) {
	case 100:
		return "Initial redirect message";
	case 110:
		return "Proxy notification";
	case 120:
		return "Authentication notification";
	case 130:
		return "Logoff notification";
	case 140:
		return "Response to Authentication Poll";
	case 150:
		return "Response to Abort Login";
	}

	return NULL;
}

static const char *response_code_to_string(int response_code)
{
	switch (response_code) {
	case 0:
		return "No error";
	case 50:
		return "Login succeeded";
	case 100:
		return "Login failed";
	case 102:
		return "RADIUS server error/timeout";
	case 105:
		return "RADIUS server not enabled";
	case 150:
		return "Logoff succeeded";
	case 151:
		return "Login aborted";
	case 200:
		return "Proxy detection/repeat operation";
	case 201:
		return "Authentication pending";
	case 255:
		return "Access gateway internal error";
	}

	return NULL;
}

static struct {
	const char *str;
	enum {
		WISPR_ELEMENT_NONE              = 0,
		WISPR_ELEMENT_ACCESS_PROCEDURE  = 1,
		WISPR_ELEMENT_ACCESS_LOCATION   = 2,
		WISPR_ELEMENT_LOCATION_NAME     = 3,
		WISPR_ELEMENT_LOGIN_URL         = 4,
		WISPR_ELEMENT_ABORT_LOGIN_URL   = 5,
		WISPR_ELEMENT_MESSAGE_TYPE      = 6,
		WISPR_ELEMENT_RESPONSE_CODE     = 7,
		WISPR_ELEMENT_NEXT_URL          = 8,
		WISPR_ELEMENT_DELAY             = 9,
		WISPR_ELEMENT_REPLY_MESSAGE     = 10,
		WISPR_ELEMENT_LOGIN_RESULTS_URL = 11,
		WISPR_ELEMENT_LOGOFF_URL        = 12,
	} element;
} wispr_element_map[] = {
	{ "AccessProcedure",	WISPR_ELEMENT_ACCESS_PROCEDURE	},
	{ "AccessLocation",	WISPR_ELEMENT_ACCESS_LOCATION	},
	{ "LocationName",	WISPR_ELEMENT_LOCATION_NAME	},
	{ "LoginURL",		WISPR_ELEMENT_LOGIN_URL		},
	{ "AbortLoginURL",	WISPR_ELEMENT_ABORT_LOGIN_URL	},
	{ "MessageType",	WISPR_ELEMENT_MESSAGE_TYPE	},
	{ "ResponseCode",	WISPR_ELEMENT_RESPONSE_CODE	},
	{ "NextURL",		WISPR_ELEMENT_NEXT_URL		},
	{ "Delay",		WISPR_ELEMENT_DELAY		},
	{ "ReplyMessage",	WISPR_ELEMENT_REPLY_MESSAGE	},
	{ "LoginResultsURL",	WISPR_ELEMENT_LOGIN_RESULTS_URL	},
	{ "LogoffURL",		WISPR_ELEMENT_LOGOFF_URL	},
	{ NULL,			WISPR_ELEMENT_NONE		},
};

static void xml_wispr_start_element_handler(GMarkupParseContext *context,
					const gchar *element_name,
					const gchar **attribute_names,
					const gchar **attribute_values,
					gpointer user_data, GError **error)
{
	struct connman_wispr_message *msg = user_data;

	msg->current_element = element_name;
}

static void xml_wispr_end_element_handler(GMarkupParseContext *context,
					const gchar *element_name,
					gpointer user_data, GError **error)
{
	struct connman_wispr_message *msg = user_data;

	msg->current_element = NULL;
}

static void xml_wispr_text_handler(GMarkupParseContext *context,
					const gchar *text, gsize text_len,
					gpointer user_data, GError **error)
{
	struct connman_wispr_message *msg = user_data;
	int i;

	if (!msg->current_element)
		return;

	for (i = 0; wispr_element_map[i].str; i++) {
		if (!g_str_equal(wispr_element_map[i].str, msg->current_element))
			continue;

		switch (wispr_element_map[i].element) {
		case WISPR_ELEMENT_NONE:
		case WISPR_ELEMENT_ACCESS_PROCEDURE:
			g_free(msg->access_procedure);
			msg->access_procedure = g_strdup(text);
			break;
		case WISPR_ELEMENT_ACCESS_LOCATION:
			g_free(msg->access_location);
			msg->access_location = g_strdup(text);
			break;
		case WISPR_ELEMENT_LOCATION_NAME:
			g_free(msg->location_name);
			msg->location_name = g_strdup(text);
			break;
		case WISPR_ELEMENT_LOGIN_URL:
			g_free(msg->login_url);
			msg->login_url = g_strdup(text);
			break;
		case WISPR_ELEMENT_ABORT_LOGIN_URL:
			g_free(msg->abort_login_url);
			msg->abort_login_url = g_strdup(text);
			break;
		case WISPR_ELEMENT_MESSAGE_TYPE:
			msg->message_type = atoi(text);
			break;
		case WISPR_ELEMENT_RESPONSE_CODE:
			msg->response_code = atoi(text);
			break;
		case WISPR_ELEMENT_NEXT_URL:
		case WISPR_ELEMENT_DELAY:
		case WISPR_ELEMENT_REPLY_MESSAGE:
		case WISPR_ELEMENT_LOGIN_RESULTS_URL:
			break;
		case WISPR_ELEMENT_LOGOFF_URL:
			g_free(msg->logoff_url);
			msg->logoff_url = g_strdup(text);
			break;
		}
	}
}

static void xml_wispr_error_handler(GMarkupParseContext *context,
					GError *error, gpointer user_data)
{
	struct connman_wispr_message *msg = user_data;

	msg->has_error = true;
}

static const GMarkupParser xml_wispr_parser_handlers = {
	xml_wispr_start_element_handler,
	xml_wispr_end_element_handler,
	xml_wispr_text_handler,
	NULL,
	xml_wispr_error_handler,
};

static void xml_wispr_parser_callback(const char *str, gpointer user_data)
{
	struct connman_wispr_portal_context *wp_context = user_data;
	GMarkupParseContext *parser_context = NULL;
	bool result;

	DBG("");

	parser_context = g_markup_parse_context_new(&xml_wispr_parser_handlers,
					G_MARKUP_TREAT_CDATA_AS_TEXT,
					&(wp_context->wispr_msg), NULL);

	result = g_markup_parse_context_parse(parser_context,
					str, strlen(str), NULL);
	if (result)
		g_markup_parse_context_end_parse(parser_context, NULL);

	g_markup_parse_context_free(parser_context);
}

static void web_debug(const char *str, void *data)
{
	connman_info("%s: %s\n", (const char *) data, str);
}

static void wispr_portal_error(struct connman_wispr_portal_context *wp_context)
{
	DBG("Failed to proceed wispr/portal web request");

	wp_context->wispr_result = CONNMAN_WISPR_RESULT_FAILED;
}

static void portal_manage_status(GWebResult *result,
			struct connman_wispr_portal_context *wp_context)
{
	struct connman_service *service = wp_context->service;
	enum connman_ipconfig_type type = wp_context->type;
	const char *str = NULL;

	DBG("");

	/* We currently don't do anything with this info */
	if (g_web_result_get_header(result, "X-ConnMan-Client-IP",
				&str))
		connman_info("Client-IP: %s", str);

	if (g_web_result_get_header(result, "X-ConnMan-Client-Country",
				&str))
		connman_info("Client-Country: %s", str);

	if (g_web_result_get_header(result, "X-ConnMan-Client-Region",
				&str))
		connman_info("Client-Region: %s", str);

	if (g_web_result_get_header(result, "X-ConnMan-Client-Timezone",
				&str))
		connman_info("Client-Timezone: %s", str);

	__connman_service_ipconfig_indicate_state(service,
					CONNMAN_SERVICE_STATE_ONLINE, type);

	wispr_stop(wp_context, ONLINE_CHECK_SUCCESS, true);
}

static bool wispr_route_request(const char *address, int ai_family,
		int if_index, gpointer user_data)
{
	int result = -1;
	struct connman_wispr_portal_context *wp_context = user_data;
	const char *gateway;
	struct wispr_route *route;

	gateway = __connman_ipconfig_get_gateway_from_index(if_index,
		wp_context->type);

	OC_PRINT("address %s if %d gw %s", address, if_index, gateway);

	if (!gateway)
		return false;

	route = g_try_new0(struct wispr_route, 1);
	if (route == 0) {
		OC_PRINT("could not create struct");
		return false;
	}

	switch (wp_context->type) {
	case CONNMAN_IPCONFIG_TYPE_IPV4:
		result = connman_inet_add_host_route(if_index, address,
				gateway);
		break;
	case CONNMAN_IPCONFIG_TYPE_IPV6:
		result = connman_inet_add_ipv6_host_route(if_index, address,
				gateway);
		break;
	case CONNMAN_IPCONFIG_TYPE_UNKNOWN:
	case CONNMAN_IPCONFIG_TYPE_ALL:
		break;
	}

	if (result < 0) {
		OC_PRINT("add host route failed, result %d", result);
		g_free(route);
		return false;
	}

	route->address = g_strdup(address);
	route->if_index = if_index;
	wp_context->route_list = g_slist_prepend(wp_context->route_list, route);

	return true;
}

static void wispr_portal_request_portal(
		struct connman_wispr_portal_context *wp_context)
{
	DBG("");

	wp_context->request_id = g_web_request_get(wp_context->web,
					wp_context->status_url,
					wp_context->wispr_result_func,
					wispr_route_request,
					wp_context);

	if (wp_context->request_id == 0) {
		OC_PRINT("g_web_request_get return error");
		wispr_portal_error(wp_context);
	}
}

static bool wispr_input(const guint8 **data, gsize *length,
						gpointer user_data)
{
	struct connman_wispr_portal_context *wp_context = user_data;
	GString *buf;
	gsize count;

	DBG("");

	buf = g_string_sized_new(100);

	g_string_append(buf, "button=Login&UserName=");
	g_string_append_uri_escaped(buf, wp_context->wispr_username,
								NULL, FALSE);
	g_string_append(buf, "&Password=");
	g_string_append_uri_escaped(buf, wp_context->wispr_password,
								NULL, FALSE);
	g_string_append(buf, "&FNAME=0&OriginatingServer=");
	g_string_append_uri_escaped(buf, wp_context->status_url, NULL, FALSE);

	count = buf->len;

	g_free(wp_context->wispr_formdata);
	wp_context->wispr_formdata = g_string_free(buf, FALSE);

	*data = (guint8 *) wp_context->wispr_formdata;
	*length = count;

	return false;
}

static void wispr_portal_browser_reply_cb(struct connman_service *service,
					bool authentication_done,
					const char *error, void *user_data)
{
	struct connman_wispr_portal_context *wp_context = user_data;

	DBG("");

	if (!service || !wp_context)
		return;

	if (!authentication_done) {
		OC_PRINT("authentication not done");
		wispr_portal_error(wp_context);
		free_wispr_routes(wp_context);
		return;
	}

	/* Restarting the test */
	__connman_wispr_start(service, wp_context->type, wp_context->wispr_server);
}

static void wispr_portal_request_wispr_login(struct connman_service *service,
				bool success,
				const char *ssid, int ssid_len,
				const char *username, const char *password,
				bool wps, const char *wpspin,
				const char *error, void *user_data)
{
	struct connman_wispr_portal_context *wp_context = user_data;

	DBG("");

	if (error) {
		if (g_strcmp0(error,
			"net.connman.Agent.Error.LaunchBrowser") == 0) {
			if (__connman_agent_request_browser(service,
					wispr_portal_browser_reply_cb,
					wp_context->redirect_url,
					wp_context) == -EINPROGRESS)
				return;
		}

		wispr_stop(wp_context, ONLINE_CHECK_FAIL, true);
		return;
	}

	g_free(wp_context->wispr_username);
	wp_context->wispr_username = g_strdup(username);

	g_free(wp_context->wispr_password);
	wp_context->wispr_password = g_strdup(password);

	wp_context->request_id = g_web_request_post(wp_context->web,
					wp_context->wispr_msg.login_url,
					"application/x-www-form-urlencoded",
					wispr_input, wp_context->wispr_result_func,
					wp_context);

	connman_wispr_message_init(&wp_context->wispr_msg);
}

static bool wispr_manage_message(GWebResult *result,
			struct connman_wispr_portal_context *wp_context)
{
	DBG("Message type: %s (%d)",
		message_type_to_string(wp_context->wispr_msg.message_type),
					wp_context->wispr_msg.message_type);
	DBG("Response code: %s (%d)",
		response_code_to_string(wp_context->wispr_msg.response_code),
					wp_context->wispr_msg.response_code);

	if (wp_context->wispr_msg.access_procedure)
		DBG("Access procedure: %s",
			wp_context->wispr_msg.access_procedure);
	if (wp_context->wispr_msg.access_location)
		DBG("Access location: %s",
			wp_context->wispr_msg.access_location);
	if (wp_context->wispr_msg.location_name)
		DBG("Location name: %s",
			wp_context->wispr_msg.location_name);
	if (wp_context->wispr_msg.login_url)
		DBG("Login URL: %s", wp_context->wispr_msg.login_url);
	if (wp_context->wispr_msg.abort_login_url)
		DBG("Abort login URL: %s",
			wp_context->wispr_msg.abort_login_url);
	if (wp_context->wispr_msg.logoff_url)
		DBG("Logoff URL: %s", wp_context->wispr_msg.logoff_url);

	switch (wp_context->wispr_msg.message_type) {
	case 100:
		DBG("Login required");

		wp_context->wispr_result = CONNMAN_WISPR_RESULT_LOGIN;

		if (__connman_agent_request_login_input(wp_context->service,
					wispr_portal_request_wispr_login,
					wp_context) != -EINPROGRESS)
			wispr_portal_error(wp_context);
		else
			return true;

		break;
	case 120: /* Falling down */
	case 140:
		if (wp_context->wispr_msg.response_code == 50) {
			wp_context->wispr_result = CONNMAN_WISPR_RESULT_ONLINE;

			g_free(wp_context->wispr_username);
			wp_context->wispr_username = NULL;

			g_free(wp_context->wispr_password);
			wp_context->wispr_password = NULL;

			g_free(wp_context->wispr_formdata);
			wp_context->wispr_formdata = NULL;

			wispr_portal_request_portal(wp_context);

			return true;
		} else
			wispr_portal_error(wp_context);

		break;
	default:
		break;
	}

	return false;
}

static bool wispr_portal_web_result_connman(GWebResult *result, gpointer user_data)
{
	struct connman_wispr_portal_context *wp_context = user_data;
	const char *redirect = NULL;
	const guint8 *chunk = NULL;
	const char *str = NULL;
	guint16 status;
	gsize length;

	DBG("");

	if (wp_context->wispr_result != CONNMAN_WISPR_RESULT_ONLINE) {
		g_web_result_get_chunk(result, &chunk, &length);

		if (length > 0) {
			g_web_parser_feed_data(wp_context->wispr_parser,
								chunk, length);
			return true;
		}

		g_web_parser_end_data(wp_context->wispr_parser);

		if (wp_context->wispr_msg.message_type >= 0) {
			if (wispr_manage_message(result, wp_context))
				goto done;
		}
	}

	status = g_web_result_get_status(result);

	DBG("status: %03u", status);

	switch (status) {
	case 000:
		__connman_agent_request_browser(wp_context->service,
				wispr_portal_browser_reply_cb,
				wp_context->status_url, wp_context);
		break;
	case 200:
		if (wp_context->wispr_msg.message_type >= 0)
			break;

		if (g_web_result_get_header(result, "X-ConnMan-Status",
						&str)) {
			portal_manage_status(result, wp_context);
			return false;
		} else
			__connman_agent_request_browser(wp_context->service,
					wispr_portal_browser_reply_cb,
					wp_context->redirect_url, wp_context);

		break;
	case 302:
		if (!g_web_supports_tls() ||
			!g_web_result_get_header(result, "Location",
							&redirect)) {

			__connman_agent_request_browser(wp_context->service,
					wispr_portal_browser_reply_cb,
					wp_context->status_url, wp_context);
			break;
		}

		DBG("Redirect URL: %s", redirect);

		wp_context->redirect_url = g_strdup(redirect);

		wp_context->request_id = g_web_request_get(wp_context->web,
				redirect, wispr_portal_web_result_connman,
				wispr_route_request, wp_context);

		goto done;
	case 400:
	case 404:
	case 9002:
		if (__connman_service_online_check_failed(wp_context->service,
						wp_context->type) == 0) {
			wispr_portal_error(wp_context);
			wispr_stop(wp_context, (status == 9002) ? ONLINE_CHECK_DNS_FAIL : ONLINE_CHECK_FAIL, true);
			return false;
		}

		break;
	case 505:
		__connman_agent_request_browser(wp_context->service,
				wispr_portal_browser_reply_cb,
				wp_context->status_url, wp_context);
		break;
	default:
		break;
	}

	free_wispr_routes(wp_context);
	wp_context->request_id = 0;
done:
	wp_context->wispr_msg.message_type = -1;
	return false;
}

static bool wispr_portal_web_result_google(GWebResult *result, gpointer user_data)
{
	struct connman_wispr_portal_context *wp_context = user_data;
	const guint8 *chunk = NULL;
	guint16 status;
	gsize length;

	DBG("");

	if (wp_context->wispr_result != CONNMAN_WISPR_RESULT_ONLINE) {
		g_web_result_get_chunk(result, &chunk, &length);

		if (length > 0) {
			g_web_parser_feed_data(wp_context->wispr_parser,
								chunk, length);
			return true;
		}

		g_web_parser_end_data(wp_context->wispr_parser);

		if (wp_context->wispr_msg.message_type >= 0) {
			if (wispr_manage_message(result, wp_context))
				goto done;
		}
	}

	status = g_web_result_get_status(result);

	OC_PRINT("status: %03u", status);

	switch (status) {
	case 000:
		__connman_agent_request_browser(wp_context->service,
				wispr_portal_browser_reply_cb,
				wp_context->status_url, wp_context);
		break;

	case 200: // It means: "OK"
	case 204: // It means: "No content"
	case 206: // It means: "Partial content"
	case 301: // It means: "Moved permanently"
	case 302: // It means: "Found"

		if (wp_context->wispr_msg.message_type >= 0)
			break;

		portal_manage_status(result, wp_context);
		return false;

	case 400:
	case 404:
	case 9002:
		if (__connman_service_online_check_failed(wp_context->service,
						wp_context->type) == 0) {
			wispr_portal_error(wp_context);
			wispr_stop(wp_context, (status == 9002) ? ONLINE_CHECK_DNS_FAIL : ONLINE_CHECK_FAIL, true);
			return false;
		}

		break;
	case 505:
		__connman_agent_request_browser(wp_context->service,
				wispr_portal_browser_reply_cb,
				wp_context->status_url, wp_context);
		break;
	default:
		break;
	}

	free_wispr_routes(wp_context);
	wp_context->request_id = 0;
done:
	wp_context->wispr_msg.message_type = -1;
	return false;
}


static void proxy_callback(const char *proxy, void *user_data)
{
	struct connman_wispr_portal_context *wp_context = user_data;

	DBG("proxy %s", proxy);

	if (!wp_context)
		return;

	wp_context->token = 0;

	if (proxy && g_strcmp0(proxy, "DIRECT") != 0) {
		if (g_str_has_prefix(proxy, "PROXY")) {
			proxy += 5;
			for (; *proxy == ' ' && *proxy != '\0'; proxy++);
		}
		g_web_set_proxy(wp_context->web, proxy);
	}

	g_web_set_accept(wp_context->web, NULL);
	g_web_set_user_agent(wp_context->web, "ConnMan/%s wispr", VERSION);
	g_web_set_close_connection(wp_context->web, TRUE);

	connman_wispr_message_init(&wp_context->wispr_msg);

	wp_context->wispr_parser = g_web_parser_new(
					"<WISPAccessGatewayParam",
					"WISPAccessGatewayParam>",
					xml_wispr_parser_callback, wp_context);

	wispr_portal_request_portal(wp_context);
}

static gboolean no_proxy_callback(gpointer user_data)
{
	struct connman_wispr_portal_context *wp_context = user_data;

	wp_context->timeout = 0;

	proxy_callback("DIRECT", wp_context);

	return FALSE;
}

static int wispr_portal_detect(struct connman_wispr_portal_context *wp_context)
{
	enum connman_service_proxy_method proxy_method;
	enum connman_service_type service_type;
	char *interface = NULL;
	char **nameservers = NULL;
	int if_index;
	int err = 0;
	int i;

	DBG("wispr/portal context %p", wp_context);
	DBG("service %p", wp_context->service);

	service_type = connman_service_get_type(wp_context->service);

	switch (service_type) {
	case CONNMAN_SERVICE_TYPE_ETHERNET:
	case CONNMAN_SERVICE_TYPE_WIFI:
	case CONNMAN_SERVICE_TYPE_BLUETOOTH:
	case CONNMAN_SERVICE_TYPE_CELLULAR:
	case CONNMAN_SERVICE_TYPE_GADGET:
		break;
	case CONNMAN_SERVICE_TYPE_UNKNOWN:
	case CONNMAN_SERVICE_TYPE_SYSTEM:
	case CONNMAN_SERVICE_TYPE_GPS:
	case CONNMAN_SERVICE_TYPE_VPN:
	case CONNMAN_SERVICE_TYPE_P2P:
	case CONNMAN_SERVICE_TYPE_LOWPAN:
		return -EOPNOTSUPP;
	}

	interface = connman_service_get_interface(wp_context->service);
	if (!interface) {
		OC_PRINT("can't find interface for wp_context %p", wp_context);
		return -EINVAL;
	}

	DBG("interface %s", interface);

	if_index = connman_inet_ifindex(interface);
	if (if_index < 0) {
		OC_PRINT("Could not get ifindex");
		err = -EINVAL;
		goto done;
	}

	nameservers = connman_service_get_nameservers(wp_context->service);
	if (!nameservers) {
		OC_PRINT("Could not get nameservers");
		err = -EINVAL;
		goto done;
	}

	wp_context->web = g_web_new(if_index);
	if (!wp_context->web) {
		OC_PRINT("Could not set up GWeb");
		err = -ENOMEM;
		goto done;
	}

	//if (getenv("CONNMAN_WEB_DEBUG"))
		g_web_set_debug(wp_context->web, web_debug, OC_TAG);

	if (wp_context->wispr_server == CONNMAN_WISPR_SERVER_CONNMAN) {
		if (wp_context->type == CONNMAN_IPCONFIG_TYPE_IPV4) {
			g_web_set_address_family(wp_context->web, AF_INET);
			wp_context->status_url = STATUS_URL_IPV4;
		} else {
			g_web_set_address_family(wp_context->web, AF_INET6);
			wp_context->status_url = STATUS_URL_IPV6;
		}
		wp_context->wispr_result_func = wispr_portal_web_result_connman;
	} else {
		if (wp_context->type == CONNMAN_IPCONFIG_TYPE_IPV4) {
			g_web_set_address_family(wp_context->web, AF_INET);
			wp_context->status_url = STATUS_URL_GOOGLE;
		} else {
			g_web_set_address_family(wp_context->web, AF_INET6);
			wp_context->status_url = STATUS_URL_GOOGLE;
		}
		wp_context->wispr_result_func = wispr_portal_web_result_google;
	}

	for (i = 0; nameservers[i]; i++)
		g_web_add_nameserver(wp_context->web, nameservers[i]);

	proxy_method = connman_service_get_proxy_method(wp_context->service);

	if (proxy_method != CONNMAN_SERVICE_PROXY_METHOD_DIRECT) {
		wp_context->token = connman_proxy_lookup(interface,
						wp_context->status_url,
						wp_context->service,
						proxy_callback, wp_context);

		if (wp_context->token == 0) {
			err = -EINVAL;
			OC_PRINT("connman_proxy_lookup failed");
			wispr_stop(wp_context, ONLINE_CHECK_FAIL, true);
		}
	} else if (wp_context->timeout == 0) {
		wp_context->timeout =
			g_timeout_add_seconds(0, no_proxy_callback, wp_context);
	}

done:
	g_strfreev(nameservers);

	g_free(interface);
	return err;
}

int __connman_wispr_start(struct connman_service *service,
					enum connman_ipconfig_type type, enum connman_wispr_server wispr_server)
{
	struct connman_wispr_portal_context *wp_context = NULL;
	struct connman_wispr_portal *wispr_portal = NULL;
	int index;

	DBG("service %p", service);

	if (!wispr_portal_list)
		return -EINVAL;

	index = __connman_service_get_index(service);
	if (index < 0) {
		OC_PRINT("can't find index for service %p", service);
		return -EINVAL;
	}

	wispr_portal = g_hash_table_lookup(wispr_portal_list,
					GINT_TO_POINTER(index));
	if (!wispr_portal) {
		wispr_portal = g_try_new0(struct connman_wispr_portal, 1);
		if (!wispr_portal) {
			OC_PRINT("failed to allocate portal structure");
			return -ENOMEM;
		}

		g_hash_table_replace(wispr_portal_list,
					GINT_TO_POINTER(index), wispr_portal);
	}

	if ((type != CONNMAN_IPCONFIG_TYPE_IPV4) && (type != CONNMAN_IPCONFIG_TYPE_IPV6)) {
		OC_PRINT("check type %d is not valid", type);
		return -EINVAL;
	}

	wp_context = create_wispr_portal_context();
	if (!wp_context) {
		OC_PRINT("failed to create portal context");
		return -ENOMEM;
	}

	wp_context->service = service;
	wp_context->type = type;
	wp_context->wispr_portal = wispr_portal;
	wp_context->wispr_server = wispr_server;

	wispr_start(wp_context, true);

	if (wispr_pending_timeout)
		g_source_remove(wispr_pending_timeout);
	wispr_pending_timeout = g_timeout_add_seconds(0, wispr_schedule_pendings, NULL);

	return 0;
}

void __connman_wispr_stop(struct connman_service *service)
{
	int index;
	struct connman_wispr_portal *wispr_portal = NULL;
	struct connman_wispr_portal_context *wp_context = NULL;

	DBG("service %p", service);

	if (!wispr_portal_list)
		return;

	index = __connman_service_get_index(service);
	if (index < 0) {
		OC_PRINT("can't find index for service %p", service);
		return;
	}

	wispr_portal = g_hash_table_lookup(wispr_portal_list,
						GINT_TO_POINTER(index));

	if (!wispr_portal)
		return;

	if (wispr_portal->ipv4_context)
		wp_context = wispr_portal->ipv4_context;
	else if (wispr_portal->ipv6_context)
		wp_context = wispr_portal->ipv6_context;

	if (!wp_context)
		return;

	if (wp_context->service == service) {
		wispr_cleanup_pendings(wp_context->service);
		g_hash_table_remove(wispr_portal_list, GINT_TO_POINTER(index));
	} else {
		DBG("service not match, dont stop wispr");
	}
}

int __connman_wispr_init(void)
{
	DBG("");

	wispr_portal_list = g_hash_table_new_full(g_direct_hash,
						g_direct_equal, NULL,
						free_connman_wispr_portal);

	return 0;
}

void __connman_wispr_cleanup(void)
{
	DBG("");

	/* flush pending list */
	if (wispr_pending)
		wispr_cleanup_pendings(NULL);

	g_hash_table_destroy(wispr_portal_list);
	wispr_portal_list = NULL;
}