[net-next-2.6.git] / fs / ecryptfs / messaging.c

/**
 * eCryptfs: Linux filesystem encryption layer
 *
 * Copyright (C) 2004-2006 International Business Machines Corp.
 *   Author(s): Michael A. Halcrow <mhalcrow@us.ibm.com>
 *		Tyler Hicks <tyhicks@ou.edu>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License version
 * 2 as published by the Free Software Foundation.
 *
 * 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., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 */

#include "ecryptfs_kernel.h"

LIST_HEAD(ecryptfs_msg_ctx_free_list);
LIST_HEAD(ecryptfs_msg_ctx_alloc_list);
struct mutex ecryptfs_msg_ctx_lists_mux;

struct hlist_head *ecryptfs_daemon_id_hash;
struct mutex ecryptfs_daemon_id_hash_mux;
int ecryptfs_hash_buckets;

unsigned int ecryptfs_msg_counter;
struct ecryptfs_msg_ctx *ecryptfs_msg_ctx_arr;

/**
 * ecryptfs_acquire_free_msg_ctx
 * @msg_ctx: The context that was acquired from the free list
 *
 * Acquires a context element from the free list and locks the mutex
 * on the context.  Returns zero on success; non-zero on error or upon
 * failure to acquire a free context element.  Be sure to lock the
 * list mutex before calling.
 */
static int ecryptfs_acquire_free_msg_ctx(struct ecryptfs_msg_ctx **msg_ctx)
{
	struct list_head *p;
	int rc;

	if (list_empty(&ecryptfs_msg_ctx_free_list)) {
		ecryptfs_printk(KERN_WARNING, "The eCryptfs free "
				"context list is empty.  It may be helpful to "
				"specify the ecryptfs_message_buf_len "
				"parameter to be greater than the current "
				"value of [%d]\n", ecryptfs_message_buf_len);
		rc = -ENOMEM;
		goto out;
	}
	list_for_each(p, &ecryptfs_msg_ctx_free_list) {
		*msg_ctx = list_entry(p, struct ecryptfs_msg_ctx, node);
		if (mutex_trylock(&(*msg_ctx)->mux)) {
			(*msg_ctx)->task = current;
			rc = 0;
			goto out;
		}
	}
	rc = -ENOMEM;
out:
	return rc;
}

/**
 * ecryptfs_msg_ctx_free_to_alloc
 * @msg_ctx: The context to move from the free list to the alloc list
 *
 * Be sure to lock the list mutex and the context mutex before
 * calling.
 */
static void ecryptfs_msg_ctx_free_to_alloc(struct ecryptfs_msg_ctx *msg_ctx)
{
	list_move(&msg_ctx->node, &ecryptfs_msg_ctx_alloc_list);
	msg_ctx->state = ECRYPTFS_MSG_CTX_STATE_PENDING;
	msg_ctx->counter = ++ecryptfs_msg_counter;
}

/**
 * ecryptfs_msg_ctx_alloc_to_free
 * @msg_ctx: The context to move from the alloc list to the free list
 *
 * Be sure to lock the list mutex and the context mutex before
 * calling.
 */
static void ecryptfs_msg_ctx_alloc_to_free(struct ecryptfs_msg_ctx *msg_ctx)
{
	list_move(&(msg_ctx->node), &ecryptfs_msg_ctx_free_list);
	if (msg_ctx->msg)
		kfree(msg_ctx->msg);
	msg_ctx->state = ECRYPTFS_MSG_CTX_STATE_FREE;
}

/**
 * ecryptfs_find_daemon_id
 * @uid: The user id which maps to the desired daemon id
 * @id: If return value is zero, points to the desired daemon id
 *      pointer
 *
 * Search the hash list for the given user id.  Returns zero if the
 * user id exists in the list; non-zero otherwise.  The daemon id hash
 * mutex should be held before calling this function.
 */
static int ecryptfs_find_daemon_id(uid_t uid, struct ecryptfs_daemon_id **id)
{
	struct hlist_node *elem;
	int rc;

	hlist_for_each_entry(*id, elem,
			     &ecryptfs_daemon_id_hash[ecryptfs_uid_hash(uid)],
			     id_chain) {
		if ((*id)->uid == uid) {
			rc = 0;
			goto out;
		}
	}
	rc = -EINVAL;
out:
	return rc;
}

static int ecryptfs_send_raw_message(unsigned int transport, u16 msg_type,
				     pid_t pid)
{
	int rc;

	switch(transport) {
	case ECRYPTFS_TRANSPORT_NETLINK:
		rc = ecryptfs_send_netlink(NULL, 0, NULL, msg_type, 0, pid);
		break;
	case ECRYPTFS_TRANSPORT_CONNECTOR:
	case ECRYPTFS_TRANSPORT_RELAYFS:
	default:
		rc = -ENOSYS;
	}
	return rc;
}

/**
 * ecryptfs_process_helo
 * @transport: The underlying transport (netlink, etc.)
 * @uid: The user ID owner of the message
 * @pid: The process ID for the userspace program that sent the
 *       message
 *
 * Adds the uid and pid values to the daemon id hash.  If a uid
 * already has a daemon pid registered, the daemon will be
 * unregistered before the new daemon id is put into the hash list.
 * Returns zero after adding a new daemon id to the hash list;
 * non-zero otherwise.
 */
