af_rxrpc.c 25 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077
  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. #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, atomic_read(&call->usage));
  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. case RXRPC_CLIENT_UNBOUND:
  410. case RXRPC_CLIENT_BOUND:
  411. break;
  412. default:
  413. ret = -EBUSY;
  414. goto error;
  415. }
  416. rx->connect_srx = *srx;
  417. set_bit(RXRPC_SOCK_CONNECTED, &rx->flags);
  418. ret = 0;
  419. error:
  420. release_sock(&rx->sk);
  421. return ret;
  422. }
  423. /*
  424. * send a message through an RxRPC socket
  425. * - in a client this does a number of things:
  426. * - finds/sets up a connection for the security specified (if any)
  427. * - initiates a call (ID in control data)
  428. * - ends the request phase of a call (if MSG_MORE is not set)
  429. * - sends a call data packet
  430. * - may send an abort (abort code in control data)
  431. */
  432. static int rxrpc_sendmsg(struct socket *sock, struct msghdr *m, size_t len)
  433. {
  434. struct rxrpc_local *local;
  435. struct rxrpc_sock *rx = rxrpc_sk(sock->sk);
  436. int ret;
  437. _enter(",{%d},,%zu", rx->sk.sk_state, len);
  438. if (m->msg_flags & MSG_OOB)
  439. return -EOPNOTSUPP;
  440. if (m->msg_name) {
  441. ret = rxrpc_validate_address(rx, m->msg_name, m->msg_namelen);
  442. if (ret < 0) {
  443. _leave(" = %d [bad addr]", ret);
  444. return ret;
  445. }
  446. }
  447. lock_sock(&rx->sk);
  448. switch (rx->sk.sk_state) {
  449. case RXRPC_UNBOUND:
  450. case RXRPC_CLIENT_UNBOUND:
  451. rx->srx.srx_family = AF_RXRPC;
  452. rx->srx.srx_service = 0;
  453. rx->srx.transport_type = SOCK_DGRAM;
  454. rx->srx.transport.family = rx->family;
  455. switch (rx->family) {
  456. case AF_INET:
  457. rx->srx.transport_len = sizeof(struct sockaddr_in);
  458. break;
  459. #ifdef CONFIG_AF_RXRPC_IPV6
  460. case AF_INET6:
  461. rx->srx.transport_len = sizeof(struct sockaddr_in6);
  462. break;
  463. #endif
  464. default:
  465. ret = -EAFNOSUPPORT;
  466. goto error_unlock;
  467. }
  468. local = rxrpc_lookup_local(sock_net(sock->sk), &rx->srx);
  469. if (IS_ERR(local)) {
  470. ret = PTR_ERR(local);
  471. goto error_unlock;
  472. }
  473. rx->local = local;
  474. rx->sk.sk_state = RXRPC_CLIENT_BOUND;
  475. fallthrough;
  476. case RXRPC_CLIENT_BOUND:
  477. if (!m->msg_name &&
  478. test_bit(RXRPC_SOCK_CONNECTED, &rx->flags)) {
  479. m->msg_name = &rx->connect_srx;
  480. m->msg_namelen = sizeof(rx->connect_srx);
  481. }
  482. fallthrough;
  483. case RXRPC_SERVER_BOUND:
  484. case RXRPC_SERVER_LISTENING:
  485. ret = rxrpc_do_sendmsg(rx, m, len);
  486. /* The socket has been unlocked */
  487. goto out;
  488. default:
  489. ret = -EINVAL;
  490. goto error_unlock;
  491. }
  492. error_unlock:
  493. release_sock(&rx->sk);
  494. out:
  495. _leave(" = %d", ret);
  496. return ret;
  497. }
  498. int rxrpc_sock_set_min_security_level(struct sock *sk, unsigned int val)
  499. {
  500. if (sk->sk_state != RXRPC_UNBOUND)
  501. return -EISCONN;
  502. if (val > RXRPC_SECURITY_MAX)
  503. return -EINVAL;
  504. lock_sock(sk);
  505. rxrpc_sk(sk)->min_sec_level = val;
  506. release_sock(sk);
  507. return 0;
  508. }
  509. EXPORT_SYMBOL(rxrpc_sock_set_min_security_level);
  510. /*
  511. * set RxRPC socket options
  512. */
  513. static int rxrpc_setsockopt(struct socket *sock, int level, int optname,
  514. sockptr_t optval, unsigned int optlen)
  515. {
  516. struct rxrpc_sock *rx = rxrpc_sk(sock->sk);
  517. unsigned int min_sec_level;
  518. u16 service_upgrade[2];
  519. int ret;
  520. _enter(",%d,%d,,%d", level, optname, optlen);
  521. lock_sock(&rx->sk);
  522. ret = -EOPNOTSUPP;
  523. if (level == SOL_RXRPC) {
  524. switch (optname) {
  525. case RXRPC_EXCLUSIVE_CONNECTION:
  526. ret = -EINVAL;
  527. if (optlen != 0)
  528. goto error;
  529. ret = -EISCONN;
  530. if (rx->sk.sk_state != RXRPC_UNBOUND)
  531. goto error;
  532. rx->exclusive = true;
  533. goto success;
  534. case RXRPC_SECURITY_KEY:
  535. ret = -EINVAL;
  536. if (rx->key)
  537. goto error;
  538. ret = -EISCONN;
  539. if (rx->sk.sk_state != RXRPC_UNBOUND)
  540. goto error;
  541. ret = rxrpc_request_key(rx, optval, optlen);
  542. goto error;
  543. case RXRPC_SECURITY_KEYRING:
  544. ret = -EINVAL;
  545. if (rx->key)
  546. goto error;
  547. ret = -EISCONN;
  548. if (rx->sk.sk_state != RXRPC_UNBOUND)
  549. goto error;
  550. ret = rxrpc_server_keyring(rx, optval, optlen);
  551. goto error;
  552. case RXRPC_MIN_SECURITY_LEVEL:
  553. ret = -EINVAL;
  554. if (optlen != sizeof(unsigned int))
  555. goto error;
  556. ret = -EISCONN;
  557. if (rx->sk.sk_state != RXRPC_UNBOUND)
  558. goto error;
  559. ret = copy_from_sockptr(&min_sec_level, optval,
  560. sizeof(unsigned int));
  561. if (ret < 0)
  562. goto error;
  563. ret = -EINVAL;
  564. if (min_sec_level > RXRPC_SECURITY_MAX)
  565. goto error;
  566. rx->min_sec_level = min_sec_level;
  567. goto success;
  568. case RXRPC_UPGRADEABLE_SERVICE:
  569. ret = -EINVAL;
  570. if (optlen != sizeof(service_upgrade) ||
  571. rx->service_upgrade.from != 0)
  572. goto error;
  573. ret = -EISCONN;
  574. if (rx->sk.sk_state != RXRPC_SERVER_BOUND2)
  575. goto error;
  576. ret = -EFAULT;
  577. if (copy_from_sockptr(service_upgrade, optval,
  578. sizeof(service_upgrade)) != 0)
  579. goto error;
  580. ret = -EINVAL;
  581. if ((service_upgrade[0] != rx->srx.srx_service ||
  582. service_upgrade[1] != rx->second_service) &&
  583. (service_upgrade[0] != rx->second_service ||
  584. service_upgrade[1] != rx->srx.srx_service))
  585. goto error;
  586. rx->service_upgrade.from = service_upgrade[0];
  587. rx->service_upgrade.to = service_upgrade[1];
  588. goto success;
  589. default:
  590. break;
  591. }
  592. }
  593. success:
  594. ret = 0;
  595. error:
  596. release_sock(&rx->sk);
  597. return ret;
  598. }
  599. /*
  600. * Get socket options.
  601. */
  602. static int rxrpc_getsockopt(struct socket *sock, int level, int optname,
  603. char __user *optval, int __user *_optlen)
  604. {
  605. int optlen;
  606. if (level != SOL_RXRPC)
  607. return -EOPNOTSUPP;
  608. if (get_user(optlen, _optlen))
  609. return -EFAULT;
  610. switch (optname) {
  611. case RXRPC_SUPPORTED_CMSG:
  612. if (optlen < sizeof(int))
  613. return -ETOOSMALL;
  614. if (put_user(RXRPC__SUPPORTED - 1, (int __user *)optval) ||
  615. put_user(sizeof(int), _optlen))
  616. return -EFAULT;
  617. return 0;
  618. default:
  619. return -EOPNOTSUPP;
  620. }
  621. }
  622. /*
  623. * permit an RxRPC socket to be polled
  624. */
  625. static __poll_t rxrpc_poll(struct file *file, struct socket *sock,
  626. poll_table *wait)
  627. {
  628. struct sock *sk = sock->sk;
  629. struct rxrpc_sock *rx = rxrpc_sk(sk);
  630. __poll_t mask;
  631. sock_poll_wait(file, sock, wait);
  632. mask = 0;
  633. /* the socket is readable if there are any messages waiting on the Rx
  634. * queue */
  635. if (!list_empty(&rx->recvmsg_q))
  636. mask |= EPOLLIN | EPOLLRDNORM;
  637. /* the socket is writable if there is space to add new data to the
  638. * socket; there is no guarantee that any particular call in progress
  639. * on the socket may have space in the Tx ACK window */
  640. if (rxrpc_writable(sk))
  641. mask |= EPOLLOUT | EPOLLWRNORM;
  642. return mask;
  643. }
  644. /*
  645. * create an RxRPC socket
  646. */
  647. static int rxrpc_create(struct net *net, struct socket *sock, int protocol,
  648. int kern)
  649. {
  650. struct rxrpc_net *rxnet;
  651. struct rxrpc_sock *rx;
  652. struct sock *sk;
  653. _enter("%p,%d", sock, protocol);
  654. /* we support transport protocol UDP/UDP6 only */
  655. if (protocol != PF_INET &&
  656. IS_ENABLED(CONFIG_AF_RXRPC_IPV6) && protocol != PF_INET6)
  657. return -EPROTONOSUPPORT;
  658. if (sock->type != SOCK_DGRAM)
  659. return -ESOCKTNOSUPPORT;
  660. sock->ops = &rxrpc_rpc_ops;
  661. sock->state = SS_UNCONNECTED;
  662. sk = sk_alloc(net, PF_RXRPC, GFP_KERNEL, &rxrpc_proto, kern);
  663. if (!sk)
  664. return -ENOMEM;
  665. sock_init_data(sock, sk);
  666. sock_set_flag(sk, SOCK_RCU_FREE);
  667. sk->sk_state = RXRPC_UNBOUND;
  668. sk->sk_write_space = rxrpc_write_space;
  669. sk->sk_max_ack_backlog = 0;
  670. sk->sk_destruct = rxrpc_sock_destructor;
  671. rx = rxrpc_sk(sk);
  672. rx->family = protocol;
  673. rx->calls = RB_ROOT;
  674. spin_lock_init(&rx->incoming_lock);
  675. INIT_LIST_HEAD(&rx->sock_calls);
  676. INIT_LIST_HEAD(&rx->to_be_accepted);
  677. INIT_LIST_HEAD(&rx->recvmsg_q);
  678. rwlock_init(&rx->recvmsg_lock);
  679. rwlock_init(&rx->call_lock);
  680. memset(&rx->srx, 0, sizeof(rx->srx));
  681. rxnet = rxrpc_net(sock_net(&rx->sk));
  682. timer_reduce(&rxnet->peer_keepalive_timer, jiffies + 1);
  683. _leave(" = 0 [%p]", rx);
  684. return 0;
  685. }
  686. /*
  687. * Kill all the calls on a socket and shut it down.
  688. */
  689. static int rxrpc_shutdown(struct socket *sock, int flags)
  690. {
  691. struct sock *sk = sock->sk;
  692. struct rxrpc_sock *rx = rxrpc_sk(sk);
  693. int ret = 0;
  694. _enter("%p,%d", sk, flags);
  695. if (flags != SHUT_RDWR)
  696. return -EOPNOTSUPP;
  697. if (sk->sk_state == RXRPC_CLOSE)
  698. return -ESHUTDOWN;
  699. lock_sock(sk);
  700. spin_lock_bh(&sk->sk_receive_queue.lock);
  701. if (sk->sk_state < RXRPC_CLOSE) {
  702. sk->sk_state = RXRPC_CLOSE;
  703. sk->sk_shutdown = SHUTDOWN_MASK;
  704. } else {
  705. ret = -ESHUTDOWN;
  706. }
  707. spin_unlock_bh(&sk->sk_receive_queue.lock);
  708. rxrpc_discard_prealloc(rx);
  709. release_sock(sk);
  710. return ret;
  711. }
  712. /*
  713. * RxRPC socket destructor
  714. */
  715. static void rxrpc_sock_destructor(struct sock *sk)
  716. {
  717. _enter("%p", sk);
  718. rxrpc_purge_queue(&sk->sk_receive_queue);
  719. WARN_ON(refcount_read(&sk->sk_wmem_alloc));
  720. WARN_ON(!sk_unhashed(sk));
  721. WARN_ON(sk->sk_socket);
  722. if (!sock_flag(sk, SOCK_DEAD)) {
  723. printk("Attempt to release alive rxrpc socket: %p\n", sk);
  724. return;
  725. }
  726. }
  727. /*
  728. * release an RxRPC socket
  729. */
  730. static int rxrpc_release_sock(struct sock *sk)
  731. {
  732. struct rxrpc_sock *rx = rxrpc_sk(sk);
  733. _enter("%p{%d,%d}", sk, sk->sk_state, refcount_read(&sk->sk_refcnt));
  734. /* declare the socket closed for business */
  735. sock_orphan(sk);
  736. sk->sk_shutdown = SHUTDOWN_MASK;
  737. /* We want to kill off all connections from a service socket
  738. * as fast as possible because we can't share these; client
  739. * sockets, on the other hand, can share an endpoint.
  740. */
  741. switch (sk->sk_state) {
  742. case RXRPC_SERVER_BOUND:
  743. case RXRPC_SERVER_BOUND2:
  744. case RXRPC_SERVER_LISTENING:
  745. case RXRPC_SERVER_LISTEN_DISABLED:
  746. rx->local->service_closed = true;
  747. break;
  748. }
  749. spin_lock_bh(&sk->sk_receive_queue.lock);
  750. sk->sk_state = RXRPC_CLOSE;
  751. spin_unlock_bh(&sk->sk_receive_queue.lock);
  752. if (rx->local && rcu_access_pointer(rx->local->service) == rx) {
  753. write_lock(&rx->local->services_lock);
  754. rcu_assign_pointer(rx->local->service, NULL);
  755. write_unlock(&rx->local->services_lock);
  756. }
  757. /* try to flush out this socket */
  758. rxrpc_discard_prealloc(rx);
  759. rxrpc_release_calls_on_socket(rx);
  760. flush_workqueue(rxrpc_workqueue);
  761. rxrpc_purge_queue(&sk->sk_receive_queue);
  762. rxrpc_unuse_local(rx->local);
  763. rxrpc_put_local(rx->local);
  764. rx->local = NULL;
  765. key_put(rx->key);
  766. rx->key = NULL;
  767. key_put(rx->securities);
  768. rx->securities = NULL;
  769. sock_put(sk);
  770. _leave(" = 0");
  771. return 0;
  772. }
  773. /*
  774. * release an RxRPC BSD socket on close() or equivalent
  775. */
  776. static int rxrpc_release(struct socket *sock)
  777. {
  778. struct sock *sk = sock->sk;
  779. _enter("%p{%p}", sock, sk);
  780. if (!sk)
  781. return 0;
  782. sock->sk = NULL;
  783. return rxrpc_release_sock(sk);
  784. }
  785. /*
  786. * RxRPC network protocol
  787. */
  788. static const struct proto_ops rxrpc_rpc_ops = {
  789. .family = PF_RXRPC,
  790. .owner = THIS_MODULE,
  791. .release = rxrpc_release,
  792. .bind = rxrpc_bind,
  793. .connect = rxrpc_connect,
  794. .socketpair = sock_no_socketpair,
  795. .accept = sock_no_accept,
  796. .getname = sock_no_getname,
  797. .poll = rxrpc_poll,
  798. .ioctl = sock_no_ioctl,
  799. .listen = rxrpc_listen,
  800. .shutdown = rxrpc_shutdown,
  801. .setsockopt = rxrpc_setsockopt,
  802. .getsockopt = rxrpc_getsockopt,
  803. .sendmsg = rxrpc_sendmsg,
  804. .recvmsg = rxrpc_recvmsg,
  805. .mmap = sock_no_mmap,
  806. .sendpage = sock_no_sendpage,
  807. };
  808. static struct proto rxrpc_proto = {
  809. .name = "RXRPC",
  810. .owner = THIS_MODULE,
  811. .obj_size = sizeof(struct rxrpc_sock),
  812. .max_header = sizeof(struct rxrpc_wire_header),
  813. };
  814. static const struct net_proto_family rxrpc_family_ops = {
  815. .family = PF_RXRPC,
  816. .create = rxrpc_create,
  817. .owner = THIS_MODULE,
  818. };
  819. /*
  820. * initialise and register the RxRPC protocol
  821. */
  822. static int __init af_rxrpc_init(void)
  823. {
  824. int ret = -1;
  825. unsigned int tmp;
  826. BUILD_BUG_ON(sizeof(struct rxrpc_skb_priv) > sizeof_field(struct sk_buff, cb));
  827. get_random_bytes(&tmp, sizeof(tmp));
  828. tmp &= 0x3fffffff;
  829. if (tmp == 0)
  830. tmp = 1;
  831. idr_set_cursor(&rxrpc_client_conn_ids, tmp);
  832. ret = -ENOMEM;
  833. rxrpc_call_jar = kmem_cache_create(
  834. "rxrpc_call_jar", sizeof(struct rxrpc_call), 0,
  835. SLAB_HWCACHE_ALIGN, NULL);
  836. if (!rxrpc_call_jar) {
  837. pr_notice("Failed to allocate call jar\n");
  838. goto error_call_jar;
  839. }
  840. rxrpc_workqueue = alloc_workqueue("krxrpcd", 0, 1);
  841. if (!rxrpc_workqueue) {
  842. pr_notice("Failed to allocate work queue\n");
  843. goto error_work_queue;
  844. }
  845. ret = rxrpc_init_security();
  846. if (ret < 0) {
  847. pr_crit("Cannot initialise security\n");
  848. goto error_security;
  849. }
  850. ret = register_pernet_device(&rxrpc_net_ops);
  851. if (ret)
  852. goto error_pernet;
  853. ret = proto_register(&rxrpc_proto, 1);
  854. if (ret < 0) {
  855. pr_crit("Cannot register protocol\n");
  856. goto error_proto;
  857. }
  858. ret = sock_register(&rxrpc_family_ops);
  859. if (ret < 0) {
  860. pr_crit("Cannot register socket family\n");
  861. goto error_sock;
  862. }
  863. ret = register_key_type(&key_type_rxrpc);
  864. if (ret < 0) {
  865. pr_crit("Cannot register client key type\n");
  866. goto error_key_type;
  867. }
  868. ret = register_key_type(&key_type_rxrpc_s);
  869. if (ret < 0) {
  870. pr_crit("Cannot register server key type\n");
  871. goto error_key_type_s;
  872. }
  873. ret = rxrpc_sysctl_init();
  874. if (ret < 0) {
  875. pr_crit("Cannot register sysctls\n");
  876. goto error_sysctls;
  877. }
  878. return 0;
  879. error_sysctls:
  880. unregister_key_type(&key_type_rxrpc_s);
  881. error_key_type_s:
  882. unregister_key_type(&key_type_rxrpc);
  883. error_key_type:
  884. sock_unregister(PF_RXRPC);
  885. error_sock:
  886. proto_unregister(&rxrpc_proto);
  887. error_proto:
  888. unregister_pernet_device(&rxrpc_net_ops);
  889. error_pernet:
  890. rxrpc_exit_security();
  891. error_security:
  892. destroy_workqueue(rxrpc_workqueue);
  893. error_work_queue:
  894. kmem_cache_destroy(rxrpc_call_jar);
  895. error_call_jar:
  896. return ret;
  897. }
  898. /*
  899. * unregister the RxRPC protocol
  900. */
  901. static void __exit af_rxrpc_exit(void)
  902. {
  903. _enter("");
  904. rxrpc_sysctl_exit();
  905. unregister_key_type(&key_type_rxrpc_s);
  906. unregister_key_type(&key_type_rxrpc);
  907. sock_unregister(PF_RXRPC);
  908. proto_unregister(&rxrpc_proto);
  909. unregister_pernet_device(&rxrpc_net_ops);
  910. ASSERTCMP(atomic_read(&rxrpc_n_tx_skbs), ==, 0);
  911. ASSERTCMP(atomic_read(&rxrpc_n_rx_skbs), ==, 0);
  912. /* Make sure the local and peer records pinned by any dying connections
  913. * are released.
  914. */
  915. rcu_barrier();
  916. rxrpc_destroy_client_conn_ids();
  917. destroy_workqueue(rxrpc_workqueue);
  918. rxrpc_exit_security();
  919. kmem_cache_destroy(rxrpc_call_jar);
  920. _leave("");
  921. }
  922. module_init(af_rxrpc_init);
  923. module_exit(af_rxrpc_exit);