/*

 * Copyright (c) 2004-2009 Voltaire, Inc. All rights reserved.

 * Copyright (c) 2002-2007 Mellanox Technologies LTD. All rights reserved.

 * Copyright (c) 1996-2003 Intel Corporation. All rights reserved.

 * Copyright (c) 2013 Oracle and/or its affiliates. All rights reserved.

 *

 * This software is available to you under a choice of one of two

 * licenses.  You may choose to be licensed under the terms of the GNU

 * General Public License (GPL) Version 2, available from the file

 * COPYING in the main directory of this source tree, or the

 * OpenIB.org BSD license below:

 *

 *     Redistribution and use in source and binary forms, with or

 *     without modification, are permitted provided that the following

 *     conditions are met:

 *

 *      - Redistributions of source code must retain the above

 *        copyright notice, this list of conditions and the following

 *        disclaimer.

 *

 *      - Redistributions in binary form must reproduce the above

 *        copyright notice, this list of conditions and the following

 *        disclaimer in the documentation and/or other materials

 *        provided with the distribution.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS

 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

 * SOFTWARE.

 *

 */

/*

 * Abstract:

 * Implementation of the osm_db interface using simple text files

 */

#if HAVE_CONFIG_H

#  include <config.h>

#endif				/* HAVE_CONFIG_H */

#include <sys/stat.h>

#include <sys/types.h>

#include <errno.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <opensm/osm_file_ids.h>

#define FILE_ID OSM_FILE_DB_FILES_C

#include <opensm/st.h>

#include <opensm/osm_db.h>

#include <opensm/osm_log.h>

/****d* Database/OSM_DB_MAX_LINE_LEN

 * NAME

 * OSM_DB_MAX_LINE_LEN

 *

 * DESCRIPTION

 * The Maximal line length allowed for the file

 *

 * SYNOPSIS

 */

#define OSM_DB_MAX_LINE_LEN 1024

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

/****s* OpenSM: Database/osm_db_domain_imp

 * NAME

 * osm_db_domain_imp

 *

 * DESCRIPTION

 * An implementation for domain of the database based on text files and

 *  hash tables.

 *

 * SYNOPSIS

 */

typedef struct osm_db_domain_imp {

	char *file_name;

	st_table *p_hash;

	cl_spinlock_t lock;

	boolean_t dirty;

} osm_db_domain_imp_t;

/*

 * FIELDS

 *

 * SEE ALSO

 * osm_db_domain_t

 *********/

/****s* OpenSM: Database/osm_db_imp_t

 * NAME

 * osm_db_imp_t

 *

 * DESCRIPTION

 * An implementation for file based database

 *

 * SYNOPSIS

 */

typedef struct osm_db_imp {

	const char *db_dir_name;

} osm_db_imp_t;

/*

 * FIELDS

 *

 * db_dir_name

 *   The directory holding the database

 *

 * SEE ALSO

 * osm_db_t

 *********/

void osm_db_construct(IN osm_db_t * p_db)

{

	memset(p_db, 0, sizeof(osm_db_t));

	cl_list_construct(&p_db->domains);

}

void osm_db_domain_destroy(IN osm_db_domain_t * p_db_domain)

{

	osm_db_domain_imp_t *p_domain_imp;

	p_domain_imp = (osm_db_domain_imp_t *) p_db_domain->p_domain_imp;

	osm_db_clear(p_db_domain);

	cl_spinlock_destroy(&p_domain_imp->lock);

	st_free_table(p_domain_imp->p_hash);

	free(p_domain_imp->file_name);

	free(p_domain_imp);

}

void osm_db_destroy(IN osm_db_t * p_db)

{

	osm_db_domain_t *p_domain;

	while ((p_domain = cl_list_remove_head(&p_db->domains)) != NULL) {

		osm_db_domain_destroy(p_domain);

		free(p_domain);

	}

	cl_list_destroy(&p_db->domains);

	free(p_db->p_db_imp);

}

int osm_db_init(IN osm_db_t * p_db, IN osm_log_t * p_log)