int ecryptfs_process_helo(unsigned int transport, uid_t uid, pid_t pid)
{
	struct ecryptfs_daemon_id *new_id;
	struct ecryptfs_daemon_id *old_id;
	int rc;

	mutex_lock(&ecryptfs_daemon_id_hash_mux);
	new_id = kmalloc(sizeof(*new_id), GFP_KERNEL);
	if (!new_id) {
		rc = -ENOMEM;
		ecryptfs_printk(KERN_ERR, "Failed to allocate memory; unable "
				"to register daemon [%d] for user\n", pid, uid);
		goto unlock;
	}
	if (!ecryptfs_find_daemon_id(uid, &old_id)) {
		printk(KERN_WARNING "Received request from user [%d] "
		       "to register daemon [%d]; unregistering daemon "
		       "[%d]\n", uid, pid, old_id->pid);
		hlist_del(&old_id->id_chain);
		rc = ecryptfs_send_raw_message(transport, ECRYPTFS_NLMSG_QUIT,
					       old_id->pid);
		if (rc)
			printk(KERN_WARNING "Failed to send QUIT "
			       "message to daemon [%d]; rc = [%d]\n",
			       old_id->pid, rc);
		kfree(old_id);
	}
	new_id->uid = uid;
	new_id->pid = pid;
	hlist_add_head(&new_id->id_chain,
		       &ecryptfs_daemon_id_hash[ecryptfs_uid_hash(uid)]);
	rc = 0;
unlock:
	mutex_unlock(&ecryptfs_daemon_id_hash_mux);
	return rc;
}

/**
 * ecryptfs_process_quit
 * @uid: The user ID owner of the message
 * @pid: The process ID for the userspace program that sent the
 *       message
 *
 * Deletes the corresponding daemon id for the given uid and pid, if
 * it is the registered that is requesting the deletion. Returns zero
 * after deleting the desired daemon id; non-zero otherwise.
 */
int ecryptfs_process_quit(uid_t uid, pid_t pid)
{
	struct ecryptfs_daemon_id *id;
	int rc;

	mutex_lock(&ecryptfs_daemon_id_hash_mux);
	if (ecryptfs_find_daemon_id(uid, &id)) {
		rc = -EINVAL;
		ecryptfs_printk(KERN_ERR, "Received request from user [%d] to "
				"unregister unrecognized daemon [%d]\n", uid,
				pid);
		goto unlock;
	}
	if (id->pid != pid) {
		rc = -EINVAL;
		ecryptfs_printk(KERN_WARNING, "Received request from user [%d] "
				"with pid [%d] to unregister daemon [%d]\n",
				uid, pid, id->pid);
		goto unlock;
	}
	hlist_del(&id->id_chain);
	kfree(id);
	rc = 0;
unlock:
	mutex_unlock(&ecryptfs_daemon_id_hash_mux);
	return rc;
}

/**
 * ecryptfs_process_reponse
 * @msg: The ecryptfs message received; the caller should sanity check
 *       msg->data_len
 * @pid: The process ID of the userspace application that sent the
 *       message
 * @seq: The sequence number of the message
 *
 * Processes a response message after sending a operation request to
 * userspace. Returns zero upon delivery to desired context element;
 * non-zero upon delivery failure or error.
 */
int ecryptfs_process_response(struct ecryptfs_message *msg, pid_t pid, u32 seq)
{
	struct ecryptfs_daemon_id *id;
	struct ecryptfs_msg_ctx *msg_ctx;
	int msg_size;
	int rc;

	if (msg->index >= ecryptfs_message_buf_len) {
		rc = -EINVAL;
		ecryptfs_printk(KERN_ERR, "Attempt to reference "
				"context buffer at index [%d]; maximum "
				"allowable is [%d]\n", msg->index,
				(ecryptfs_message_buf_len - 1));
		goto out;
	}
	msg_ctx = &ecryptfs_msg_ctx_arr[msg->index];
	mutex_lock(&msg_ctx->mux);
	if (ecryptfs_find_daemon_id(msg_ctx->task->euid, &id)) {
		rc = -EBADMSG;
		ecryptfs_printk(KERN_WARNING, "User [%d] received a "
				"message response from process [%d] but does "
				"not have a registered daemon\n",
				msg_ctx->task->euid, pid);
		goto wake_up;
	}
	if (id->pid != pid) {
		rc = -EBADMSG;
		ecryptfs_printk(KERN_ERR, "User [%d] received a "
				"message response from an unrecognized "
				"process [%d]\n", msg_ctx->task->euid, pid);
		goto unlock;
	}
	if (msg_ctx->state != ECRYPTFS_MSG_CTX_STATE_PENDING) {
		rc = -EINVAL;
		ecryptfs_printk(KERN_WARNING, "Desired context element is not "
				"pending a response\n");
		goto unlock;
	} else if (msg_ctx->counter != seq) {
		rc = -EINVAL;
		ecryptfs_printk(KERN_WARNING, "Invalid message sequence; "
				"expected [%d]; received [%d]\n",
				msg_ctx->counter, seq);
		goto unlock;
	}
	msg_size = sizeof(*msg) + msg->data_len;
	msg_ctx->msg = kmalloc(msg_size, GFP_KERNEL);
	if (!msg_ctx->msg) {
		rc = -ENOMEM;
		ecryptfs_printk(KERN_ERR, "Failed to allocate memory\n");
		goto unlock;
	}
	memcpy(msg_ctx->msg, msg, msg_size);
	msg_ctx->state = ECRYPTFS_MSG_CTX_STATE_DONE;
	rc = 0;
wake_up:
	wake_up_process(msg_ctx->task);
unlock:
	mutex_unlock(&msg_ctx->mux);
out:
	return rc;
}

