path: root/vconf-kdb.c

/*
 * libslp-setting
 *
 * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
 *
 * Contact: Hakjoo Ko <hakjoo.ko@samsung.com>
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */

#include <sys/types.h>
#include <sys/inotify.h>
#include <errno.h>
#include <fcntl.h>
#include <string.h>
#include <linux/version.h>
#include <stdlib.h>
#include <pthread.h>
#include <glib.h>
#include "vconf-internals.h"

#include <glib.h>

#define INOTY_EVENT_MASK   (IN_CLOSE_WRITE | IN_DELETE_SELF)

/* inotify */
struct noti_node {
	int wd;
	char *keyname;
	vconf_callback_fn cb;
	void *cb_data;
	struct noti_node *next;
};
typedef struct noti_node notilist;
static GList *g_notilist;

static int _vconf_inoti_comp_with_wd(gconstpointer a, gconstpointer b)
{
	int r;

	notilist *key1 = (notilist *) a;
	notilist *key2 = (notilist *) b;

	r = key1->wd - key2->wd;
	return r;
}

static int _vconf_inoti_comp_with_wd_cb(gconstpointer a, gconstpointer b)
{
	int r;

	notilist *key1 = (notilist *) a;
	notilist *key2 = (notilist *) b;

	r = key1->wd - key2->wd;
	if (r != 0)
		return r;

	r = (int)(key1->cb - key2->cb);
	return r;
}

static int _kdb_inoti_fd;

static pthread_mutex_t _kdb_inoti_fd_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t _kdb_g_ns_mutex = PTHREAD_MUTEX_INITIALIZER;

static GSource *_kdb_handler;

static gboolean _vconf_kdb_gio_cb(GIOChannel *src, GIOCondition cond, gpointer data)
{
	int fd, r;
	struct inotify_event ie;

	INFO("vconf noti function");

	fd = g_io_channel_unix_get_fd(src);
	r = read(fd, &ie, sizeof(ie));

	while (r > 0) {
		INFO("read event from GIOChannel. pid : %d", getpid());

		if (g_notilist) {

			struct noti_node *t = NULL;
			GList *noti_list = NULL;
			keynode_t* keynode = NULL;

			retvm_if(!(ie.mask & INOTY_EVENT_MASK), TRUE,
				"Invalid argument: ie.mask(%d), ie.len(%d)",
				 ie.mask, ie.len);

			/* pthread_mutex_lock(&_kdb_g_ns_mutex); */

			noti_list = g_list_first(g_notilist);

			while (noti_list) {
				t = noti_list->data;

				keynode_t* keynode = _vconf_keynode_new();
				retvm_if(keynode == NULL, TRUE, "key malloc fail");

				if( (t) && (t->wd == ie.wd) ) {
					if ((ie.mask & IN_DELETE_SELF)) {
						INFO("Notify that key(%s) is deleted", t->keyname);
						_vconf_keynode_set_keyname(keynode, (const char *)t->keyname);
						_vconf_keynode_set_null(keynode);
						t->cb(keynode, t->cb_data);
						_vconf_kdb_del_notify(t->keyname, t->cb);
					} else {
						_vconf_keynode_set_keyname(keynode, t->keyname);
						_vconf_get_key(keynode);
						t->cb(keynode, t->cb_data);
					}
				}

				_vconf_keynode_free(keynode);

				noti_list = g_list_next(noti_list);
			}
		}

		if (ie.len > 0)
			lseek(fd, ie.len, SEEK_CUR);

		r = read(fd, &ie, sizeof(ie));
	}
	return TRUE;
}

static int _vconf_kdb_noti_init(void)
{
	GIOChannel *gio;

	pthread_mutex_lock(&_kdb_inoti_fd_mutex);

	retm_if(0 < _kdb_inoti_fd, "Error : invalid _kdb_inoti_fd");

	_kdb_inoti_fd = inotify_init();
	if (_kdb_inoti_fd == -1) {
		char err_buf[100] = { 0, };
		strerror_r(errno, err_buf, sizeof(err_buf));
		ERR("inotify init: %s", err_buf);
		pthread_mutex_unlock(&_kdb_inoti_fd_mutex);
		return VCONF_ERROR;
	}

	fcntl(_kdb_inoti_fd, F_SETFD, FD_CLOEXEC);
	fcntl(_kdb_inoti_fd, F_SETFL, O_NONBLOCK);

	pthread_mutex_unlock(&_kdb_inoti_fd_mutex);

	gio = g_io_channel_unix_new(_kdb_inoti_fd);
	retvm_if(gio == NULL, -1, "Error: create a new GIOChannel");

	g_io_channel_set_flags(gio, G_IO_FLAG_NONBLOCK, NULL);

	_kdb_handler = g_io_create_watch(gio, G_IO_IN);
	g_source_set_callback(_kdb_handler, (GSourceFunc) _vconf_kdb_gio_cb, NULL, NULL);
	g_source_attach(_kdb_handler, NULL);
	g_io_channel_unref(gio);
	g_source_unref(_kdb_handler);

	return VCONF_OK;
}