{

	osm_db_imp_t *p_db_imp;

	struct stat dstat;

	OSM_LOG_ENTER(p_log);

	p_db_imp = malloc(sizeof(osm_db_imp_t));

	if (!p_db_imp) {

		OSM_LOG(p_log, OSM_LOG_ERROR, "ERR 6100: "

			"Failed to allocate db memory\n");

		return -1;

	}

	p_db_imp->db_dir_name = getenv("OSM_CACHE_DIR");

	if (!p_db_imp->db_dir_name || !(*p_db_imp->db_dir_name))

		p_db_imp->db_dir_name = OSM_DEFAULT_CACHE_DIR;

	/* Create the directory if it doesn't exist */

	/* There is a difference in creating directory between windows and linux */

#ifdef __WIN__

	{

		int ret;

		ret = SHCreateDirectoryEx(NULL, p_db_imp->db_dir_name, NULL);

		if (ret != ERROR_SUCCESS && ret != ERROR_ALREADY_EXISTS &&

			ret != ERROR_FILE_EXISTS)

			goto err;

	}

#else				/* __WIN__ */

	/* make sure the directory exists */

	if (lstat(p_db_imp->db_dir_name, &dstat)) {

		if (mkdir(p_db_imp->db_dir_name, 0755))

			goto err;

	}

#endif

	p_db->p_log = p_log;

	p_db->p_db_imp = (void *)p_db_imp;

	cl_list_init(&p_db->domains, 5);

	OSM_LOG_EXIT(p_log);

	return 0;

err:

	OSM_LOG(p_log, OSM_LOG_ERROR, "ERR 6101: "

		"Failed to create the db directory:%s\n",

		p_db_imp->db_dir_name);

	free(p_db_imp);

	OSM_LOG_EXIT(p_log);

	return 1;

}

osm_db_domain_t *osm_db_domain_init(IN osm_db_t * p_db, IN const char *domain_name)

{

	osm_db_domain_t *p_domain;

	osm_db_domain_imp_t *p_domain_imp;

	size_t path_len;

	osm_log_t *p_log = p_db->p_log;

	FILE *p_file;

	OSM_LOG_ENTER(p_log);

	/* allocate a new domain object */

	p_domain = malloc(sizeof(osm_db_domain_t));

	if (p_domain == NULL) {

		OSM_LOG(p_log, OSM_LOG_ERROR, "ERR 610C: "

			"Failed to allocate domain memory\n");

		goto Exit;

	}

	p_domain_imp = malloc(sizeof(osm_db_domain_imp_t));

	if (p_domain_imp == NULL) {

		OSM_LOG(p_log, OSM_LOG_ERROR, "ERR 610D: "

			"Failed to allocate domain_imp memory\n");

		free(p_domain);

		p_domain = NULL;

		goto Exit;

	}

	path_len = strlen(((osm_db_imp_t *) p_db->p_db_imp)->db_dir_name)

	    + strlen(domain_name) + 2;

	/* set the domain file name */

	p_domain_imp->file_name = malloc(path_len);

	if (p_domain_imp->file_name == NULL) {

		OSM_LOG(p_log, OSM_LOG_ERROR, "ERR 610E: "

			"Failed to allocate file_name memory\n");

		free(p_domain_imp);

		free(p_domain);

		p_domain = NULL;

		goto Exit;

	}

	snprintf(p_domain_imp->file_name, path_len, "%s/%s",

		 ((osm_db_imp_t *) p_db->p_db_imp)->db_dir_name, domain_name);

	/* make sure the file exists - or exit if not writable */

	p_file = fopen(p_domain_imp->file_name, "a+");

	if (!p_file) {

		OSM_LOG(p_log, OSM_LOG_ERROR, "ERR 6102: "

			"Failed to open the db file:%s\n",

			p_domain_imp->file_name);

		free(p_domain_imp);

		free(p_domain);

		p_domain = NULL;

		goto Exit;

	}

	fclose(p_file);

	/* initialize the hash table object */

	p_domain_imp->p_hash = st_init_strtable();

	CL_ASSERT(p_domain_imp->p_hash != NULL);

	p_domain_imp->dirty = FALSE;

	p_domain->p_db = p_db;

	cl_list_insert_tail(&p_db->domains, p_domain);

	p_domain->p_domain_imp = p_domain_imp;

	cl_spinlock_construct(&p_domain_imp->lock);

	cl_spinlock_init(&p_domain_imp->lock);

Exit:

	OSM_LOG_EXIT(p_log);

	return p_domain;

}

