af_rxrpc.c 25 KB

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