linux/net/dccp/proto.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 *  net/dccp/proto.c
 *
 *  An implementation of the DCCP protocol
 *  Arnaldo Carvalho de Melo <[email protected]>
 */

#include <linux/dccp.h>
#include <linux/module.h>
#include <linux/types.h>
#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/skbuff.h>
#include <linux/netdevice.h>
#include <linux/in.h>
#include <linux/if_arp.h>
#include <linux/init.h>
#include <linux/random.h>
#include <linux/slab.h>
#include <net/checksum.h>

#include <net/inet_sock.h>
#include <net/inet_common.h>
#include <net/sock.h>
#include <net/xfrm.h>

#include <asm/ioctls.h>
#include <linux/spinlock.h>
#include <linux/timer.h>
#include <linux/delay.h>
#include <linux/poll.h>

#include "ccid.h"
#include "dccp.h"
#include "feat.h"

#define CREATE_TRACE_POINTS
#include "trace.h"

DEFINE_SNMP_STAT(struct dccp_mib, dccp_statistics) __read_mostly;

EXPORT_SYMBOL_GPL(…);

DEFINE_PER_CPU(unsigned int, dccp_orphan_count);
EXPORT_PER_CPU_SYMBOL_GPL(…);

struct inet_hashinfo dccp_hashinfo;
EXPORT_SYMBOL_GPL(…);

/* the maximum queue length for tx in packets. 0 is no limit */
int sysctl_dccp_tx_qlen __read_mostly = …;

#ifdef CONFIG_IP_DCCP_DEBUG
static const char *dccp_state_name(const int state)
{ … }
#endif

void dccp_set_state(struct sock *sk, const int state)
{ … }

EXPORT_SYMBOL_GPL(…);

static void dccp_finish_passive_close(struct sock *sk)
{ … }

void dccp_done(struct sock *sk)
{ … }

EXPORT_SYMBOL_GPL(…);

const char *dccp_packet_name(const int type)
{ … }

EXPORT_SYMBOL_GPL(…);

void dccp_destruct_common(struct sock *sk)
{ … }
EXPORT_SYMBOL_GPL(…);

static void dccp_sk_destruct(struct sock *sk)
{ … }

int dccp_init_sock(struct sock *sk, const __u8 ctl_sock_initialized)
{ … }

EXPORT_SYMBOL_GPL(…);

void dccp_destroy_sock(struct sock *sk)
{ … }

EXPORT_SYMBOL_GPL(…);

static inline int dccp_need_reset(int state)
{ … }

int dccp_disconnect(struct sock *sk, int flags)
{ … }

EXPORT_SYMBOL_GPL(…);

/*
 *	Wait for a DCCP event.
 *
 *	Note that we don't need to lock the socket, as the upper poll layers
 *	take care of normal races (between the test and the event) and we don't
 *	go look at any of the socket buffers directly.
 */
__poll_t dccp_poll(struct file *file, struct socket *sock,
		       poll_table *wait)
{ … }
EXPORT_SYMBOL_GPL(…);

int dccp_ioctl(struct sock *sk, int cmd, int *karg)
{ … }

EXPORT_SYMBOL_GPL(…);

static int dccp_setsockopt_service(struct sock *sk, const __be32 service,
				   sockptr_t optval, unsigned int optlen)
{ … }

static int dccp_setsockopt_cscov(struct sock *sk, int cscov, bool rx)
{ … }

static int dccp_setsockopt_ccid(struct sock *sk, int type,
				sockptr_t optval, unsigned int optlen)
{ … }

static int do_dccp_setsockopt(struct sock *sk, int level, int optname,
		sockptr_t optval, unsigned int optlen)
{ … }

int dccp_setsockopt(struct sock *sk, int level, int optname, sockptr_t optval,
		    unsigned int optlen)
{ … }

EXPORT_SYMBOL_GPL(…);

static int dccp_getsockopt_service(struct sock *sk, int len,
				   __be32 __user *optval,
				   int __user *optlen)
{ … }

static int do_dccp_getsockopt(struct sock *sk, int level, int optname,
		    char __user *optval, int __user *optlen)
{ … }

int dccp_getsockopt(struct sock *sk, int level, int optname,
		    char __user *optval, int __user *optlen)
{ … }

EXPORT_SYMBOL_GPL(…);

static int dccp_msghdr_parse(struct msghdr *msg, struct sk_buff *skb)
{ … }

int dccp_sendmsg(struct sock *sk, struct msghdr *msg, size_t len)
{ … }

EXPORT_SYMBOL_GPL(…);

int dccp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, int flags,
		 int *addr_len)
{ … }

EXPORT_SYMBOL_GPL(…);

int inet_dccp_listen(struct socket *sock, int backlog)
{ … }

EXPORT_SYMBOL_GPL(…);

static void dccp_terminate_connection(struct sock *sk)
{ … }

void dccp_close(struct sock *sk, long timeout)
{ … }

EXPORT_SYMBOL_GPL(…);

void dccp_shutdown(struct sock *sk, int how)
{ … }

EXPORT_SYMBOL_GPL(…);

static inline int __init dccp_mib_init(void)
{ … }

static inline void dccp_mib_exit(void)
{ … }

static int thash_entries;
module_param(thash_entries, int, 0444);
MODULE_PARM_DESC(…) …;

#ifdef CONFIG_IP_DCCP_DEBUG
bool dccp_debug;
module_param(dccp_debug, bool, 0644);
MODULE_PARM_DESC(…) …;

EXPORT_SYMBOL_GPL(…);
#endif

static int __init dccp_init(void)
{ … }

static void __exit dccp_fini(void)
{ … }

module_init(…) …;
module_exit(dccp_fini);

MODULE_LICENSE(…) …;
MODULE_AUTHOR(…) …;
MODULE_DESCRIPTION(…) …;