int
_vconf_kdb_add_notify(const char *keyname, vconf_callback_fn cb, void *data)
{
	char path[KEY_PATH];
	int wd, r;
	struct noti_node t, *n;
	char err_buf[ERR_LEN] = { 0, };
	int ret = 0;
	GList *list = NULL;
	int func_ret = VCONF_OK;

	retvm_if((keyname == NULL || cb == NULL), VCONF_ERROR,
		"_vconf_kdb_add_notify : Invalid argument - keyname(%s) cb(%p)",
		 keyname, cb);

	if (_kdb_inoti_fd <= 0)
		if (_vconf_kdb_noti_init())
			return VCONF_ERROR;

	ret = _vconf_get_key_path((char*)keyname, path);
	retvm_if(ret != VCONF_OK, VCONF_ERROR, "Invalid argument: key is not valid");

	if (0 != access(path, F_OK)) {
		if (errno == ENOENT) {
			ERR("_vconf_kdb_add_notify : Key(%s) does not exist", keyname);
			return VCONF_ERROR;
		}
	}

	wd = inotify_add_watch(_kdb_inoti_fd, path, INOTY_EVENT_MASK);
	if (wd == -1) {
		strerror_r(errno, err_buf, sizeof(err_buf));
		ERR("_vconf_kdb_add_notify : add noti(%s)", err_buf);
		return VCONF_ERROR;
	}

	t.wd = wd;
	t.cb = cb;

	pthread_mutex_lock(&_kdb_g_ns_mutex);

	list = g_list_find_custom(g_notilist, &t, (GCompareFunc)_vconf_inoti_comp_with_wd_cb);
	if (list) {
		ERR("_vconf_kdb_add_notify : key(%s) has same callback(%p)", keyname, cb);
		errno = EALREADY;
		func_ret = VCONF_ERROR;
		goto out_func;
	}

	n = calloc(1, sizeof(notilist));
	if (n == NULL) {
		strerror_r(errno, err_buf, sizeof(err_buf));
		ERR("_vconf_kdb_add_notify : add noti(%s)", err_buf);
		func_ret = VCONF_ERROR;
		goto out_func;
	}

	n->wd = wd;
	n->keyname = strndup(keyname, BUF_LEN);
	n->cb_data = data;
	n->cb = cb;

	g_notilist = g_list_append(g_notilist, n);
	if(!g_notilist) {
		ERR("g_list_append fail");
	}

	INFO("cb(%p) is added for %s. tot cb cnt : %d\n", cb, n->keyname, g_list_length(g_notilist));

out_func:
	pthread_mutex_unlock(&_kdb_g_ns_mutex);

	return func_ret;
}

int
_vconf_kdb_del_notify(const char *keyname, vconf_callback_fn cb)
{
	int wd = 0;
	int r = 0;
	struct noti_node *n = NULL;
	struct noti_node t;
	char path[KEY_PATH] = { 0, };
	char err_buf[ERR_LEN] = { 0, };
	int del = 0;
	int remain = 0;
	int ret = 0;
	int func_ret = VCONF_OK;
	GList *noti_list;

	retvm_if(keyname == NULL, VCONF_ERROR, "Invalid argument: keyname(%s)", keyname);
	retvm_if(_kdb_inoti_fd == 0, VCONF_ERROR, "Invalid operation: not exist anything for inotify");

	ret = _vconf_get_key_path((char*)keyname, path);
	retvm_if(ret != VCONF_OK, VCONF_ERROR, "Invalid argument: key is not valid");

	/* get wd */
	wd = inotify_add_watch(_kdb_inoti_fd, path, INOTY_EVENT_MASK);
	if (wd == -1) {
		strerror_r(errno, err_buf, sizeof(err_buf));
		ERR("Error: inotify_add_watch() [%s]: %s", path, err_buf);
		return VCONF_ERROR;
	}

	pthread_mutex_lock(&_kdb_g_ns_mutex);

	t.wd = wd;
	t.cb = cb;

	noti_list = g_list_find_custom(g_notilist, &t, (GCompareFunc)_vconf_inoti_comp_with_wd_cb);
	if(noti_list) {
		del++;

		n = noti_list->data;
		g_notilist = g_list_remove(g_notilist, n);
		g_free(n->keyname);
		g_free(n);

		INFO("key(%s) cb is removed. remained noti list total length(%d)",
			keyname, g_list_length(g_notilist));
	}

	noti_list = NULL;
	noti_list = g_list_find_custom(g_notilist, &t, (GCompareFunc)_vconf_inoti_comp_with_wd);
	if(noti_list == NULL) {
		INFO("all noti for keyname(%s)/wd(%d) is removed", keyname, wd);

		r = inotify_rm_watch(_kdb_inoti_fd, wd);
		if(r == -1) {
			strerror_r(errno, err_buf, sizeof(err_buf));
			ERR("Error: inotify_rm_watch [%s]: %s", keyname, err_buf);
			func_ret = VCONF_ERROR;
		}
	}

	if(g_list_length(g_notilist) == 0) {
		close(_kdb_inoti_fd);
		_kdb_inoti_fd = 0;

		g_source_destroy(_kdb_handler);
		_kdb_handler = NULL;

		g_list_free(g_notilist);
		g_notilist = NULL;

		INFO("all noti list is freed");
	}

	pthread_mutex_unlock(&_kdb_g_ns_mutex);

	if(del == 0) {
		ERR("Error: nothing deleted");
		errno = ENOENT;
		func_ret = VCONF_ERROR;
	}

	return func_ret;
}