1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* AF_RXRPC implementation
3  *
4  * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
5  * Written by David Howells (dhowells@redhat.com)
6  */
7 
8 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
9 
10 #include <linux/module.h>
11 #include <linux/kernel.h>
12 #include <linux/net.h>
13 #include <linux/slab.h>
14 #include <linux/skbuff.h>
15 #include <linux/random.h>
16 #include <linux/poll.h>
17 #include <linux/proc_fs.h>
18 #include <linux/key-type.h>
19 #include <net/net_namespace.h>
20 #include <net/sock.h>
21 #include <net/af_rxrpc.h>
22 #define CREATE_TRACE_POINTS
23 #include "ar-internal.h"
24 
25 MODULE_DESCRIPTION("RxRPC network protocol");
26 MODULE_AUTHOR("Red Hat, Inc.");
27 MODULE_LICENSE("GPL");
28 MODULE_ALIAS_NETPROTO(PF_RXRPC);
29 
30 unsigned int rxrpc_debug; // = RXRPC_DEBUG_KPROTO;
31 module_param_named(debug, rxrpc_debug, uint, 0644);
32 MODULE_PARM_DESC(debug, "RxRPC debugging mask");
33 
34 static struct proto rxrpc_proto;
35 static const struct proto_ops rxrpc_rpc_ops;
36 
37 /* current debugging ID */
38 atomic_t rxrpc_debug_id;
39 EXPORT_SYMBOL(rxrpc_debug_id);
40 
41 /* count of skbs currently in use */
42 atomic_t rxrpc_n_tx_skbs, rxrpc_n_rx_skbs;
43 
44 struct workqueue_struct *rxrpc_workqueue;
45 
46 static void rxrpc_sock_destructor(struct sock *);
47 
48 /*
49  * see if an RxRPC socket is currently writable
50  */
rxrpc_writable(struct sock * sk)51 static inline int rxrpc_writable(struct sock *sk)
52 {
53 	return refcount_read(&sk->sk_wmem_alloc) < (size_t) sk->sk_sndbuf;
54 }
55 
56 /*
57  * wait for write bufferage to become available
58  */
rxrpc_write_space(struct sock * sk)59 static void rxrpc_write_space(struct sock *sk)
60 {
61 	_enter("%p", sk);
62 	rcu_read_lock();
63 	if (rxrpc_writable(sk)) {
64 		struct socket_wq *wq = rcu_dereference(sk->sk_wq);
65 
66 		if (skwq_has_sleeper(wq))
67 			wake_up_interruptible(&wq->wait);
68 		sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT);
69 	}
70 	rcu_read_unlock();
71 }
72 
73 /*
74  * validate an RxRPC address
75  */
rxrpc_validate_address(struct rxrpc_sock * rx,struct sockaddr_rxrpc * srx,int len)76 static int rxrpc_validate_address(struct rxrpc_sock *rx,
77 				  struct sockaddr_rxrpc *srx,
78 				  int len)
79 {
80 	unsigned int tail;
81 
82 	if (len < sizeof(struct sockaddr_rxrpc))
83 		return -EINVAL;
84 
85 	if (srx->srx_family != AF_RXRPC)
86 		return -EAFNOSUPPORT;
87 
88 	if (srx->transport_type != SOCK_DGRAM)
89 		return -ESOCKTNOSUPPORT;
90 
91 	len -= offsetof(struct sockaddr_rxrpc, transport);
92 	if (srx->transport_len < sizeof(sa_family_t) ||
93 	    srx->transport_len > len)
94 		return -EINVAL;
95 
96 	if (srx->transport.family != rx->family &&
97 	    srx->transport.family == AF_INET && rx->family != AF_INET6)
98 		return -EAFNOSUPPORT;
99 
100 	switch (srx->transport.family) {
101 	case AF_INET:
102 		if (srx->transport_len < sizeof(struct sockaddr_in))
103 			return -EINVAL;
104 		tail = offsetof(struct sockaddr_rxrpc, transport.sin.__pad);
105 		break;
106 
107 #ifdef CONFIG_AF_RXRPC_IPV6
108 	case AF_INET6:
109 		if (srx->transport_len < sizeof(struct sockaddr_in6))
110 			return -EINVAL;
111 		tail = offsetof(struct sockaddr_rxrpc, transport) +
112 			sizeof(struct sockaddr_in6);
113 		break;
114 #endif
115 
116 	default:
117 		return -EAFNOSUPPORT;
118 	}
119 
120 	if (tail < len)
121 		memset((void *)srx + tail, 0, len - tail);
122 	_debug("INET: %pISp", &srx->transport);
123 	return 0;
124 }
125 
126 /*
127  * bind a local address to an RxRPC socket
128  */
rxrpc_bind(struct socket * sock,struct sockaddr * saddr,int len)129 static int rxrpc_bind(struct socket *sock, struct sockaddr *saddr, int len)
130 {
131 	struct sockaddr_rxrpc *srx = (struct sockaddr_rxrpc *)saddr;
132 	struct rxrpc_local *local;
133 	struct rxrpc_sock *rx = rxrpc_sk(sock->sk);
134 	u16 service_id;
135 	int ret;
136 
137 	_enter("%p,%p,%d", rx, saddr, len);
138 
139 	ret = rxrpc_validate_address(rx, srx, len);
140 	if (ret < 0)
141 		goto error;
142 	service_id = srx->srx_service;
143 
144 	lock_sock(&rx->sk);
145 
146 	switch (rx->sk.sk_state) {
147 	case RXRPC_UNBOUND:
148 		rx->srx = *srx;
149 		local = rxrpc_lookup_local(sock_net(&rx->sk), &rx->srx);
150 		if (IS_ERR(local)) {
151 			ret = PTR_ERR(local);
152 			goto error_unlock;
153 		}
154 
155 		if (service_id) {
156 			write_lock(&local->services_lock);
157 			if (rcu_access_pointer(local->service))
158 				goto service_in_use;
159 			rx->local = local;
160 			rcu_assign_pointer(local->service, rx);
161 			write_unlock(&local->services_lock);
162 
163 			rx->sk.sk_state = RXRPC_SERVER_BOUND;
164 		} else {
165 			rx->local = local;
166 			rx->sk.sk_state = RXRPC_CLIENT_BOUND;
167 		}
168 		break;
169 
170 	case RXRPC_SERVER_BOUND:
171 		ret = -EINVAL;
172 		if (service_id == 0)
173 			goto error_unlock;
174 		ret = -EADDRINUSE;
175 		if (service_id == rx->srx.srx_service)
176 			goto error_unlock;
177 		ret = -EINVAL;
178 		srx->srx_service = rx->srx.srx_service;
179 		if (memcmp(srx, &rx->srx, sizeof(*srx)) != 0)
180 			goto error_unlock;
181 		rx->second_service = service_id;
182 		rx->sk.sk_state = RXRPC_SERVER_BOUND2;
183 		break;
184 
185 	default:
186 		ret = -EINVAL;
187 		goto error_unlock;
188 	}
189 
190 	release_sock(&rx->sk);
191 	_leave(" = 0");
192 	return 0;
193 
194 service_in_use:
195 	write_unlock(&local->services_lock);
196 	rxrpc_unuse_local(local);
197 	rxrpc_put_local(local);
198 	ret = -EADDRINUSE;
199 error_unlock:
200 	release_sock(&rx->sk);
201 error:
202 	_leave(" = %d", ret);
203 	return ret;
204 }
205 
206 /*
207  * set the number of pending calls permitted on a listening socket
208  */
rxrpc_listen(struct socket * sock,int backlog)209 static int rxrpc_listen(struct socket *sock, int backlog)
210 {
211 	struct sock *sk = sock->sk;
212 	struct rxrpc_sock *rx = rxrpc_sk(sk);
213 	unsigned int max, old;
214 	int ret;
215 
216 	_enter("%p,%d", rx, backlog);
217 
218 	lock_sock(&rx->sk);
219 
220 	switch (rx->sk.sk_state) {
221 	case RXRPC_UNBOUND:
222 		ret = -EADDRNOTAVAIL;
223 		break;
224 	case RXRPC_SERVER_BOUND:
225 	case RXRPC_SERVER_BOUND2:
226 		ASSERT(rx->local != NULL);
227 		max = READ_ONCE(rxrpc_max_backlog);
228 		ret = -EINVAL;
229 		if (backlog == INT_MAX)
230 			backlog = max;
231 		else if (backlog < 0 || backlog > max)
232 			break;
233 		old = sk->sk_max_ack_backlog;
234 		sk->sk_max_ack_backlog = backlog;
235 		ret = rxrpc_service_prealloc(rx, GFP_KERNEL);
236 		if (ret == 0)
237 			rx->sk.sk_state = RXRPC_SERVER_LISTENING;
238 		else
239 			sk->sk_max_ack_backlog = old;
240 		break;
241 	case RXRPC_SERVER_LISTENING:
242 		if (backlog == 0) {
243 			rx->sk.sk_state = RXRPC_SERVER_LISTEN_DISABLED;
244 			sk->sk_max_ack_backlog = 0;
245 			rxrpc_discard_prealloc(rx);
246 			ret = 0;
247 			break;
248 		}
249 		fallthrough;
250 	default:
251 		ret = -EBUSY;
252 		break;
253 	}
254 
255 	release_sock(&rx->sk);
256 	_leave(" = %d", ret);
257 	return ret;
258 }
259 
260 /**
261  * rxrpc_kernel_begin_call - Allow a kernel service to begin a call
262  * @sock: The socket on which to make the call
263  * @srx: The address of the peer to contact
264  * @key: The security context to use (defaults to socket setting)
265  * @user_call_ID: The ID to use
266  * @tx_total_len: Total length of data to transmit during the call (or -1)
267  * @gfp: The allocation constraints
268  * @notify_rx: Where to send notifications instead of socket queue
269  * @upgrade: Request service upgrade for call
270  * @interruptibility: The call is interruptible, or can be canceled.
271  * @debug_id: The debug ID for tracing to be assigned to the call
272  *
273  * Allow a kernel service to begin a call on the nominated socket.  This just
274  * sets up all the internal tracking structures and allocates connection and
275  * call IDs as appropriate.  The call to be used is returned.
276  *
277  * The default socket destination address and security may be overridden by
278  * supplying @srx and @key.
279  */
rxrpc_kernel_begin_call(struct socket * sock,struct sockaddr_rxrpc * srx,struct key * key,unsigned long user_call_ID,s64 tx_total_len,gfp_t gfp,rxrpc_notify_rx_t notify_rx,bool upgrade,enum rxrpc_interruptibility interruptibility,unsigned int debug_id)280 struct rxrpc_call *rxrpc_kernel_begin_call(struct socket *sock,
281 					   struct sockaddr_rxrpc *srx,
282 					   struct key *key,
283 					   unsigned long user_call_ID,
284 					   s64 tx_total_len,
285 					   gfp_t gfp,
286 					   rxrpc_notify_rx_t notify_rx,
287 					   bool upgrade,
288 					   enum rxrpc_interruptibility interruptibility,
289 					   unsigned int debug_id)
290 {
291 	struct rxrpc_conn_parameters cp;
292 	struct rxrpc_call_params p;
293 	struct rxrpc_call *call;
294 	struct rxrpc_sock *rx = rxrpc_sk(sock->sk);
295 	int ret;
296 
297 	_enter(",,%x,%lx", key_serial(key), user_call_ID);
298 
299 	ret = rxrpc_validate_address(rx, srx, sizeof(*srx));
300 	if (ret < 0)
301 		return ERR_PTR(ret);
302 
303 	lock_sock(&rx->sk);
304 
305 	if (!key)
306 		key = rx->key;
307 	if (key && !key->payload.data[0])
308 		key = NULL; /* a no-security key */
309 
310 	memset(&p, 0, sizeof(p));
311 	p.user_call_ID		= user_call_ID;
312 	p.tx_total_len		= tx_total_len;
313 	p.interruptibility	= interruptibility;
314 	p.kernel		= true;
315 
316 	memset(&cp, 0, sizeof(cp));
317 	cp.local		= rx->local;
318 	cp.key			= key;
319 	cp.security_level	= rx->min_sec_level;
320 	cp.exclusive		= false;
321 	cp.upgrade		= upgrade;
322 	cp.service_id		= srx->srx_service;
323 	call = rxrpc_new_client_call(rx, &cp, srx, &p, gfp, debug_id);
324 	/* The socket has been unlocked. */
325 	if (!IS_ERR(call)) {
326 		call->notify_rx = notify_rx;
327 		mutex_unlock(&call->user_mutex);
328 	}
329 
330 	rxrpc_put_peer(cp.peer);
331 	_leave(" = %p", call);
332 	return call;
333 }
334 EXPORT_SYMBOL(rxrpc_kernel_begin_call);
335 
336 /*
337  * Dummy function used to stop the notifier talking to recvmsg().
338  */
rxrpc_dummy_notify_rx(struct sock * sk,struct rxrpc_call * rxcall,unsigned long call_user_ID)339 static void rxrpc_dummy_notify_rx(struct sock *sk, struct rxrpc_call *rxcall,
340 				  unsigned long call_user_ID)
341 {
342 }
343 
344 /**
345  * rxrpc_kernel_end_call - Allow a kernel service to end a call it was using
346  * @sock: The socket the call is on
347  * @call: The call to end
348  *
349  * Allow a kernel service to end a call it was using.  The call must be
350  * complete before this is called (the call should be aborted if necessary).
351  */
rxrpc_kernel_end_call(struct socket * sock,struct rxrpc_call * call)352 void rxrpc_kernel_end_call(struct socket *sock, struct rxrpc_call *call)
353 {
354 	_enter("%d{%d}", call->debug_id, refcount_read(&call->ref));
355 
356 	mutex_lock(&call->user_mutex);
357 	rxrpc_release_call(rxrpc_sk(sock->sk), call);
358 
359 	/* Make sure we're not going to call back into a kernel service */
360 	if (call->notify_rx) {
361 		spin_lock_bh(&call->notify_lock);
362 		call->notify_rx = rxrpc_dummy_notify_rx;
363 		spin_unlock_bh(&call->notify_lock);
364 	}
365 
366 	mutex_unlock(&call->user_mutex);
367 	rxrpc_put_call(call, rxrpc_call_put_kernel);
368 }
369 EXPORT_SYMBOL(rxrpc_kernel_end_call);
370 
371 /**
372  * rxrpc_kernel_check_life - Check to see whether a call is still alive
373  * @sock: The socket the call is on
374  * @call: The call to check
375  *
376  * Allow a kernel service to find out whether a call is still alive -
377  * ie. whether it has completed.
378  */
rxrpc_kernel_check_life(const struct socket * sock,const struct rxrpc_call * call)379 bool rxrpc_kernel_check_life(const struct socket *sock,
380 			     const struct rxrpc_call *call)
381 {
382 	return call->state != RXRPC_CALL_COMPLETE;
383 }
384 EXPORT_SYMBOL(rxrpc_kernel_check_life);
385 
386 /**
387  * rxrpc_kernel_get_epoch - Retrieve the epoch value from a call.
388  * @sock: The socket the call is on
389  * @call: The call to query
390  *
391  * Allow a kernel service to retrieve the epoch value from a service call to
392  * see if the client at the other end rebooted.
393  */
rxrpc_kernel_get_epoch(struct socket * sock,struct rxrpc_call * call)394 u32 rxrpc_kernel_get_epoch(struct socket *sock, struct rxrpc_call *call)
395 {
396 	return call->conn->proto.epoch;
397 }
398 EXPORT_SYMBOL(rxrpc_kernel_get_epoch);
399 
400 /**
401  * rxrpc_kernel_new_call_notification - Get notifications of new calls
402  * @sock: The socket to intercept received messages on
403  * @notify_new_call: Function to be called when new calls appear
404  * @discard_new_call: Function to discard preallocated calls
405  *
406  * Allow a kernel service to be given notifications about new calls.
407  */
rxrpc_kernel_new_call_notification(struct socket * sock,rxrpc_notify_new_call_t notify_new_call,rxrpc_discard_new_call_t discard_new_call)408 void rxrpc_kernel_new_call_notification(
409 	struct socket *sock,
410 	rxrpc_notify_new_call_t notify_new_call,
411 	rxrpc_discard_new_call_t discard_new_call)
412 {
413 	struct rxrpc_sock *rx = rxrpc_sk(sock->sk);
414 
415 	rx->notify_new_call = notify_new_call;
416 	rx->discard_new_call = discard_new_call;
417 }
418 EXPORT_SYMBOL(rxrpc_kernel_new_call_notification);
419 
420 /**
421  * rxrpc_kernel_set_max_life - Set maximum lifespan on a call
422  * @sock: The socket the call is on
423  * @call: The call to configure
424  * @hard_timeout: The maximum lifespan of the call in jiffies
425  *
426  * Set the maximum lifespan of a call.  The call will end with ETIME or
427  * ETIMEDOUT if it takes longer than this.
428  */
rxrpc_kernel_set_max_life(struct socket * sock,struct rxrpc_call * call,unsigned long hard_timeout)429 void rxrpc_kernel_set_max_life(struct socket *sock, struct rxrpc_call *call,
430 			       unsigned long hard_timeout)
431 {
432 	unsigned long now;
433 
434 	mutex_lock(&call->user_mutex);
435 
436 	now = jiffies;
437 	hard_timeout += now;
438 	WRITE_ONCE(call->expect_term_by, hard_timeout);
439 	rxrpc_reduce_call_timer(call, hard_timeout, now, rxrpc_timer_set_for_hard);
440 
441 	mutex_unlock(&call->user_mutex);
442 }
443 EXPORT_SYMBOL(rxrpc_kernel_set_max_life);
444 
445 /*
446  * connect an RxRPC socket
447  * - this just targets it at a specific destination; no actual connection
448  *   negotiation takes place
449  */
rxrpc_connect(struct socket * sock,struct sockaddr * addr,int addr_len,int flags)450 static int rxrpc_connect(struct socket *sock, struct sockaddr *addr,
451 			 int addr_len, int flags)
452 {
453 	struct sockaddr_rxrpc *srx = (struct sockaddr_rxrpc *)addr;
454 	struct rxrpc_sock *rx = rxrpc_sk(sock->sk);
455 	int ret;
456 
457 	_enter("%p,%p,%d,%d", rx, addr, addr_len, flags);
458 
459 	ret = rxrpc_validate_address(rx, srx, addr_len);
460 	if (ret < 0) {
461 		_leave(" = %d [bad addr]", ret);
462 		return ret;
463 	}
464 
465 	lock_sock(&rx->sk);
466 
467 	ret = -EISCONN;
468 	if (test_bit(RXRPC_SOCK_CONNECTED, &rx->flags))
469 		goto error;
470 
471 	switch (rx->sk.sk_state) {
472 	case RXRPC_UNBOUND:
473 		rx->sk.sk_state = RXRPC_CLIENT_UNBOUND;
474 		break;
475 	case RXRPC_CLIENT_UNBOUND:
476 	case RXRPC_CLIENT_BOUND:
477 		break;
478 	default:
479 		ret = -EBUSY;
480 		goto error;
481 	}
482 
483 	rx->connect_srx = *srx;
484 	set_bit(RXRPC_SOCK_CONNECTED, &rx->flags);
485 	ret = 0;
486 
487 error:
488 	release_sock(&rx->sk);
489 	return ret;
490 }
491 
492 /*
493  * send a message through an RxRPC socket
494  * - in a client this does a number of things:
495  *   - finds/sets up a connection for the security specified (if any)
496  *   - initiates a call (ID in control data)
497  *   - ends the request phase of a call (if MSG_MORE is not set)
498  *   - sends a call data packet
499  *   - may send an abort (abort code in control data)
500  */
rxrpc_sendmsg(struct socket * sock,struct msghdr * m,size_t len)501 static int rxrpc_sendmsg(struct socket *sock, struct msghdr *m, size_t len)
502 {
503 	struct rxrpc_local *local;
504 	struct rxrpc_sock *rx = rxrpc_sk(sock->sk);
505 	int ret;
506 
507 	_enter(",{%d},,%zu", rx->sk.sk_state, len);
508 
509 	if (m->msg_flags & MSG_OOB)
510 		return -EOPNOTSUPP;
511 
512 	if (m->msg_name) {
513 		ret = rxrpc_validate_address(rx, m->msg_name, m->msg_namelen);
514 		if (ret < 0) {
515 			_leave(" = %d [bad addr]", ret);
516 			return ret;
517 		}
518 	}
519 
520 	lock_sock(&rx->sk);
521 
522 	switch (rx->sk.sk_state) {
523 	case RXRPC_UNBOUND:
524 	case RXRPC_CLIENT_UNBOUND:
525 		rx->srx.srx_family = AF_RXRPC;
526 		rx->srx.srx_service = 0;
527 		rx->srx.transport_type = SOCK_DGRAM;
528 		rx->srx.transport.family = rx->family;
529 		switch (rx->family) {
530 		case AF_INET:
531 			rx->srx.transport_len = sizeof(struct sockaddr_in);
532 			break;
533 #ifdef CONFIG_AF_RXRPC_IPV6
534 		case AF_INET6:
535 			rx->srx.transport_len = sizeof(struct sockaddr_in6);
536 			break;
537 #endif
538 		default:
539 			ret = -EAFNOSUPPORT;
540 			goto error_unlock;
541 		}
542 		local = rxrpc_lookup_local(sock_net(sock->sk), &rx->srx);
543 		if (IS_ERR(local)) {
544 			ret = PTR_ERR(local);
545 			goto error_unlock;
546 		}
547 
548 		rx->local = local;
549 		rx->sk.sk_state = RXRPC_CLIENT_BOUND;
550 		fallthrough;
551 
552 	case RXRPC_CLIENT_BOUND:
553 		if (!m->msg_name &&
554 		    test_bit(RXRPC_SOCK_CONNECTED, &rx->flags)) {
555 			m->msg_name = &rx->connect_srx;
556 			m->msg_namelen = sizeof(rx->connect_srx);
557 		}
558 		fallthrough;
559 	case RXRPC_SERVER_BOUND:
560 	case RXRPC_SERVER_LISTENING:
561 		ret = rxrpc_do_sendmsg(rx, m, len);
562 		/* The socket has been unlocked */
563 		goto out;
564 	default:
565 		ret = -EINVAL;
566 		goto error_unlock;
567 	}
568 
569 error_unlock:
570 	release_sock(&rx->sk);
571 out:
572 	_leave(" = %d", ret);
573 	return ret;
574 }
575 
rxrpc_sock_set_min_security_level(struct sock * sk,unsigned int val)576 int rxrpc_sock_set_min_security_level(struct sock *sk, unsigned int val)
577 {
578 	if (sk->sk_state != RXRPC_UNBOUND)
579 		return -EISCONN;
580 	if (val > RXRPC_SECURITY_MAX)
581 		return -EINVAL;
582 	lock_sock(sk);
583 	rxrpc_sk(sk)->min_sec_level = val;
584 	release_sock(sk);
585 	return 0;
586 }
587 EXPORT_SYMBOL(rxrpc_sock_set_min_security_level);
588 
589 /*
590  * set RxRPC socket options
591  */
rxrpc_setsockopt(struct socket * sock,int level,int optname,sockptr_t optval,unsigned int optlen)592 static int rxrpc_setsockopt(struct socket *sock, int level, int optname,
593 			    sockptr_t optval, unsigned int optlen)
594 {
595 	struct rxrpc_sock *rx = rxrpc_sk(sock->sk);
596 	unsigned int min_sec_level;
597 	u16 service_upgrade[2];
598 	int ret;
599 
600 	_enter(",%d,%d,,%d", level, optname, optlen);
601 
602 	lock_sock(&rx->sk);
603 	ret = -EOPNOTSUPP;
604 
605 	if (level == SOL_RXRPC) {
606 		switch (optname) {
607 		case RXRPC_EXCLUSIVE_CONNECTION:
608 			ret = -EINVAL;
609 			if (optlen != 0)
610 				goto error;
611 			ret = -EISCONN;
612 			if (rx->sk.sk_state != RXRPC_UNBOUND)
613 				goto error;
614 			rx->exclusive = true;
615 			goto success;
616 
617 		case RXRPC_SECURITY_KEY:
618 			ret = -EINVAL;
619 			if (rx->key)
620 				goto error;
621 			ret = -EISCONN;
622 			if (rx->sk.sk_state != RXRPC_UNBOUND)
623 				goto error;
624 			ret = rxrpc_request_key(rx, optval, optlen);
625 			goto error;
626 
627 		case RXRPC_SECURITY_KEYRING:
628 			ret = -EINVAL;
629 			if (rx->key)
630 				goto error;
631 			ret = -EISCONN;
632 			if (rx->sk.sk_state != RXRPC_UNBOUND)
633 				goto error;
634 			ret = rxrpc_server_keyring(rx, optval, optlen);
635 			goto error;
636 
637 		case RXRPC_MIN_SECURITY_LEVEL:
638 			ret = -EINVAL;
639 			if (optlen != sizeof(unsigned int))
640 				goto error;
641 			ret = -EISCONN;
642 			if (rx->sk.sk_state != RXRPC_UNBOUND)
643 				goto error;
644 			ret = copy_from_sockptr(&min_sec_level, optval,
645 				       sizeof(unsigned int));
646 			if (ret < 0)
647 				goto error;
648 			ret = -EINVAL;
649 			if (min_sec_level > RXRPC_SECURITY_MAX)
650 				goto error;
651 			rx->min_sec_level = min_sec_level;
652 			goto success;
653 
654 		case RXRPC_UPGRADEABLE_SERVICE:
655 			ret = -EINVAL;
656 			if (optlen != sizeof(service_upgrade) ||
657 			    rx->service_upgrade.from != 0)
658 				goto error;
659 			ret = -EISCONN;
660 			if (rx->sk.sk_state != RXRPC_SERVER_BOUND2)
661 				goto error;
662 			ret = -EFAULT;
663 			if (copy_from_sockptr(service_upgrade, optval,
664 					   sizeof(service_upgrade)) != 0)
665 				goto error;
666 			ret = -EINVAL;
667 			if ((service_upgrade[0] != rx->srx.srx_service ||
668 			     service_upgrade[1] != rx->second_service) &&
669 			    (service_upgrade[0] != rx->second_service ||
670 			     service_upgrade[1] != rx->srx.srx_service))
671 				goto error;
672 			rx->service_upgrade.from = service_upgrade[0];
673 			rx->service_upgrade.to = service_upgrade[1];
674 			goto success;
675 
676 		default:
677 			break;
678 		}
679 	}
680 
681 success:
682 	ret = 0;
683 error:
684 	release_sock(&rx->sk);
685 	return ret;
686 }
687 
688 /*
689  * Get socket options.
690  */
rxrpc_getsockopt(struct socket * sock,int level,int optname,char __user * optval,int __user * _optlen)691 static int rxrpc_getsockopt(struct socket *sock, int level, int optname,
692 			    char __user *optval, int __user *_optlen)
693 {
694 	int optlen;
695 
696 	if (level != SOL_RXRPC)
697 		return -EOPNOTSUPP;
698 
699 	if (get_user(optlen, _optlen))
700 		return -EFAULT;
701 
702 	switch (optname) {
703 	case RXRPC_SUPPORTED_CMSG:
704 		if (optlen < sizeof(int))
705 			return -ETOOSMALL;
706 		if (put_user(RXRPC__SUPPORTED - 1, (int __user *)optval) ||
707 		    put_user(sizeof(int), _optlen))
708 			return -EFAULT;
709 		return 0;
710 
711 	default:
712 		return -EOPNOTSUPP;
713 	}
714 }
715 
716 /*
717  * permit an RxRPC socket to be polled
718  */
rxrpc_poll(struct file * file,struct socket * sock,poll_table * wait)719 static __poll_t rxrpc_poll(struct file *file, struct socket *sock,
720 			       poll_table *wait)
721 {
722 	struct sock *sk = sock->sk;
723 	struct rxrpc_sock *rx = rxrpc_sk(sk);
724 	__poll_t mask;
725 
726 	sock_poll_wait(file, sock, wait);
727 	mask = 0;
728 
729 	/* the socket is readable if there are any messages waiting on the Rx
730 	 * queue */
731 	if (!list_empty(&rx->recvmsg_q))
732 		mask |= EPOLLIN | EPOLLRDNORM;
733 
734 	/* the socket is writable if there is space to add new data to the
735 	 * socket; there is no guarantee that any particular call in progress
736 	 * on the socket may have space in the Tx ACK window */
737 	if (rxrpc_writable(sk))
738 		mask |= EPOLLOUT | EPOLLWRNORM;
739 
740 	return mask;
741 }
742 
743 /*
744  * create an RxRPC socket
745  */
rxrpc_create(struct net * net,struct socket * sock,int protocol,int kern)746 static int rxrpc_create(struct net *net, struct socket *sock, int protocol,
747 			int kern)
748 {
749 	struct rxrpc_net *rxnet;
750 	struct rxrpc_sock *rx;
751 	struct sock *sk;
752 
753 	_enter("%p,%d", sock, protocol);
754 
755 	/* we support transport protocol UDP/UDP6 only */
756 	if (protocol != PF_INET &&
757 	    IS_ENABLED(CONFIG_AF_RXRPC_IPV6) && protocol != PF_INET6)
758 		return -EPROTONOSUPPORT;
759 
760 	if (sock->type != SOCK_DGRAM)
761 		return -ESOCKTNOSUPPORT;
762 
763 	sock->ops = &rxrpc_rpc_ops;
764 	sock->state = SS_UNCONNECTED;
765 
766 	sk = sk_alloc(net, PF_RXRPC, GFP_KERNEL, &rxrpc_proto, kern);
767 	if (!sk)
768 		return -ENOMEM;
769 
770 	sock_init_data(sock, sk);
771 	sock_set_flag(sk, SOCK_RCU_FREE);
772 	sk->sk_state		= RXRPC_UNBOUND;
773 	sk->sk_write_space	= rxrpc_write_space;
774 	sk->sk_max_ack_backlog	= 0;
775 	sk->sk_destruct		= rxrpc_sock_destructor;
776 
777 	rx = rxrpc_sk(sk);
778 	rx->family = protocol;
779 	rx->calls = RB_ROOT;
780 
781 	spin_lock_init(&rx->incoming_lock);
782 	INIT_LIST_HEAD(&rx->sock_calls);
783 	INIT_LIST_HEAD(&rx->to_be_accepted);
784 	INIT_LIST_HEAD(&rx->recvmsg_q);
785 	rwlock_init(&rx->recvmsg_lock);
786 	rwlock_init(&rx->call_lock);
787 	memset(&rx->srx, 0, sizeof(rx->srx));
788 
789 	rxnet = rxrpc_net(sock_net(&rx->sk));
790 	timer_reduce(&rxnet->peer_keepalive_timer, jiffies + 1);
791 
792 	_leave(" = 0 [%p]", rx);
793 	return 0;
794 }
795 
796 /*
797  * Kill all the calls on a socket and shut it down.
798  */
rxrpc_shutdown(struct socket * sock,int flags)799 static int rxrpc_shutdown(struct socket *sock, int flags)
800 {
801 	struct sock *sk = sock->sk;
802 	struct rxrpc_sock *rx = rxrpc_sk(sk);
803 	int ret = 0;
804 
805 	_enter("%p,%d", sk, flags);
806 
807 	if (flags != SHUT_RDWR)
808 		return -EOPNOTSUPP;
809 	if (sk->sk_state == RXRPC_CLOSE)
810 		return -ESHUTDOWN;
811 
812 	lock_sock(sk);
813 
814 	spin_lock_bh(&sk->sk_receive_queue.lock);
815 	if (sk->sk_state < RXRPC_CLOSE) {
816 		sk->sk_state = RXRPC_CLOSE;
817 		sk->sk_shutdown = SHUTDOWN_MASK;
818 	} else {
819 		ret = -ESHUTDOWN;
820 	}
821 	spin_unlock_bh(&sk->sk_receive_queue.lock);
822 
823 	rxrpc_discard_prealloc(rx);
824 
825 	release_sock(sk);
826 	return ret;
827 }
828 
829 /*
830  * RxRPC socket destructor
831  */
rxrpc_sock_destructor(struct sock * sk)832 static void rxrpc_sock_destructor(struct sock *sk)
833 {
834 	_enter("%p", sk);
835 
836 	rxrpc_purge_queue(&sk->sk_receive_queue);
837 
838 	WARN_ON(refcount_read(&sk->sk_wmem_alloc));
839 	WARN_ON(!sk_unhashed(sk));
840 	WARN_ON(sk->sk_socket);
841 
842 	if (!sock_flag(sk, SOCK_DEAD)) {
843 		printk("Attempt to release alive rxrpc socket: %p\n", sk);
844 		return;
845 	}
846 }
847 
848 /*
849  * release an RxRPC socket
850  */
rxrpc_release_sock(struct sock * sk)851 static int rxrpc_release_sock(struct sock *sk)
852 {
853 	struct rxrpc_sock *rx = rxrpc_sk(sk);
854 
855 	_enter("%p{%d,%d}", sk, sk->sk_state, refcount_read(&sk->sk_refcnt));
856 
857 	/* declare the socket closed for business */
858 	sock_orphan(sk);
859 	sk->sk_shutdown = SHUTDOWN_MASK;
860 
861 	/* We want to kill off all connections from a service socket
862 	 * as fast as possible because we can't share these; client
863 	 * sockets, on the other hand, can share an endpoint.
864 	 */
865 	switch (sk->sk_state) {
866 	case RXRPC_SERVER_BOUND:
867 	case RXRPC_SERVER_BOUND2:
868 	case RXRPC_SERVER_LISTENING:
869 	case RXRPC_SERVER_LISTEN_DISABLED:
870 		rx->local->service_closed = true;
871 		break;
872 	}
873 
874 	spin_lock_bh(&sk->sk_receive_queue.lock);
875 	sk->sk_state = RXRPC_CLOSE;
876 	spin_unlock_bh(&sk->sk_receive_queue.lock);
877 
878 	if (rx->local && rcu_access_pointer(rx->local->service) == rx) {
879 		write_lock(&rx->local->services_lock);
880 		rcu_assign_pointer(rx->local->service, NULL);
881 		write_unlock(&rx->local->services_lock);
882 	}
883 
884 	/* try to flush out this socket */
885 	rxrpc_discard_prealloc(rx);
886 	rxrpc_release_calls_on_socket(rx);
887 	flush_workqueue(rxrpc_workqueue);
888 	rxrpc_purge_queue(&sk->sk_receive_queue);
889 
890 	rxrpc_unuse_local(rx->local);
891 	rxrpc_put_local(rx->local);
892 	rx->local = NULL;
893 	key_put(rx->key);
894 	rx->key = NULL;
895 	key_put(rx->securities);
896 	rx->securities = NULL;
897 	sock_put(sk);
898 
899 	_leave(" = 0");
900 	return 0;
901 }
902 
903 /*
904  * release an RxRPC BSD socket on close() or equivalent
905  */
rxrpc_release(struct socket * sock)906 static int rxrpc_release(struct socket *sock)
907 {
908 	struct sock *sk = sock->sk;
909 
910 	_enter("%p{%p}", sock, sk);
911 
912 	if (!sk)
913 		return 0;
914 
915 	sock->sk = NULL;
916 
917 	return rxrpc_release_sock(sk);
918 }
919 
920 /*
921  * RxRPC network protocol
922  */
923 static const struct proto_ops rxrpc_rpc_ops = {
924 	.family		= PF_RXRPC,
925 	.owner		= THIS_MODULE,
926 	.release	= rxrpc_release,
927 	.bind		= rxrpc_bind,
928 	.connect	= rxrpc_connect,
929 	.socketpair	= sock_no_socketpair,
930 	.accept		= sock_no_accept,
931 	.getname	= sock_no_getname,
932 	.poll		= rxrpc_poll,
933 	.ioctl		= sock_no_ioctl,
934 	.listen		= rxrpc_listen,
935 	.shutdown	= rxrpc_shutdown,
936 	.setsockopt	= rxrpc_setsockopt,
937 	.getsockopt	= rxrpc_getsockopt,
938 	.sendmsg	= rxrpc_sendmsg,
939 	.recvmsg	= rxrpc_recvmsg,
940 	.mmap		= sock_no_mmap,
941 	.sendpage	= sock_no_sendpage,
942 };
943 
944 static struct proto rxrpc_proto = {
945 	.name		= "RXRPC",
946 	.owner		= THIS_MODULE,
947 	.obj_size	= sizeof(struct rxrpc_sock),
948 	.max_header	= sizeof(struct rxrpc_wire_header),
949 };
950 
951 static const struct net_proto_family rxrpc_family_ops = {
952 	.family	= PF_RXRPC,
953 	.create = rxrpc_create,
954 	.owner	= THIS_MODULE,
955 };
956 
957 /*
958  * initialise and register the RxRPC protocol
959  */
af_rxrpc_init(void)960 static int __init af_rxrpc_init(void)
961 {
962 	int ret = -1;
963 	unsigned int tmp;
964 
965 	BUILD_BUG_ON(sizeof(struct rxrpc_skb_priv) > sizeof_field(struct sk_buff, cb));
966 
967 	get_random_bytes(&tmp, sizeof(tmp));
968 	tmp &= 0x3fffffff;
969 	if (tmp == 0)
970 		tmp = 1;
971 	idr_set_cursor(&rxrpc_client_conn_ids, tmp);
972 
973 	ret = -ENOMEM;
974 	rxrpc_call_jar = kmem_cache_create(
975 		"rxrpc_call_jar", sizeof(struct rxrpc_call), 0,
976 		SLAB_HWCACHE_ALIGN, NULL);
977 	if (!rxrpc_call_jar) {
978 		pr_notice("Failed to allocate call jar\n");
979 		goto error_call_jar;
980 	}
981 
982 	rxrpc_workqueue = alloc_workqueue("krxrpcd", 0, 1);
983 	if (!rxrpc_workqueue) {
984 		pr_notice("Failed to allocate work queue\n");
985 		goto error_work_queue;
986 	}
987 
988 	ret = rxrpc_init_security();
989 	if (ret < 0) {
990 		pr_crit("Cannot initialise security\n");
991 		goto error_security;
992 	}
993 
994 	ret = register_pernet_device(&rxrpc_net_ops);
995 	if (ret)
996 		goto error_pernet;
997 
998 	ret = proto_register(&rxrpc_proto, 1);
999 	if (ret < 0) {
1000 		pr_crit("Cannot register protocol\n");
1001 		goto error_proto;
1002 	}
1003 
1004 	ret = sock_register(&rxrpc_family_ops);
1005 	if (ret < 0) {
1006 		pr_crit("Cannot register socket family\n");
1007 		goto error_sock;
1008 	}
1009 
1010 	ret = register_key_type(&key_type_rxrpc);
1011 	if (ret < 0) {
1012 		pr_crit("Cannot register client key type\n");
1013 		goto error_key_type;
1014 	}
1015 
1016 	ret = register_key_type(&key_type_rxrpc_s);
1017 	if (ret < 0) {
1018 		pr_crit("Cannot register server key type\n");
1019 		goto error_key_type_s;
1020 	}
1021 
1022 	ret = rxrpc_sysctl_init();
1023 	if (ret < 0) {
1024 		pr_crit("Cannot register sysctls\n");
1025 		goto error_sysctls;
1026 	}
1027 
1028 	return 0;
1029 
1030 error_sysctls:
1031 	unregister_key_type(&key_type_rxrpc_s);
1032 error_key_type_s:
1033 	unregister_key_type(&key_type_rxrpc);
1034 error_key_type:
1035 	sock_unregister(PF_RXRPC);
1036 error_sock:
1037 	proto_unregister(&rxrpc_proto);
1038 error_proto:
1039 	unregister_pernet_device(&rxrpc_net_ops);
1040 error_pernet:
1041 	rxrpc_exit_security();
1042 error_security:
1043 	destroy_workqueue(rxrpc_workqueue);
1044 error_work_queue:
1045 	kmem_cache_destroy(rxrpc_call_jar);
1046 error_call_jar:
1047 	return ret;
1048 }
1049 
1050 /*
1051  * unregister the RxRPC protocol
1052  */
af_rxrpc_exit(void)1053 static void __exit af_rxrpc_exit(void)
1054 {
1055 	_enter("");
1056 	rxrpc_sysctl_exit();
1057 	unregister_key_type(&key_type_rxrpc_s);
1058 	unregister_key_type(&key_type_rxrpc);
1059 	sock_unregister(PF_RXRPC);
1060 	proto_unregister(&rxrpc_proto);
1061 	unregister_pernet_device(&rxrpc_net_ops);
1062 	ASSERTCMP(atomic_read(&rxrpc_n_tx_skbs), ==, 0);
1063 	ASSERTCMP(atomic_read(&rxrpc_n_rx_skbs), ==, 0);
1064 
1065 	/* Make sure the local and peer records pinned by any dying connections
1066 	 * are released.
1067 	 */
1068 	rcu_barrier();
1069 	rxrpc_destroy_client_conn_ids();
1070 
1071 	destroy_workqueue(rxrpc_workqueue);
1072 	rxrpc_exit_security();
1073 	kmem_cache_destroy(rxrpc_call_jar);
1074 	_leave("");
1075 }
1076 
1077 module_init(af_rxrpc_init);
1078 module_exit(af_rxrpc_exit);
1079