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 13 #include <linux/kernel.h> 14 #include <linux/slab.h> 15 #include <linux/socket.h> 16 #include <asm/ioctls.h> 17 #include <net/sock.h> 18 19 #include <linux/phonet.h> 20 #include <linux/export.h> 21 #include <net/phonet/phonet.h> 22 23 static int pn_backlog_rcv(struct sock *sk, struct sk_buff *skb); 24 25 /* associated socket ceases to exist */ 26 static void pn_sock_close(struct sock *sk, long timeout) 27 { 28 sk_common_release(sk); 29 } 30 31 static int pn_ioctl(struct sock *sk, int cmd, int *karg) 32 { 33 struct sk_buff *skb; 34 35 switch (cmd) { 36 case SIOCINQ: 37 spin_lock_bh(&sk->sk_receive_queue.lock); 38 skb = skb_peek(&sk->sk_receive_queue); 39 *karg = skb ? skb->len : 0; 40 spin_unlock_bh(&sk->sk_receive_queue.lock); 41 return 0; 42 43 case SIOCPNADDRESOURCE: 44 case SIOCPNDELRESOURCE: { 45 u32 res = *karg; 46 if (res >= 256) 47 return -EINVAL; 48 if (cmd == SIOCPNADDRESOURCE) 49 return pn_sock_bind_res(sk, res); 50 else 51 return pn_sock_unbind_res(sk, res); 52 } 53 } 54 55 return -ENOIOCTLCMD; 56 } 57 58 /* Destroy socket. All references are gone. */ 59 static void pn_destruct(struct sock *sk) 60 { 61 skb_queue_purge(&sk->sk_receive_queue); 62 } 63 64 static int pn_init(struct sock *sk) 65 { 66 sk->sk_destruct = pn_destruct; 67 return 0; 68 } 69 70 static int pn_sendmsg(struct sock *sk, struct msghdr *msg, size_t len) 71 { 72 DECLARE_SOCKADDR(struct sockaddr_pn *, target, msg->msg_name); 73 struct sk_buff *skb; 74 int err; 75 76 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR|MSG_NOSIGNAL| 77 MSG_CMSG_COMPAT)) 78 return -EOPNOTSUPP; 79 80 if (target == NULL) 81 return -EDESTADDRREQ; 82 83 if (msg->msg_namelen < sizeof(struct sockaddr_pn)) 84 return -EINVAL; 85 86 if (target->spn_family != AF_PHONET) 87 return -EAFNOSUPPORT; 88 89 skb = sock_alloc_send_skb(sk, MAX_PHONET_HEADER + len, 90 msg->msg_flags & MSG_DONTWAIT, &err); 91 if (skb == NULL) 92 return err; 93 skb_reserve(skb, MAX_PHONET_HEADER); 94 95 err = memcpy_from_msg((void *)skb_put(skb, len), msg, len); 96 if (err < 0) { 97 kfree_skb(skb); 98 return err; 99 } 100 101 /* 102 * Fill in the Phonet header and 103 * finally pass the packet forwards. 104 */ 105 err = pn_skb_send(sk, skb, target); 106 107 /* If ok, return len. */ 108 return (err >= 0) ? len : err; 109 } 110 111 static int pn_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, 112 int flags, int *addr_len) 113 { 114 struct sk_buff *skb = NULL; 115 struct sockaddr_pn sa; 116 int rval = -EOPNOTSUPP; 117 int copylen; 118 119 if (flags & ~(MSG_PEEK|MSG_TRUNC|MSG_DONTWAIT|MSG_NOSIGNAL| 120 MSG_CMSG_COMPAT)) 121 goto out_nofree; 122 123 skb = skb_recv_datagram(sk, flags, &rval); 124 if (skb == NULL) 125 goto out_nofree; 126 127 pn_skb_get_src_sockaddr(skb, &sa); 128 129 copylen = skb->len; 130 if (len < copylen) { 131 msg->msg_flags |= MSG_TRUNC; 132 copylen = len; 133 } 134 135 rval = skb_copy_datagram_msg(skb, 0, msg, copylen); 136 if (rval) { 137 rval = -EFAULT; 138 goto out; 139 } 140 141 rval = (flags & MSG_TRUNC) ? skb->len : copylen; 142 143 if (msg->msg_name != NULL) { 144 __sockaddr_check_size(sizeof(sa)); 145 memcpy(msg->msg_name, &sa, sizeof(sa)); 146 *addr_len = sizeof(sa); 147 } 148 149 out: 150 skb_free_datagram(sk, skb); 151 152 out_nofree: 153 return rval; 154 } 155 156 /* Queue an skb for a sock. */ 157 static int pn_backlog_rcv(struct sock *sk, struct sk_buff *skb) 158 { 159 int err = sock_queue_rcv_skb(sk, skb); 160 161 if (err < 0) 162 kfree_skb(skb); 163 return err ? NET_RX_DROP : NET_RX_SUCCESS; 164 } 165 166 /* Module registration */ 167 static struct proto pn_proto = { 168 .close = pn_sock_close, 169 .ioctl = pn_ioctl, 170 .init = pn_init, 171 .sendmsg = pn_sendmsg, 172 .recvmsg = pn_recvmsg, 173 .backlog_rcv = pn_backlog_rcv, 174 .hash = pn_sock_hash, 175 .unhash = pn_sock_unhash, 176 .get_port = pn_sock_get_port, 177 .obj_size = sizeof(struct pn_sock), 178 .owner = THIS_MODULE, 179 .name = "PHONET", 180 }; 181 182 static const struct phonet_protocol pn_dgram_proto = { 183 .ops = &phonet_dgram_ops, 184 .prot = &pn_proto, 185 .sock_type = SOCK_DGRAM, 186 }; 187 188 int __init isi_register(void) 189 { 190 return phonet_proto_register(PN_PROTO_PHONET, &pn_dgram_proto); 191 } 192 193 void __exit isi_unregister(void) 194 { 195 phonet_proto_unregister(PN_PROTO_PHONET, &pn_dgram_proto); 196 } 197