linux/net/atm/clip.c

// SPDX-License-Identifier: GPL-2.0-only
/* net/atm/clip.c - RFC1577 Classical IP over ATM */

/* Written 1995-2000 by Werner Almesberger, EPFL LRC/ICA */

#define pr_fmt(fmt) …

#include <linux/string.h>
#include <linux/errno.h>
#include <linux/kernel.h> /* for UINT_MAX */
#include <linux/module.h>
#include <linux/init.h>
#include <linux/netdevice.h>
#include <linux/skbuff.h>
#include <linux/wait.h>
#include <linux/timer.h>
#include <linux/if_arp.h> /* for some manifest constants */
#include <linux/notifier.h>
#include <linux/atm.h>
#include <linux/atmdev.h>
#include <linux/atmclip.h>
#include <linux/atmarp.h>
#include <linux/capability.h>
#include <linux/ip.h> /* for net/route.h */
#include <linux/in.h> /* for struct sockaddr_in */
#include <linux/if.h> /* for IFF_UP */
#include <linux/inetdevice.h>
#include <linux/bitops.h>
#include <linux/poison.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/rcupdate.h>
#include <linux/jhash.h>
#include <linux/slab.h>
#include <net/route.h> /* for struct rtable and routing */
#include <net/icmp.h> /* icmp_send */
#include <net/arp.h>
#include <linux/param.h> /* for HZ */
#include <linux/uaccess.h>
#include <asm/byteorder.h> /* for htons etc. */
#include <linux/atomic.h>

#include "common.h"
#include "resources.h"
#include <net/atmclip.h>

static struct net_device *clip_devs;
static struct atm_vcc *atmarpd;
static struct timer_list idle_timer;
static const struct neigh_ops clip_neigh_ops;

static int to_atmarpd(enum atmarp_ctrl_type type, int itf, __be32 ip)
{ … }

static void link_vcc(struct clip_vcc *clip_vcc, struct atmarp_entry *entry)
{ … }

static void unlink_clip_vcc(struct clip_vcc *clip_vcc)
{ … }

/* The neighbour entry n->lock is held. */
static int neigh_check_cb(struct neighbour *n)
{ … }

static void idle_timer_check(struct timer_list *unused)
{ … }

static int clip_arp_rcv(struct sk_buff *skb)
{ … }

static const unsigned char llc_oui[] = …;

static void clip_push(struct atm_vcc *vcc, struct sk_buff *skb)
{ … }

/*
 * Note: these spinlocks _must_not_ block on non-SMP. The only goal is that
 * clip_pop is atomic with respect to the critical section in clip_start_xmit.
 */

static void clip_pop(struct atm_vcc *vcc, struct sk_buff *skb)
{ … }

static void clip_neigh_solicit(struct neighbour *neigh, struct sk_buff *skb)
{ … }

static void clip_neigh_error(struct neighbour *neigh, struct sk_buff *skb)
{ … }

static const struct neigh_ops clip_neigh_ops = …;

static int clip_constructor(struct net_device *dev, struct neighbour *neigh)
{ … }

/* @@@ copy bh locking from arp.c -- need to bh-enable atm code before */

/*
 * We play with the resolve flag: 0 and 1 have the usual meaning, but -1 means
 * to allocate the neighbour entry but not to ask atmarpd for resolution. Also,
 * don't increment the usage count. This is used to create entries in
 * clip_setentry.
 */

static int clip_encap(struct atm_vcc *vcc, int mode)
{ … }

static netdev_tx_t clip_start_xmit(struct sk_buff *skb,
				   struct net_device *dev)
{ … }

static int clip_mkip(struct atm_vcc *vcc, int timeout)
{ … }

static int clip_setentry(struct atm_vcc *vcc, __be32 ip)
{ … }

static const struct net_device_ops clip_netdev_ops = …;

static void clip_setup(struct net_device *dev)
{ … }

static int clip_create(int number)
{ … }

static int clip_device_event(struct notifier_block *this, unsigned long event,
			     void *ptr)
{ … }

static int clip_inet_event(struct notifier_block *this, unsigned long event,
			   void *ifa)
{ … }

static struct notifier_block clip_dev_notifier = …;



static struct notifier_block clip_inet_notifier = …;



static void atmarpd_close(struct atm_vcc *vcc)
{ … }

static const struct atmdev_ops atmarpd_dev_ops = …;


static struct atm_dev atmarpd_dev = …;


static int atm_init_atmarp(struct atm_vcc *vcc)
{ … }

static int clip_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
{ … }

static struct atm_ioctl clip_ioctl_ops = …;

#ifdef CONFIG_PROC_FS

static void svc_addr(struct seq_file *seq, struct sockaddr_atmsvc *addr)
{ … }

/* This means the neighbour entry has no attached VCC objects. */
#define SEQ_NO_VCC_TOKEN …

static void atmarp_info(struct seq_file *seq, struct neighbour *n,
			struct atmarp_entry *entry, struct clip_vcc *clip_vcc)
{ … }

struct clip_seq_state { … };

static struct clip_vcc *clip_seq_next_vcc(struct atmarp_entry *e,
					  struct clip_vcc *curr)
{ … }

static void *clip_seq_vcc_walk(struct clip_seq_state *state,
			       struct atmarp_entry *e, loff_t * pos)
{ … }

static void *clip_seq_sub_iter(struct neigh_seq_state *_state,
			       struct neighbour *n, loff_t * pos)
{ … }

static void *clip_seq_start(struct seq_file *seq, loff_t * pos)
{ … }

static int clip_seq_show(struct seq_file *seq, void *v)
{ … }

static const struct seq_operations arp_seq_ops = …;
#endif

static void atm_clip_exit_noproc(void);

static int __init atm_clip_init(void)
{ … }

static void atm_clip_exit_noproc(void)
{ … }

static void __exit atm_clip_exit(void)
{ … }

module_init(…) …;
module_exit(atm_clip_exit);
MODULE_AUTHOR(…) …;
MODULE_DESCRIPTION(…) …;
MODULE_LICENSE(…) …;