/**
 * ecryptfs_send_message
 * @transport: The transport over which to send the message (i.e.,
 *             netlink)
 * @data: The data to send
 * @data_len: The length of data
 * @msg_ctx: The message context allocated for the send
 */
int ecryptfs_send_message(unsigned int transport, char *data, int data_len,
			  struct ecryptfs_msg_ctx **msg_ctx)
{
	struct ecryptfs_daemon_id *id;
	int rc;

	mutex_lock(&ecryptfs_daemon_id_hash_mux);
	if (ecryptfs_find_daemon_id(current->euid, &id)) {
		mutex_unlock(&ecryptfs_daemon_id_hash_mux);
		rc = -ENOTCONN;
		ecryptfs_printk(KERN_ERR, "User [%d] does not have a daemon "
				"registered\n", current->euid);
		goto out;
	}
	mutex_unlock(&ecryptfs_daemon_id_hash_mux);
	mutex_lock(&ecryptfs_msg_ctx_lists_mux);
	rc = ecryptfs_acquire_free_msg_ctx(msg_ctx);
	if (rc) {
		mutex_unlock(&ecryptfs_msg_ctx_lists_mux);
		ecryptfs_printk(KERN_WARNING, "Could not claim a free "
				"context element\n");
		goto out;
	}
	ecryptfs_msg_ctx_free_to_alloc(*msg_ctx);
	mutex_unlock(&(*msg_ctx)->mux);
	mutex_unlock(&ecryptfs_msg_ctx_lists_mux);
	switch (transport) {
	case ECRYPTFS_TRANSPORT_NETLINK:
		rc = ecryptfs_send_netlink(data, data_len, *msg_ctx,
					   ECRYPTFS_NLMSG_REQUEST, 0, id->pid);
		break;
	case ECRYPTFS_TRANSPORT_CONNECTOR:
	case ECRYPTFS_TRANSPORT_RELAYFS:
	default:
		rc = -ENOSYS;
	}
	if (rc) {
		printk(KERN_ERR "Error attempting to send message to userspace "
		       "daemon; rc = [%d]\n", rc);
	}
out:
	return rc;
}

/**
 * ecryptfs_wait_for_response
 * @msg_ctx: The context that was assigned when sending a message
 * @msg: The incoming message from userspace; not set if rc != 0
 *
 * Sleeps until awaken by ecryptfs_receive_message or until the amount
 * of time exceeds ecryptfs_message_wait_timeout.  If zero is
 * returned, msg will point to a valid message from userspace; a
 * non-zero value is returned upon failure to receive a message or an
 * error occurs.
 */
int ecryptfs_wait_for_response(struct ecryptfs_msg_ctx *msg_ctx,
			       struct ecryptfs_message **msg)
{
	signed long timeout = ecryptfs_message_wait_timeout * HZ;
	int rc = 0;

sleep:
	timeout = schedule_timeout_interruptible(timeout);
	mutex_lock(&ecryptfs_msg_ctx_lists_mux);
	mutex_lock(&msg_ctx->mux);
	if (msg_ctx->state != ECRYPTFS_MSG_CTX_STATE_DONE) {
		if (timeout) {
			mutex_unlock(&msg_ctx->mux);
			mutex_unlock(&ecryptfs_msg_ctx_lists_mux);
			goto sleep;
		}
		rc = -ENOMSG;
	} else {
		*msg = msg_ctx->msg;
		msg_ctx->msg = NULL;
	}
	ecryptfs_msg_ctx_alloc_to_free(msg_ctx);
	mutex_unlock(&msg_ctx->mux);
	mutex_unlock(&ecryptfs_msg_ctx_lists_mux);
	return rc;
}