int osm_db_restore(IN osm_db_domain_t * p_domain)

{

	osm_log_t *p_log = p_domain->p_db->p_log;

	osm_db_domain_imp_t *p_domain_imp =

	    (osm_db_domain_imp_t *) p_domain->p_domain_imp;

	FILE *p_file;

	int status;

	char sLine[OSM_DB_MAX_LINE_LEN];

	boolean_t before_key;

	char *p_first_word, *p_rest_of_line, *p_last;

	char *p_key = NULL;

	char *p_prev_val = NULL, *p_accum_val = NULL;

	char *endptr = NULL;

	unsigned int line_num;

	OSM_LOG_ENTER(p_log);

	/* take the lock on the domain */

	cl_spinlock_acquire(&p_domain_imp->lock);

	/* open the file - read mode */

	p_file = fopen(p_domain_imp->file_name, "r");

	if (!p_file) {

		OSM_LOG(p_log, OSM_LOG_ERROR, "ERR 6103: "

			"Failed to open the db file:%s\n",

			p_domain_imp->file_name);

		status = 1;

		goto Exit;

	}

	/* parse the file allocating new hash tables as required */

	/*

	   states:

	   before_key (0) -> in_key (1)

	   before_key: if a word on the first byte - it is the key. state=in_key

	   the rest of the line is start of the value.

	   in_key: unless the line is empty - add it (with newlines) to the value.

	   if empty: state=before_key

	 */

	status = 0;

	before_key = TRUE;

	line_num = 0;

	/* if we got to EOF in the middle of a key we add a last newline */

	while ((fgets(sLine, OSM_DB_MAX_LINE_LEN, p_file) != NULL) ||

	       ((before_key == FALSE) && strcpy(sLine, "\n"))

	    ) {

		line_num++;

		if (before_key) {

			if ((sLine[0] != ' ') && (sLine[0] != '\t')

			    && (sLine[0] != '\n')) {

				/* we got a new key */

				before_key = FALSE;

				/* handle the key */

				p_first_word =

				    strtok_r(sLine, " \t\n", &p_last);

				if (!p_first_word) {

					OSM_LOG(p_log, OSM_LOG_ERROR,

						"ERR 6104: "

						"Failed to get key from line:%u : %s (file:%s)\n",

						line_num, sLine,

						p_domain_imp->file_name);

					status = 1;

					goto EndParsing;

				}

				p_key = malloc(sizeof(char) *

					       (strlen(p_first_word) + 1));

				strcpy(p_key, p_first_word);

				p_rest_of_line = strtok_r(NULL, "\n", &p_last);

				if (p_rest_of_line != NULL) {

					p_accum_val = malloc(sizeof(char) *

					    (strlen(p_rest_of_line) + 1));

					strcpy(p_accum_val, p_rest_of_line);

				} else {

					p_accum_val = malloc(2);

					strcpy(p_accum_val, "\0");

				}

			} else if (sLine[0] != '\n') {

				OSM_LOG(p_log, OSM_LOG_ERROR, "ERR 6105: "

					"How did we get here? line:%u : %s (file:%s)\n",

					line_num, sLine,

					p_domain_imp->file_name);

				status = 1;

				goto EndParsing;

			}

		} /* before key */

		else {

			/* we already have a key */

			if (sLine[0] == '\n') {

				/* got an end of key */

				before_key = TRUE;

				/* make sure the key was not previously used */

				if (st_lookup(p_domain_imp->p_hash,

					      (st_data_t) p_key,

					      (void *)&p_prev_val)) {

					/* if previously used we ignore this guid */

					OSM_LOG(p_log, OSM_LOG_ERROR,

						"ERR 6106: "

						"Key:%s already exists in:%s with value:%s."

						" Removing it\n", p_key,

						p_domain_imp->file_name,

						p_prev_val);

						free(p_key);

						p_key = NULL;

						free(p_accum_val);

						p_accum_val = NULL;

						continue;

				} else {

					p_prev_val = NULL;

				}

				OSM_LOG(p_log, OSM_LOG_DEBUG,

					"Got key:%s value:%s\n", p_key,

					p_accum_val);

				/* check that the key is a number */

				if (!strtouq(p_key, &endptr, 0)

				    && *endptr != '\0') {

					OSM_LOG(p_log, OSM_LOG_ERROR,

						"ERR 610B: "

						"Key:%s is invalid\n", p_key);

						free(p_key);

						p_key = NULL;

						free(p_accum_val);

						p_accum_val = NULL;

				} else {

					/* store our key and value */

					st_insert(p_domain_imp->p_hash,

						  (st_data_t) p_key,

						  (st_data_t) p_accum_val);

				}

			} else {

				/* accumulate into the value */

				p_prev_val = p_accum_val;

				p_accum_val = malloc(strlen(p_prev_val) +

						     strlen(sLine) + 1);

				strcpy(p_accum_val, p_prev_val);

				free(p_prev_val);

				p_prev_val = NULL;

				strcat(p_accum_val, sLine);

			}

		}		/* in key */

	}			/* while lines or last line */

EndParsing:

	fclose(p_file);

Exit:

	cl_spinlock_release(&p_domain_imp->lock);

	OSM_LOG_EXIT(p_log);

	return status;

}

