/*
 * MySQL module interface
 *
 * Copyright (C) 2001-2003 FhG FOKUS
 * Copyright (C) 2006-2007 iptelorg GmbH
 *
 * This file is part of Kamailio, a free SIP server.
 *
 * Kamailio 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; either version 2 of the License, or
 * (at your option) any later version
 *
 * Kamailio 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 Street, Fifth Floor, Boston, MA  02110-1301  USA
 */

#include "my_uri.h"

#include "../../core/dprint.h"
#include "../../core/mem/mem.h"
#include "../../core/ut.h"
#include "../../lib/srdb2/db_gen.h"

#include <stdlib.h>
#include <string.h>


/* compare s1 & s2  with a function f (which should return 0 if ==);
 * s1 & s2 can be null
 * return 0 if match, 1 if not */
#define cmpstr(s1, s2, f) \
	((s1) != (s2)) && ((s1) == 0 || (s2) == 0 || (f)((s1), (s2)) != 0)

/*
 * Compare two connection identifiers
 */
static unsigned char my_uri_cmp(db_uri_t *uri1, db_uri_t *uri2)
{
	struct my_uri *muri1, *muri2;

	if(!uri1 || !uri2)
		return 0;

	muri1 = DB_GET_PAYLOAD(uri1);
	muri2 = DB_GET_PAYLOAD(uri2);
	if(muri1->port != muri2->port)
		return 0;

	if(cmpstr(muri1->username, muri2->username, strcmp))
		return 0;
	if(cmpstr(muri1->password, muri2->password, strcmp))
		return 0;
	if(cmpstr(muri1->host, muri2->host, strcasecmp))
		return 0;
	if(cmpstr(muri1->database, muri2->database, strcmp))
		return 0;
	return 1;
}


/*
 * Duplicate a string
 */
static int dupl_string(char **dst, const char *begin, const char *end)
{
	if(*dst)
		pkg_free(*dst);

	*dst = pkg_malloc(end - begin + 1);
	if((*dst) == NULL) {
		PKG_MEM_ERROR;
		return -1;
	}

	memcpy(*dst, begin, end - begin);
	(*dst)[end - begin] = '\0';
	return 0;
}


/*
 * Parse mysql URI of form
 * //[username[:password]@]hostname[:port]/database
 *
 * Returns 0 if parsing was successful and -1 otherwise
 */