int ecryptfs_init_messaging(unsigned int transport)
{
	int i;
	int rc = 0;

	if (ecryptfs_number_of_users > ECRYPTFS_MAX_NUM_USERS) {
		ecryptfs_number_of_users = ECRYPTFS_MAX_NUM_USERS;
		ecryptfs_printk(KERN_WARNING, "Specified number of users is "
				"too large, defaulting to [%d] users\n",
				ecryptfs_number_of_users);
	}
	mutex_init(&ecryptfs_daemon_id_hash_mux);
	mutex_lock(&ecryptfs_daemon_id_hash_mux);
	ecryptfs_hash_buckets = 0;
	while (ecryptfs_number_of_users >> ++ecryptfs_hash_buckets);
	ecryptfs_daemon_id_hash = kmalloc(sizeof(struct hlist_head)
					  * ecryptfs_hash_buckets, GFP_KERNEL);
	if (!ecryptfs_daemon_id_hash) {
		rc = -ENOMEM;
		ecryptfs_printk(KERN_ERR, "Failed to allocate memory\n");
		goto out;
	}
	for (i = 0; i < ecryptfs_hash_buckets; i++)
		INIT_HLIST_HEAD(&ecryptfs_daemon_id_hash[i]);
	mutex_unlock(&ecryptfs_daemon_id_hash_mux);

	ecryptfs_msg_ctx_arr = kmalloc((sizeof(struct ecryptfs_msg_ctx)
				      * ecryptfs_message_buf_len), GFP_KERNEL);
	if (!ecryptfs_msg_ctx_arr) {
		rc = -ENOMEM;
		ecryptfs_printk(KERN_ERR, "Failed to allocate memory\n");
		goto out;
	}
	mutex_init(&ecryptfs_msg_ctx_lists_mux);
	mutex_lock(&ecryptfs_msg_ctx_lists_mux);
	ecryptfs_msg_counter = 0;
	for (i = 0; i < ecryptfs_message_buf_len; i++) {
		INIT_LIST_HEAD(&ecryptfs_msg_ctx_arr[i].node);
		mutex_init(&ecryptfs_msg_ctx_arr[i].mux);
		mutex_lock(&ecryptfs_msg_ctx_arr[i].mux);
		ecryptfs_msg_ctx_arr[i].index = i;
		ecryptfs_msg_ctx_arr[i].state = ECRYPTFS_MSG_CTX_STATE_FREE;
		ecryptfs_msg_ctx_arr[i].counter = 0;
		ecryptfs_msg_ctx_arr[i].task = NULL;
		ecryptfs_msg_ctx_arr[i].msg = NULL;
		list_add_tail(&ecryptfs_msg_ctx_arr[i].node,
			      &ecryptfs_msg_ctx_free_list);
		mutex_unlock(&ecryptfs_msg_ctx_arr[i].mux);
	}
	mutex_unlock(&ecryptfs_msg_ctx_lists_mux);
	switch(transport) {
	case ECRYPTFS_TRANSPORT_NETLINK:
		rc = ecryptfs_init_netlink();
		if (rc)
			ecryptfs_release_messaging(transport);
		break;
	case ECRYPTFS_TRANSPORT_CONNECTOR:
	case ECRYPTFS_TRANSPORT_RELAYFS:
	default:
		rc = -ENOSYS;
	}
out:
	return rc;
}