static int dump_tbl_entry(st_data_t key, st_data_t val, st_data_t arg)

{

	FILE *p_file = (FILE *) arg;

	char *p_key = (char *)key;

	char *p_val = (char *)val;

	fprintf(p_file, "%s %s\n\n", p_key, p_val);

	return ST_CONTINUE;

}

int osm_db_store(IN osm_db_domain_t * p_domain,

		 IN boolean_t fsync_high_avail_files)

{

	osm_log_t *p_log = p_domain->p_db->p_log;

	osm_db_domain_imp_t *p_domain_imp;

	FILE *p_file = NULL;

	int fd, status = 0;

	char *p_tmp_file_name = NULL;

	OSM_LOG_ENTER(p_log);

	p_domain_imp = (osm_db_domain_imp_t *) p_domain->p_domain_imp;

	p_tmp_file_name = malloc(sizeof(char) *

				 (strlen(p_domain_imp->file_name) + 8));

	if (!p_tmp_file_name) {

		OSM_LOG(p_log, OSM_LOG_ERROR, "ERR 6113: "

			"Failed to allocate memory for temporary file name\n");

		goto Exit2;

	}

	strcpy(p_tmp_file_name, p_domain_imp->file_name);

	strcat(p_tmp_file_name, ".tmp");

	cl_spinlock_acquire(&p_domain_imp->lock);

	if (p_domain_imp->dirty == FALSE)

		goto Exit;

	/* open up the output file */

	p_file = fopen(p_tmp_file_name, "w");

	if (!p_file) {

		OSM_LOG(p_log, OSM_LOG_ERROR, "ERR 6107: "

			"Failed to open the db file:%s for writing: err:%s\n",

			p_domain_imp->file_name, strerror(errno));

		status = 1;

		goto Exit;

	}

	st_foreach(p_domain_imp->p_hash, dump_tbl_entry, (st_data_t) p_file);

	if (fsync_high_avail_files) {

		if (fflush(p_file) == 0) {

			fd = fileno(p_file);

			if (fd != -1) {

				if (fsync(fd) == -1)

					OSM_LOG(p_log, OSM_LOG_ERROR,

						"ERR 6110: fsync() failed (%s) for %s\n",

						strerror(errno),

						p_domain_imp->file_name);

			} else

				OSM_LOG(p_log, OSM_LOG_ERROR, "ERR 6111: "

					"fileno() failed for %s\n",

					p_domain_imp->file_name);

		} else

			OSM_LOG(p_log, OSM_LOG_ERROR, "ERR 6112: "

				"fflush() failed (%s) for %s\n",

				strerror(errno), p_domain_imp->file_name);

	}

	fclose(p_file);

	status = rename(p_tmp_file_name, p_domain_imp->file_name);

	if (status) {

		OSM_LOG(p_log, OSM_LOG_ERROR, "ERR 6108: "

			"Failed to rename the db file to:%s (err:%s)\n",

			p_domain_imp->file_name, strerror(errno));

		goto Exit;

	}

	p_domain_imp->dirty = FALSE;

Exit:

	cl_spinlock_release(&p_domain_imp->lock);

	free(p_tmp_file_name);

Exit2:

	OSM_LOG_EXIT(p_log);

	return status;

}

