[linux-2.6-block.git] / net / phonet / datagram.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * File: datagram.c
 *
 * Datagram (ISI) Phonet sockets
 *
 * Copyright (C) 2008 Nokia Corporation.
 *
 * Authors: Sakari Ailus <sakari.ailus@nokia.com>
 *          Rémi Denis-Courmont
 */

#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/socket.h>
#include <asm/ioctls.h>
#include <net/sock.h>

#include <linux/phonet.h>
#include <linux/export.h>
#include <net/phonet/phonet.h>

static int pn_backlog_rcv(struct sock *sk, struct sk_buff *skb);

/* associated socket ceases to exist */
static void pn_sock_close(struct sock *sk, long timeout)
{
	sk_common_release(sk);
}

static int pn_ioctl(struct sock *sk, int cmd, int *karg)
{
	struct sk_buff *skb;

	switch (cmd) {
	case SIOCINQ:
		spin_lock_bh(&sk->sk_receive_queue.lock);
		skb = skb_peek(&sk->sk_receive_queue);
		*karg = skb ? skb->len : 0;
		spin_unlock_bh(&sk->sk_receive_queue.lock);
		return 0;

	case SIOCPNADDRESOURCE:
	case SIOCPNDELRESOURCE: {
			u32 res = *karg;
			if (res >= 256)
				return -EINVAL;
			if (cmd == SIOCPNADDRESOURCE)
				return pn_sock_bind_res(sk, res);
			else
				return pn_sock_unbind_res(sk, res);
		}
	}

	return -ENOIOCTLCMD;
}

/* Destroy socket. All references are gone. */
static void pn_destruct(struct sock *sk)
{
	skb_queue_purge(&sk->sk_receive_queue);
}

static int pn_init(struct sock *sk)
{
	sk->sk_destruct = pn_destruct;
	return 0;
}

static int pn_sendmsg(struct sock *sk, struct msghdr *msg, size_t len)
{
	DECLARE_SOCKADDR(struct sockaddr_pn *, target, msg->msg_name);
	struct sk_buff *skb;
	int err;

	if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR|MSG_NOSIGNAL|
				MSG_CMSG_COMPAT))
		return -EOPNOTSUPP;

	if (target == NULL)
		return -EDESTADDRREQ;

	if (msg->msg_namelen < sizeof(struct sockaddr_pn))
		return -EINVAL;

	if (target->spn_family != AF_PHONET)
		return -EAFNOSUPPORT;

	skb = sock_alloc_send_skb(sk, MAX_PHONET_HEADER + len,
					msg->msg_flags & MSG_DONTWAIT, &err);
	if (skb == NULL)
		return err;
	skb_reserve(skb, MAX_PHONET_HEADER);

	err = memcpy_from_msg((void *)skb_put(skb, len), msg, len);
	if (err < 0) {
		kfree_skb(skb);
		return err;
	}

	/*
	 * Fill in the Phonet header and
	 * finally pass the packet forwards.
	 */
	err = pn_skb_send(sk, skb, target);

	/* If ok, return len. */
	return (err >= 0) ? len : err;
}

static int pn_recvmsg(struct sock *sk, struct msghdr *msg, size_t len,
		      int flags, int *addr_len)
{
	struct sk_buff *skb = NULL;
	struct sockaddr_pn sa;
	int rval = -EOPNOTSUPP;
	int copylen;

	if (flags & ~(MSG_PEEK|MSG_TRUNC|MSG_DONTWAIT|MSG_NOSIGNAL|
			MSG_CMSG_COMPAT))
		goto out_nofree;

	skb = skb_recv_datagram(sk, flags, &rval);
	if (skb == NULL)
		goto out_nofree;

	pn_skb_get_src_sockaddr(skb, &sa);

	copylen = skb->len;
	if (len < copylen) {
		msg->msg_flags |= MSG_TRUNC;
		copylen = len;
	}

	rval = skb_copy_datagram_msg(skb, 0, msg, copylen);
	if (rval) {
		rval = -EFAULT;
		goto out;
	}

	rval = (flags & MSG_TRUNC) ? skb->len : copylen;

	if (msg->msg_name != NULL) {
		__sockaddr_check_size(sizeof(sa));
		memcpy(msg->msg_name, &sa, sizeof(sa));
		*addr_len = sizeof(sa);
	}

out:
	skb_free_datagram(sk, skb);

out_nofree:
	return rval;
}

/* Queue an skb for a sock. */
static int pn_backlog_rcv(struct sock *sk, struct sk_buff *skb)
{
	int err = sock_queue_rcv_skb(sk, skb);

	if (err < 0)
		kfree_skb(skb);
	return err ? NET_RX_DROP : NET_RX_SUCCESS;
}

/* Module registration */
static struct proto pn_proto = {
	.close		= pn_sock_close,
	.ioctl		= pn_ioctl,
	.init		= pn_init,
	.sendmsg	= pn_sendmsg,
	.recvmsg	= pn_recvmsg,
	.backlog_rcv	= pn_backlog_rcv,
	.hash		= pn_sock_hash,
	.unhash		= pn_sock_unhash,
	.get_port	= pn_sock_get_port,
	.obj_size	= sizeof(struct pn_sock),
	.owner		= THIS_MODULE,
	.name		= "PHONET",
};

