aboutsummaryrefslogtreecommitdiffstats
path: root/net/rxrpc/krxsecd.c
diff options
context:
space:
mode:
Diffstat (limited to 'net/rxrpc/krxsecd.c')
-rw-r--r--net/rxrpc/krxsecd.c270
1 files changed, 0 insertions, 270 deletions
diff --git a/net/rxrpc/krxsecd.c b/net/rxrpc/krxsecd.c
deleted file mode 100644
index 9a1e7f5e034c..000000000000
--- a/net/rxrpc/krxsecd.c
+++ /dev/null
@@ -1,270 +0,0 @@
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 <linux/freezer.h>
31#include <net/sock.h>
32#include "internal.h"
33
34static DECLARE_WAIT_QUEUE_HEAD(rxrpc_krxsecd_sleepq);
35static DECLARE_COMPLETION(rxrpc_krxsecd_dead);
36static volatile int rxrpc_krxsecd_die;
37
38static atomic_t rxrpc_krxsecd_qcount;
39
40/* queue of unprocessed inbound messages with seqno #1 and
41 * RXRPC_CLIENT_INITIATED flag set */
42static LIST_HEAD(rxrpc_krxsecd_initmsgq);
43static DEFINE_SPINLOCK(rxrpc_krxsecd_initmsgq_lock);
44
45static void rxrpc_krxsecd_process_incoming_call(struct rxrpc_message *msg);
46
47/*****************************************************************************/
48/*
49 * Rx security daemon
50 */
51static int rxrpc_krxsecd(void *arg)
52{
53 DECLARE_WAITQUEUE(krxsecd, current);
54
55 int die;
56
57 printk("Started krxsecd %d\n", current->pid);
58
59 daemonize("krxsecd");
60
61 /* loop around waiting for work to do */
62 do {
63 /* wait for work or to be told to exit */
64 _debug("### Begin Wait");
65 if (!atomic_read(&rxrpc_krxsecd_qcount)) {
66 set_current_state(TASK_INTERRUPTIBLE);
67
68 add_wait_queue(&rxrpc_krxsecd_sleepq, &krxsecd);
69
70 for (;;) {
71 set_current_state(TASK_INTERRUPTIBLE);
72 if (atomic_read(&rxrpc_krxsecd_qcount) ||
73 rxrpc_krxsecd_die ||
74 signal_pending(current))
75 break;
76
77 schedule();
78 }
79
80 remove_wait_queue(&rxrpc_krxsecd_sleepq, &krxsecd);
81 set_current_state(TASK_RUNNING);
82 }
83 die = rxrpc_krxsecd_die;
84 _debug("### End Wait");
85
86 /* see if there're incoming calls in need of authenticating */
87 _debug("### Begin Inbound Calls");
88
89 if (!list_empty(&rxrpc_krxsecd_initmsgq)) {
90 struct rxrpc_message *msg = NULL;
91
92 spin_lock(&rxrpc_krxsecd_initmsgq_lock);
93
94 if (!list_empty(&rxrpc_krxsecd_initmsgq)) {
95 msg = list_entry(rxrpc_krxsecd_initmsgq.next,
96 struct rxrpc_message, link);
97 list_del_init(&msg->link);
98 atomic_dec(&rxrpc_krxsecd_qcount);
99 }
100
101 spin_unlock(&rxrpc_krxsecd_initmsgq_lock);
102
103 if (msg) {
104 rxrpc_krxsecd_process_incoming_call(msg);
105 rxrpc_put_message(msg);
106 }
107 }
108
109 _debug("### End Inbound Calls");
110
111 try_to_freeze();
112
113 /* discard pending signals */
114 rxrpc_discard_my_signals();
115
116 } while (!die);
117
118 /* and that's all */
119 complete_and_exit(&rxrpc_krxsecd_dead, 0);
120
121} /* end rxrpc_krxsecd() */
122
123/*****************************************************************************/
124/*
125 * start up a krxsecd daemon
126 */
127int __init rxrpc_krxsecd_init(void)
128{
129 return kernel_thread(rxrpc_krxsecd, NULL, 0);
130
131} /* end rxrpc_krxsecd_init() */
132
133/*****************************************************************************/
134/*
135 * kill the krxsecd daemon and wait for it to complete
136 */
137void rxrpc_krxsecd_kill(void)
138{
139 rxrpc_krxsecd_die = 1;
140 wake_up_all(&rxrpc_krxsecd_sleepq);
141 wait_for_completion(&rxrpc_krxsecd_dead);
142
143} /* end rxrpc_krxsecd_kill() */
144
145/*****************************************************************************/
146/*
147 * clear all pending incoming calls for the specified transport
148 */
149void rxrpc_krxsecd_clear_transport(struct rxrpc_transport *trans)
150{
151 LIST_HEAD(tmp);
152
153 struct rxrpc_message *msg;
154 struct list_head *_p, *_n;
155
156 _enter("%p",trans);
157
158 /* move all the messages for this transport onto a temp list */
159 spin_lock(&rxrpc_krxsecd_initmsgq_lock);
160
161 list_for_each_safe(_p, _n, &rxrpc_krxsecd_initmsgq) {
162 msg = list_entry(_p, struct rxrpc_message, link);
163 if (msg->trans == trans) {
164 list_move_tail(&msg->link, &tmp);
165 atomic_dec(&rxrpc_krxsecd_qcount);
166 }
167 }
168
169 spin_unlock(&rxrpc_krxsecd_initmsgq_lock);
170
171 /* zap all messages on the temp list */
172 while (!list_empty(&tmp)) {
173 msg = list_entry(tmp.next, struct rxrpc_message, link);
174 list_del_init(&msg->link);
175 rxrpc_put_message(msg);
176 }
177
178 _leave("");
179} /* end rxrpc_krxsecd_clear_transport() */
180
181/*****************************************************************************/
182/*
183 * queue a message on the incoming calls list
184 */
185void rxrpc_krxsecd_queue_incoming_call(struct rxrpc_message *msg)
186{
187 _enter("%p", msg);
188
189 /* queue for processing by krxsecd */
190 spin_lock(&rxrpc_krxsecd_initmsgq_lock);
191
192 if (!rxrpc_krxsecd_die) {
193 rxrpc_get_message(msg);
194 list_add_tail(&msg->link, &rxrpc_krxsecd_initmsgq);
195 atomic_inc(&rxrpc_krxsecd_qcount);
196 }
197
198 spin_unlock(&rxrpc_krxsecd_initmsgq_lock);
199
200 wake_up(&rxrpc_krxsecd_sleepq);
201
202 _leave("");
203} /* end rxrpc_krxsecd_queue_incoming_call() */
204
205/*****************************************************************************/
206/*
207 * process the initial message of an incoming call
208 */
209void rxrpc_krxsecd_process_incoming_call(struct rxrpc_message *msg)
210{
211 struct rxrpc_transport *trans = msg->trans;
212 struct rxrpc_service *srv;
213 struct rxrpc_call *call;
214 struct list_head *_p;
215 unsigned short sid;
216 int ret;
217
218 _enter("%p{tr=%p}", msg, trans);
219
220 ret = rxrpc_incoming_call(msg->conn, msg, &call);
221 if (ret < 0)
222 goto out;
223
224 /* find the matching service on the transport */
225 sid = ntohs(msg->hdr.serviceId);
226 srv = NULL;
227
228 spin_lock(&trans->lock);
229 list_for_each(_p, &trans->services) {
230 srv = list_entry(_p, struct rxrpc_service, link);
231 if (srv->service_id == sid && try_module_get(srv->owner)) {
232 /* found a match (made sure it won't vanish) */
233 _debug("found service '%s'", srv->name);
234 call->owner = srv->owner;
235 break;
236 }
237 }
238 spin_unlock(&trans->lock);
239
240 /* report the new connection
241 * - the func must inc the call's usage count to keep it
242 */
243 ret = -ENOENT;
244 if (_p != &trans->services) {
245 /* attempt to accept the call */
246 call->conn->service = srv;
247 call->app_attn_func = srv->attn_func;
248 call->app_error_func = srv->error_func;
249 call->app_aemap_func = srv->aemap_func;
250
251 ret = srv->new_call(call);
252
253 /* send an abort if an error occurred */
254 if (ret < 0) {
255 rxrpc_call_abort(call, ret);
256 }
257 else {
258 /* formally receive and ACK the new packet */
259 ret = rxrpc_conn_receive_call_packet(call->conn,
260 call, msg);
261 }
262 }
263
264 rxrpc_put_call(call);
265 out:
266 if (ret < 0)
267 rxrpc_trans_immediate_abort(trans, msg, ret);
268
269 _leave(" (%d)", ret);
270} /* end rxrpc_krxsecd_process_incoming_call() */
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-13 05:47:39 -0500