void ecryptfs_release_messaging(unsigned int transport)
{
	if (ecryptfs_msg_ctx_arr) {
		int i;

		mutex_lock(&ecryptfs_msg_ctx_lists_mux);
		for (i = 0; i < ecryptfs_message_buf_len; i++) {
			mutex_lock(&ecryptfs_msg_ctx_arr[i].mux);
			if (ecryptfs_msg_ctx_arr[i].msg)
				kfree(ecryptfs_msg_ctx_arr[i].msg);
			mutex_unlock(&ecryptfs_msg_ctx_arr[i].mux);
		}
		kfree(ecryptfs_msg_ctx_arr);
		mutex_unlock(&ecryptfs_msg_ctx_lists_mux);
	}
	if (ecryptfs_daemon_id_hash) {
		struct hlist_node *elem;
		struct ecryptfs_daemon_id *id;
		int i;

		mutex_lock(&ecryptfs_daemon_id_hash_mux);
		for (i = 0; i < ecryptfs_hash_buckets; i++) {
			hlist_for_each_entry(id, elem,
					     &ecryptfs_daemon_id_hash[i],
					     id_chain) {
				hlist_del(elem);
				kfree(id);
			}
		}
		kfree(ecryptfs_daemon_id_hash);
		mutex_unlock(&ecryptfs_daemon_id_hash_mux);
	}
	switch(transport) {
	case ECRYPTFS_TRANSPORT_NETLINK:
		ecryptfs_release_netlink();
		break;
	case ECRYPTFS_TRANSPORT_CONNECTOR:
	case ECRYPTFS_TRANSPORT_RELAYFS:
	default:
		break;
	}
	return;
}
Commit	Line	Data
88b4a07e MH	1	/**
	2	* eCryptfs: Linux filesystem encryption layer
	3	*
	4	* Copyright (C) 2004-2006 International Business Machines Corp.
	5	* Author(s): Michael A. Halcrow <mhalcrow@us.ibm.com>
	6	* Tyler Hicks <tyhicks@ou.edu>
	7	*
	8	* This program is free software; you can redistribute it and/or
	9	* modify it under the terms of the GNU General Public License version
	10	* 2 as published by the Free Software Foundation.
	11	*
	12	* This program is distributed in the hope that it will be useful, but
	13	* WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	15	* General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU General Public License
	18	* along with this program; if not, write to the Free Software
	19	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
	20	* 02111-1307, USA.
	21	*/
	22
	23	#include "ecryptfs_kernel.h"
	24
	25	LIST_HEAD(ecryptfs_msg_ctx_free_list);
	26	LIST_HEAD(ecryptfs_msg_ctx_alloc_list);
	27	struct mutex ecryptfs_msg_ctx_lists_mux;
	28
	29	struct hlist_head *ecryptfs_daemon_id_hash;
	30	struct mutex ecryptfs_daemon_id_hash_mux;
	31	int ecryptfs_hash_buckets;
	32
	33	unsigned int ecryptfs_msg_counter;
	34	struct ecryptfs_msg_ctx *ecryptfs_msg_ctx_arr;
	35
	36	/**
	37	* ecryptfs_acquire_free_msg_ctx
	38	* @msg_ctx: The context that was acquired from the free list
	39	*
	40	* Acquires a context element from the free list and locks the mutex
	41	* on the context. Returns zero on success; non-zero on error or upon
	42	* failure to acquire a free context element. Be sure to lock the
	43	* list mutex before calling.
	44	*/
	45	static int ecryptfs_acquire_free_msg_ctx(struct ecryptfs_msg_ctx **msg_ctx)
	46	{
	47	struct list_head *p;
	48	int rc;
	49
	50	if (list_empty(&ecryptfs_msg_ctx_free_list)) {
	51	ecryptfs_printk(KERN_WARNING, "The eCryptfs free "
	52	"context list is empty. It may be helpful to "
	53	"specify the ecryptfs_message_buf_len "
	54	"parameter to be greater than the current "
	55	"value of [%d]\n", ecryptfs_message_buf_len);
	56	rc = -ENOMEM;
	57	goto out;
	58	}
	59	list_for_each(p, &ecryptfs_msg_ctx_free_list) {
	60	*msg_ctx = list_entry(p, struct ecryptfs_msg_ctx, node);
	61	if (mutex_trylock(&(*msg_ctx)->mux)) {
	62	(*msg_ctx)->task = current;
	63	rc = 0;
	64	goto out;
65	}
66	}
67	rc = -ENOMEM;
68	out:
69	return rc;
70	}
71
72	/**
73	* ecryptfs_msg_ctx_free_to_alloc
74	* @msg_ctx: The context to move from the free list to the alloc list
75	*
76	* Be sure to lock the list mutex and the context mutex before
77	* calling.
78	*/
79	static void ecryptfs_msg_ctx_free_to_alloc(struct ecryptfs_msg_ctx *msg_ctx)
80	{
81	list_move(&msg_ctx->node, &ecryptfs_msg_ctx_alloc_list);
82	msg_ctx->state = ECRYPTFS_MSG_CTX_STATE_PENDING;
83	msg_ctx->counter = ++ecryptfs_msg_counter;
84	}
85
86	/**
87	* ecryptfs_msg_ctx_alloc_to_free
88	* @msg_ctx: The context to move from the alloc list to the free list
89	*
90	* Be sure to lock the list mutex and the context mutex before
91	* calling.
92	*/
93	static void ecryptfs_msg_ctx_alloc_to_free(struct ecryptfs_msg_ctx *msg_ctx)
94	{
95	list_move(&(msg_ctx->node), &ecryptfs_msg_ctx_free_list);
96	if (msg_ctx->msg)
97	kfree(msg_ctx->msg);
98	msg_ctx->state = ECRYPTFS_MSG_CTX_STATE_FREE;
99	}
100
101	/**
102	* ecryptfs_find_daemon_id
103	* @uid: The user id which maps to the desired daemon id
104	* @id: If return value is zero, points to the desired daemon id
105	* pointer
106	*
107	* Search the hash list for the given user id. Returns zero if the
108	* user id exists in the list; non-zero otherwise. The daemon id hash
109	* mutex should be held before calling this function.
110	*/
111	static int ecryptfs_find_daemon_id(uid_t uid, struct ecryptfs_daemon_id **id)
112	{
113	struct hlist_node *elem;
114	int rc;
115
116	hlist_for_each_entry(*id, elem,
117	&ecryptfs_daemon_id_hash[ecryptfs_uid_hash(uid)],
118	id_chain) {
119	if ((*id)->uid == uid) {
120	rc = 0;
121	goto out;
122	}
123	}
124	rc = -EINVAL;
125	out:
126	return rc;
127	}
128
129	static int ecryptfs_send_raw_message(unsigned int transport, u16 msg_type,
130	pid_t pid)
131	{
132	int rc;
133
134	switch(transport) {
135	case ECRYPTFS_TRANSPORT_NETLINK:
136	rc = ecryptfs_send_netlink(NULL, 0, NULL, msg_type, 0, pid);
137	break;
138	case ECRYPTFS_TRANSPORT_CONNECTOR:
139	case ECRYPTFS_TRANSPORT_RELAYFS:
140	default:
141	rc = -ENOSYS;
142	}
143	return rc;
144	}
145
146	/**
147	* ecryptfs_process_helo
148	* @transport: The underlying transport (netlink, etc.)
149	* @uid: The user ID owner of the message
150	* @pid: The process ID for the userspace program that sent the
151	* message
152	*
153	* Adds the uid and pid values to the daemon id hash. If a uid
154	* already has a daemon pid registered, the daemon will be
155	* unregistered before the new daemon id is put into the hash list.
156	* Returns zero after adding a new daemon id to the hash list;
157	* non-zero otherwise.
158	*/
159	int ecryptfs_process_helo(unsigned int transport, uid_t uid, pid_t pid)
160	{
161	struct ecryptfs_daemon_id *new_id;
162	struct ecryptfs_daemon_id *old_id;
163	int rc;
164
165	mutex_lock(&ecryptfs_daemon_id_hash_mux);
166	new_id = kmalloc(sizeof(*new_id), GFP_KERNEL);
167	if (!new_id) {
168	rc = -ENOMEM;
169	ecryptfs_printk(KERN_ERR, "Failed to allocate memory; unable "
170	"to register daemon [%d] for user\n", pid, uid);
171	goto unlock;
172	}
173	if (!ecryptfs_find_daemon_id(uid, &old_id)) {
174	printk(KERN_WARNING "Received request from user [%d] "
175	"to register daemon [%d]; unregistering daemon "
176	"[%d]\n", uid, pid, old_id->pid);
177	hlist_del(&old_id->id_chain);
178	rc = ecryptfs_send_raw_message(transport, ECRYPTFS_NLMSG_QUIT,
179	old_id->pid);
180	if (rc)
181	printk(KERN_WARNING "Failed to send QUIT "
182	"message to daemon [%d]; rc = [%d]\n",
183	old_id->pid, rc);
184	kfree(old_id);
185	}
186	new_id->uid = uid;
187	new_id->pid = pid;
188	hlist_add_head(&new_id->id_chain,
189	&ecryptfs_daemon_id_hash[ecryptfs_uid_hash(uid)]);
190	rc = 0;
191	unlock:
192	mutex_unlock(&ecryptfs_daemon_id_hash_mux);
193	return rc;
194	}
195
196	/**
197	* ecryptfs_process_quit
198	* @uid: The user ID owner of the message
199	* @pid: The process ID for the userspace program that sent the
200	* message
201	*
202	* Deletes the corresponding daemon id for the given uid and pid, if
203	* it is the registered that is requesting the deletion. Returns zero
204	* after deleting the desired daemon id; non-zero otherwise.
205	*/
206	int ecryptfs_process_quit(uid_t uid, pid_t pid)
207	{
208	struct ecryptfs_daemon_id *id;
209	int rc;
210
211	mutex_lock(&ecryptfs_daemon_id_hash_mux);
212	if (ecryptfs_find_daemon_id(uid, &id)) {
213	rc = -EINVAL;
214	ecryptfs_printk(KERN_ERR, "Received request from user [%d] to "
215	"unregister unrecognized daemon [%d]\n", uid,
216	pid);
217	goto unlock;
218	}
219	if (id->pid != pid) {
220	rc = -EINVAL;
221	ecryptfs_printk(KERN_WARNING, "Received request from user [%d] "
222	"with pid [%d] to unregister daemon [%d]\n",
223	uid, pid, id->pid);
224	goto unlock;
225	}
226	hlist_del(&id->id_chain);
227	kfree(id);
228	rc = 0;
229	unlock:
230	mutex_unlock(&ecryptfs_daemon_id_hash_mux);
231	return rc;
232	}
233
234	/**
235	* ecryptfs_process_reponse
236	* @msg: The ecryptfs message received; the caller should sanity check
237	* msg->data_len
238	* @pid: The process ID of the userspace application that sent the
239	* message
240	* @seq: The sequence number of the message
241	*
242	* Processes a response message after sending a operation request to
243	* userspace. Returns zero upon delivery to desired context element;
244	* non-zero upon delivery failure or error.
245	*/
246	int ecryptfs_process_response(struct ecryptfs_message *msg, pid_t pid, u32 seq)
247	{
248	struct ecryptfs_daemon_id *id;
249	struct ecryptfs_msg_ctx *msg_ctx;
250	int msg_size;
251	int rc;
252
253	if (msg->index >= ecryptfs_message_buf_len) {
254	rc = -EINVAL;
255	ecryptfs_printk(KERN_ERR, "Attempt to reference "
256	"context buffer at index [%d]; maximum "
257	"allowable is [%d]\n", msg->index,
258	(ecryptfs_message_buf_len - 1));
259	goto out;
260	}
261	msg_ctx = &ecryptfs_msg_ctx_arr[msg->index];
262	mutex_lock(&msg_ctx->mux);
263	if (ecryptfs_find_daemon_id(msg_ctx->task->euid, &id)) {
264	rc = -EBADMSG;
265	ecryptfs_printk(KERN_WARNING, "User [%d] received a "
266	"message response from process [%d] but does "
267	"not have a registered daemon\n",
268	msg_ctx->task->euid, pid);
269	goto wake_up;
270	}
271	if (id->pid != pid) {
272	rc = -EBADMSG;
273	ecryptfs_printk(KERN_ERR, "User [%d] received a "
274	"message response from an unrecognized "
275	"process [%d]\n", msg_ctx->task->euid, pid);
276	goto unlock;
277	}
278	if (msg_ctx->state != ECRYPTFS_MSG_CTX_STATE_PENDING) {
279	rc = -EINVAL;
280	ecryptfs_printk(KERN_WARNING, "Desired context element is not "
281	"pending a response\n");
282	goto unlock;
283	} else if (msg_ctx->counter != seq) {
284	rc = -EINVAL;
285	ecryptfs_printk(KERN_WARNING, "Invalid message sequence; "
286	"expected [%d]; received [%d]\n",
287	msg_ctx->counter, seq);
288	goto unlock;
289	}
290	msg_size = sizeof(*msg) + msg->data_len;
291	msg_ctx->msg = kmalloc(msg_size, GFP_KERNEL);
292	if (!msg_ctx->msg) {
293	rc = -ENOMEM;
294	ecryptfs_printk(KERN_ERR, "Failed to allocate memory\n");
295	goto unlock;
296	}
297	memcpy(msg_ctx->msg, msg, msg_size);
298	msg_ctx->state = ECRYPTFS_MSG_CTX_STATE_DONE;
299	rc = 0;
300	wake_up:
301	wake_up_process(msg_ctx->task);
302	unlock:
303	mutex_unlock(&msg_ctx->mux);
304	out:
305	return rc;
306	}
307
308	/**
309	* ecryptfs_send_message
310	* @transport: The transport over which to send the message (i.e.,
311	* netlink)
312	* @data: The data to send
313	* @data_len: The length of data
314	* @msg_ctx: The message context allocated for the send
315	*/
316	int ecryptfs_send_message(unsigned int transport, char *data, int data_len,
317	struct ecryptfs_msg_ctx **msg_ctx)
318	{
319	struct ecryptfs_daemon_id *id;
320	int rc;
321
322	mutex_lock(&ecryptfs_daemon_id_hash_mux);
323	if (ecryptfs_find_daemon_id(current->euid, &id)) {
324	mutex_unlock(&ecryptfs_daemon_id_hash_mux);
325	rc = -ENOTCONN;
326	ecryptfs_printk(KERN_ERR, "User [%d] does not have a daemon "
327	"registered\n", current->euid);
328	goto out;
329	}
330	mutex_unlock(&ecryptfs_daemon_id_hash_mux);
331	mutex_lock(&ecryptfs_msg_ctx_lists_mux);
332	rc = ecryptfs_acquire_free_msg_ctx(msg_ctx);
333	if (rc) {
334	mutex_unlock(&ecryptfs_msg_ctx_lists_mux);
335	ecryptfs_printk(KERN_WARNING, "Could not claim a free "
336	"context element\n");
337	goto out;
338	}
339	ecryptfs_msg_ctx_free_to_alloc(*msg_ctx);
340	mutex_unlock(&(*msg_ctx)->mux);
341	mutex_unlock(&ecryptfs_msg_ctx_lists_mux);
342	switch (transport) {
343	case ECRYPTFS_TRANSPORT_NETLINK:
344	rc = ecryptfs_send_netlink(data, data_len, *msg_ctx,
345	ECRYPTFS_NLMSG_REQUEST, 0, id->pid);
346	break;
347	case ECRYPTFS_TRANSPORT_CONNECTOR:
348	case ECRYPTFS_TRANSPORT_RELAYFS:
349	default:
350	rc = -ENOSYS;
351	}
352	if (rc) {
353	printk(KERN_ERR "Error attempting to send message to userspace "
354	"daemon; rc = [%d]\n", rc);
355	}
356	out:
357	return rc;
358	}
359
360	/**
361	* ecryptfs_wait_for_response
362	* @msg_ctx: The context that was assigned when sending a message
363	* @msg: The incoming message from userspace; not set if rc != 0
364	*
365	* Sleeps until awaken by ecryptfs_receive_message or until the amount
366	* of time exceeds ecryptfs_message_wait_timeout. If zero is
367	* returned, msg will point to a valid message from userspace; a
368	* non-zero value is returned upon failure to receive a message or an
369	* error occurs.
370	*/
371	int ecryptfs_wait_for_response(struct ecryptfs_msg_ctx *msg_ctx,
372	struct ecryptfs_message **msg)
373	{
374	signed long timeout = ecryptfs_message_wait_timeout * HZ;
375	int rc = 0;
376
377	sleep:
378	timeout = schedule_timeout_interruptible(timeout);
379	mutex_lock(&ecryptfs_msg_ctx_lists_mux);
380	mutex_lock(&msg_ctx->mux);
381	if (msg_ctx->state != ECRYPTFS_MSG_CTX_STATE_DONE) {
382	if (timeout) {
383	mutex_unlock(&msg_ctx->mux);
384	mutex_unlock(&ecryptfs_msg_ctx_lists_mux);
385	goto sleep;
386	}
387	rc = -ENOMSG;
388	} else {
389	*msg = msg_ctx->msg;
390	msg_ctx->msg = NULL;
391	}
392	ecryptfs_msg_ctx_alloc_to_free(msg_ctx);
393	mutex_unlock(&msg_ctx->mux);
394	mutex_unlock(&ecryptfs_msg_ctx_lists_mux);
395	return rc;
396	}
397
398	int ecryptfs_init_messaging(unsigned int transport)
399	{
400	int i;
401	int rc = 0;
402
403	if (ecryptfs_number_of_users > ECRYPTFS_MAX_NUM_USERS) {
404	ecryptfs_number_of_users = ECRYPTFS_MAX_NUM_USERS;
405	ecryptfs_printk(KERN_WARNING, "Specified number of users is "
406	"too large, defaulting to [%d] users\n",
407	ecryptfs_number_of_users);
408	}
409	mutex_init(&ecryptfs_daemon_id_hash_mux);
410	mutex_lock(&ecryptfs_daemon_id_hash_mux);
411	ecryptfs_hash_buckets = 0;
412	while (ecryptfs_number_of_users >> ++ecryptfs_hash_buckets);
413	ecryptfs_daemon_id_hash = kmalloc(sizeof(struct hlist_head)
414	* ecryptfs_hash_buckets, GFP_KERNEL);
415	if (!ecryptfs_daemon_id_hash) {
416	rc = -ENOMEM;
417	ecryptfs_printk(KERN_ERR, "Failed to allocate memory\n");
418	goto out;
419	}
420	for (i = 0; i < ecryptfs_hash_buckets; i++)
421	INIT_HLIST_HEAD(&ecryptfs_daemon_id_hash[i]);
422	mutex_unlock(&ecryptfs_daemon_id_hash_mux);
423
424	ecryptfs_msg_ctx_arr = kmalloc((sizeof(struct ecryptfs_msg_ctx)
425	* ecryptfs_message_buf_len), GFP_KERNEL);
426	if (!ecryptfs_msg_ctx_arr) {
427	rc = -ENOMEM;
428	ecryptfs_printk(KERN_ERR, "Failed to allocate memory\n");
429	goto out;
430	}
431	mutex_init(&ecryptfs_msg_ctx_lists_mux);
432	mutex_lock(&ecryptfs_msg_ctx_lists_mux);
433	ecryptfs_msg_counter = 0;
434	for (i = 0; i < ecryptfs_message_buf_len; i++) {
435	INIT_LIST_HEAD(&ecryptfs_msg_ctx_arr[i].node);
436	mutex_init(&ecryptfs_msg_ctx_arr[i].mux);
437	mutex_lock(&ecryptfs_msg_ctx_arr[i].mux);
438	ecryptfs_msg_ctx_arr[i].index = i;
439	ecryptfs_msg_ctx_arr[i].state = ECRYPTFS_MSG_CTX_STATE_FREE;
440	ecryptfs_msg_ctx_arr[i].counter = 0;
441	ecryptfs_msg_ctx_arr[i].task = NULL;
442	ecryptfs_msg_ctx_arr[i].msg = NULL;
443	list_add_tail(&ecryptfs_msg_ctx_arr[i].node,
444	&ecryptfs_msg_ctx_free_list);
445	mutex_unlock(&ecryptfs_msg_ctx_arr[i].mux);
446	}
447	mutex_unlock(&ecryptfs_msg_ctx_lists_mux);
448	switch(transport) {
449	case ECRYPTFS_TRANSPORT_NETLINK:
450	rc = ecryptfs_init_netlink();
451	if (rc)
452	ecryptfs_release_messaging(transport);
453	break;
454	case ECRYPTFS_TRANSPORT_CONNECTOR:
455	case ECRYPTFS_TRANSPORT_RELAYFS:
456	default:
457	rc = -ENOSYS;
458	}
459	out:
460	return rc;
461	}
462
463	void ecryptfs_release_messaging(unsigned int transport)
464	{
465	if (ecryptfs_msg_ctx_arr) {
466	int i;
467
468	mutex_lock(&ecryptfs_msg_ctx_lists_mux);
469	for (i = 0; i < ecryptfs_message_buf_len; i++) {
470	mutex_lock(&ecryptfs_msg_ctx_arr[i].mux);
471	if (ecryptfs_msg_ctx_arr[i].msg)
472	kfree(ecryptfs_msg_ctx_arr[i].msg);
473	mutex_unlock(&ecryptfs_msg_ctx_arr[i].mux);
474	}
475	kfree(ecryptfs_msg_ctx_arr);
476	mutex_unlock(&ecryptfs_msg_ctx_lists_mux);
477	}
478	if (ecryptfs_daemon_id_hash) {
479	struct hlist_node *elem;
480	struct ecryptfs_daemon_id *id;
481	int i;
482
483	mutex_lock(&ecryptfs_daemon_id_hash_mux);
484	for (i = 0; i < ecryptfs_hash_buckets; i++) {
485	hlist_for_each_entry(id, elem,
486	&ecryptfs_daemon_id_hash[i],
487	id_chain) {
488	hlist_del(elem);
489	kfree(id);
490	}
491	}
492	kfree(ecryptfs_daemon_id_hash);
493	mutex_unlock(&ecryptfs_daemon_id_hash_mux);
494	}
495	switch(transport) {
496	case ECRYPTFS_TRANSPORT_NETLINK:
497	ecryptfs_release_netlink();
498	break;
499	case ECRYPTFS_TRANSPORT_CONNECTOR:
500	case ECRYPTFS_TRANSPORT_RELAYFS:
501	default:
502	break;
503	}
504	return;
505	}