datagram.c 4.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * File: datagram.c
  4. *
  5. * Datagram (ISI) Phonet sockets
  6. *
  7. * Copyright (C) 2008 Nokia Corporation.
  8. *
  9. * Authors: Sakari Ailus <sakari.ailus@nokia.com>
  10. * Rémi Denis-Courmont
  11. */
  12. #include <linux/kernel.h>
  13. #include <linux/slab.h>
  14. #include <linux/socket.h>
  15. #include <asm/ioctls.h>
  16. #include <net/sock.h>
  17. #include <linux/phonet.h>
  18. #include <linux/export.h>
  19. #include <net/phonet/phonet.h>
  20. static int pn_backlog_rcv(struct sock *sk, struct sk_buff *skb);
  21. /* associated socket ceases to exist */
  22. static void pn_sock_close(struct sock *sk, long timeout)
  23. {
  24. sk_common_release(sk);
  25. }
  26. static int pn_ioctl(struct sock *sk, int cmd, unsigned long arg)
  27. {
  28. struct sk_buff *skb;
  29. int answ;
  30. switch (cmd) {
  31. case SIOCINQ:
  32. lock_sock(sk);
  33. skb = skb_peek(&sk->sk_receive_queue);
  34. answ = skb ? skb->len : 0;
  35. release_sock(sk);
  36. return put_user(answ, (int __user *)arg);
  37. case SIOCPNADDRESOURCE:
  38. case SIOCPNDELRESOURCE: {
  39. u32 res;
  40. if (get_user(res, (u32 __user *)arg))
  41. return -EFAULT;
  42. if (res >= 256)
  43. return -EINVAL;
  44. if (cmd == SIOCPNADDRESOURCE)
  45. return pn_sock_bind_res(sk, res);
  46. else
  47. return pn_sock_unbind_res(sk, res);
  48. }
  49. }
  50. return -ENOIOCTLCMD;
  51. }
  52. /* Destroy socket. All references are gone. */
  53. static void pn_destruct(struct sock *sk)
  54. {
  55. skb_queue_purge(&sk->sk_receive_queue);
  56. }
  57. static int pn_init(struct sock *sk)
  58. {
  59. sk->sk_destruct = pn_destruct;
  60. return 0;
  61. }
  62. static int pn_sendmsg(struct sock *sk, struct msghdr *msg, size_t len)
  63. {
  64. DECLARE_SOCKADDR(struct sockaddr_pn *, target, msg->msg_name);
  65. struct sk_buff *skb;
  66. int err;
  67. if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR|MSG_NOSIGNAL|
  68. MSG_CMSG_COMPAT))
  69. return -EOPNOTSUPP;
  70. if (target == NULL)
  71. return -EDESTADDRREQ;
  72. if (msg->msg_namelen < sizeof(struct sockaddr_pn))
  73. return -EINVAL;
  74. if (target->spn_family != AF_PHONET)
  75. return -EAFNOSUPPORT;
  76. skb = sock_alloc_send_skb(sk, MAX_PHONET_HEADER + len,
  77. msg->msg_flags & MSG_DONTWAIT, &err);
  78. if (skb == NULL)
  79. return err;
  80. skb_reserve(skb, MAX_PHONET_HEADER);
  81. err = memcpy_from_msg((void *)skb_put(skb, len), msg, len);
  82. if (err < 0) {
  83. kfree_skb(skb);
  84. return err;
  85. }
  86. /*
  87. * Fill in the Phonet header and
  88. * finally pass the packet forwards.
  89. */
  90. err = pn_skb_send(sk, skb, target);
  91. /* If ok, return len. */
  92. return (err >= 0) ? len : err;
  93. }
  94. static int pn_recvmsg(struct sock *sk, struct msghdr *msg, size_t len,
  95. int noblock, int flags, int *addr_len)
  96. {
  97. struct sk_buff *skb = NULL;
  98. struct sockaddr_pn sa;
  99. int rval = -EOPNOTSUPP;
  100. int copylen;
  101. if (flags & ~(MSG_PEEK|MSG_TRUNC|MSG_DONTWAIT|MSG_NOSIGNAL|
  102. MSG_CMSG_COMPAT))
  103. goto out_nofree;
  104. skb = skb_recv_datagram(sk, flags, noblock, &rval);
  105. if (skb == NULL)
  106. goto out_nofree;
  107. pn_skb_get_src_sockaddr(skb, &sa);
  108. copylen = skb->len;
  109. if (len < copylen) {
  110. msg->msg_flags |= MSG_TRUNC;
  111. copylen = len;
  112. }
  113. rval = skb_copy_datagram_msg(skb, 0, msg, copylen);
  114. if (rval) {
  115. rval = -EFAULT;
  116. goto out;
  117. }
  118. rval = (flags & MSG_TRUNC) ? skb->len : copylen;
  119. if (msg->msg_name != NULL) {
  120. __sockaddr_check_size(sizeof(sa));
  121. memcpy(msg->msg_name, &sa, sizeof(sa));
  122. *addr_len = sizeof(sa);
  123. }
  124. out:
  125. skb_free_datagram(sk, skb);
  126. out_nofree:
  127. return rval;
  128. }
  129. /* Queue an skb for a sock. */
  130. static int pn_backlog_rcv(struct sock *sk, struct sk_buff *skb)
  131. {
  132. int err = sock_queue_rcv_skb(sk, skb);
  133. if (err < 0)
  134. kfree_skb(skb);
  135. return err ? NET_RX_DROP : NET_RX_SUCCESS;
  136. }
  137. /* Module registration */
  138. static struct proto pn_proto = {
  139. .close = pn_sock_close,
  140. .ioctl = pn_ioctl,
  141. .init = pn_init,
  142. .sendmsg = pn_sendmsg,
  143. .recvmsg = pn_recvmsg,
  144. .backlog_rcv = pn_backlog_rcv,
  145. .hash = pn_sock_hash,
  146. .unhash = pn_sock_unhash,
  147. .get_port = pn_sock_get_port,
  148. .obj_size = sizeof(struct pn_sock),
  149. .owner = THIS_MODULE,
  150. .name = "PHONET",
  151. };
  152. static const struct phonet_protocol pn_dgram_proto = {
  153. .ops = &phonet_dgram_ops,
  154. .prot = &pn_proto,
  155. .sock_type = SOCK_DGRAM,
  156. };
  157. int __init isi_register(void)
  158. {
  159. return phonet_proto_register(PN_PROTO_PHONET, &pn_dgram_proto);
  160. }
  161. void __exit isi_unregister(void)
  162. {
  163. phonet_proto_unregister(PN_PROTO_PHONET, &pn_dgram_proto);
  164. }