[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / staging / pohmelfs / config.c

/*
 * 2007+ Copyright (c) Evgeniy Polyakov <zbr@ioremap.net>
 * 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 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.
 */

#include <linux/kernel.h>
#include <linux/connector.h>
#include <linux/crypto.h>
#include <linux/list.h>
#include <linux/mutex.h>
#include <linux/string.h>
#include <linux/in.h>
#include <linux/slab.h>

#include "netfs.h"

/*
 * Global configuration list.
 * Each client can be asked to get one of them.
 *
 * Allows to provide remote server address (ipv4/v6/whatever), port
 * and so on via kernel connector.
 */

static struct cb_id pohmelfs_cn_id = {.idx = POHMELFS_CN_IDX, .val = POHMELFS_CN_VAL};
static LIST_HEAD(pohmelfs_config_list);
static DEFINE_MUTEX(pohmelfs_config_lock);

static inline int pohmelfs_config_eql(struct pohmelfs_ctl *sc, struct pohmelfs_ctl *ctl)
{
	if (sc->idx == ctl->idx && sc->type == ctl->type &&
			sc->proto == ctl->proto &&
			sc->addrlen == ctl->addrlen &&
			!memcmp(&sc->addr, &ctl->addr, ctl->addrlen))
		return 1;

	return 0;
}

static struct pohmelfs_config_group *pohmelfs_find_config_group(unsigned int idx)
{
	struct pohmelfs_config_group *g, *group = NULL;

	list_for_each_entry(g, &pohmelfs_config_list, group_entry) {
		if (g->idx == idx) {
			group = g;
			break;
		}
	}

	return group;
}

static struct pohmelfs_config_group *pohmelfs_find_create_config_group(unsigned int idx)
{
	struct pohmelfs_config_group *g;

	g = pohmelfs_find_config_group(idx);
	if (g)
		return g;

	g = kzalloc(sizeof(struct pohmelfs_config_group), GFP_KERNEL);
	if (!g)
		return NULL;

	INIT_LIST_HEAD(&g->config_list);
	g->idx = idx;
	g->num_entry = 0;

	list_add_tail(&g->group_entry, &pohmelfs_config_list);

	return g;
}

static inline void pohmelfs_insert_config_entry(struct pohmelfs_sb *psb, struct pohmelfs_config *dst)
{
	struct pohmelfs_config *tmp;

	INIT_LIST_HEAD(&dst->config_entry);

	list_for_each_entry(tmp, &psb->state_list, config_entry) {
		if (dst->state.ctl.prio > tmp->state.ctl.prio)
			list_add_tail(&dst->config_entry, &tmp->config_entry);
	}
	if (list_empty(&dst->config_entry))
		list_add_tail(&dst->config_entry, &psb->state_list);
}

static int pohmelfs_move_config_entry(struct pohmelfs_sb *psb,
		struct pohmelfs_config *dst, struct pohmelfs_config *new)
{
	if ((dst->state.ctl.prio == new->state.ctl.prio) &&
		(dst->state.ctl.perm == new->state.ctl.perm))
		return 0;

	dprintk("%s: dst: prio: %d, perm: %x, new: prio: %d, perm: %d.\n",
			__func__, dst->state.ctl.prio, dst->state.ctl.perm,
			new->state.ctl.prio, new->state.ctl.perm);
	dst->state.ctl.prio = new->state.ctl.prio;
	dst->state.ctl.perm = new->state.ctl.perm;

	list_del_init(&dst->config_entry);
	pohmelfs_insert_config_entry(psb, dst);
	return 0;
}

/*
 * pohmelfs_copy_config() is used to copy new state configs from the
 * config group (controlled by the netlink messages) into the superblock.
 * This happens either at startup time where no transactions can access
 * the list of the configs (and thus list of the network states), or at
 * run-time, where it is protected by the psb->state_lock.
 */
int pohmelfs_copy_config(struct pohmelfs_sb *psb)
{
	struct pohmelfs_config_group *g;
	struct pohmelfs_config *c, *dst;
	int err = -ENODEV;

	mutex_lock(&pohmelfs_config_lock);

	g = pohmelfs_find_config_group(psb->idx);
	if (!g)
		goto out_unlock;

	/*
	 * Run over all entries in given config group and try to crate and
	 * initialize those, which do not exist in superblock list.
	 * Skip all existing entries.
	 */

	list_for_each_entry(c, &g->config_list, config_entry) {
		err = 0;
		list_for_each_entry(dst, &psb->state_list, config_entry) {
			if (pohmelfs_config_eql(&dst->state.ctl, &c->state.ctl)) {
				err = pohmelfs_move_config_entry(psb, dst, c);
				if (!err)
					err = -EEXIST;
				break;
			}
		}

		if (err)
			continue;

		dst = kzalloc(sizeof(struct pohmelfs_config), GFP_KERNEL);
		if (!dst) {
			err = -ENOMEM;
			break;
		}

		memcpy(&dst->state.ctl, &c->state.ctl, sizeof(struct pohmelfs_ctl));

		pohmelfs_insert_config_entry(psb, dst);

		err = pohmelfs_state_init_one(psb, dst);
		if (err) {
			list_del(&dst->config_entry);
			kfree(dst);
		}

		err = 0;
	}

out_unlock:
	mutex_unlock(&pohmelfs_config_lock);

	return err;
}

int pohmelfs_copy_crypto(struct pohmelfs_sb *psb)
{
	struct pohmelfs_config_group *g;
	int err = -ENOENT;

	mutex_lock(&pohmelfs_config_lock);
	g = pohmelfs_find_config_group(psb->idx);
	if (!g)
		goto err_out_exit;

	if (g->hash_string) {
		err = -ENOMEM;
		psb->hash_string = kstrdup(g->hash_string, GFP_KERNEL);
		if (!psb->hash_string)
			goto err_out_exit;
		psb->hash_strlen = g->hash_strlen;
	}

	if (g->cipher_string) {
		psb->cipher_string = kstrdup(g->cipher_string, GFP_KERNEL);
		if (!psb->cipher_string)
			goto err_out_free_hash_string;
		psb->cipher_strlen = g->cipher_strlen;
	}

	if (g->hash_keysize) {
		psb->hash_key = kmalloc(g->hash_keysize, GFP_KERNEL);
		if (!psb->hash_key)
			goto err_out_free_cipher_string;
		memcpy(psb->hash_key, g->hash_key, g->hash_keysize);
		psb->hash_keysize = g->hash_keysize;
	}

	if (g->cipher_keysize) {
		psb->cipher_key = kmalloc(g->cipher_keysize, GFP_KERNEL);
		if (!psb->cipher_key)
			goto err_out_free_hash;
		memcpy(psb->cipher_key, g->cipher_key, g->cipher_keysize);
		psb->cipher_keysize = g->cipher_keysize;
	}

	mutex_unlock(&pohmelfs_config_lock);

	return 0;

err_out_free_hash:
	kfree(psb->hash_key);
err_out_free_cipher_string:
	kfree(psb->cipher_string);
err_out_free_hash_string:
	kfree(psb->hash_string);
err_out_exit:
	mutex_unlock(&pohmelfs_config_lock);
	return err;
}

static int pohmelfs_send_reply(int err, int msg_num, int action, struct cn_msg *msg, struct pohmelfs_ctl *ctl)
{
	struct pohmelfs_cn_ack *ack;

	ack = kmalloc(sizeof(struct pohmelfs_cn_ack), GFP_KERNEL);
	if (!ack)
		return -ENOMEM;

	memset(ack, 0, sizeof(struct pohmelfs_cn_ack));
	memcpy(&ack->msg, msg, sizeof(struct cn_msg));

	if (action == POHMELFS_CTLINFO_ACK)
		memcpy(&ack->ctl, ctl, sizeof(struct pohmelfs_ctl));

	ack->msg.len = sizeof(struct pohmelfs_cn_ack) - sizeof(struct cn_msg);
	ack->msg.ack = msg->ack + 1;
	ack->error = err;
	ack->msg_num = msg_num;

	cn_netlink_send(&ack->msg, 0, GFP_KERNEL);
	kfree(ack);
	return 0;
}

static int pohmelfs_cn_disp(struct cn_msg *msg)
{
	struct pohmelfs_config_group *g;
	struct pohmelfs_ctl *ctl = (struct pohmelfs_ctl *)msg->data;
	struct pohmelfs_config *c, *tmp;
	int err = 0, i = 1;

	if (msg->len != sizeof(struct pohmelfs_ctl))
		return -EBADMSG;

	mutex_lock(&pohmelfs_config_lock);

	g = pohmelfs_find_config_group(ctl->idx);
	if (!g) {
		pohmelfs_send_reply(err, 0, POHMELFS_NOINFO_ACK, msg, NULL);
		goto out_unlock;
	}

	list_for_each_entry_safe(c, tmp, &g->config_list, config_entry) {
		struct pohmelfs_ctl *sc = &c->state.ctl;
		if (pohmelfs_send_reply(err, g->num_entry - i, POHMELFS_CTLINFO_ACK, msg, sc)) {
			err = -ENOMEM;
			goto out_unlock;
		}
		i += 1;
	}

 out_unlock:
	mutex_unlock(&pohmelfs_config_lock);
	return err;
}

static int pohmelfs_cn_dump(struct cn_msg *msg)
{
	struct pohmelfs_config_group *g;
	struct pohmelfs_config *c, *tmp;
	int err = 0, i = 1;
	int total_msg = 0;

	if (msg->len != sizeof(struct pohmelfs_ctl))
		return -EBADMSG;

	mutex_lock(&pohmelfs_config_lock);

	list_for_each_entry(g, &pohmelfs_config_list, group_entry) {
		if (g)
			total_msg += g->num_entry;
	}
	if (total_msg == 0) {
		if (pohmelfs_send_reply(err, 0, POHMELFS_NOINFO_ACK, msg, NULL))
			err = -ENOMEM;
		goto out_unlock;
	}

	list_for_each_entry(g, &pohmelfs_config_list, group_entry) {
		if (g) {
			list_for_each_entry_safe(c, tmp, &g->config_list, config_entry) {
				struct pohmelfs_ctl *sc = &c->state.ctl;
				if (pohmelfs_send_reply(err, total_msg - i, POHMELFS_CTLINFO_ACK, msg, sc)) {
					err = -ENOMEM;
					goto out_unlock;
				}
				i += 1;
			}
		}
	}

out_unlock:
	mutex_unlock(&pohmelfs_config_lock);
	return err;
}

static int pohmelfs_cn_flush(struct cn_msg *msg)
{
	struct pohmelfs_config_group *g;
	struct pohmelfs_ctl *ctl = (struct pohmelfs_ctl *)msg->data;
	struct pohmelfs_config *c, *tmp;
	int err = 0;

	if (msg->len != sizeof(struct pohmelfs_ctl))
		return -EBADMSG;

	mutex_lock(&pohmelfs_config_lock);

	if (ctl->idx != POHMELFS_NULL_IDX) {
		g = pohmelfs_find_config_group(ctl->idx);

		if (!g)
			goto out_unlock;

		list_for_each_entry_safe(c, tmp, &g->config_list, config_entry) {
			list_del(&c->config_entry);
			g->num_entry--;
			kfree(c);
		}
	} else {
		list_for_each_entry(g, &pohmelfs_config_list, group_entry) {
			if (g) {
				list_for_each_entry_safe(c, tmp, &g->config_list, config_entry) {
					list_del(&c->config_entry);
					g->num_entry--;
					kfree(c);
				}
			}
		}
	}

out_unlock:
	mutex_unlock(&pohmelfs_config_lock);
	pohmelfs_cn_dump(msg);

	return err;
}

static int pohmelfs_modify_config(struct pohmelfs_ctl *old, struct pohmelfs_ctl *new)
{
	old->perm = new->perm;
	old->prio = new->prio;
	return 0;
}

static int pohmelfs_cn_ctl(struct cn_msg *msg, int action)
{
	struct pohmelfs_config_group *g;
	struct pohmelfs_ctl *ctl = (struct pohmelfs_ctl *)msg->data;
	struct pohmelfs_config *c, *tmp;
	int err = 0;

	if (msg->len != sizeof(struct pohmelfs_ctl))
		return -EBADMSG;

	mutex_lock(&pohmelfs_config_lock);

	g = pohmelfs_find_create_config_group(ctl->idx);
	if (!g) {
		err = -ENOMEM;
		goto out_unlock;
	}

	list_for_each_entry_safe(c, tmp, &g->config_list, config_entry) {
		struct pohmelfs_ctl *sc = &c->state.ctl;

		if (pohmelfs_config_eql(sc, ctl)) {
			if (action == POHMELFS_FLAGS_ADD) {
				err = -EEXIST;
				goto out_unlock;
			} else if (action == POHMELFS_FLAGS_DEL) {
				list_del(&c->config_entry);
				g->num_entry--;
				kfree(c);
				goto out_unlock;
			} else if (action == POHMELFS_FLAGS_MODIFY) {
				err = pohmelfs_modify_config(sc, ctl);
				goto out_unlock;
			} else {
				err = -EEXIST;
				goto out_unlock;
			}
		}
	}
	if (action == POHMELFS_FLAGS_DEL) {
		err = -EBADMSG;
		goto out_unlock;
	}

	c = kzalloc(sizeof(struct pohmelfs_config), GFP_KERNEL);
	if (!c) {
		err = -ENOMEM;
		goto out_unlock;
	}
	memcpy(&c->state.ctl, ctl, sizeof(struct pohmelfs_ctl));
	g->num_entry++;

	list_add_tail(&c->config_entry, &g->config_list);

 out_unlock:
	mutex_unlock(&pohmelfs_config_lock);
	if (pohmelfs_send_reply(err, 0, POHMELFS_NOINFO_ACK, msg, NULL))
		err = -ENOMEM;

	return err;
}

static int pohmelfs_crypto_hash_init(struct pohmelfs_config_group *g, struct pohmelfs_crypto *c)
{
	char *algo = (char *)c->data;
	u8 *key = (u8 *)(algo + c->strlen);

	if (g->hash_string)
		return -EEXIST;

	g->hash_string = kstrdup(algo, GFP_KERNEL);
	if (!g->hash_string)
		return -ENOMEM;
	g->hash_strlen = c->strlen;
	g->hash_keysize = c->keysize;

	g->hash_key = kmalloc(c->keysize, GFP_KERNEL);
	if (!g->hash_key) {
		kfree(g->hash_string);
		return -ENOMEM;
	}

	memcpy(g->hash_key, key, c->keysize);

	return 0;
}

static int pohmelfs_crypto_cipher_init(struct pohmelfs_config_group *g, struct pohmelfs_crypto *c)
{
	char *algo = (char *)c->data;
	u8 *key = (u8 *)(algo + c->strlen);

	if (g->cipher_string)
		return -EEXIST;

	g->cipher_string = kstrdup(algo, GFP_KERNEL);
	if (!g->cipher_string)
		return -ENOMEM;
	g->cipher_strlen = c->strlen;
	g->cipher_keysize = c->keysize;

	g->cipher_key = kmalloc(c->keysize, GFP_KERNEL);
	if (!g->cipher_key) {
		kfree(g->cipher_string);
		return -ENOMEM;
	}

	memcpy(g->cipher_key, key, c->keysize);

	return 0;
}

static int pohmelfs_cn_crypto(struct cn_msg *msg)
{
	struct pohmelfs_crypto *crypto = (struct pohmelfs_crypto *)msg->data;
	struct pohmelfs_config_group *g;
	int err = 0;

	dprintk("%s: idx: %u, strlen: %u, type: %u, keysize: %u, algo: %s.\n",
			__func__, crypto->idx, crypto->strlen, crypto->type,
			crypto->keysize, (char *)crypto->data);

	mutex_lock(&pohmelfs_config_lock);
	g = pohmelfs_find_create_config_group(crypto->idx);
	if (!g) {
		err = -ENOMEM;
		goto out_unlock;
	}

	switch (crypto->type) {
		case POHMELFS_CRYPTO_HASH:
			err = pohmelfs_crypto_hash_init(g, crypto);
			break;
		case POHMELFS_CRYPTO_CIPHER:
			err = pohmelfs_crypto_cipher_init(g, crypto);
			break;
		default:
			err = -ENOTSUPP;
			break;
	}

out_unlock:
	mutex_unlock(&pohmelfs_config_lock);
	if (pohmelfs_send_reply(err, 0, POHMELFS_NOINFO_ACK, msg, NULL))
		err = -ENOMEM;

	return err;
}

static void pohmelfs_cn_callback(struct cn_msg *msg, struct netlink_skb_parms *nsp)
{
	int err;

	if (!cap_raised(nsp->eff_cap, CAP_SYS_ADMIN))
		return;

	switch (msg->flags) {
		case POHMELFS_FLAGS_ADD:
		case POHMELFS_FLAGS_DEL:
		case POHMELFS_FLAGS_MODIFY:
			err = pohmelfs_cn_ctl(msg, msg->flags);
			break;
		case POHMELFS_FLAGS_FLUSH:
			err = pohmelfs_cn_flush(msg);
			break;
		case POHMELFS_FLAGS_SHOW:
			err = pohmelfs_cn_disp(msg);
			break;
		case POHMELFS_FLAGS_DUMP:
			err = pohmelfs_cn_dump(msg);
			break;
		case POHMELFS_FLAGS_CRYPTO:
			err = pohmelfs_cn_crypto(msg);
			break;
		default:
			err = -ENOSYS;
			break;
	}
}

int pohmelfs_config_check(struct pohmelfs_config *config, int idx)
{
	struct pohmelfs_ctl *ctl = &config->state.ctl;
	struct pohmelfs_config *tmp;
	int err = -ENOENT;
	struct pohmelfs_ctl *sc;
	struct pohmelfs_config_group *g;

	mutex_lock(&pohmelfs_config_lock);

	g = pohmelfs_find_config_group(ctl->idx);
	if (g) {
		list_for_each_entry(tmp, &g->config_list, config_entry) {
			sc = &tmp->state.ctl;

			if (pohmelfs_config_eql(sc, ctl)) {
				err = 0;
				break;
			}
		}
	}

	mutex_unlock(&pohmelfs_config_lock);

	return err;
}

int __init pohmelfs_config_init(void)
{
	/* XXX remove (void *) cast when vanilla connector got synced */
	return cn_add_callback(&pohmelfs_cn_id, "pohmelfs", (void *)pohmelfs_cn_callback);
}

void pohmelfs_config_exit(void)
{
	struct pohmelfs_config *c, *tmp;
	struct pohmelfs_config_group *g, *gtmp;

	cn_del_callback(&pohmelfs_cn_id);

	mutex_lock(&pohmelfs_config_lock);
	list_for_each_entry_safe(g, gtmp, &pohmelfs_config_list, group_entry) {
		list_for_each_entry_safe(c, tmp, &g->config_list, config_entry) {
			list_del(&c->config_entry);
			kfree(c);
		}

		list_del(&g->group_entry);

		if (g->hash_string)
			kfree(g->hash_string);

		if (g->cipher_string)
			kfree(g->cipher_string);

		kfree(g);
	}
	mutex_unlock(&pohmelfs_config_lock);
}
Commit	Line	Data
9ce8b619 EP	1	/*
	2	* 2007+ Copyright (c) Evgeniy Polyakov <zbr@ioremap.net>
	3	* All rights reserved.
	4	*
	5	* This program is free software; you can redistribute it and/or modify
	6	* it under the terms of the GNU General Public License as published by
	7	* the Free Software Foundation; either version 2 of the License, or
	8	* (at your option) any later version.
	9	*
	10	* This program is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	* GNU General Public License for more details.
	14	*/
	15
	16	#include <linux/kernel.h>
	17	#include <linux/connector.h>
	18	#include <linux/crypto.h>
	19	#include <linux/list.h>
	20	#include <linux/mutex.h>
	21	#include <linux/string.h>
	22	#include <linux/in.h>
5a0e3ad6	23	#include <linux/slab.h>
9ce8b619 EP	24
	25	#include "netfs.h"
	26
	27	/*
	28	* Global configuration list.
	29	* Each client can be asked to get one of them.
	30	*
	31	* Allows to provide remote server address (ipv4/v6/whatever), port
	32	* and so on via kernel connector.
	33	*/
	34
	35	static struct cb_id pohmelfs_cn_id = {.idx = POHMELFS_CN_IDX, .val = POHMELFS_CN_VAL};
	36	static LIST_HEAD(pohmelfs_config_list);
	37	static DEFINE_MUTEX(pohmelfs_config_lock);
	38
	39	static inline int pohmelfs_config_eql(struct pohmelfs_ctl sc, struct pohmelfs_ctl ctl)
	40	{
	41	if (sc->idx == ctl->idx && sc->type == ctl->type &&
	42	sc->proto == ctl->proto &&
	43	sc->addrlen == ctl->addrlen &&
	44	!memcmp(&sc->addr, &ctl->addr, ctl->addrlen))
	45	return 1;
	46
	47	return 0;
	48	}
	49
	50	static struct pohmelfs_config_group *pohmelfs_find_config_group(unsigned int idx)
	51	{
	52	struct pohmelfs_config_group g, group = NULL;
	53
	54	list_for_each_entry(g, &pohmelfs_config_list, group_entry) {
	55	if (g->idx == idx) {
	56	group = g;
	57	break;
	58	}
	59	}
	60
	61	return group;
	62	}
	63
	64	static struct pohmelfs_config_group *pohmelfs_find_create_config_group(unsigned int idx)
	65	{
	66	struct pohmelfs_config_group *g;
	67
	68	g = pohmelfs_find_config_group(idx);
	69	if (g)
	70	return g;
	71
	72	g = kzalloc(sizeof(struct pohmelfs_config_group), GFP_KERNEL);
	73	if (!g)
	74	return NULL;
	75
	76	INIT_LIST_HEAD(&g->config_list);
	77	g->idx = idx;
	78	g->num_entry = 0;
	79
	80	list_add_tail(&g->group_entry, &pohmelfs_config_list);
	81
	82	return g;
	83	}
	84
e0ca8739 EP	85	static inline void pohmelfs_insert_config_entry(struct pohmelfs_sb psb, struct pohmelfs_config dst)
	86	{
	87	struct pohmelfs_config *tmp;
	88
	89	INIT_LIST_HEAD(&dst->config_entry);
	90
	91	list_for_each_entry(tmp, &psb->state_list, config_entry) {
	92	if (dst->state.ctl.prio > tmp->state.ctl.prio)
	93	list_add_tail(&dst->config_entry, &tmp->config_entry);
	94	}
	95	if (list_empty(&dst->config_entry))
	96	list_add_tail(&dst->config_entry, &psb->state_list);
	97	}
	98
	99	static int pohmelfs_move_config_entry(struct pohmelfs_sb *psb,
	100	struct pohmelfs_config dst, struct pohmelfs_config new)
	101	{
	102	if ((dst->state.ctl.prio == new->state.ctl.prio) &&
	103	(dst->state.ctl.perm == new->state.ctl.perm))
	104	return 0;
	105
	106	dprintk("%s: dst: prio: %d, perm: %x, new: prio: %d, perm: %d.\n",
	107	__func__, dst->state.ctl.prio, dst->state.ctl.perm,
	108	new->state.ctl.prio, new->state.ctl.perm);
	109	dst->state.ctl.prio = new->state.ctl.prio;
	110	dst->state.ctl.perm = new->state.ctl.perm;
	111
	112	list_del_init(&dst->config_entry);
	113	pohmelfs_insert_config_entry(psb, dst);
	114	return 0;
	115	}
	116
	117	/*
	118	* pohmelfs_copy_config() is used to copy new state configs from the
	119	* config group (controlled by the netlink messages) into the superblock.
	120	* This happens either at startup time where no transactions can access
	121	* the list of the configs (and thus list of the network states), or at
	122	* run-time, where it is protected by the psb->state_lock.
	123	*/
9ce8b619 EP	124	int pohmelfs_copy_config(struct pohmelfs_sb *psb)
	125	{
	126	struct pohmelfs_config_group *g;
	127	struct pohmelfs_config c, dst;
	128	int err = -ENODEV;
	129
	130	mutex_lock(&pohmelfs_config_lock);
	131
	132	g = pohmelfs_find_config_group(psb->idx);
	133	if (!g)
	134	goto out_unlock;
	135
	136	/*
	137	* Run over all entries in given config group and try to crate and
	138	* initialize those, which do not exist in superblock list.
	139	* Skip all existing entries.
	140	*/
	141
	142	list_for_each_entry(c, &g->config_list, config_entry) {
	143	err = 0;
	144	list_for_each_entry(dst, &psb->state_list, config_entry) {
	145	if (pohmelfs_config_eql(&dst->state.ctl, &c->state.ctl)) {
e0ca8739 EP	146	err = pohmelfs_move_config_entry(psb, dst, c);
	147	if (!err)
	148	err = -EEXIST;
9ce8b619 EP	149	break;
	150	}
	151	}
	152
	153	if (err)
	154	continue;
	155
	156	dst = kzalloc(sizeof(struct pohmelfs_config), GFP_KERNEL);
	157	if (!dst) {
	158	err = -ENOMEM;
	159	break;
	160	}
	161
	162	memcpy(&dst->state.ctl, &c->state.ctl, sizeof(struct pohmelfs_ctl));
	163
e0ca8739	164	pohmelfs_insert_config_entry(psb, dst);
9ce8b619 EP	165
	166	err = pohmelfs_state_init_one(psb, dst);
	167	if (err) {
	168	list_del(&dst->config_entry);
	169	kfree(dst);
	170	}
	171
	172	err = 0;
	173	}
	174
	175	out_unlock:
	176	mutex_unlock(&pohmelfs_config_lock);
	177
	178	return err;
	179	}
	180
	181	int pohmelfs_copy_crypto(struct pohmelfs_sb *psb)
	182	{
	183	struct pohmelfs_config_group *g;
	184	int err = -ENOENT;
	185
	186	mutex_lock(&pohmelfs_config_lock);
	187	g = pohmelfs_find_config_group(psb->idx);
	188	if (!g)
	189	goto err_out_exit;
	190
	191	if (g->hash_string) {
	192	err = -ENOMEM;
	193	psb->hash_string = kstrdup(g->hash_string, GFP_KERNEL);
	194	if (!psb->hash_string)
	195	goto err_out_exit;
	196	psb->hash_strlen = g->hash_strlen;
	197	}
	198
	199	if (g->cipher_string) {
	200	psb->cipher_string = kstrdup(g->cipher_string, GFP_KERNEL);
	201	if (!psb->cipher_string)
	202	goto err_out_free_hash_string;
	203	psb->cipher_strlen = g->cipher_strlen;
	204	}
	205
	206	if (g->hash_keysize) {
	207	psb->hash_key = kmalloc(g->hash_keysize, GFP_KERNEL);
	208	if (!psb->hash_key)
	209	goto err_out_free_cipher_string;
	210	memcpy(psb->hash_key, g->hash_key, g->hash_keysize);
	211	psb->hash_keysize = g->hash_keysize;
	212	}
	213
	214	if (g->cipher_keysize) {
	215	psb->cipher_key = kmalloc(g->cipher_keysize, GFP_KERNEL);
	216	if (!psb->cipher_key)
	217	goto err_out_free_hash;
	218	memcpy(psb->cipher_key, g->cipher_key, g->cipher_keysize);
	219	psb->cipher_keysize = g->cipher_keysize;
	220	}
	221
	222	mutex_unlock(&pohmelfs_config_lock);
	223
	224	return 0;
	225
	226	err_out_free_hash:
	227	kfree(psb->hash_key);
	228	err_out_free_cipher_string:
229	kfree(psb->cipher_string);
230	err_out_free_hash_string:
231	kfree(psb->hash_string);
232	err_out_exit:
233	mutex_unlock(&pohmelfs_config_lock);
234	return err;
235	}
236
237	static int pohmelfs_send_reply(int err, int msg_num, int action, struct cn_msg msg, struct pohmelfs_ctl ctl)
238	{
239	struct pohmelfs_cn_ack *ack;
240
241	ack = kmalloc(sizeof(struct pohmelfs_cn_ack), GFP_KERNEL);
242	if (!ack)
243	return -ENOMEM;
244
245	memset(ack, 0, sizeof(struct pohmelfs_cn_ack));
246	memcpy(&ack->msg, msg, sizeof(struct cn_msg));
247
248	if (action == POHMELFS_CTLINFO_ACK)
249	memcpy(&ack->ctl, ctl, sizeof(struct pohmelfs_ctl));
250
251	ack->msg.len = sizeof(struct pohmelfs_cn_ack) - sizeof(struct cn_msg);
252	ack->msg.ack = msg->ack + 1;
253	ack->error = err;
254	ack->msg_num = msg_num;
255
256	cn_netlink_send(&ack->msg, 0, GFP_KERNEL);
257	kfree(ack);
258	return 0;
259	}
260
261	static int pohmelfs_cn_disp(struct cn_msg *msg)
262	{
263	struct pohmelfs_config_group *g;
264	struct pohmelfs_ctl ctl = (struct pohmelfs_ctl )msg->data;
265	struct pohmelfs_config c, tmp;
266	int err = 0, i = 1;
267
268	if (msg->len != sizeof(struct pohmelfs_ctl))
269	return -EBADMSG;
270
271	mutex_lock(&pohmelfs_config_lock);
272
273	g = pohmelfs_find_config_group(ctl->idx);
274	if (!g) {
275	pohmelfs_send_reply(err, 0, POHMELFS_NOINFO_ACK, msg, NULL);
276	goto out_unlock;
277	}
278
279	list_for_each_entry_safe(c, tmp, &g->config_list, config_entry) {
280	struct pohmelfs_ctl *sc = &c->state.ctl;
281	if (pohmelfs_send_reply(err, g->num_entry - i, POHMELFS_CTLINFO_ACK, msg, sc)) {
282	err = -ENOMEM;
283	goto out_unlock;
284	}
285	i += 1;
286	}
287
2d7cf8ef EP	288	out_unlock:
	289	mutex_unlock(&pohmelfs_config_lock);
	290	return err;
	291	}
	292
	293	static int pohmelfs_cn_dump(struct cn_msg *msg)
	294	{
	295	struct pohmelfs_config_group *g;
	296	struct pohmelfs_config c, tmp;
	297	int err = 0, i = 1;
	298	int total_msg = 0;
	299
	300	if (msg->len != sizeof(struct pohmelfs_ctl))
	301	return -EBADMSG;
	302
	303	mutex_lock(&pohmelfs_config_lock);
	304
	305	list_for_each_entry(g, &pohmelfs_config_list, group_entry) {
	306	if (g)
	307	total_msg += g->num_entry;
	308	}
	309	if (total_msg == 0) {
	310	if (pohmelfs_send_reply(err, 0, POHMELFS_NOINFO_ACK, msg, NULL))
	311	err = -ENOMEM;
	312	goto out_unlock;
	313	}
	314
	315	list_for_each_entry(g, &pohmelfs_config_list, group_entry) {
	316	if (g) {
	317	list_for_each_entry_safe(c, tmp, &g->config_list, config_entry) {
	318	struct pohmelfs_ctl *sc = &c->state.ctl;
	319	if (pohmelfs_send_reply(err, total_msg - i, POHMELFS_CTLINFO_ACK, msg, sc)) {
	320	err = -ENOMEM;
	321	goto out_unlock;
	322	}
	323	i += 1;
	324	}
	325	}
	326	}
	327
9ce8b619	328	out_unlock:
2d7cf8ef EP	329	mutex_unlock(&pohmelfs_config_lock);
	330	return err;
	331	}
	332
	333	static int pohmelfs_cn_flush(struct cn_msg *msg)
	334	{
	335	struct pohmelfs_config_group *g;
	336	struct pohmelfs_ctl ctl = (struct pohmelfs_ctl )msg->data;
	337	struct pohmelfs_config c, tmp;
	338	int err = 0;
	339
	340	if (msg->len != sizeof(struct pohmelfs_ctl))
	341	return -EBADMSG;
	342
	343	mutex_lock(&pohmelfs_config_lock);
	344
	345	if (ctl->idx != POHMELFS_NULL_IDX) {
	346	g = pohmelfs_find_config_group(ctl->idx);
	347
	348	if (!g)
	349	goto out_unlock;
	350
	351	list_for_each_entry_safe(c, tmp, &g->config_list, config_entry) {
	352	list_del(&c->config_entry);
	353	g->num_entry--;
	354	kfree(c);
	355	}
	356	} else {
	357	list_for_each_entry(g, &pohmelfs_config_list, group_entry) {
	358	if (g) {
	359	list_for_each_entry_safe(c, tmp, &g->config_list, config_entry) {
	360	list_del(&c->config_entry);
	361	g->num_entry--;
	362	kfree(c);
	363	}
	364	}
	365	}
	366	}
	367
	368	out_unlock:
	369	mutex_unlock(&pohmelfs_config_lock);
	370	pohmelfs_cn_dump(msg);
	371
	372	return err;
9ce8b619 EP	373	}
9ce8b619 EP	374
e0ca8739 EP	375	static int pohmelfs_modify_config(struct pohmelfs_ctl old, struct pohmelfs_ctl new)
	376	{
	377	old->perm = new->perm;
	378	old->prio = new->prio;
	379	return 0;
	380	}
	381
9ce8b619 EP	382	static int pohmelfs_cn_ctl(struct cn_msg *msg, int action)
	383	{
	384	struct pohmelfs_config_group *g;
	385	struct pohmelfs_ctl ctl = (struct pohmelfs_ctl )msg->data;
	386	struct pohmelfs_config c, tmp;
	387	int err = 0;
	388
	389	if (msg->len != sizeof(struct pohmelfs_ctl))
	390	return -EBADMSG;
	391
	392	mutex_lock(&pohmelfs_config_lock);
	393
	394	g = pohmelfs_find_create_config_group(ctl->idx);
	395	if (!g) {
	396	err = -ENOMEM;
	397	goto out_unlock;
	398	}
	399
	400	list_for_each_entry_safe(c, tmp, &g->config_list, config_entry) {
	401	struct pohmelfs_ctl *sc = &c->state.ctl;
	402
	403	if (pohmelfs_config_eql(sc, ctl)) {
	404	if (action == POHMELFS_FLAGS_ADD) {
	405	err = -EEXIST;
	406	goto out_unlock;
	407	} else if (action == POHMELFS_FLAGS_DEL) {
	408	list_del(&c->config_entry);
	409	g->num_entry--;
	410	kfree(c);
	411	goto out_unlock;
e0ca8739 EP	412	} else if (action == POHMELFS_FLAGS_MODIFY) {
	413	err = pohmelfs_modify_config(sc, ctl);
	414	goto out_unlock;
9ce8b619 EP	415	} else {
	416	err = -EEXIST;
	417	goto out_unlock;
	418	}
	419	}
	420	}
	421	if (action == POHMELFS_FLAGS_DEL) {
	422	err = -EBADMSG;
	423	goto out_unlock;
	424	}
	425
	426	c = kzalloc(sizeof(struct pohmelfs_config), GFP_KERNEL);
	427	if (!c) {
	428	err = -ENOMEM;
	429	goto out_unlock;
	430	}
	431	memcpy(&c->state.ctl, ctl, sizeof(struct pohmelfs_ctl));
	432	g->num_entry++;
e0ca8739	433
9ce8b619 EP	434	list_add_tail(&c->config_entry, &g->config_list);
9ce8b619 EP	435
2d7cf8ef	436	out_unlock:
9ce8b619 EP	437	mutex_unlock(&pohmelfs_config_lock);
	438	if (pohmelfs_send_reply(err, 0, POHMELFS_NOINFO_ACK, msg, NULL))
	439	err = -ENOMEM;
	440
	441	return err;
	442	}
	443
	444	static int pohmelfs_crypto_hash_init(struct pohmelfs_config_group g, struct pohmelfs_crypto c)
	445	{
	446	char algo = (char )c->data;
	447	u8 key = (u8 )(algo + c->strlen);
	448
	449	if (g->hash_string)
	450	return -EEXIST;
	451
	452	g->hash_string = kstrdup(algo, GFP_KERNEL);
	453	if (!g->hash_string)
	454	return -ENOMEM;
	455	g->hash_strlen = c->strlen;
	456	g->hash_keysize = c->keysize;
	457
	458	g->hash_key = kmalloc(c->keysize, GFP_KERNEL);
	459	if (!g->hash_key) {
	460	kfree(g->hash_string);
	461	return -ENOMEM;
	462	}
	463
	464	memcpy(g->hash_key, key, c->keysize);
	465
	466	return 0;
	467	}
	468
	469	static int pohmelfs_crypto_cipher_init(struct pohmelfs_config_group g, struct pohmelfs_crypto c)
	470	{
	471	char algo = (char )c->data;
	472	u8 key = (u8 )(algo + c->strlen);
	473
	474	if (g->cipher_string)
	475	return -EEXIST;
	476
	477	g->cipher_string = kstrdup(algo, GFP_KERNEL);
	478	if (!g->cipher_string)
	479	return -ENOMEM;
	480	g->cipher_strlen = c->strlen;
	481	g->cipher_keysize = c->keysize;
	482
	483	g->cipher_key = kmalloc(c->keysize, GFP_KERNEL);
	484	if (!g->cipher_key) {
	485	kfree(g->cipher_string);
	486	return -ENOMEM;
	487	}
	488
	489	memcpy(g->cipher_key, key, c->keysize);
	490
	491	return 0;
	492	}
	493
9ce8b619 EP	494	static int pohmelfs_cn_crypto(struct cn_msg *msg)
	495	{
	496	struct pohmelfs_crypto crypto = (struct pohmelfs_crypto )msg->data;
	497	struct pohmelfs_config_group *g;
	498	int err = 0;
	499
	500	dprintk("%s: idx: %u, strlen: %u, type: %u, keysize: %u, algo: %s.\n",
	501	__func__, crypto->idx, crypto->strlen, crypto->type,
	502	crypto->keysize, (char *)crypto->data);
	503
	504	mutex_lock(&pohmelfs_config_lock);
	505	g = pohmelfs_find_create_config_group(crypto->idx);
	506	if (!g) {
	507	err = -ENOMEM;
	508	goto out_unlock;
	509	}
	510
	511	switch (crypto->type) {
	512	case POHMELFS_CRYPTO_HASH:
	513	err = pohmelfs_crypto_hash_init(g, crypto);
	514	break;
	515	case POHMELFS_CRYPTO_CIPHER:
	516	err = pohmelfs_crypto_cipher_init(g, crypto);
	517	break;
	518	default:
	519	err = -ENOTSUPP;
	520	break;
	521	}
	522
	523	out_unlock:
	524	mutex_unlock(&pohmelfs_config_lock);
	525	if (pohmelfs_send_reply(err, 0, POHMELFS_NOINFO_ACK, msg, NULL))
	526	err = -ENOMEM;
	527
	528	return err;
	529	}
	530
7069331d	531	static void pohmelfs_cn_callback(struct cn_msg msg, struct netlink_skb_parms nsp)
9ce8b619	532	{
9ce8b619 EP	533	int err;
9ce8b619 EP	534
98a5783a PR	535	if (!cap_raised(nsp->eff_cap, CAP_SYS_ADMIN))
	536	return;
	537
9ce8b619 EP	538	switch (msg->flags) {
9ce8b619 EP	539	case POHMELFS_FLAGS_ADD:
9ce8b619	540	case POHMELFS_FLAGS_DEL:
e0ca8739 EP	541	case POHMELFS_FLAGS_MODIFY:
e0ca8739 EP	542	err = pohmelfs_cn_ctl(msg, msg->flags);
9ce8b619	543	break;
2d7cf8ef EP	544	case POHMELFS_FLAGS_FLUSH:
	545	err = pohmelfs_cn_flush(msg);
	546	break;
9ce8b619 EP	547	case POHMELFS_FLAGS_SHOW:
	548	err = pohmelfs_cn_disp(msg);
	549	break;
2d7cf8ef EP	550	case POHMELFS_FLAGS_DUMP:
	551	err = pohmelfs_cn_dump(msg);
	552	break;
9ce8b619 EP	553	case POHMELFS_FLAGS_CRYPTO:
	554	err = pohmelfs_cn_crypto(msg);
	555	break;
	556	default:
	557	err = -ENOSYS;
	558	break;
	559	}
	560	}
	561
	562	int pohmelfs_config_check(struct pohmelfs_config *config, int idx)
	563	{
	564	struct pohmelfs_ctl *ctl = &config->state.ctl;
	565	struct pohmelfs_config *tmp;
	566	int err = -ENOENT;
	567	struct pohmelfs_ctl *sc;
	568	struct pohmelfs_config_group *g;
	569
	570	mutex_lock(&pohmelfs_config_lock);
	571
	572	g = pohmelfs_find_config_group(ctl->idx);
	573	if (g) {
	574	list_for_each_entry(tmp, &g->config_list, config_entry) {
	575	sc = &tmp->state.ctl;
	576
	577	if (pohmelfs_config_eql(sc, ctl)) {
	578	err = 0;
	579	break;
	580	}
	581	}
	582	}
	583
	584	mutex_unlock(&pohmelfs_config_lock);
	585
	586	return err;
	587	}
	588
	589	int __init pohmelfs_config_init(void)
	590	{
2d7cf8ef EP	591	/* XXX remove (void ) cast when vanilla connector got synced /
2d7cf8ef EP	592	return cn_add_callback(&pohmelfs_cn_id, "pohmelfs", (void *)pohmelfs_cn_callback);
9ce8b619 EP	593	}
	594
	595	void pohmelfs_config_exit(void)
	596	{
	597	struct pohmelfs_config c, tmp;
	598	struct pohmelfs_config_group g, gtmp;
	599
	600	cn_del_callback(&pohmelfs_cn_id);
	601
	602	mutex_lock(&pohmelfs_config_lock);
	603	list_for_each_entry_safe(g, gtmp, &pohmelfs_config_list, group_entry) {
	604	list_for_each_entry_safe(c, tmp, &g->config_list, config_entry) {
	605	list_del(&c->config_entry);
	606	kfree(c);
	607	}
	608
	609	list_del(&g->group_entry);
	610
	611	if (g->hash_string)
	612	kfree(g->hash_string);
	613
	614	if (g->cipher_string)
	615	kfree(g->cipher_string);
	616
	617	kfree(g);
	618	}
	619	mutex_unlock(&pohmelfs_config_lock);
	620	}