/* simply de-allocate the key and the value and return the code

   that makes the st_foreach delete the entry */

static int clear_tbl_entry(st_data_t key, st_data_t val, st_data_t arg)

{

	free((char *)key);

	free((char *)val);

	return ST_DELETE;

}

int osm_db_clear(IN osm_db_domain_t * p_domain)

{

	osm_db_domain_imp_t *p_domain_imp =

	    (osm_db_domain_imp_t *) p_domain->p_domain_imp;

	cl_spinlock_acquire(&p_domain_imp->lock);

	st_foreach(p_domain_imp->p_hash, clear_tbl_entry, (st_data_t) NULL);

	cl_spinlock_release(&p_domain_imp->lock);

	return 0;

}

static int get_key_of_tbl_entry(st_data_t key, st_data_t val, st_data_t arg)

{

	cl_list_t *p_list = (cl_list_t *) arg;

	cl_list_insert_tail(p_list, (void *)key);

	return ST_CONTINUE;

}

int osm_db_keys(IN osm_db_domain_t * p_domain, OUT cl_list_t * p_key_list)

{

	osm_db_domain_imp_t *p_domain_imp =

	    (osm_db_domain_imp_t *) p_domain->p_domain_imp;

	cl_spinlock_acquire(&p_domain_imp->lock);

	st_foreach(p_domain_imp->p_hash, get_key_of_tbl_entry,

		   (st_data_t) p_key_list);

	cl_spinlock_release(&p_domain_imp->lock);

	return 0;

}

char *osm_db_lookup(IN osm_db_domain_t * p_domain, IN char *p_key)

{

	osm_db_domain_imp_t *p_domain_imp =

	    (osm_db_domain_imp_t *) p_domain->p_domain_imp;

	char *p_val = NULL;

	cl_spinlock_acquire(&p_domain_imp->lock);

	if (!st_lookup(p_domain_imp->p_hash, (st_data_t) p_key, (void *)&p_val))

		p_val = NULL;

	cl_spinlock_release(&p_domain_imp->lock);

	return p_val;

}

int osm_db_update(IN osm_db_domain_t * p_domain, IN char *p_key, IN char *p_val)

{

	osm_log_t *p_log = p_domain->p_db->p_log;

	osm_db_domain_imp_t *p_domain_imp =

	    (osm_db_domain_imp_t *) p_domain->p_domain_imp;

	char *p_prev_val = NULL;

	char *p_new_key;

	char *p_new_val;

	cl_spinlock_acquire(&p_domain_imp->lock);

	if (st_lookup(p_domain_imp->p_hash,

		      (st_data_t) p_key, (void *)&p_prev_val)) {

		OSM_LOG(p_log, OSM_LOG_DEBUG,

			"Key:%s previously exists in:%s with value:%s\n",

			p_key, p_domain_imp->file_name, p_prev_val);

		p_new_key = p_key;

		/* same key, same value - nothing to update */

		if (p_prev_val && !strcmp(p_val, p_prev_val))

			goto Exit;

	} else {

		/* need to allocate the key */

		p_new_key = malloc(sizeof(char) * (strlen(p_key) + 1));

		strcpy(p_new_key, p_key);

	}

	/* need to arrange a new copy of the value */

	p_new_val = malloc(sizeof(char) * (strlen(p_val) + 1));

	strcpy(p_new_val, p_val);

	st_insert(p_domain_imp->p_hash, (st_data_t) p_new_key,

		  (st_data_t) p_new_val);

	if (p_prev_val)

		free(p_prev_val);

	p_domain_imp->dirty = TRUE;

Exit:

	cl_spinlock_release(&p_domain_imp->lock);

	return 0;

}

