[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 "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)
{
	int err;

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