[PATCH] scx200_acb: Fix the state machine
[linux-3.10.git] / net / rxrpc / krxsecd.c
1 /* krxsecd.c: Rx security daemon
2  *
3  * Copyright (C) 2002 Red Hat, Inc. All Rights Reserved.
4  * Written by David Howells (dhowells@redhat.com)
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version
9  * 2 of the License, or (at your option) any later version.
10  *
11  * This daemon deals with:
12  * - consulting the application as to whether inbound peers and calls should be authorised
13  * - generating security challenges for inbound connections
14  * - responding to security challenges on outbound connections
15  */
16
17 #include <linux/module.h>
18 #include <linux/sched.h>
19 #include <linux/completion.h>
20 #include <linux/spinlock.h>
21 #include <linux/init.h>
22 #include <rxrpc/krxsecd.h>
23 #include <rxrpc/transport.h>
24 #include <rxrpc/connection.h>
25 #include <rxrpc/message.h>
26 #include <rxrpc/peer.h>
27 #include <rxrpc/call.h>
28 #include <linux/udp.h>
29 #include <linux/ip.h>
30 #include <net/sock.h>
31 #include "internal.h"
32
33 static DECLARE_WAIT_QUEUE_HEAD(rxrpc_krxsecd_sleepq);
34 static DECLARE_COMPLETION(rxrpc_krxsecd_dead);
35 static volatile int rxrpc_krxsecd_die;
36
37 static atomic_t rxrpc_krxsecd_qcount;
38
39 /* queue of unprocessed inbound messages with seqno #1 and
40  * RXRPC_CLIENT_INITIATED flag set */
41 static LIST_HEAD(rxrpc_krxsecd_initmsgq);
42 static DEFINE_SPINLOCK(rxrpc_krxsecd_initmsgq_lock);
43
44 static void rxrpc_krxsecd_process_incoming_call(struct rxrpc_message *msg);
45
46 /*****************************************************************************/
47 /*
48  * Rx security daemon
49  */
50 static int rxrpc_krxsecd(void *arg)
51 {
52         DECLARE_WAITQUEUE(krxsecd, current);
53
54         int die;
55
56         printk("Started krxsecd %d\n", current->pid);
57
58         daemonize("krxsecd");
59
60         /* loop around waiting for work to do */
61         do {
62                 /* wait for work or to be told to exit */
63                 _debug("### Begin Wait");
64                 if (!atomic_read(&rxrpc_krxsecd_qcount)) {
65                         set_current_state(TASK_INTERRUPTIBLE);
66
67                         add_wait_queue(&rxrpc_krxsecd_sleepq, &krxsecd);
68
69                         for (;;) {
70                                 set_current_state(TASK_INTERRUPTIBLE);
71                                 if (atomic_read(&rxrpc_krxsecd_qcount) ||
72                                     rxrpc_krxsecd_die ||
73                                     signal_pending(current))
74                                         break;
75
76                                 schedule();
77                         }
78
79                         remove_wait_queue(&rxrpc_krxsecd_sleepq, &krxsecd);
80                         set_current_state(TASK_RUNNING);
81                 }
82                 die = rxrpc_krxsecd_die;
83                 _debug("### End Wait");
84
85                 /* see if there're incoming calls in need of authenticating */
86                 _debug("### Begin Inbound Calls");
87
88                 if (!list_empty(&rxrpc_krxsecd_initmsgq)) {
89                         struct rxrpc_message *msg = NULL;
90
91                         spin_lock(&rxrpc_krxsecd_initmsgq_lock);
92
93                         if (!list_empty(&rxrpc_krxsecd_initmsgq)) {
94                                 msg = list_entry(rxrpc_krxsecd_initmsgq.next,
95                                                  struct rxrpc_message, link);
96                                 list_del_init(&msg->link);
97                                 atomic_dec(&rxrpc_krxsecd_qcount);
98                         }
99
100                         spin_unlock(&rxrpc_krxsecd_initmsgq_lock);
101
102                         if (msg) {
103                                 rxrpc_krxsecd_process_incoming_call(msg);
104                                 rxrpc_put_message(msg);
105                         }
106                 }
107
108                 _debug("### End Inbound Calls");
109
110                 try_to_freeze();
111
112                 /* discard pending signals */
113                 rxrpc_discard_my_signals();
114
115         } while (!die);
116
117         /* and that's all */
118         complete_and_exit(&rxrpc_krxsecd_dead, 0);
119
120 } /* end rxrpc_krxsecd() */
121
122 /*****************************************************************************/
123 /*
124  * start up a krxsecd daemon
125  */
126 int __init rxrpc_krxsecd_init(void)
127 {
128         return kernel_thread(rxrpc_krxsecd, NULL, 0);
129
130 } /* end rxrpc_krxsecd_init() */
131
132 /*****************************************************************************/
133 /*
134  * kill the krxsecd daemon and wait for it to complete
135  */
136 void rxrpc_krxsecd_kill(void)
137 {
138         rxrpc_krxsecd_die = 1;
139         wake_up_all(&rxrpc_krxsecd_sleepq);
140         wait_for_completion(&rxrpc_krxsecd_dead);
141
142 } /* end rxrpc_krxsecd_kill() */
143
144 /*****************************************************************************/
145 /*
146  * clear all pending incoming calls for the specified transport
147  */
148 void rxrpc_krxsecd_clear_transport(struct rxrpc_transport *trans)
149 {
150         LIST_HEAD(tmp);
151
152         struct rxrpc_message *msg;
153         struct list_head *_p, *_n;
154
155         _enter("%p",trans);
156
157         /* move all the messages for this transport onto a temp list */
158         spin_lock(&rxrpc_krxsecd_initmsgq_lock);
159
160         list_for_each_safe(_p, _n, &rxrpc_krxsecd_initmsgq) {
161                 msg = list_entry(_p, struct rxrpc_message, link);
162                 if (msg->trans == trans) {
163                         list_move_tail(&msg->link, &tmp);
164                         atomic_dec(&rxrpc_krxsecd_qcount);
165                 }
166         }
167
168         spin_unlock(&rxrpc_krxsecd_initmsgq_lock);
169
170         /* zap all messages on the temp list */
171         while (!list_empty(&tmp)) {
172                 msg = list_entry(tmp.next, struct rxrpc_message, link);
173                 list_del_init(&msg->link);
174                 rxrpc_put_message(msg);
175         }
176
177         _leave("");
178 } /* end rxrpc_krxsecd_clear_transport() */
179
180 /*****************************************************************************/
181 /*
182  * queue a message on the incoming calls list
183  */
184 void rxrpc_krxsecd_queue_incoming_call(struct rxrpc_message *msg)
185 {
186         _enter("%p", msg);
187
188         /* queue for processing by krxsecd */
189         spin_lock(&rxrpc_krxsecd_initmsgq_lock);
190
191         if (!rxrpc_krxsecd_die) {
192                 rxrpc_get_message(msg);
193                 list_add_tail(&msg->link, &rxrpc_krxsecd_initmsgq);
194                 atomic_inc(&rxrpc_krxsecd_qcount);
195         }
196
197         spin_unlock(&rxrpc_krxsecd_initmsgq_lock);
198
199         wake_up(&rxrpc_krxsecd_sleepq);
200
201         _leave("");
202 } /* end rxrpc_krxsecd_queue_incoming_call() */
203
204 /*****************************************************************************/
205 /*
206  * process the initial message of an incoming call
207  */
208 void rxrpc_krxsecd_process_incoming_call(struct rxrpc_message *msg)
209 {
210         struct rxrpc_transport *trans = msg->trans;
211         struct rxrpc_service *srv;
212         struct rxrpc_call *call;
213         struct list_head *_p;
214         unsigned short sid;
215         int ret;
216
217         _enter("%p{tr=%p}", msg, trans);
218
219         ret = rxrpc_incoming_call(msg->conn, msg, &call);
220         if (ret < 0)
221                 goto out;
222
223         /* find the matching service on the transport */
224         sid = ntohs(msg->hdr.serviceId);
225         srv = NULL;
226
227         spin_lock(&trans->lock);
228         list_for_each(_p, &trans->services) {
229                 srv = list_entry(_p, struct rxrpc_service, link);
230                 if (srv->service_id == sid && try_module_get(srv->owner)) {
231                         /* found a match (made sure it won't vanish) */
232                         _debug("found service '%s'", srv->name);
233                         call->owner = srv->owner;
234                         break;
235                 }
236         }
237         spin_unlock(&trans->lock);
238
239         /* report the new connection
240          * - the func must inc the call's usage count to keep it
241          */
242         ret = -ENOENT;
243         if (_p != &trans->services) {
244                 /* attempt to accept the call */
245                 call->conn->service = srv;
246                 call->app_attn_func = srv->attn_func;
247                 call->app_error_func = srv->error_func;
248                 call->app_aemap_func = srv->aemap_func;
249
250                 ret = srv->new_call(call);
251
252                 /* send an abort if an error occurred */
253                 if (ret < 0) {
254                         rxrpc_call_abort(call, ret);
255                 }
256                 else {
257                         /* formally receive and ACK the new packet */
258                         ret = rxrpc_conn_receive_call_packet(call->conn,
259                                                              call, msg);
260                 }
261         }
262
263         rxrpc_put_call(call);
264  out:
265         if (ret < 0)
266                 rxrpc_trans_immediate_abort(trans, msg, ret);
267
268         _leave(" (%d)", ret);
269 } /* end rxrpc_krxsecd_process_incoming_call() */