/*

 * Simple file storage for fprintd

 * Copyright (C) 2007 Daniel Drake <dsd@gentoo.org>

 * Copyright (C) 2008 Vasily Khoruzhick <anarsoul@gmail.com>

 *

 * 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; either version 2 of the License, or

 * (at your option) any later version.

 * 

 * 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 Street, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 */

/* FIXME:

 * This file almost duplicate data.c from libfprint

 * Maybe someday data.c will be upgraded to this one ;)

 */

#include <errno.h>

#include <stdlib.h>

#include <string.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <unistd.h>

#include <glib.h>

#include <glib/gstdio.h>

#include <fprint.h>

#include "file_storage.h"

#define FILE_STORAGE_PATH "/var/lib/fprint"

#define DIR_PERMS 0700

#define FP_FINGER_IS_VALID(finger) \

	((finger) >= FP_FINGER_LEFT_THUMB && (finger) <= FP_FINGER_RIGHT_LITTLE)

static const char *get_storage_path()

{

	const char *path;

	/* set by systemd >= 240 to an absolute path

	 * taking into account the StateDirectory

	 * unit file setting */

	path = g_getenv ("STATE_DIRECTORY");

	if (path != NULL)

		return path;

	return FILE_STORAGE_PATH;

}

static char *get_path_to_storedir(const char *driver, const char * device_id, char *base_store)

{

	return g_build_filename(base_store, driver, device_id, NULL);

}

static char *__get_path_to_print(const char *driver, const char * device_id,

	FpFinger finger, char *base_store)

{

	char *dirpath;

	char *path;

	char fingername[2];

	g_snprintf(fingername, 2, "%x", finger);

	dirpath = get_path_to_storedir(driver, device_id, base_store);

	path = g_build_filename(dirpath, fingername, NULL);

	g_free(dirpath);

	return path;

}

static char *get_path_to_print(FpDevice *dev, FpFinger finger, char *base_store)

{

	return __get_path_to_print(fp_device_get_driver (dev),

				   fp_device_get_device_id(dev),

				   finger,

				   base_store);

}

static char *get_path_to_print_dscv(FpDevice *dev, FpFinger finger, char *base_store)

{

	return __get_path_to_print(fp_device_get_driver (dev),

				   fp_device_get_device_id(dev),

				   finger,

				   base_store);

}

static char *file_storage_get_basestore_for_username(const char *username)

{

	return g_build_filename(get_storage_path(), username, NULL);

}

int file_storage_print_data_save(FpPrint *print)

