[PATCH] eCryptfs: Public key transport mechanism
[linux-2.6] / fs / ecryptfs / messaging.c
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 }