static const struct phonet_protocol pn_dgram_proto = {
	.ops		= &phonet_dgram_ops,
	.prot		= &pn_proto,
	.sock_type	= SOCK_DGRAM,
};

int __init isi_register(void)
{
	return phonet_proto_register(PN_PROTO_PHONET, &pn_dgram_proto);
}

void __exit isi_unregister(void)
{
	phonet_proto_unregister(PN_PROTO_PHONET, &pn_dgram_proto);
}
Commit	Line	Data
2b27bdcc	1	// SPDX-License-Identifier: GPL-2.0-only
107d0d9b RDC	2	/*
	3	* File: datagram.c
	4	*
	5	* Datagram (ISI) Phonet sockets
	6	*
	7	* Copyright (C) 2008 Nokia Corporation.
	8	*
31fdc555 RDC	9	* Authors: Sakari Ailus <sakari.ailus@nokia.com>
31fdc555 RDC	10	* Rémi Denis-Courmont
107d0d9b RDC	11	*/
	12
	13	#include <linux/kernel.h>
5a0e3ad6	14	#include <linux/slab.h>
107d0d9b RDC	15	#include <linux/socket.h>
	16	#include <asm/ioctls.h>
	17	#include <net/sock.h>
	18
	19	#include <linux/phonet.h>
bc3b2d7f	20	#include <linux/export.h>
107d0d9b RDC	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
e1d001fa	31	static int pn_ioctl(struct sock sk, int cmd, int karg)
107d0d9b RDC	32	{
107d0d9b RDC	33	struct sk_buff *skb;
107d0d9b RDC	34
	35	switch (cmd) {
	36	case SIOCINQ:
3b2d9bc4	37	spin_lock_bh(&sk->sk_receive_queue.lock);
107d0d9b	38	skb = skb_peek(&sk->sk_receive_queue);
e1d001fa	39	*karg = skb ? skb->len : 0;
3b2d9bc4	40	spin_unlock_bh(&sk->sk_receive_queue.lock);
e1d001fa	41	return 0;
7417fa83 RDC	42
	43	case SIOCPNADDRESOURCE:
	44	case SIOCPNDELRESOURCE: {
e1d001fa	45	u32 res = *karg;
7417fa83 RDC	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	}
107d0d9b RDC	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
1b784140	70	static int pn_sendmsg(struct sock sk, struct msghdr msg, size_t len)
107d0d9b	71	{
342dfc30	72	DECLARE_SOCKADDR(struct sockaddr_pn *, target, msg->msg_name);
107d0d9b RDC	73	struct sk_buff *skb;
	74	int err;
	75
82ecbcb9 RDC	76	if (msg->msg_flags & ~(MSG_DONTWAIT\|MSG_EOR\|MSG_NOSIGNAL\|
82ecbcb9 RDC	77	MSG_CMSG_COMPAT))
107d0d9b RDC	78	return -EOPNOTSUPP;
107d0d9b RDC	79
342dfc30	80	if (target == NULL)
107d0d9b RDC	81	return -EDESTADDRREQ;
	82
	83	if (msg->msg_namelen < sizeof(struct sockaddr_pn))
	84	return -EINVAL;
	85
107d0d9b RDC	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
6ce8e9ce	95	err = memcpy_from_msg((void *)skb_put(skb, len), msg, len);
107d0d9b RDC	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
1b784140	111	static int pn_recvmsg(struct sock sk, struct msghdr msg, size_t len,
ec095263	112	int flags, int *addr_len)
107d0d9b RDC	113	{
	114	struct sk_buff *skb = NULL;
	115	struct sockaddr_pn sa;
	116	int rval = -EOPNOTSUPP;
	117	int copylen;
	118
82ecbcb9 RDC	119	if (flags & ~(MSG_PEEK\|MSG_TRUNC\|MSG_DONTWAIT\|MSG_NOSIGNAL\|
82ecbcb9 RDC	120	MSG_CMSG_COMPAT))
107d0d9b RDC	121	goto out_nofree;
107d0d9b RDC	122
f4b41f06	123	skb = skb_recv_datagram(sk, flags, &rval);
107d0d9b RDC	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
51f3d02b	135	rval = skb_copy_datagram_msg(skb, 0, msg, copylen);
107d0d9b RDC	136	if (rval) {
	137	rval = -EFAULT;
	138	goto out;
	139	}
	140
	141	rval = (flags & MSG_TRUNC) ? skb->len : copylen;
	142
bceaa902	143	if (msg->msg_name != NULL) {
342dfc30	144	__sockaddr_check_size(sizeof(sa));
bceaa902 HFS	145	memcpy(msg->msg_name, &sa, sizeof(sa));
	146	*addr_len = sizeof(sa);
	147	}
107d0d9b RDC	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);
766e9037 ED	160
766e9037 ED	161	if (err < 0)
107d0d9b RDC	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
548ec114	182	static const struct phonet_protocol pn_dgram_proto = {
107d0d9b RDC	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	}