static int parse_mysql_uri(struct my_uri *res, str *uri)
{
#define SHORTEST_DB_URL "//a/b"
#define SHORTEST_DB_URL_LEN (sizeof(SHORTEST_DB_URL) - 1)

	enum state
	{
		ST_SLASH1,	  /* First slash */
		ST_SLASH2,	  /* Second slash */
		ST_USER_HOST, /* Username or hostname */
		ST_PASS_PORT, /* Password or port part */
		ST_HOST,	  /* Hostname part */
		ST_HOST6,	  /* Hostname part IPv6 */
		ST_PORT,	  /* Port part */
		ST_DB		  /* Database part */
	};

	enum state st;
	int i, ipv6_flag = 0;
	const char *begin;
	char *prev_token;

	prev_token = 0;

	if(!res || !uri) {
		goto err;
	}

	if(uri->len < SHORTEST_DB_URL_LEN) {
		goto err;
	}

	st = ST_SLASH1;
	begin = uri->s;

	for(i = 0; i < uri->len; i++) {
		switch(st) {
			case ST_SLASH1:
				switch(uri->s[i]) {
					case '/':
						st = ST_SLASH2;
						break;

					default:
						goto err;
				}
				break;

			case ST_SLASH2:
				switch(uri->s[i]) {
					case '/':
						st = ST_USER_HOST;
						begin = uri->s + i + 1;
						break;

					default:
						goto err;
				}
				break;

			case ST_USER_HOST:
				switch(uri->s[i]) {
					case '@':
						st = ST_HOST;
						if(dupl_string(&res->username, begin, uri->s + i) < 0)
							goto err;
						begin = uri->s + i + 1;
						break;

					case ':':
						st = ST_PASS_PORT;
						if(dupl_string(&prev_token, begin, uri->s + i) < 0)
							goto err;
						begin = uri->s + i + 1;
						break;

					case '[':
						st = ST_HOST6;
						begin = uri->s + i + 1;
						break;

					case '/':
						if(dupl_string(&res->host, begin, uri->s + i) < 0)
							goto err;
						if(dupl_string(&res->database, uri->s + i + 1,
								   uri->s + uri->len)
								< 0)
							goto err;
						return 0;
				}
				break;

			case ST_PASS_PORT:
				switch(uri->s[i]) {
					case '@':
						st = ST_HOST;
						res->username = prev_token;
						prev_token = 0;
						if(dupl_string(&res->password, begin, uri->s + i) < 0)
							goto err;
						begin = uri->s + i + 1;
						break;

					case '/':
						res->host = prev_token;
						prev_token = 0;
						res->port = str2s(begin, uri->s + i - begin, 0);
						if(dupl_string(&res->database, uri->s + i + 1,
								   uri->s + uri->len)
								< 0)
							goto err;
						return 0;
				}
				break;

			case ST_HOST:
				switch(uri->s[i]) {
					case '[':
						st = ST_HOST6;
						begin = uri->s + i + 1;
						break;

					case ':':
						st = ST_PORT;
						if(dupl_string(
								   &res->host, begin, uri->s + i - ipv6_flag)
								< 0)
							goto err;
						begin = uri->s + i + 1;
						break;

					case '/':
						if(dupl_string(
								   &res->host, begin, uri->s + i - ipv6_flag)
								< 0)
							goto err;
						if(dupl_string(&res->database, uri->s + i + 1,
								   uri->s + uri->len)
								< 0)
							goto err;
						return 0;
				}
				break;

			case ST_HOST6:
				switch(uri->s[i]) {
					case ']':
						ipv6_flag = 1;
						st = ST_HOST;
						break;
				}
				break;

			case ST_PORT:
				switch(uri->s[i]) {
					case '/':
						res->port = str2s(begin, uri->s + i - begin, 0);
						if(dupl_string(&res->database, uri->s + i + 1,
								   uri->s + uri->len)
								< 0)
							goto err;
						return 0;
				}
				break;

			case ST_DB:
				break;
		}
	}

	if(st != ST_DB)
		goto err;
	return 0;

err:
	if(prev_token)
		pkg_free(prev_token);
	if(res == NULL)
		return -1;
	if(res->username) {
		pkg_free(res->username);
		res->username = NULL;
	}
	if(res->password) {
		pkg_free(res->password);
		res->password = NULL;
	}
	if(res->host) {
		pkg_free(res->host);
		res->host = NULL;
	}
	if(res->database) {
		pkg_free(res->database);
		res->database = NULL;
	}
	return -1;
}


static void my_uri_free(db_uri_t *uri, struct my_uri *payload)
{
	if(payload == NULL)
		return;
	db_drv_free(&payload->drv);
	if(payload->username)
		pkg_free(payload->username);
	if(payload->password)
		pkg_free(payload->password);
	if(payload->host)
		pkg_free(payload->host);
	if(payload->database)
		pkg_free(payload->database);
	pkg_free(payload);
}


int my_uri(db_uri_t *uri)
{
	struct my_uri *res;

	res = (struct my_uri *)pkg_malloc(sizeof(struct my_uri));
	if(res == NULL) {
		PKG_MEM_ERROR;
		goto error;
	}
	memset(res, '\0', sizeof(struct my_uri));
	if(db_drv_init(&res->drv, my_uri_free) < 0)
		goto error;
	if(parse_mysql_uri(res, &uri->body) < 0)
		goto error;

	DB_SET_PAYLOAD(uri, res);
	uri->cmp = my_uri_cmp;
	return 0;

error:
	if(res) {
		db_drv_free(&res->drv);
		if(res)
			pkg_free(res);
	}
	return -1;
}