int osm_db_delete(IN osm_db_domain_t * p_domain, IN char *p_key)

{

	osm_log_t *p_log = p_domain->p_db->p_log;

	osm_db_domain_imp_t *p_domain_imp =

	    (osm_db_domain_imp_t *) p_domain->p_domain_imp;

	char *p_prev_val = NULL;

	int res;

	OSM_LOG_ENTER(p_log);

	cl_spinlock_acquire(&p_domain_imp->lock);

	if (st_delete(p_domain_imp->p_hash,

		      (void *)&p_key, (void *)&p_prev_val)) {

		if (st_lookup(p_domain_imp->p_hash,

			      (st_data_t) p_key, (void *)&p_prev_val)) {

			OSM_LOG(p_log, OSM_LOG_ERROR,

				"key:%s still exists in:%s with value:%s\n",

				p_key, p_domain_imp->file_name, p_prev_val);

			res = 1;

		} else {

			free(p_key);

			free(p_prev_val);

			p_domain_imp->dirty = TRUE;

			res = 0;

		}

	} else {

		OSM_LOG(p_log, OSM_LOG_DEBUG,

			"fail to find key:%s. delete failed\n", p_key);

		res = 1;

	}

	cl_spinlock_release(&p_domain_imp->lock);

	OSM_LOG_EXIT(p_log);

	return res;

}

#ifdef TEST_OSMDB

#include <stdlib.h>

#include <math.h>

int main(int argc, char **argv)

{

	osm_db_t db;

	osm_log_t log;

	osm_db_domain_t *p_dbd;

	cl_list_t keys;

	cl_list_iterator_t kI;

	char *p_key;

	char *p_val;

	int i;

	cl_list_construct(&keys);

	cl_list_init(&keys, 10);

	osm_log_init_v2(&log, TRUE, 0xff, "/var/log/osm_db_test.log", 0, FALSE);

	osm_db_construct(&db);

	if (osm_db_init(&db, &log)) {

		printf("db init failed\n");

		exit(1);

	}

	p_dbd = osm_db_domain_init(&db, "lid_by_guid");

	if (!p_dbd) {

		printf("db domain init failed\n");

		exit(1);

	}

	if (osm_db_restore(p_dbd)) {

		printf("failed to restore\n");

	}

	if (osm_db_keys(p_dbd, &keys)) {

		printf("failed to get keys\n");

	} else {

		kI = cl_list_head(&keys);

		while (kI != cl_list_end(&keys)) {

			p_key = cl_list_obj(kI);

			kI = cl_list_next(kI);

			p_val = osm_db_lookup(p_dbd, p_key);

			printf("key = %s val = %s\n", p_key, p_val);

		}

	}

	cl_list_remove_all(&keys);

	/* randomly add and remove numbers */

	for (i = 0; i < 10; i++) {

		int k;

		float v;

		int is_add;

		char val_buf[16];

		char key_buf[16];

		k = floor(1.0 * rand() / RAND_MAX * 100);

		v = rand();

		sprintf(key_buf, "%u", k);

		sprintf(val_buf, "%u", v);

		is_add = (rand() < RAND_MAX / 2);

		if (is_add) {

			osm_db_update(p_dbd, key_buf, val_buf);

		} else {

			osm_db_delete(p_dbd, key_buf);

		}

	}

	if (osm_db_keys(p_dbd, &keys)) {

		printf("failed to get keys\n");

	} else {

		kI = cl_list_head(&keys);

		while (kI != cl_list_end(&keys)) {

			p_key = cl_list_obj(kI);

			kI = cl_list_next(kI);

			p_val = osm_db_lookup(p_dbd, p_key);

			printf("key = %s val = %s\n", p_key, p_val);

		}

	}

	if (osm_db_store(p_dbd, FALSE))

		printf("failed to store\n");

	osm_db_destroy(&db);

	cl_list_destroy(&keys);

}

#endif