{

	g_autoptr(GError) err = NULL;

	g_autofree char *path = NULL;

	g_autofree char *dirpath = NULL;

	g_autofree char *base_store = NULL;

	g_autofree char *buf = NULL;

	gsize len;

	int r;

	base_store = file_storage_get_basestore_for_username(fp_print_get_username (print));

	if (!fp_print_serialize (print, (guchar **) &buf, &len, &err)) {

		g_warning ("Error serializing data: %s", err->message);

		return -ENOMEM;

	}

	path = __get_path_to_print(fp_print_get_driver (print),

	                           fp_print_get_device_id (print),

	                           fp_print_get_finger (print),

	                           base_store);

	dirpath = g_path_get_dirname(path);

	r = g_mkdir_with_parents(dirpath, DIR_PERMS);

	if (r < 0) {

		g_debug("file_storage_print_data_save(): could not mkdir(\"%s\"): %s",

			dirpath, g_strerror(r));

		return r;

	}

	//fp_dbg("saving to %s", path);

	g_file_set_contents(path, buf, len, &err;;

	if (err) {

		g_debug("file_storage_print_data_save(): could not save '%s': %s",

			path, err->message);

		/* FIXME interpret error codes */

		return err->code;

	}

	return 0;

}

static int load_from_file(char *path, FpPrint **print)

{

	g_autoptr(GError) err = NULL;

	gsize length;

	char *contents;

	FpPrint *new;

	//fp_dbg("from %s", path);

	g_file_get_contents(path, &contents, &length, &err;;

	if (err) {

		int r = err->code;

		/* FIXME interpret more error codes */

		if (r == G_FILE_ERROR_NOENT)

			return -ENOENT;

		else

			return r;

	}

	new = fp_print_deserialize ((guchar *) contents, length, &err;;

	if (!new) {

		g_print ("Error deserializing data: %s", err->message);

		return -EIO;

	}

	*print = new;

	return 0;

}

int file_storage_print_data_load(FpDevice *dev,

				 FpFinger  finger,

				 const char *username,

				 FpPrint **print)

{

	g_autofree gchar *path = NULL;

	g_autofree gchar *base_store = NULL;

	FpPrint *new = NULL;

	int r;

	base_store = file_storage_get_basestore_for_username(username);

	path = get_path_to_print(dev, finger, base_store);

	r = load_from_file(path, &new;;

	g_debug ("file_storage_print_data_load(): loaded '%s' %s",

		 path, g_strerror(r));

	if (r)

		return r;

	if (!fp_print_compatible (new, dev)) {

		g_object_unref (new);

		return -EINVAL;

	}

	*print = new;

	return 0;

}

int file_storage_print_data_delete(FpDevice *dev, FpFinger finger, const char *username)

{

	g_autofree gchar *base_store = NULL;

	g_autofree gchar *path = NULL;

	int r;

	base_store = file_storage_get_basestore_for_username(username);

	path = get_path_to_print_dscv(dev, finger, base_store);

	r = g_unlink(path);

	g_debug("file_storage_print_data_delete(): unlink(\"%s\") %s",

		path, g_strerror(r));

	/* FIXME: cleanup empty directory */

	return g_unlink(path);

}

static GSList *scan_dev_storedir(char *devpath,

                                 GSList *list)

{

	g_autoptr(GError) err = NULL;

	const gchar *ent;

	GDir *dir = g_dir_open(devpath, 0, &err;;

	if (!dir) {

		g_debug("scan_dev_storedir(): opendir(\"%s\") failed: %s", devpath, err->message);

		return list;

	}

	while ((ent = g_dir_read_name(dir))) {

		/* ent is an 1 hex character fp_finger code */

		guint64 val;

		gchar *endptr;

		if (*ent == 0 || strlen(ent) != 1)

			continue;

		val = g_ascii_strtoull(ent, &endptr, 16);

		if (endptr == ent || !FP_FINGER_IS_VALID(val)) {

			g_debug("scan_dev_storedir(): skipping print file '%s'", ent);

			continue;

		}

		list = g_slist_prepend(list, GINT_TO_POINTER(val));

	}

	g_dir_close(dir);

	return list;

}

GSList *file_storage_discover_prints(FpDevice *dev, const char *username)

{

	GSList *list = NULL;

	g_autofree gchar *base_store = NULL;

	g_autofree gchar *storedir = NULL;

	base_store = file_storage_get_basestore_for_username(username);

	storedir = get_path_to_storedir(fp_device_get_driver (dev),

					fp_device_get_device_id (dev),

					base_store);

	g_debug ("file_storage_discover_prints() for user '%s' in '%s'",

		 username, storedir);

	list = scan_dev_storedir(storedir, list);

	return list;

}

GSList *file_storage_discover_users()

{

	g_autoptr(GError) err = NULL;

	GSList *list = NULL;

	const gchar *ent;

	GDir *dir = g_dir_open(get_storage_path(), 0, &err;;

	if (!dir) {

		return list;

	}

	while ((ent = g_dir_read_name(dir))) {

		/* ent is a username */

		if (*ent == 0)

			continue;

		list = g_slist_prepend(list, g_strdup (ent));

	}

	g_dir_close(dir);

	return list;

}

int file_storage_init(void)

{

	/* Nothing to do */

	return 0;

}

int file_storage_deinit(void)

{

	/* Nothing to do */

	return 0;

}