summaryrefslogtreecommitdiff
path: root/drivers
diff options
context:
space:
mode:
Diffstat (limited to 'drivers')
-rw-r--r--drivers/ipoe/CMakeLists.txt24
-rw-r--r--drivers/ipoe/ipoe.c218
-rw-r--r--drivers/ipoe/ipoe.h1
-rw-r--r--drivers/ppposeq/CMakeLists.txt (renamed from drivers/pptp/CMakeLists.txt)10
-rw-r--r--drivers/ppposeq/Makefile (renamed from drivers/pptp/Makefile)2
-rw-r--r--drivers/ppposeq/ppposeq.c569
-rw-r--r--drivers/ppposeq/ppposeq.h39
-rw-r--r--drivers/pptp/gre.c220
-rw-r--r--drivers/pptp/gre.h18
-rw-r--r--drivers/pptp/if_pppox.h222
-rw-r--r--drivers/pptp/pptp.c1272
-rw-r--r--drivers/vlan_mon/vlan_mon.c3
12 files changed, 856 insertions, 1742 deletions
diff --git a/drivers/ipoe/CMakeLists.txt b/drivers/ipoe/CMakeLists.txt
index e221a7ec..d0d6902c 100644
--- a/drivers/ipoe/CMakeLists.txt
+++ b/drivers/ipoe/CMakeLists.txt
@@ -3,11 +3,35 @@ if (NOT DEFINED KDIR)
set(KDIR "/usr/src/linux")
endif (NOT DEFINED KDIR)
+# Try to figure out the kernel release once so we can show it before building.
+execute_process(
+ COMMAND make -s -C ${KDIR} kernelrelease
+ RESULT_VARIABLE IPOE_KERNEL_RELEASE_RESULT
+ OUTPUT_VARIABLE IPOE_KERNEL_RELEASE
+ OUTPUT_STRIP_TRAILING_WHITESPACE
+ ERROR_QUIET
+)
+
+if (NOT IPOE_KERNEL_RELEASE_RESULT STREQUAL "0" OR IPOE_KERNEL_RELEASE STREQUAL "")
+ find_program(UNAME_EXECUTABLE uname)
+
+ if (UNAME_EXECUTABLE)
+ execute_process(
+ COMMAND ${UNAME_EXECUTABLE} -r
+ OUTPUT_VARIABLE IPOE_KERNEL_RELEASE
+ OUTPUT_STRIP_TRAILING_WHITESPACE
+ )
+ else()
+ set(IPOE_KERNEL_RELEASE "unknown")
+ endif()
+endif()
+
ADD_CUSTOM_COMMAND(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/driver/ipoe.ko
COMMAND rm -rf ${CMAKE_CURRENT_BINARY_DIR}/driver
COMMAND mkdir ${CMAKE_CURRENT_BINARY_DIR}/driver
COMMAND ln -sf ${CMAKE_CURRENT_SOURCE_DIR}/* ${CMAKE_CURRENT_BINARY_DIR}/driver
COMMAND ln -sf ${CMAKE_BINARY_DIR}/version.h ${CMAKE_CURRENT_BINARY_DIR}/driver
+ COMMAND ${CMAKE_COMMAND} -E echo "[ 99%] Generating driver/ipoe.ko for kernel ${IPOE_KERNEL_RELEASE}"
COMMAND make -C ${KDIR} M=${CMAKE_CURRENT_BINARY_DIR}/driver modules
DEPENDS ipoe.c ipoe.h
)
diff --git a/drivers/ipoe/ipoe.c b/drivers/ipoe/ipoe.c
index fa7dec3f..251fec96 100644
--- a/drivers/ipoe/ipoe.c
+++ b/drivers/ipoe/ipoe.c
@@ -15,17 +15,22 @@
#include <linux/init.h>
#include <linux/if_ether.h>
#include <linux/if_vlan.h>
+#include <linux/ipv6.h>
#include <linux/semaphore.h>
#include <linux/netfilter_ipv4.h>
#include <linux/u64_stats_sync.h>
#include <linux/version.h>
#include <net/genetlink.h>
+#include <net/rtnetlink.h>
#include <net/route.h>
#include <net/sock.h>
#include <net/ip.h>
#include <net/icmp.h>
#include <net/flow.h>
+#ifdef flowi4_dscp
+#include <net/inet_dscp.h>
+#endif
#include <net/xfrm.h>
#include <net/net_namespace.h>
#include <net/netns/generic.h>
@@ -58,6 +63,23 @@
#define RHEL_MAJOR 0
#endif
+/* ipv6.disable=1 leaves the IPv6 FIB uninitialized, so ip6_route_output()
+ * oopses; ipv6_mod_enabled() detects that (and CONFIG_IPV6=n) since 4.8 */
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(4,8,0)
+#define ipoe_ipv6_enabled() ipv6_mod_enabled()
+#else
+#define ipoe_ipv6_enabled() 1
+#endif
+
+static inline void ipoe_flowi4_set_tos(struct flowi4 *fl4, __u8 dsfield)
+{
+#ifdef flowi4_dscp
+ fl4->flowi4_dscp = inet_dsfield_to_dscp(dsfield);
+#else
+ fl4->flowi4_tos = dsfield;
+#endif
+}
+
struct ipoe_stats {
struct u64_stats_sync sync;
u64 packets;
@@ -83,6 +105,10 @@ struct ipoe_session {
atomic_t refs;
+ /* set under ipoe_wlock by whoever starts tearing the session down,
+ * so that the genl and the rtnetlink path do not do it twice */
+ unsigned int dying:1;
+
struct ipoe_stats __percpu *rx_stats;
struct ipoe_stats __percpu *tx_stats;
};
@@ -263,7 +289,7 @@ static int check_nat_required(struct sk_buff *skb, struct net_device *link)
memset(&fl4, 0, sizeof(fl4));
fl4.daddr = iph->daddr;
- fl4.flowi4_tos = RT_TOS(0);
+ ipoe_flowi4_set_tos(&fl4, RT_TOS(0));
fl4.flowi4_scope = RT_SCOPE_UNIVERSE;
rt = ip_route_output_key(net, &fl4);
if (IS_ERR(rt))
@@ -702,7 +728,11 @@ nl_err:
if (!list_empty(&ipoe_list2_u))
mod_timer(&ipoe_timer_u, jiffies + IPOE_TIMEOUT_U * HZ);
else
+#if LINUX_VERSION_CODE < KERNEL_VERSION(6,2,0)
del_timer(&ipoe_timer_u);
+#else
+ timer_delete(&ipoe_timer_u);
+#endif
}
static struct ipoe_session *ipoe_lookup(__be32 addr)
@@ -767,7 +797,7 @@ static struct ipoe_session *ipoe_lookup_rt4(struct sk_buff *skb, __be32 addr, st
memset(&fl4, 0, sizeof(fl4));
fl4.daddr = addr;
- fl4.flowi4_tos = RT_TOS(0);
+ ipoe_flowi4_set_tos(&fl4, RT_TOS(0));
fl4.flowi4_scope = RT_SCOPE_UNIVERSE;
rt = ip_route_output_key(net, &fl4);
if (IS_ERR(rt))
@@ -874,6 +904,9 @@ static rx_handler_result_t ipoe_recv(struct sk_buff **pskb)
return RX_HANDLER_CONSUMED;
}
} else if (skb->protocol == htons(ETH_P_IPV6)) {
+ if (!ipoe_ipv6_enabled())
+ return RX_HANDLER_PASS;
+
if (!pskb_may_pull(skb, sizeof(*ip6h) + noff))
return RX_HANDLER_PASS;
@@ -1088,6 +1121,83 @@ static const struct header_ops ipoe_hard_header_ops = {
.cache_update = eth_header_cache_update,
};
+/* Is anybody subscribed to our packet group, i.e. is a control daemon
+ * running at all? */
+static int ipoe_ctrl_attached(void)
+{
+#if LINUX_VERSION_CODE < KERNEL_VERSION(3,13,0) && RHEL_MAJOR < 7
+ return netlink_has_listeners(init_net.genl_sock, ipoe_nl_mcg.id);
+#else
+ return genl_has_listeners(&ipoe_nl_family, &init_net, 0);
+#endif
+}
+
+/* Sessions are created through IPOE_CMD_CREATE, which also sets up the
+ * private state. A device made by rtnetlink would have none of it, so
+ * refuse 'ip link add ... type ipoe' explicitly. */
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(6,13,0)
+static int ipoe_newlink(struct net_device *dev,
+ struct rtnl_newlink_params *params,
+ struct netlink_ext_ack *extack)
+#elif LINUX_VERSION_CODE >= KERNEL_VERSION(4,13,0)
+static int ipoe_newlink(struct net *src_net, struct net_device *dev,
+ struct nlattr *tb[], struct nlattr *data[],
+ struct netlink_ext_ack *extack)
+#else
+static int ipoe_newlink(struct net *src_net, struct net_device *dev,
+ struct nlattr *tb[], struct nlattr *data[])
+#endif
+{
+ return -EOPNOTSUPP;
+}
+
+/* Called by rtnetlink with rtnl held, so the teardown ipoe_nl_cmd_delete()
+ * does after dropping ipoe_wlock has to happen here as well. */
+static void ipoe_dellink(struct net_device *dev, struct list_head *head)
+{
+ struct ipoe_session *ses = netdev_priv(dev);
+
+ down(&ipoe_wlock);
+
+ if (ses->dying) {
+ /* the genl path is already removing it, it will unregister
+ * the device itself once it gets rtnl */
+ up(&ipoe_wlock);
+ return;
+ }
+
+ ses->dying = 1;
+
+ if (ses->peer_addr)
+ list_del_rcu(&ses->entry);
+ list_del(&ses->entry2);
+ if (ses->u.hwaddr_u)
+ list_del_rcu(&ses->entry3);
+
+ up(&ipoe_wlock);
+
+ /* A session left behind by a dead daemon looks exactly like one that
+ * is still in use, so removing it can not be refused on state alone.
+ * Complain only if somebody is still subscribed to our multicast
+ * group, which means a daemon is around to be surprised by it. */
+ if (ses->peer_addr && ipoe_ctrl_attached())
+ pr_warn("ipoe: %s: removed through rtnetlink while bound to %pI4"
+ " and a control daemon is attached\n",
+ dev->name, &ses->peer_addr);
+
+ synchronize_rcu();
+
+ while (atomic_read(&ses->refs))
+ schedule_timeout_uninterruptible(1);
+
+ if (ses->link_dev) {
+ dev_put(ses->link_dev);
+ ses->link_dev = NULL;
+ }
+
+ unregister_netdevice_queue(dev, head);
+}
+
static void ipoe_netdev_setup(struct net_device *dev)
{
dev->netdev_ops = &ipoe_netdev_ops;
@@ -1105,12 +1215,26 @@ static void ipoe_netdev_setup(struct net_device *dev)
dev->iflink = 0;
#endif
dev->addr_len = ETH_ALEN;
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(6,15,0)
+ dev->netns_immutable = true;
+#elif LINUX_VERSION_CODE >= KERNEL_VERSION(6,12,0)
+ dev->netns_local = true;
+#else
dev->features |= NETIF_F_NETNS_LOCAL;
+#endif
dev->features &= ~(NETIF_F_HW_VLAN_FILTER | NETIF_F_LRO);
dev->header_ops = &ipoe_hard_header_ops;
dev->priv_flags &= ~IFF_XMIT_DST_RELEASE;
}
+static struct rtnl_link_ops ipoe_link_ops __read_mostly = {
+ .kind = "ipoe",
+ .priv_size = sizeof(struct ipoe_session),
+ .setup = ipoe_netdev_setup,
+ .newlink = ipoe_newlink,
+ .dellink = ipoe_dellink,
+};
+
static int ipoe_create(__be32 peer_addr, __be32 addr, __be32 gw, int ifindex, const __u8 *hwaddr)
{
struct ipoe_session *ses;
@@ -1186,6 +1310,7 @@ static int ipoe_create(__be32 peer_addr, __be32 addr, __be32 gw, int ifindex, co
}*/
dev->tx_queue_len = 100;
+ dev->rtnl_link_ops = &ipoe_link_ops;
rtnl_lock();
r = register_netdevice(dev);
@@ -1359,12 +1484,22 @@ static int ipoe_nl_cmd_delete(struct sk_buff *skb, struct genl_info *info)
//pr_info("ipoe: delete %08x\n", ses->peer_addr);
+ if (ses->dying) {
+ /* already on its way out through ipoe_dellink() or a flush */
+ ret = 0;
+ goto out_unlock;
+ }
+
+ ses->dying = 1;
+
if (ses->peer_addr)
list_del_rcu(&ses->entry);
list_del(&ses->entry2);
if (ses->u.hwaddr_u)
list_del_rcu(&ses->entry3);
+ /* drop the lock before sleeping in synchronize_rcu() and taking rtnl
+ * in unregister_netdev() */
up(&ipoe_wlock);
synchronize_rcu();
@@ -1377,13 +1512,61 @@ static int ipoe_nl_cmd_delete(struct sk_buff *skb, struct genl_info *info)
unregister_netdev(ses->dev);
- ret = 0;
+ return 0;
out_unlock:
up(&ipoe_wlock);
return ret;
}
+static int ipoe_nl_cmd_flush(struct sk_buff *skb, struct genl_info *info)
+{
+ struct ipoe_session *ses;
+ LIST_HEAD(list);
+ LIST_HEAD(kill_list);
+
+ down(&ipoe_wlock);
+
+ list_splice_init(&ipoe_list2, &list);
+
+ list_for_each_entry(ses, &list, entry2) {
+ ses->dying = 1;
+
+ if (ses->peer_addr)
+ list_del_rcu(&ses->entry);
+ if (ses->u.hwaddr_u)
+ list_del_rcu(&ses->entry3);
+ }
+
+ up(&ipoe_wlock);
+
+ if (list_empty(&list))
+ return 0;
+
+ /* a single grace period covers the whole batch */
+ synchronize_rcu();
+
+ list_for_each_entry(ses, &list, entry2) {
+ while (atomic_read(&ses->refs))
+ schedule_timeout_uninterruptible(1);
+
+ if (ses->link_dev) {
+ dev_put(ses->link_dev);
+ ses->link_dev = NULL;
+ }
+ }
+
+ rtnl_lock();
+ list_for_each_entry(ses, &list, entry2)
+ unregister_netdevice_queue(ses->dev, &kill_list);
+ unregister_netdevice_many(&kill_list);
+ rtnl_unlock();
+
+ /* the sessions are freed by now, do not touch 'list' again */
+
+ return 0;
+}
+
static int ipoe_nl_cmd_modify(struct sk_buff *skb, struct genl_info *info)
{
int ret = -EINVAL, r = 0;
@@ -1543,7 +1726,11 @@ static int ipoe_nl_cmd_dump_sessions(struct sk_buff *skb, struct netlink_callbac
#else
if (fill_info(skb, ses, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq) < 0)
#endif
+ {
+ /* this one did not fit, resume from it next time */
+ idx--;
break;
+ }
}
up(&ipoe_wlock);
@@ -1856,6 +2043,14 @@ static const struct genl_ops ipoe_nl_ops[] = {
.policy = ipoe_nl_policy,
#endif
},
+ {
+ .cmd = IPOE_CMD_FLUSH,
+ .doit = ipoe_nl_cmd_flush,
+ .flags = GENL_ADMIN_PERM,
+#if LINUX_VERSION_CODE < KERNEL_VERSION(5,2,0)
+ .policy = ipoe_nl_policy,
+#endif
+ },
};
#if LINUX_VERSION_CODE < KERNEL_VERSION(3,13,0) && RHEL_MAJOR < 7
@@ -1926,6 +2121,12 @@ static int __init ipoe_init(void)
skb_queue_head_init(&ipoe_queue);
INIT_WORK(&ipoe_queue_work, ipoe_process_queue);
+ err = rtnl_link_register(&ipoe_link_ops);
+ if (err < 0) {
+ printk(KERN_INFO "ipoe: can't register link operations\n");
+ return err;
+ }
+
#if LINUX_VERSION_CODE < KERNEL_VERSION(3,13,0) && RHEL_MAJOR < 7
err = genl_register_family_with_ops(&ipoe_nl_family, ipoe_nl_ops, ARRAY_SIZE(ipoe_nl_ops));
#elif LINUX_VERSION_CODE < KERNEL_VERSION(4,10,0)
@@ -1935,6 +2136,7 @@ static int __init ipoe_init(void)
#endif
if (err < 0) {
printk(KERN_INFO "ipoe: can't register netlink interface\n");
+ rtnl_link_unregister(&ipoe_link_ops);
return err;
}
@@ -1943,6 +2145,7 @@ static int __init ipoe_init(void)
if (err < 0) {
printk(KERN_INFO "ipoe: can't register netlink multicast group\n");
genl_unregister_family(&ipoe_nl_family);
+ rtnl_link_unregister(&ipoe_link_ops);
return err;
}
#endif
@@ -1962,6 +2165,10 @@ static void __exit ipoe_fini(void)
#endif
genl_unregister_family(&ipoe_nl_family);
+ /* takes down whatever sessions are left through ipoe_dellink() and
+ * keeps rtnetlink from starting another one behind our back */
+ rtnl_link_unregister(&ipoe_link_ops);
+
down(&ipoe_wlock);
up(&ipoe_wlock);
@@ -1984,8 +2191,11 @@ static void __exit ipoe_fini(void)
flush_work(&ipoe_queue_work);
skb_queue_purge(&ipoe_queue);
-
+#if LINUX_VERSION_CODE < KERNEL_VERSION(6,2,0)
del_timer(&ipoe_timer_u);
+#else
+ timer_delete(&ipoe_timer_u);
+#endif
for (i = 0; i <= IPOE_HASH_BITS; i++)
rcu_assign_pointer(ipoe_list[i].next, &ipoe_list[i]);
diff --git a/drivers/ipoe/ipoe.h b/drivers/ipoe/ipoe.h
index 4097e2da..2d041c50 100644
--- a/drivers/ipoe/ipoe.h
+++ b/drivers/ipoe/ipoe.h
@@ -16,6 +16,7 @@ enum {
IPOE_CMD_DEL_EXCLUDE,
IPOE_CMD_ADD_NET,
IPOE_CMD_DEL_NET,
+ IPOE_CMD_FLUSH,
__IPOE_CMD_MAX,
};
diff --git a/drivers/pptp/CMakeLists.txt b/drivers/ppposeq/CMakeLists.txt
index fd732e6a..08c45c76 100644
--- a/drivers/pptp/CMakeLists.txt
+++ b/drivers/ppposeq/CMakeLists.txt
@@ -2,18 +2,18 @@ if (NOT DEFINED KDIR)
set(KDIR "/usr/src/linux")
endif (NOT DEFINED KDIR)
-ADD_CUSTOM_COMMAND(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/driver/pptp.ko
+ADD_CUSTOM_COMMAND(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/driver/ppposeq.ko
COMMAND rm -rf ${CMAKE_CURRENT_BINARY_DIR}/driver
COMMAND mkdir ${CMAKE_CURRENT_BINARY_DIR}/driver
COMMAND ln -sf ${CMAKE_CURRENT_SOURCE_DIR}/* ${CMAKE_CURRENT_BINARY_DIR}/driver
COMMAND make -C ${KDIR} M=${CMAKE_CURRENT_BINARY_DIR}/driver modules
- DEPENDS pptp.c
+ DEPENDS ppposeq.c ppposeq.h
)
-ADD_CUSTOM_TARGET(pptp_drv ALL
- DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/driver/pptp.ko
+ADD_CUSTOM_TARGET(ppposeq_drv ALL
+ DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/driver/ppposeq.ko
)
IF (NOT DEFINED CPACK_TYPE)
INSTALL(CODE "EXECUTE_PROCESS(COMMAND make -C ${KDIR} M=${CMAKE_CURRENT_BINARY_DIR}/driver modules_install)")
-ENDIF (NOT DEFINED CPACK_TYPE)
+ENDIF()
diff --git a/drivers/pptp/Makefile b/drivers/ppposeq/Makefile
index 8ccbbedf..f66096c6 100644
--- a/drivers/pptp/Makefile
+++ b/drivers/ppposeq/Makefile
@@ -1,4 +1,4 @@
-obj-m += pptp.o
+obj-m += ppposeq.o
default:
make -C $(KDIR) M=$(PWD) modules
diff --git a/drivers/ppposeq/ppposeq.c b/drivers/ppposeq/ppposeq.c
new file mode 100644
index 00000000..b4c5718d
--- /dev/null
+++ b/drivers/ppposeq/ppposeq.c
@@ -0,0 +1,569 @@
+/*
+ * ppposeq - PPP over SEQPACKET socket driver.
+ *
+ * Replaces the pty + ppp_async transport for userspace PPP terminators.
+ * A pty is a byte stream: the tty flip buffer merges frames written
+ * back to back (flush_to_ldisc hands receive_buf everything committed
+ * since the last flush in one call), so PPP over a pty needs HDLC
+ * framing to re-delimit frames. Here the socket is the PPP endpoint
+ * and one datagram is one PPP frame, so no HDLC framing is needed.
+ *
+ * Copyright (C) 2026 Vladislav Grishenko
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/skbuff.h>
+#include <linux/net.h>
+#include <linux/version.h>
+#include <linux/ppp_defs.h>
+#if LINUX_VERSION_CODE < KERNEL_VERSION(3,4,0)
+#include <linux/if.h>
+#include <linux/if_ppp.h>
+#else
+#include <linux/ppp-ioctl.h>
+#endif
+#include <linux/ppp_channel.h>
+#include <linux/if_pppox.h>
+
+#include <net/sock.h>
+
+#include "ppposeq.h"
+
+/* proto_ops connect/bind signatures changed to sockaddr_unsized in 6.19 */
+#if LINUX_VERSION_CODE < KERNEL_VERSION(6,19,0)
+#define sockaddr_unsized sockaddr
+#endif
+
+/* the noblock argument was folded into flags in 5.19 */
+#if LINUX_VERSION_CODE < KERNEL_VERSION(5,19,0)
+#define ppposeq_recv_datagram(sk, flags, err) \
+ skb_recv_datagram(sk, (flags), (flags) & MSG_DONTWAIT, err)
+#else
+#define ppposeq_recv_datagram(sk, flags, err) \
+ skb_recv_datagram(sk, flags, err)
+#endif
+
+/* __sock_queue_rcv_skb was introduced in 4.7 */
+#if LINUX_VERSION_CODE < KERNEL_VERSION(4,7,0)
+#define ppposeq_queue_rcv_skb(sk, skb) \
+ sock_queue_rcv_skb(sk, skb)
+#else
+#define ppposeq_queue_rcv_skb(sk, skb) \
+ __sock_queue_rcv_skb(sk, skb)
+#endif
+
+/* sk_alloc gained a trailing kern argument in 4.2 */
+#if LINUX_VERSION_CODE < KERNEL_VERSION(4,2,0)
+#define ppposeq_sk_alloc(net, fam, prio, prot, kern) \
+ sk_alloc(net, fam, prio, prot)
+#else
+#define ppposeq_sk_alloc(net, fam, prio, prot, kern) \
+ sk_alloc(net, fam, prio, prot, kern)
+#endif
+
+/* memcpy_from_msg appeared in 3.19, replacing memcpy_fromiovec */
+#if LINUX_VERSION_CODE < KERNEL_VERSION(3,19,0)
+#define memcpy_from_msg(data, msg, len) \
+ memcpy_fromiovec(data, (msg)->msg_iov, len)
+#define skb_copy_datagram_msg(skb, off, msg, len) \
+ skb_copy_datagram_iovec(skb, off, (msg)->msg_iov, len)
+#endif
+
+/* smp_mb__after_atomic was introduced in 3.16 */
+#if LINUX_VERSION_CODE < KERNEL_VERSION(3,16,0)
+#define smp_mb__after_atomic() smp_mb()
+#endif
+
+/* U16_MAX was introduced in 3.14 */
+#if LINUX_VERSION_CODE < KERNEL_VERSION(3,14,0)
+#define U16_MAX ((u16)~0U)
+#endif
+
+#define XMIT_WAKEUP 0
+
+#define XMIT_PULL_PROT (1 << 0)
+#define XMIT_PUSH_AC (1 << 1)
+
+#define SC_RCV_BITS (SC_RCV_B7_1|SC_RCV_B7_0|SC_RCV_ODDP|SC_RCV_EVNP)
+
+struct ppposeq_opt {
+ int mru;
+ unsigned int flags;
+ unsigned long xmit_flags;
+};
+
+/*
+ * pppox_sock's proto union is fixed by the core, so keep our state
+ * alongside the socket rather than in it.
+ */
+struct ppposeq_sock {
+ struct pppox_sock po;
+ struct ppposeq_opt opt;
+};
+
+static inline struct ppposeq_sock *ppposeq_sk(struct sock *sk)
+{
+ return (struct ppposeq_sock *)sk;
+}
+
+static const struct proto_ops ppposeq_ops;
+
+static struct proto ppposeq_sk_proto = {
+ .name = "PPPOSEQ",
+ .owner = THIS_MODULE,
+ .obj_size = sizeof(struct ppposeq_sock),
+};
+
+/*
+ * Transmit: kernel -> userspace. Called from ppp_generic with
+ * spin_lock(&pch->downl) held, so this must not sleep. Queue the frame on
+ * the socket's receive queue; userspace picks it up with recvmsg. One skb
+ * in, one datagram out.
+ */
+static int ppposeq_xmit(struct ppp_channel *chan, struct sk_buff *skb)
+{
+ struct sock *sk = (struct sock *)chan->private;
+ struct ppposeq_sock *ps = ppposeq_sk(sk);
+ int err, proto, islcp, flags = 0;
+ u8 *data;
+
+ if (sock_flag(sk, SOCK_DEAD) || !(sk->sk_state & PPPOX_CONNECTED))
+ goto drop;
+
+ /* Ensure we can safely access protocol field and LCP code */
+ if (!pskb_may_pull(skb, 3))
+ goto drop;
+
+ /* Apply negotiated PFC/ACFC, like ppp_sync_txmunge. */
+ data = skb->data;
+ proto = (data[0] << 8) + data[1];
+
+ /* LCP codes 1..7 must be sent uncompressed. */
+ islcp = (proto == PPP_LCP) && data[2] >= 1 && data[2] <= 7;
+
+ /* compress protocol field if PFC is in effect */
+ if ((ps->opt.flags & SC_COMP_PROT) && data[0] == 0 && !islcp) {
+ skb_pull(skb, 1);
+ flags |= XMIT_PULL_PROT;
+ }
+
+ /* prepend address/control unless ACFC is in effect (or it's LCP) */
+ if ((ps->opt.flags & SC_COMP_AC) == 0 || islcp) {
+ if (skb_cow_head(skb, 2))
+ goto drop;
+ skb_push(skb, 2);
+ skb->data[0] = PPP_ALLSTATIONS;
+ skb->data[1] = PPP_UI;
+ flags |= XMIT_PUSH_AC;
+ }
+
+ /*
+ * Set the wakeup flag before attempting to queue and clear on success,
+ * so a concurrent ppposeq_recvmsg that frees space cannot miss it.
+ * Spurious wakeups may only happen during the brief queue window,
+ * not on every frame.
+ */
+ set_bit(XMIT_WAKEUP, &ps->opt.xmit_flags);
+ smp_mb__after_atomic();
+
+ /* Bypass receive filter machinery where the helper is available. */
+ err = ppposeq_queue_rcv_skb(sk, skb);
+ if (unlikely(err < 0)) {
+ /*
+ * Receive queue full. Restore the frame and ask ppp_generic to
+ * retry: it requeues the skb, so do not free it here.
+ */
+ if (flags & XMIT_PUSH_AC)
+ __skb_pull(skb, 2);
+ if (flags & XMIT_PULL_PROT)
+ *(u8 *)skb_push(skb, 1) = 0;
+ return 0;
+ }
+
+ clear_bit(XMIT_WAKEUP, &ps->opt.xmit_flags);
+ return 1;
+
+drop:
+ kfree_skb(skb);
+ return 1;
+}
+
+/*
+ * Channel ioctls. The framing-related ones ppp_synctty implements
+ * (PPPIOC[GS]ASYNCMAP, PPPIOC[GS]RASYNCMAP, PPPIOC[GS]XASYNCMAP) have no
+ * meaning without async framing, so only flags and MRU carry over.
+ */
+static int ppposeq_chan_ioctl(struct ppp_channel *chan, unsigned int cmd,
+ unsigned long arg)
+{
+ struct sock *sk = (struct sock *)chan->private;
+ struct ppposeq_sock *ps = ppposeq_sk(sk);
+ void __user *argp = (void __user *)arg;
+ int err, val;
+
+ err = -EFAULT;
+ switch (cmd) {
+ case PPPIOCGFLAGS:
+ if (put_user(ps->opt.flags, (int __user *)argp))
+ break;
+ err = 0;
+ break;
+ case PPPIOCSFLAGS:
+ if (get_user(val, (int __user *)argp))
+ break;
+ ps->opt.flags = val & ~SC_RCV_BITS;
+ err = 0;
+ break;
+ case PPPIOCGMRU:
+ if (put_user(ps->opt.mru, (int __user *)argp))
+ break;
+ err = 0;
+ break;
+ case PPPIOCSMRU:
+ if (get_user(val, (int __user *)argp))
+ break;
+ if (val > U16_MAX) {
+ err = -EINVAL;
+ break;
+ }
+ if (val < PPP_MRU)
+ val = PPP_MRU;
+ ps->opt.mru = val;
+ err = 0;
+ break;
+ default:
+ err = -ENOTTY;
+ break;
+ }
+
+ return err;
+}
+
+static const struct ppp_channel_ops ppposeq_chan_ops = {
+ .start_xmit = ppposeq_xmit,
+ .ioctl = ppposeq_chan_ioctl,
+};
+
+/*
+ * Receive: userspace -> kernel. One sendmsg is one frame, so there is no
+ * reassembly to do -- just validate and hand it to the ppp layer.
+ */
+#if LINUX_VERSION_CODE < KERNEL_VERSION(4,1,0)
+static int ppposeq_sendmsg(struct kiocb *iocb, struct socket *sock,
+ struct msghdr *m, size_t total_len)
+#else
+static int ppposeq_sendmsg(struct socket *sock, struct msghdr *m,
+ size_t total_len)
+#endif
+{
+ struct sock *sk = sock->sk;
+ struct ppposeq_sock *ps = ppposeq_sk(sk);
+ struct pppox_sock *po = pppox_sk(sk);
+ struct sk_buff *skb;
+ int err;
+ u8 *data;
+
+ if (total_len == 0)
+ return 0;
+
+ lock_sock(sk);
+
+ if (sock_flag(sk, SOCK_DEAD) || !(sk->sk_state & PPPOX_CONNECTED)) {
+ err = -ENOTCONN;
+ goto out;
+ }
+
+ if (total_len > ps->opt.mru + PPP_HDRLEN) {
+ err = -EMSGSIZE;
+ goto out;
+ }
+
+ /* plus headroom for network and PFC decompression */
+ skb = sock_alloc_send_skb(sk, NET_SKB_PAD + 2 + total_len,
+ m->msg_flags & MSG_DONTWAIT, &err);
+ if (!skb)
+ goto out;
+ skb_reserve(skb, NET_SKB_PAD + 2);
+
+ err = memcpy_from_msg(skb_put(skb, total_len), m, total_len);
+ if (err) {
+ kfree_skb(skb);
+ goto out;
+ }
+
+ /* strip address/control field if present */
+ data = skb->data;
+ if (data[0] == PPP_ALLSTATIONS) {
+ /* chop off address/control */
+ if (skb->len < 3 || data[1] != PPP_UI) {
+ kfree_skb(skb);
+ err = -EINVAL;
+ goto out;
+ }
+ data = skb_pull(skb, 2);
+ }
+
+ /* decompress protocol field if compressed */
+ if (data[0] & 0x01) {
+ *(u8 *)skb_push(skb, 1) = 0;
+ } else if (skb->len < 2) {
+ kfree_skb(skb);
+ err = -EINVAL;
+ goto out;
+ }
+
+ ppp_input(&po->chan, skb);
+ err = total_len;
+
+out:
+ release_sock(sk);
+ return err;
+}
+
+#if LINUX_VERSION_CODE < KERNEL_VERSION(4,1,0)
+static int ppposeq_recvmsg(struct kiocb *iocb, struct socket *sock,
+ struct msghdr *m, size_t total_len, int flags)
+#else
+static int ppposeq_recvmsg(struct socket *sock, struct msghdr *m,
+ size_t total_len, int flags)
+#endif
+{
+ struct sock *sk = sock->sk;
+ struct ppposeq_sock *ps = ppposeq_sk(sk);
+ struct pppox_sock *po = pppox_sk(sk);
+ struct sk_buff *skb;
+ int err;
+
+ if (flags & MSG_OOB)
+ return -EOPNOTSUPP;
+
+ skb = ppposeq_recv_datagram(sk, flags, &err);
+ if (!skb)
+ return err;
+
+ if (total_len > skb->len)
+ total_len = skb->len;
+ else if (total_len < skb->len)
+ m->msg_flags |= MSG_TRUNC;
+
+ err = skb_copy_datagram_msg(skb, 0, m, total_len);
+ if (likely(err == 0))
+ err = (flags & MSG_TRUNC) ? skb->len : total_len;
+
+ skb_free_datagram(sk, skb);
+ if (flags & MSG_PEEK)
+ return err;
+
+ /* Pair with the barrier after XMIT_WAKEUP is set in xmit. */
+ smp_mb();
+
+ /* Room freed: let ppp_generic retry the restored PPP frame. */
+ if (test_bit(XMIT_WAKEUP, &ps->opt.xmit_flags))
+ ppp_output_wakeup(&po->chan);
+
+ return err;
+}
+
+/*
+ * connect() registers the ppp channel. There is no transport to look up --
+ * this socket is the endpoint -- so the address carries nothing but the
+ * family and protocol.
+ */
+static int ppposeq_connect(struct socket *sock, struct sockaddr_unsized *uservaddr,
+ int sockaddr_len, int flags)
+{
+ struct sock *sk = sock->sk;
+ struct sockaddr_pppox *sp = (struct sockaddr_pppox *)uservaddr;
+ struct ppposeq_sock *ps = ppposeq_sk(sk);
+ struct pppox_sock *po = pppox_sk(sk);
+ int err;
+
+ if (sockaddr_len < sizeof(struct sockaddr_ppposeq))
+ return -EINVAL;
+
+ if (sp->sa_protocol != PX_PROTO_OSEQ)
+ return -EINVAL;
+
+ lock_sock(sk);
+
+ if (sk->sk_state & PPPOX_CONNECTED) {
+ err = -EBUSY;
+ goto out;
+ }
+
+ if (sk->sk_state & PPPOX_DEAD) {
+ err = -EALREADY;
+ goto out;
+ }
+
+ po->chan.private = sk;
+ po->chan.ops = &ppposeq_chan_ops;
+ po->chan.mtu = ps->opt.mru;
+ /* reserve the address/control bytes ppposeq_xmit prepends, so the
+ * core leaves us the headroom to skb_push them without a copy */
+ po->chan.hdrlen = 2;
+
+ err = ppp_register_net_channel(sock_net(sk), &po->chan);
+ if (err)
+ goto out;
+
+ sk->sk_state = PPPOX_CONNECTED;
+ sock->state = SS_CONNECTED;
+
+out:
+ release_sock(sk);
+ return err;
+}
+
+static int ppposeq_release(struct socket *sock)
+{
+ struct sock *sk = sock->sk;
+
+ if (!sk)
+ return 0;
+
+ lock_sock(sk);
+
+ if (sock_flag(sk, SOCK_DEAD)) {
+ release_sock(sk);
+ return -EBADF;
+ }
+
+ if (sk->sk_state & PPPOX_CONNECTED)
+ pppox_unbind_sock(sk);
+
+ /* signal the death of the socket before dropping the lock */
+ sk->sk_state = PPPOX_DEAD;
+ sock_orphan(sk);
+ sock->sk = NULL;
+
+ skb_queue_purge(&sk->sk_receive_queue);
+ release_sock(sk);
+ sock_put(sk);
+
+ return 0;
+}
+
+/* getname returned the length via *len until 4.17, by return value after */
+#if LINUX_VERSION_CODE < KERNEL_VERSION(4,17,0)
+static int ppposeq_getname(struct socket *sock, struct sockaddr *uaddr,
+ int *len, int peer)
+#else
+static int ppposeq_getname(struct socket *sock, struct sockaddr *uaddr,
+ int peer)
+#endif
+{
+ struct sockaddr_ppposeq sp;
+
+ memset(&sp, 0, sizeof(sp));
+ sp.sa_family = AF_PPPOX;
+ sp.sa_protocol = PX_PROTO_OSEQ;
+ memcpy(uaddr, &sp, sizeof(sp));
+
+#if LINUX_VERSION_CODE < KERNEL_VERSION(4,17,0)
+ *len = sizeof(sp);
+ return 0;
+#else
+ return sizeof(sp);
+#endif
+}
+
+/* pppox_proto.create gained a trailing kern argument in 4.2 */
+#if LINUX_VERSION_CODE < KERNEL_VERSION(4,2,0)
+static int ppposeq_create(struct net *net, struct socket *sock)
+#else
+static int ppposeq_create(struct net *net, struct socket *sock, int kern)
+#endif
+{
+ struct sock *sk;
+
+ sk = ppposeq_sk_alloc(net, PF_PPPOX, GFP_KERNEL, &ppposeq_sk_proto, kern);
+ if (!sk)
+ return -ENOMEM;
+
+ sock_init_data(sock, sk);
+
+ sock->state = SS_UNCONNECTED;
+ sock->ops = &ppposeq_ops;
+
+ sk->sk_state = PPPOX_NONE;
+ sk->sk_type = SOCK_SEQPACKET;
+ sk->sk_family = PF_PPPOX;
+ sk->sk_protocol = PX_PROTO_OSEQ;
+
+ ppposeq_sk(sk)->opt.mru = PPP_MRU;
+
+ return 0;
+}
+
+static const struct proto_ops ppposeq_ops = {
+ .family = AF_PPPOX,
+ .owner = THIS_MODULE,
+ .release = ppposeq_release,
+ .bind = sock_no_bind,
+ .connect = ppposeq_connect,
+ .socketpair = sock_no_socketpair,
+ .accept = sock_no_accept,
+ .getname = ppposeq_getname,
+ .poll = datagram_poll,
+ .listen = sock_no_listen,
+ .shutdown = sock_no_shutdown,
+ /* sock_no_setsockopt/getsockopt were removed and the proto_ops
+ * signatures changed to sockptr_t in 5.9 */
+#if LINUX_VERSION_CODE < KERNEL_VERSION(5,9,0)
+ .setsockopt = sock_no_setsockopt,
+ .getsockopt = sock_no_getsockopt,
+#endif
+ .sendmsg = ppposeq_sendmsg,
+ .recvmsg = ppposeq_recvmsg,
+ .mmap = sock_no_mmap,
+ .ioctl = pppox_ioctl,
+ /* pppox_compat_ioctl was added in 5.3; before that the core
+ * routed compat ioctls through .ioctl itself */
+#if defined(CONFIG_COMPAT) && LINUX_VERSION_CODE >= KERNEL_VERSION(5,3,0)
+ .compat_ioctl = pppox_compat_ioctl,
+#endif
+};
+
+static const struct pppox_proto ppposeq_proto = {
+ .create = ppposeq_create,
+ .ioctl = NULL, /* pppox_ioctl handles PPPIOCGCHAN for us */
+ .owner = THIS_MODULE,
+};
+
+static int __init ppposeq_init(void)
+{
+ int err;
+
+ err = proto_register(&ppposeq_sk_proto, 0);
+ if (err)
+ return err;
+
+ err = register_pppox_proto(PX_PROTO_OSEQ, &ppposeq_proto);
+ if (err)
+ goto out_unregister_proto;
+
+ pr_info("PPP over SEQPACKET socket driver\n");
+ return 0;
+
+out_unregister_proto:
+ proto_unregister(&ppposeq_sk_proto);
+ return err;
+}
+
+static void __exit ppposeq_exit(void)
+{
+ unregister_pppox_proto(PX_PROTO_OSEQ);
+ proto_unregister(&ppposeq_sk_proto);
+}
+
+module_init(ppposeq_init);
+module_exit(ppposeq_exit);
+
+MODULE_DESCRIPTION("PPP over SEQPACKET socket driver");
+MODULE_AUTHOR("Vladislav Grishenko");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS_NET_PF_PROTO(PF_PPPOX, PX_PROTO_OSEQ);
diff --git a/drivers/ppposeq/ppposeq.h b/drivers/ppposeq/ppposeq.h
new file mode 100644
index 00000000..b16fdce1
--- /dev/null
+++ b/drivers/ppposeq/ppposeq.h
@@ -0,0 +1,39 @@
+/*
+ * ppposeq - PPP over a SEQPACKET AF_PPPOX socket.
+ *
+ * Replaces the pty + ppp_async transport for userspace PPP terminators.
+ * A pty is a byte stream, so frame boundaries are lost in the tty flip
+ * buffer and have to be rebuilt with HDLC escape+FCS framing.
+ * Here the socket itself is the PPP endpoint and each datagram carries
+ * exactly one PPP frame, so no HDLC framing is needed on either side.
+ *
+ * fd = socket(AF_PPPOX, SOCK_SEQPACKET, PX_PROTO_OSEQ);
+ * connect(fd, &sa, sizeof(sa)); // registers the channel
+ * ioctl(fd, PPPIOCGCHAN, &idx);
+ * chan = open("/dev/ppp"); ioctl(chan, PPPIOCATTCHAN, &idx);
+ * // frames flow over fd with send()/recv()
+ *
+ * Only the protocol number is new; everything else uses the common
+ * AF_PPPOX and PPPIOC* interfaces.
+ */
+
+#ifndef __PPPOSEQ_H
+#define __PPPOSEQ_H
+
+#include <linux/if_pppox.h>
+#include <linux/version.h>
+
+#if LINUX_VERSION_CODE < KERNEL_VERSION(3,1,0)
+typedef sa_family_t __kernel_sa_family_t;
+#endif
+
+#ifndef PX_PROTO_OSEQ
+#define PX_PROTO_OSEQ 3
+#endif
+
+struct sockaddr_ppposeq {
+ __kernel_sa_family_t sa_family; /* AF_PPPOX */
+ unsigned int sa_protocol; /* PX_PROTO_OSEQ */
+} __attribute__((packed));
+
+#endif
diff --git a/drivers/pptp/gre.c b/drivers/pptp/gre.c
deleted file mode 100644
index a3c9625a..00000000
--- a/drivers/pptp/gre.c
+++ /dev/null
@@ -1,220 +0,0 @@
-#include <linux/module.h>
-#include <linux/kernel.h>
-#include <linux/init.h>
-#include <linux/skbuff.h>
-#include <linux/in.h>
-#include <linux/netdevice.h>
-#include <linux/version.h>
-#include <linux/spinlock.h>
-#include <net/protocol.h>
-
-#include "gre.h"
-
-struct gre_protocol *gre_proto[GREPROTO_MAX] ____cacheline_aligned_in_smp;
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
-static rwlock_t gre_proto_lock=RW_LOCK_UNLOCKED;
-#else
-static DEFINE_SPINLOCK(gre_proto_lock);
-#endif
-
-int gre_add_protocol(struct gre_protocol *proto, u8 version)
-{
- int ret;
-
- if (version >= GREPROTO_MAX)
- return -EINVAL;
-
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
- write_lock_bh(&gre_proto_lock);
-#else
- spin_lock(&gre_proto_lock);
-#endif
- if (gre_proto[version]) {
- ret = -EAGAIN;
- } else {
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
- gre_proto[version] = proto;
-#else
- rcu_assign_pointer(gre_proto[version], proto);
-#endif
- ret = 0;
- }
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
- write_unlock_bh(&gre_proto_lock);
-#else
- spin_unlock(&gre_proto_lock);
-#endif
-
- return ret;
-}
-
-int gre_del_protocol(struct gre_protocol *proto, u8 version)
-{
- if (version >= GREPROTO_MAX)
- goto out_err;
-
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
- write_lock_bh(&gre_proto_lock);
-#else
- spin_lock(&gre_proto_lock);
-#endif
- if (gre_proto[version] == proto)
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
- gre_proto[version] = NULL;
-#else
- rcu_assign_pointer(gre_proto[version], NULL);
-#endif
- else
- goto out_err_unlock;
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
- write_unlock_bh(&gre_proto_lock);
-#else
- spin_unlock(&gre_proto_lock);
- synchronize_rcu();
-#endif
- return 0;
-
-out_err_unlock:
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
- write_unlock_bh(&gre_proto_lock);
-#else
- spin_unlock(&gre_proto_lock);
-#endif
-out_err:
- return -EINVAL;
-}
-
-static int gre_rcv(struct sk_buff *skb)
-{
- u8 ver;
- int ret;
- struct gre_protocol *proto;
-
- if (!pskb_may_pull(skb, 12))
- goto drop_nolock;
-
- ver = skb->data[1]&0x7f;
- if (ver >= GREPROTO_MAX)
- goto drop_nolock;
-
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
- read_lock(&gre_proto_lock);
- proto = gre_proto[ver];
-#else
- rcu_read_lock();
- proto = rcu_dereference(gre_proto[ver]);
-#endif
- if (!proto || !proto->handler)
- goto drop;
-
- ret = proto->handler(skb);
-
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
- read_unlock(&gre_proto_lock);
-#else
- rcu_read_unlock();
-#endif
-
- return ret;
-
-drop:
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
- read_unlock(&gre_proto_lock);
-#else
- rcu_read_unlock();
-#endif
-drop_nolock:
- kfree_skb(skb);
- return NET_RX_DROP;
-}
-
-static void gre_err(struct sk_buff *skb, u32 info)
-{
- u8 ver;
- struct gre_protocol *proto;
-
- if (!pskb_may_pull(skb, 12))
- goto drop_nolock;
-
- ver=skb->data[1]&0x7f;
- if (ver>=GREPROTO_MAX)
- goto drop_nolock;
-
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
- read_lock(&gre_proto_lock);
- proto = gre_proto[ver];
-#else
- rcu_read_lock();
- proto = rcu_dereference(gre_proto[ver]);
-#endif
- if (!proto || !proto->err_handler)
- goto drop;
-
- proto->err_handler(skb, info);
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
- read_unlock(&gre_proto_lock);
-#else
- rcu_read_unlock();
-#endif
-
- return;
-
-drop:
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
- read_unlock(&gre_proto_lock);
-#else
- rcu_read_unlock();
-#endif
-drop_nolock:
- kfree_skb(skb);
-}
-
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
-static struct inet_protocol net_gre_protocol = {
- .handler = gre_rcv,
- .err_handler = gre_err,
- .protocol = IPPROTO_GRE,
- .name = "GRE",
-};
-#else
-static struct net_protocol net_gre_protocol = {
- .handler = gre_rcv,
- .err_handler = gre_err,
-#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,24)
- .netns_ok=1,
-#endif
-};
-#endif
-
-static int __init gre_init(void)
-{
- printk(KERN_INFO "GRE over IPv4 demultiplexor driver");
-
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
- inet_add_protocol(&net_gre_protocol);
-#else
- if (inet_add_protocol(&net_gre_protocol, IPPROTO_GRE) < 0) {
- printk(KERN_INFO "gre: can't add protocol\n");
- return -EAGAIN;
- }
-#endif
- return 0;
-}
-
-static void __exit gre_exit(void)
-{
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
- inet_del_protocol(&net_gre_protocol);
-#else
- inet_del_protocol(&net_gre_protocol, IPPROTO_GRE);
-#endif
-}
-
-module_init(gre_init);
-module_exit(gre_exit);
-
-MODULE_DESCRIPTION("GRE over IPv4 demultiplexor driver");
-MODULE_AUTHOR("Kozlov D. (xeb@mail.ru)");
-MODULE_LICENSE("GPL");
-EXPORT_SYMBOL_GPL(gre_add_protocol);
-EXPORT_SYMBOL_GPL(gre_del_protocol);
diff --git a/drivers/pptp/gre.h b/drivers/pptp/gre.h
deleted file mode 100644
index 2ca7f749..00000000
--- a/drivers/pptp/gre.h
+++ /dev/null
@@ -1,18 +0,0 @@
-#ifndef __LINUX_GRE_H
-#define __LINUX_GRE_H
-
-#include <linux/skbuff.h>
-
-#define GREPROTO_CISCO 0
-#define GREPROTO_PPTP 1
-#define GREPROTO_MAX 2
-
-struct gre_protocol {
- int (*handler)(struct sk_buff *skb);
- void (*err_handler)(struct sk_buff *skb, u32 info);
-};
-
-int gre_add_protocol(struct gre_protocol *proto, u8 version);
-int gre_del_protocol(struct gre_protocol *proto, u8 version);
-
-#endif
diff --git a/drivers/pptp/if_pppox.h b/drivers/pptp/if_pppox.h
deleted file mode 100644
index bc05b533..00000000
--- a/drivers/pptp/if_pppox.h
+++ /dev/null
@@ -1,222 +0,0 @@
-/***************************************************************************
- * Linux PPP over X - Generic PPP transport layer sockets
- * Linux PPP over Ethernet (PPPoE) Socket Implementation (RFC 2516)
- *
- * This file supplies definitions required by the PPP over Ethernet driver
- * (pppox.c). All version information wrt this file is located in pppox.c
- *
- * License:
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version
- * 2 of the License, or (at your option) any later version.
- *
- */
-
-#ifndef __LINUX_IF_PPPOX_H
-#define __LINUX_IF_PPPOX_H
-
-
-#include <asm/types.h>
-#include <asm/byteorder.h>
-#include <linux/version.h>
-
-#ifdef __KERNEL__
-#include <linux/in.h>
-#include <linux/if_ether.h>
-#include <linux/if.h>
-#include <linux/netdevice.h>
-#include <linux/ppp_channel.h>
-#endif /* __KERNEL__ */
-
-/* For user-space programs to pick up these definitions
- * which they wouldn't get otherwise without defining __KERNEL__
- */
-#ifndef AF_PPPOX
-#define AF_PPPOX 24
-#define PF_PPPOX AF_PPPOX
-#endif /* !(AF_PPPOX) */
-
-/************************************************************************
- * PPPoE addressing definition
- */
-typedef __u16 sid_t;
-struct pppoe_addr{
- sid_t sid; /* Session identifier */
- unsigned char remote[ETH_ALEN]; /* Remote address */
- char dev[IFNAMSIZ]; /* Local device to use */
-};
-
-struct pptp_addr{
- __u16 call_id;
- struct in_addr sin_addr;
-};
-/************************************************************************
- * Protocols supported by AF_PPPOX
- */
-#define PX_PROTO_OE 0 /* Currently just PPPoE */
-#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,22)
-#define PX_PROTO_PPTP 1
-#define PX_MAX_PROTO 2
-#else
-#define PX_PROTO_PPTP 2
-#define PX_MAX_PROTO 3
-#endif
-
-struct sockaddr_pppox {
- sa_family_t sa_family; /* address family, AF_PPPOX */
- unsigned int sa_protocol; /* protocol identifier */
- union{
- struct pppoe_addr pppoe;
- struct pptp_addr pptp;
- }sa_addr;
-}__attribute__ ((packed));
-
-
-/*********************************************************************
- *
- * ioctl interface for defining forwarding of connections
- *
- ********************************************************************/
-
-#define PPPOEIOCSFWD _IOW(0xB1 ,0, size_t)
-#define PPPOEIOCDFWD _IO(0xB1 ,1)
-/*#define PPPOEIOCGFWD _IOWR(0xB1,2, size_t)*/
-
-/* Codes to identify message types */
-#define PADI_CODE 0x09
-#define PADO_CODE 0x07
-#define PADR_CODE 0x19
-#define PADS_CODE 0x65
-#define PADT_CODE 0xa7
-struct pppoe_tag {
- __u16 tag_type;
- __u16 tag_len;
- char tag_data[0];
-} __attribute ((packed));
-
-/* Tag identifiers */
-#define PTT_EOL __constant_htons(0x0000)
-#define PTT_SRV_NAME __constant_htons(0x0101)
-#define PTT_AC_NAME __constant_htons(0x0102)
-#define PTT_HOST_UNIQ __constant_htons(0x0103)
-#define PTT_AC_COOKIE __constant_htons(0x0104)
-#define PTT_VENDOR __constant_htons(0x0105)
-#define PTT_RELAY_SID __constant_htons(0x0110)
-#define PTT_SRV_ERR __constant_htons(0x0201)
-#define PTT_SYS_ERR __constant_htons(0x0202)
-#define PTT_GEN_ERR __constant_htons(0x0203)
-
-struct pppoe_hdr {
-#if defined(__LITTLE_ENDIAN_BITFIELD)
- __u8 ver : 4;
- __u8 type : 4;
-#elif defined(__BIG_ENDIAN_BITFIELD)
- __u8 type : 4;
- __u8 ver : 4;
-#else
-#error "Please fix <asm/byteorder.h>"
-#endif
- __u8 code;
- __u16 sid;
- __u16 length;
- struct pppoe_tag tag[0];
-} __attribute__ ((packed));
-
-
-/* Socket options */
-#define PPTP_SO_TIMEOUT 1
-
-
-#ifdef __KERNEL__
-#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,0)
-struct pppoe_opt {
- struct net_device *dev; /* device associated with socket*/
- struct pppoe_addr pa; /* what this socket is bound to*/
- struct sockaddr_pppox relay; /* what socket data will be
- relayed to (PPPoE relaying) */
-};
-#endif
-struct pptp_opt {
- struct pptp_addr src_addr;
- struct pptp_addr dst_addr;
- __u32 ack_sent, ack_recv;
- __u32 seq_sent, seq_recv;
- int ppp_flags;
-};
-#define PPTP_FLAG_PAUSE 0
-#define PPTP_FLAG_PROC 1
-
-#include <net/sock.h>
-
-struct pppox_sock {
- /* struct sock must be the first member of pppox_sock */
- #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
- struct ppp_channel chan;
- struct sock *sk;
- #else
- struct sock sk;
- struct ppp_channel chan;
- #endif
- struct pppox_sock *next; /* for hash table */
- union {
- struct pppoe_opt pppoe;
- struct pptp_opt pptp;
- } proto;
- unsigned short num;
-};
-#define pppoe_dev proto.pppoe.dev
-#define pppoe_pa proto.pppoe.pa
-#define pppoe_relay proto.pppoe.relay
-
-static inline struct pppox_sock *pppox_sk(struct sock *sk)
-{
- #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
- return (struct pppox_sock *)sk->protinfo.pppox;
- #else
- return (struct pppox_sock *)sk;
- #endif
-}
-
-static inline struct sock *sk_pppox(struct pppox_sock *po)
-{
- #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
- return po->sk;
- #else
- return (struct sock *)po;
- #endif
-}
-
-struct module;
-
-struct pppox_proto {
- #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
- int (*create)(struct socket *sock);
- #else
- int (*create)(struct net *net, struct socket *sock);
- #endif
- int (*ioctl)(struct socket *sock, unsigned int cmd,
- unsigned long arg);
- #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,15)
- struct module *owner;
- #endif
-};
-
-extern int register_pppox_proto(int proto_num, struct pppox_proto *pp);
-extern void unregister_pppox_proto(int proto_num);
-extern void pppox_unbind_sock(struct sock *sk);/* delete ppp-channel binding */
-extern int pppox_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg);
-
-/* PPPoX socket states */
-enum {
- PPPOX_NONE = 0, /* initial state */
- PPPOX_CONNECTED = 1, /* connection established ==TCP_ESTABLISHED */
- PPPOX_BOUND = 2, /* bound to ppp device */
- PPPOX_RELAY = 4, /* forwarding is enabled */
- PPPOX_ZOMBIE = 8, /* dead, but still bound to ppp device */
- PPPOX_DEAD = 16 /* dead, useless, please clean me up!*/
-};
-
-#endif /* __KERNEL__ */
-
-#endif /* !(__LINUX_IF_PPPOX_H) */
diff --git a/drivers/pptp/pptp.c b/drivers/pptp/pptp.c
deleted file mode 100644
index 3226bdf1..00000000
--- a/drivers/pptp/pptp.c
+++ /dev/null
@@ -1,1272 +0,0 @@
-/*
- * Point-to-Point Tunneling Protocol for Linux
- *
- * Authors: Kozlov D. (xeb@mail.ru)
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version
- * 2 of the License, or (at your option) any later version.
- *
- */
-
-#include <linux/string.h>
-#include <linux/module.h>
-#include <linux/kernel.h>
-#include <linux/slab.h>
-#include <linux/errno.h>
-#include <linux/netdevice.h>
-#include <linux/net.h>
-#include <linux/skbuff.h>
-#include <linux/init.h>
-#include <linux/ppp_channel.h>
-#include <linux/ppp_defs.h>
-#include "if_pppox.h"
-#include <linux/if_ppp.h>
-#include <linux/notifier.h>
-#include <linux/file.h>
-#include <linux/in.h>
-#include <linux/ip.h>
-#include <linux/netfilter.h>
-#include <linux/netfilter_ipv4.h>
-#include <linux/version.h>
-
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
-#include <asm/bitops.h>
-#endif
-
-#include <net/sock.h>
-#include <net/protocol.h>
-#include <net/ip.h>
-#include <net/icmp.h>
-#include <net/route.h>
-
-#include <asm/uaccess.h>
-
-#define DEBUG
-//#define CONFIG_GRE
-
-#if defined(CONFIG_GRE) || defined(CONFIG_GRE_MODULE)
-#include "gre.h"
-#endif
-
-#define PPTP_DRIVER_VERSION "0.8.5"
-
-static int log_level=0;
-static int log_packets=10;
-
-#define MAX_CALLID 65535
-#define PPP_LCP_ECHOREQ 0x09
-#define PPP_LCP_ECHOREP 0x0A
-
-static DECLARE_BITMAP(callid_bitmap, MAX_CALLID + 1);
-static struct pppox_sock **callid_sock;
-
-#define SC_RCV_BITS (SC_RCV_B7_1|SC_RCV_B7_0|SC_RCV_ODDP|SC_RCV_EVNP)
-
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
-#define INIT_TIMER(_timer,_routine,_data) \
-do { \
- (_timer)->function=_routine; \
- (_timer)->data=_data; \
- init_timer(_timer); \
-} while (0);
-
-static inline void *kzalloc(size_t size,int gfp)
-{
- void *p=kmalloc(size,gfp);
- memset(p,0,size);
- return p;
-}
-
-#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,4,20)
-static inline void nf_reset(struct sk_buff *skb)
-{
-#ifdef CONFIG_NETFILTER
- nf_conntrack_put(skb->nfct);
- skb->nfct=NULL;
-#ifdef CONFIG_NETFILTER_DEBUG
- skb->nf_debug=0;
-#endif
-#endif
-}
-#define __user
-#endif
-
-/**
- * __ffs - find first bit in word.
- * @word: The word to search
- *
- * Undefined if no bit exists, so code should check against 0 first.
- */
-static inline unsigned long __ffs(unsigned long word)
-{
- int num = 0;
-
-#if BITS_PER_LONG == 64
- if ((word & 0xffffffff) == 0) {
- num += 32;
- word >>= 32;
- }
-#endif
- if ((word & 0xffff) == 0) {
- num += 16;
- word >>= 16;
- }
- if ((word & 0xff) == 0) {
- num += 8;
- word >>= 8;
- }
- if ((word & 0xf) == 0) {
- num += 4;
- word >>= 4;
- }
- if ((word & 0x3) == 0) {
- num += 2;
- word >>= 2;
- }
- if ((word & 0x1) == 0)
- num += 1;
- return num;
-}
-
-#define BITOP_WORD(nr) ((nr) / BITS_PER_LONG)
-/*
- * Find the next set bit in a memory region.
- */
-static unsigned long find_next_bit(const unsigned long *addr, unsigned long size,
- unsigned long offset)
-{
- const unsigned long *p = addr + BITOP_WORD(offset);
- unsigned long result = offset & ~(BITS_PER_LONG-1);
- unsigned long tmp;
-
- if (offset >= size)
- return size;
- size -= result;
- offset %= BITS_PER_LONG;
- if (offset) {
- tmp = *(p++);
- tmp &= (~0UL << offset);
- if (size < BITS_PER_LONG)
- goto found_first;
- if (tmp)
- goto found_middle;
- size -= BITS_PER_LONG;
- result += BITS_PER_LONG;
- }
- while (size & ~(BITS_PER_LONG-1)) {
- if ((tmp = *(p++)))
- goto found_middle;
- result += BITS_PER_LONG;
- size -= BITS_PER_LONG;
- }
- if (!size)
- return result;
- tmp = *p;
-
-found_first:
- tmp &= (~0UL >> (BITS_PER_LONG - size));
- if (tmp == 0UL) /* Are any bits set? */
- return result + size; /* Nope. */
-found_middle:
- return result + __ffs(tmp);
-}
-#endif
-
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
-static rwlock_t chan_lock=RW_LOCK_UNLOCKED;
-#define SK_STATE(sk) (sk)->state
-#else
-static DEFINE_SPINLOCK(chan_lock);
-#define SK_STATE(sk) (sk)->sk_state
-#endif
-
-static int pptp_xmit(struct ppp_channel *chan, struct sk_buff *skb);
-static int pptp_ppp_ioctl(struct ppp_channel *chan, unsigned int cmd,
- unsigned long arg);
-static int pptp_rcv_core(struct sock *sk,struct sk_buff *skb);
-
-static struct ppp_channel_ops pptp_chan_ops= {
- .start_xmit = pptp_xmit,
- .ioctl=pptp_ppp_ioctl,
-};
-
-
-#define MISSING_WINDOW 20
-#define WRAPPED( curseq, lastseq) \
- ((((curseq) & 0xffffff00) == 0) && \
- (((lastseq) & 0xffffff00 ) == 0xffffff00))
-
-/* gre header structure: -------------------------------------------- */
-
-#define PPTP_GRE_PROTO 0x880B
-#define PPTP_GRE_VER 0x1
-
-#define PPTP_GRE_FLAG_C 0x80
-#define PPTP_GRE_FLAG_R 0x40
-#define PPTP_GRE_FLAG_K 0x20
-#define PPTP_GRE_FLAG_S 0x10
-#define PPTP_GRE_FLAG_A 0x80
-
-#define PPTP_GRE_IS_C(f) ((f)&PPTP_GRE_FLAG_C)
-#define PPTP_GRE_IS_R(f) ((f)&PPTP_GRE_FLAG_R)
-#define PPTP_GRE_IS_K(f) ((f)&PPTP_GRE_FLAG_K)
-#define PPTP_GRE_IS_S(f) ((f)&PPTP_GRE_FLAG_S)
-#define PPTP_GRE_IS_A(f) ((f)&PPTP_GRE_FLAG_A)
-
-struct pptp_gre_header {
- u8 flags; /* bitfield */
- u8 ver; /* should be PPTP_GRE_VER (enhanced GRE) */
- u16 protocol; /* should be PPTP_GRE_PROTO (ppp-encaps) */
- u16 payload_len; /* size of ppp payload, not inc. gre header */
- u16 call_id; /* peer's call_id for this session */
- u32 seq; /* sequence number. Present if S==1 */
- u32 ack; /* seq number of highest packet recieved by */
- /* sender in this session */
-} __packed;
-#define PPTP_HEADER_OVERHEAD (2+sizeof(struct pptp_gre_header))
-
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
-static struct pppox_sock * lookup_chan(u16 call_id, u32 s_addr)
-#else
-static struct pppox_sock * lookup_chan(u16 call_id, __be32 s_addr)
-#endif
-{
- struct pppox_sock *sock;
- struct pptp_opt *opt;
-
-#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,0)
- rcu_read_lock();
- sock = rcu_dereference(callid_sock[call_id]);
-#else
- read_lock(&chan_lock);
- sock = callid_sock[call_id];
-#endif
- if (sock) {
- opt=&sock->proto.pptp;
- if (opt->dst_addr.sin_addr.s_addr!=s_addr) sock=NULL;
- else sock_hold(sk_pppox(sock));
- }
-#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,0)
- rcu_read_unlock();
-#else
- read_unlock(&chan_lock);
-#endif
-
- return sock;
-}
-
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
-static int lookup_chan_dst(u16 call_id, u32 d_addr)
-#else
-static int lookup_chan_dst(u16 call_id, __be32 d_addr)
-#endif
-{
- struct pppox_sock *sock;
- struct pptp_opt *opt;
- int i;
-
-#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,0)
- rcu_read_lock();
-#else
- down(&chan_lock);
-#endif
- for(i = find_next_bit(callid_bitmap,MAX_CALLID,1); i < MAX_CALLID;
- i = find_next_bit(callid_bitmap, MAX_CALLID, i + 1)){
-#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,0)
- sock = rcu_dereference(callid_sock[i]);
-#else
- sock = callid_sock[i];
-#endif
- if (!sock)
- continue;
- opt = &sock->proto.pptp;
- if (opt->dst_addr.call_id == call_id && opt->dst_addr.sin_addr.s_addr == d_addr) break;
- }
-#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,0)
- rcu_read_unlock();
-#else
- up(&chan_lock);
-#endif
-
- return i<MAX_CALLID;
-}
-
-static int add_chan(struct pppox_sock *sock)
-{
- static int call_id=0;
- int res=-1;
-
-#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,0)
- spin_lock(&chan_lock);
-#else
- write_lock_bh(&chan_lock);
-#endif
-
- if (!sock->proto.pptp.src_addr.call_id)
- {
- call_id=find_next_zero_bit(callid_bitmap,MAX_CALLID,call_id+1);
- if (call_id==MAX_CALLID)
- call_id=find_next_zero_bit(callid_bitmap,MAX_CALLID,1);
- sock->proto.pptp.src_addr.call_id=call_id;
- }
- else if (test_bit(sock->proto.pptp.src_addr.call_id,callid_bitmap))
- goto exit;
-
-#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,0)
- rcu_assign_pointer(callid_sock[sock->proto.pptp.src_addr.call_id],sock);
-#else
- callid_sock[sock->proto.pptp.src_addr.call_id] = sock;
-#endif
- set_bit(sock->proto.pptp.src_addr.call_id,callid_bitmap);
- res=0;
-
-exit:
- #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,0)
- spin_unlock(&chan_lock);
- #else
- write_unlock_bh(&chan_lock);
- #endif
-
- return res;
-}
-
-static void del_chan(struct pppox_sock *sock)
-{
-#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,0)
- spin_lock(&chan_lock);
-#else
- write_lock_bh(&chan_lock);
-#endif
- clear_bit(sock->proto.pptp.src_addr.call_id,callid_bitmap);
-#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,0)
- rcu_assign_pointer(callid_sock[sock->proto.pptp.src_addr.call_id],NULL);
- spin_unlock(&chan_lock);
- synchronize_rcu();
-#else
- callid_sock[sock->proto.pptp.src_addr.call_id] = NULL;
- write_unlock_bh(&chan_lock);
-#endif
-}
-
-static int pptp_xmit(struct ppp_channel *chan, struct sk_buff *skb)
-{
- struct sock *sk = (struct sock *) chan->private;
- struct pppox_sock *po = pppox_sk(sk);
- struct pptp_opt *opt=&po->proto.pptp;
- struct pptp_gre_header *hdr;
- unsigned int header_len=sizeof(*hdr);
- int err=0;
- int islcp;
- int len;
- unsigned char *data;
- u32 seq_recv;
-
-
- struct rtable *rt; /* Route to the other host */
- struct net_device *tdev; /* Device to other host */
- struct iphdr *iph; /* Our new IP header */
- int max_headroom; /* The extra header space needed */
-
- if (SK_STATE(sk_pppox(po)) & PPPOX_DEAD)
- goto tx_error;
-
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
- {
- struct rt_key key = {
- .dst=opt->dst_addr.sin_addr.s_addr,
- .src=opt->src_addr.sin_addr.s_addr,
- .tos=RT_TOS(0),
- };
- if ((err=ip_route_output_key(&rt, &key))) {
- goto tx_error;
- }
- }
-#else
- {
- struct flowi fl = { .oif = 0,
- .nl_u = { .ip4_u =
- { .daddr = opt->dst_addr.sin_addr.s_addr,
- .saddr = opt->src_addr.sin_addr.s_addr,
- .tos = RT_TOS(0) } },
- .proto = IPPROTO_GRE };
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25)
- if ((err=ip_route_output_key(&rt, &fl))) {
-#else
- if ((err=ip_route_output_key(&init_net,&rt, &fl))) {
-#endif
- goto tx_error;
- }
- }
-#endif
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,36)
- tdev = rt->u.dst.dev;
-#else
- tdev = rt->dst.dev;
-#endif
-
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
- max_headroom = ((tdev->hard_header_len+15)&~15) + sizeof(*iph)+sizeof(*hdr)+2;
-#else
- max_headroom = LL_RESERVED_SPACE(tdev) + sizeof(*iph)+sizeof(*hdr)+2;
-#endif
-
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22)
- if (skb_headroom(skb) < max_headroom || skb_cloned(skb) || skb_shared(skb)) {
-#else
- if (skb_headroom(skb) < max_headroom || skb_shared(skb) ||
- (skb_cloned(skb) && !skb_clone_writable(skb,0))) {
-#endif
- struct sk_buff *new_skb = skb_realloc_headroom(skb, max_headroom);
- if (!new_skb) {
- ip_rt_put(rt);
- goto tx_error;
- }
- if (skb->sk)
- skb_set_owner_w(new_skb, skb->sk);
- kfree_skb(skb);
- skb = new_skb;
- }
-
- data=skb->data;
- islcp=((data[0] << 8) + data[1])== PPP_LCP && 1 <= data[2] && data[2] <= 7;
-
- /* compress protocol field */
- if ((opt->ppp_flags & SC_COMP_PROT) && data[0]==0 && !islcp)
- skb_pull(skb,1);
-
- /*
- * Put in the address/control bytes if necessary
- */
- if ((opt->ppp_flags & SC_COMP_AC) == 0 || islcp) {
- data=skb_push(skb,2);
- data[0]=PPP_ALLSTATIONS;
- data[1]=PPP_UI;
- }
-
- len=skb->len;
-
- seq_recv = opt->seq_recv;
-
- if (opt->ack_sent == seq_recv) header_len-=sizeof(hdr->ack);
-
- // Push down and install GRE header
- skb_push(skb,header_len);
- hdr=(struct pptp_gre_header *)(skb->data);
-
- hdr->flags = PPTP_GRE_FLAG_K;
- hdr->ver = PPTP_GRE_VER;
- hdr->protocol = htons(PPTP_GRE_PROTO);
- hdr->call_id = htons(opt->dst_addr.call_id);
-
- hdr->flags |= PPTP_GRE_FLAG_S;
- hdr->seq = htonl(++opt->seq_sent);
-#ifdef DEBUG
- if (log_level>=3 && opt->seq_sent<=log_packets)
- printk(KERN_INFO"PPTP[%i]: send packet: seq=%i",opt->src_addr.call_id,opt->seq_sent);
-#endif
- if (opt->ack_sent != seq_recv) {
- /* send ack with this message */
- hdr->ver |= PPTP_GRE_FLAG_A;
- hdr->ack = htonl(seq_recv);
- opt->ack_sent = seq_recv;
-#ifdef DEBUG
- if (log_level>=3 && opt->seq_sent<=log_packets)
- printk(" ack=%i",seq_recv);
-#endif
- }
- hdr->payload_len = htons(len);
-#ifdef DEBUG
- if (log_level>=3 && opt->seq_sent<=log_packets)
- printk("\n");
-#endif
-
- /*
- * Push down and install the IP header.
- */
-
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,31)
- skb_reset_transport_header(skb);
- skb_push(skb, sizeof(*iph));
- skb_reset_network_header(skb);
-#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22)
- skb->transport_header = skb->network_header;
- skb_push(skb, sizeof(*iph));
- skb_reset_network_header(skb);
-#else
- skb->h.raw = skb->nh.raw;
- skb->nh.raw = skb_push(skb, sizeof(*iph));
-#endif
- memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
- IPCB(skb)->flags &= ~(IPSKB_XFRM_TUNNEL_SIZE | IPSKB_XFRM_TRANSFORMED |
- IPSKB_REROUTED);
-#endif
-
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22)
- iph = ip_hdr(skb);
-#else
- iph = skb->nh.iph;
-#endif
- iph->version = 4;
- iph->ihl = sizeof(struct iphdr) >> 2;
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,36)
- if (ip_dont_fragment(sk, &rt->u.dst))
-#else
- if (ip_dont_fragment(sk, &rt->dst))
-#endif
- iph->frag_off = htons(IP_DF);
- else
- iph->frag_off = 0;
- iph->protocol = IPPROTO_GRE;
- iph->tos = 0;
- iph->daddr = rt->rt_dst;
- iph->saddr = rt->rt_src;
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
- iph->ttl = sk->protinfo.af_inet.ttl;
-#else
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,36)
- iph->ttl = dst_metric(&rt->u.dst, RTAX_HOPLIMIT);
-#else
- iph->ttl = dst_metric(&rt->dst, RTAX_HOPLIMIT);
-#endif
-#endif
- iph->tot_len = htons(skb->len);
-
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,31)
- skb_dst_drop(skb);
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,36)
- skb_dst_set(skb,&rt->u.dst);
-#else
- skb_dst_set(skb,&rt->dst);
-#endif
-#else
- dst_release(skb->dst);
- skb->dst = &rt->u.dst;
-#endif
-
- nf_reset(skb);
-
- skb->ip_summed = CHECKSUM_NONE;
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,36)
- ip_select_ident(iph, &rt->u.dst, NULL);
-#else
- ip_select_ident(iph, &rt->dst, NULL);
-#endif
- ip_send_check(iph);
-
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
- err = NF_HOOK(PF_INET, NF_IP_LOCAL_OUT, skb, NULL, rt->u.dst.dev, ip_send);
-#elif LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25)
- err = NF_HOOK(PF_INET, NF_IP_LOCAL_OUT, skb, NULL, rt->u.dst.dev, dst_output);
-#else
- err = ip_local_out(skb);
-#endif
-
-tx_error:
- return 1;
-}
-
-static int pptp_rcv_core(struct sock *sk,struct sk_buff *skb)
-{
- struct pppox_sock *po = pppox_sk(sk);
- struct pptp_opt *opt=&po->proto.pptp;
- int headersize,payload_len,seq;
- u8 *payload;
- struct pptp_gre_header *header;
-
- if (!(SK_STATE(sk) & PPPOX_CONNECTED)) {
- if (sock_queue_rcv_skb(sk, skb))
- goto drop;
- return NET_RX_SUCCESS;
- }
-
- header = (struct pptp_gre_header *)(skb->data);
-
- /* test if acknowledgement present */
- if (PPTP_GRE_IS_A(header->ver)){
- u32 ack = (PPTP_GRE_IS_S(header->flags))?
- header->ack:header->seq; /* ack in different place if S = 0 */
-
- ack = ntohl( ack);
-
- if (ack > opt->ack_recv) opt->ack_recv = ack;
- /* also handle sequence number wrap-around */
- if (WRAPPED(ack,opt->ack_recv)) opt->ack_recv = ack;
- }
-
- /* test if payload present */
- if (!PPTP_GRE_IS_S(header->flags)){
- goto drop;
- }
-
- headersize = sizeof(*header);
- payload_len = ntohs(header->payload_len);
- seq = ntohl(header->seq);
-
- /* no ack present? */
- if (!PPTP_GRE_IS_A(header->ver)) headersize -= sizeof(header->ack);
- /* check for incomplete packet (length smaller than expected) */
- if (skb->len - headersize < payload_len){
-#ifdef DEBUG
- if (log_level>=1)
- printk(KERN_INFO"PPTP: discarding truncated packet (expected %d, got %d bytes)\n",
- payload_len, skb->len - headersize);
-#endif
- goto drop;
- }
-
- payload=skb->data+headersize;
- /* check for expected sequence number */
- if ( seq < opt->seq_recv + 1 || WRAPPED(opt->seq_recv, seq) ){
- if ( (payload[0] == PPP_ALLSTATIONS) && (payload[1] == PPP_UI) &&
- (PPP_PROTOCOL(payload) == PPP_LCP) &&
- ((payload[4] == PPP_LCP_ECHOREQ) || (payload[4] == PPP_LCP_ECHOREP)) ){
-#ifdef DEBUG
- if ( log_level >= 1)
- printk(KERN_INFO"PPTP[%i]: allowing old LCP Echo packet %d (expecting %d)\n", opt->src_addr.call_id,
- seq, opt->seq_recv + 1);
-#endif
- goto allow_packet;
- }
-#ifdef DEBUG
- if ( log_level >= 1)
- printk(KERN_INFO"PPTP[%i]: discarding duplicate or old packet %d (expecting %d)\n",opt->src_addr.call_id,
- seq, opt->seq_recv + 1);
-#endif
- }else{
- opt->seq_recv = seq;
-allow_packet:
-#ifdef DEBUG
- if ( log_level >= 3 && opt->seq_sent<=log_packets)
- printk(KERN_INFO"PPTP[%i]: accepting packet %d size=%i (%02x %02x %02x %02x %02x %02x)\n",opt->src_addr.call_id, seq,payload_len,
- *(payload +0),
- *(payload +1),
- *(payload +2),
- *(payload +3),
- *(payload +4),
- *(payload +5));
-#endif
-
- skb_pull(skb,headersize);
-
- if (payload[0] == PPP_ALLSTATIONS && payload[1] == PPP_UI){
- /* chop off address/control */
- if (skb->len < 3)
- goto drop;
- skb_pull(skb,2);
- }
-
- if ((*skb->data) & 1){
- /* protocol is compressed */
- skb_push(skb, 1)[0] = 0;
- }
-
- skb->ip_summed=CHECKSUM_NONE;
-#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,21)
- skb_set_network_header(skb,skb->head-skb->data);
-#endif
- ppp_input(&po->chan,skb);
-
- return NET_RX_SUCCESS;
- }
-drop:
- kfree_skb(skb);
- return NET_RX_DROP;
-}
-
-static int pptp_rcv(struct sk_buff *skb)
-{
- struct pppox_sock *po;
- struct pptp_gre_header *header;
- struct iphdr *iph;
-#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,0)
- int ret;
- struct sock *sk;
-#endif
-
- if (skb->pkt_type != PACKET_HOST)
- goto drop;
-
- /*if (!pskb_may_pull(skb, 12))
- goto drop;*/
-
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22)
- iph = ip_hdr(skb);
-#else
- iph = skb->nh.iph;
-#endif
-
- header = (struct pptp_gre_header *)skb->data;
-
- if ( /* version should be 1 */
- ((header->ver & 0x7F) != PPTP_GRE_VER) ||
- /* PPTP-GRE protocol for PPTP */
- (ntohs(header->protocol) != PPTP_GRE_PROTO)||
- /* flag C should be clear */
- PPTP_GRE_IS_C(header->flags) ||
- /* flag R should be clear */
- PPTP_GRE_IS_R(header->flags) ||
- /* flag K should be set */
- (!PPTP_GRE_IS_K(header->flags)) ||
- /* routing and recursion ctrl = 0 */
- ((header->flags&0xF) != 0)){
- /* if invalid, discard this packet */
- if (log_level>=1)
- printk(KERN_INFO"PPTP: Discarding GRE: %X %X %X %X %X %X\n",
- header->ver&0x7F, ntohs(header->protocol),
- PPTP_GRE_IS_C(header->flags),
- PPTP_GRE_IS_R(header->flags),
- PPTP_GRE_IS_K(header->flags),
- header->flags & 0xF);
- goto drop;
- }
-
-
- if ((po=lookup_chan(htons(header->call_id),iph->saddr))) {
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,31)
- skb_dst_drop(skb);
-#else
- dst_release(skb->dst);
- skb->dst = NULL;
-#endif
- nf_reset(skb);
-#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,0)
- sk=sk_pppox(po);
- bh_lock_sock(sk);
- /* Socket state is unknown, must put skb into backlog. */
- if (sk->lock.users != 0) {
- sk_add_backlog(sk, skb);
- ret = NET_RX_SUCCESS;
- } else {
- ret = pptp_rcv_core(sk, skb);
- }
- bh_unlock_sock(sk);
- sock_put(sk);
- return ret;
-
-#else /* LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,0) */
-
-#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,19)
- return sk_receive_skb(sk_pppox(po), skb);
-#else
- return sk_receive_skb(sk_pppox(po), skb, 0);
-#endif
-
-#endif /* LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,0) */
- }else {
-#ifdef DEBUG
- if (log_level>=1)
- printk(KERN_INFO"PPTP: Discarding packet from unknown call_id %i\n",htons(header->call_id));
-#endif
- }
-
-drop:
- kfree_skb(skb);
- return NET_RX_DROP;
-}
-
-static int pptp_bind(struct socket *sock,struct sockaddr *uservaddr,int sockaddr_len)
-{
- struct sock *sk = sock->sk;
- struct sockaddr_pppox *sp = (struct sockaddr_pppox *) uservaddr;
- struct pppox_sock *po = pppox_sk(sk);
- struct pptp_opt *opt=&po->proto.pptp;
- int error=0;
-
-#ifdef DEBUG
- if (log_level>=1)
- printk(KERN_INFO"PPTP: bind: addr=%X call_id=%i\n",sp->sa_addr.pptp.sin_addr.s_addr,
- sp->sa_addr.pptp.call_id);
-#endif
- lock_sock(sk);
-
- opt->src_addr=sp->sa_addr.pptp;
- if (add_chan(po))
- {
- release_sock(sk);
- error=-EBUSY;
- }
-#ifdef DEBUG
- if (log_level>=1)
- printk(KERN_INFO"PPTP: using call_id %i\n",opt->src_addr.call_id);
-#endif
-
- release_sock(sk);
- return error;
-}
-
-static int pptp_connect(struct socket *sock, struct sockaddr *uservaddr,
- int sockaddr_len, int flags)
-{
- struct sock *sk = sock->sk;
- struct sockaddr_pppox *sp = (struct sockaddr_pppox *) uservaddr;
- struct pppox_sock *po = pppox_sk(sk);
- struct pptp_opt *opt = &po->proto.pptp;
- struct rtable *rt; /* Route to the other host */
- int error=0;
-
- if (sp->sa_protocol != PX_PROTO_PPTP)
- return -EINVAL;
-
-#ifdef DEBUG
- if (log_level>=1)
- printk(KERN_INFO"PPTP[%i]: connect: addr=%X call_id=%i\n",opt->src_addr.call_id,
- sp->sa_addr.pptp.sin_addr.s_addr,sp->sa_addr.pptp.call_id);
-#endif
-
- if (lookup_chan_dst(sp->sa_addr.pptp.call_id,sp->sa_addr.pptp.sin_addr.s_addr))
- return -EALREADY;
-
- lock_sock(sk);
- /* Check for already bound sockets */
- if (SK_STATE(sk) & PPPOX_CONNECTED){
- error = -EBUSY;
- goto end;
- }
-
- /* Check for already disconnected sockets, on attempts to disconnect */
- if (SK_STATE(sk) & PPPOX_DEAD){
- error = -EALREADY;
- goto end;
- }
-
- if (!opt->src_addr.sin_addr.s_addr || !sp->sa_addr.pptp.sin_addr.s_addr){
- error = -EINVAL;
- goto end;
- }
-
- po->chan.private=sk;
- po->chan.ops=&pptp_chan_ops;
-
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
- {
- struct rt_key key = {
- .dst=opt->dst_addr.sin_addr.s_addr,
- .src=opt->src_addr.sin_addr.s_addr,
- .tos=RT_TOS(0),
- };
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25)
- if (ip_route_output_key(&rt, &key)) {
-#else
- if (ip_route_output_key(&init_net, &rt, &key)) {
-#endif
- error = -EHOSTUNREACH;
- goto end;
- }
- }
-#else
- {
- struct flowi fl = {
- .nl_u = { .ip4_u =
- { .daddr = opt->dst_addr.sin_addr.s_addr,
- .saddr = opt->src_addr.sin_addr.s_addr,
- .tos = RT_CONN_FLAGS(sk) } },
- .proto = IPPROTO_GRE };
-#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,18)
- security_sk_classify_flow(sk, &fl);
-#endif
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25)
- if (ip_route_output_key(&rt, &fl)){
-#else
- if (ip_route_output_key(&init_net, &rt, &fl)){
-#endif
- error = -EHOSTUNREACH;
- goto end;
- }
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,36)
- sk_setup_caps(sk, &rt->u.dst);
-#else
- sk_setup_caps(sk, &rt->dst);
-#endif
- }
-#endif
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
- po->chan.mtu=PPP_MTU;
-#else
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,36)
- po->chan.mtu=dst_mtu(&rt->u.dst);
-#else
- po->chan.mtu=dst_mtu(&rt->dst);
-#endif
- if (!po->chan.mtu) po->chan.mtu=PPP_MTU;
-#endif
- ip_rt_put(rt);
- po->chan.mtu-=PPTP_HEADER_OVERHEAD;
-
- po->chan.hdrlen=2+sizeof(struct pptp_gre_header);
- error = ppp_register_channel(&po->chan);
- if (error){
- printk(KERN_ERR "PPTP: failed to register PPP channel (%d)\n",error);
- goto end;
- }
-
- opt->dst_addr=sp->sa_addr.pptp;
- SK_STATE(sk) = PPPOX_CONNECTED;
-
- end:
- release_sock(sk);
- return error;
-}
-
-static int pptp_getname(struct socket *sock, struct sockaddr *uaddr,
- int *usockaddr_len, int peer)
-{
- int len = sizeof(struct sockaddr_pppox);
- struct sockaddr_pppox sp;
-
- sp.sa_family = AF_PPPOX;
- sp.sa_protocol = PX_PROTO_PPTP;
- sp.sa_addr.pptp=pppox_sk(sock->sk)->proto.pptp.src_addr;
-
- memcpy(uaddr, &sp, len);
-
- *usockaddr_len = len;
-
- return 0;
-}
-
-static int pptp_release(struct socket *sock)
-{
- struct sock *sk = sock->sk;
- struct pppox_sock *po;
- struct pptp_opt *opt;
- int error = 0;
-
- if (!sk)
- return 0;
-
- lock_sock(sk);
-
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
- if (sk->dead)
-#else
- if (sock_flag(sk, SOCK_DEAD))
-#endif
- {
- release_sock(sk);
- return -EBADF;
- }
-
- po = pppox_sk(sk);
- opt=&po->proto.pptp;
- del_chan(po);
-
- pppox_unbind_sock(sk);
- SK_STATE(sk) = PPPOX_DEAD;
-
-#ifdef DEBUG
- if (log_level>=1)
- printk(KERN_INFO"PPTP[%i]: release\n",opt->src_addr.call_id);
-#endif
-
- sock_orphan(sk);
- sock->sk = NULL;
-
- release_sock(sk);
- sock_put(sk);
-
- return error;
-}
-
-
-#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,0)
-static struct proto pptp_sk_proto = {
- .name = "PPTP",
- .owner = THIS_MODULE,
- .obj_size = sizeof(struct pppox_sock),
-};
-#endif
-
-static struct proto_ops pptp_ops = {
- .family = AF_PPPOX,
-#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,0)
- .owner = THIS_MODULE,
-#endif
- .release = pptp_release,
- .bind = pptp_bind,
- .connect = pptp_connect,
- .socketpair = sock_no_socketpair,
- .accept = sock_no_accept,
- .getname = pptp_getname,
- .poll = sock_no_poll,
- .listen = sock_no_listen,
- .shutdown = sock_no_shutdown,
- .setsockopt = sock_no_setsockopt,
- .getsockopt = sock_no_getsockopt,
- .sendmsg = sock_no_sendmsg,
- .recvmsg = sock_no_recvmsg,
- .mmap = sock_no_mmap,
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
- .ioctl = pppox_ioctl,
-#endif
-};
-
-
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
-static void pptp_sock_destruct(struct sock *sk)
-{
- skb_queue_purge(&sk->receive_queue);
- if (!(SK_STATE(sk) & PPPOX_DEAD)) {
- del_chan(pppox_sk(sk));
- pppox_unbind_sock(sk);
- }
- if (sk->protinfo.destruct_hook)
- kfree(sk->protinfo.destruct_hook);
-
- MOD_DEC_USE_COUNT;
-}
-
-static int pptp_create(struct socket *sock)
-{
- int error = -ENOMEM;
- struct sock *sk;
- struct pppox_sock *po;
- struct pptp_opt *opt;
-
- MOD_INC_USE_COUNT;
-
- sk = sk_alloc(PF_PPPOX, GFP_KERNEL, 1);
- if (!sk)
- goto out;
-
- sock_init_data(sock, sk);
-
- sock->state = SS_UNCONNECTED;
- sock->ops = &pptp_ops;
-
- //sk->sk_backlog_rcv = pppoe_rcv_core;
- sk->state = PPPOX_NONE;
- sk->type = SOCK_STREAM;
- sk->family = PF_PPPOX;
- sk->protocol = PX_PROTO_PPTP;
-
- sk->protinfo.pppox=kzalloc(sizeof(struct pppox_sock),GFP_KERNEL);
- sk->destruct=pptp_sock_destruct;
- sk->protinfo.destruct_hook=sk->protinfo.pppox;
-
- po = pppox_sk(sk);
- po->sk=sk;
- opt=&po->proto.pptp;
-
- opt->seq_sent=0; opt->seq_recv=0;
- opt->ack_recv=0; opt->ack_sent=0;
-
- error = 0;
-out:
- return error;
-}
-#else
-static void pptp_sock_destruct(struct sock *sk)
-{
- if (!(SK_STATE(sk) & PPPOX_DEAD)){
- del_chan(pppox_sk(sk));
- pppox_unbind_sock(sk);
- }
- skb_queue_purge(&sk->sk_receive_queue);
-}
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
-static int pptp_create(struct socket *sock)
-#else
-static int pptp_create(struct net *net, struct socket *sock)
-#endif
-{
- int error = -ENOMEM;
- struct sock *sk;
- struct pppox_sock *po;
- struct pptp_opt *opt;
-
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
- sk = sk_alloc(PF_PPPOX, GFP_KERNEL, &pptp_sk_proto, 1);
-#else
- sk = sk_alloc(net,PF_PPPOX, GFP_KERNEL, &pptp_sk_proto);
-#endif
- if (!sk)
- goto out;
-
- sock_init_data(sock, sk);
-
- sock->state = SS_UNCONNECTED;
- sock->ops = &pptp_ops;
-
- sk->sk_backlog_rcv = pptp_rcv_core;
- sk->sk_state = PPPOX_NONE;
- sk->sk_type = SOCK_STREAM;
- sk->sk_family = PF_PPPOX;
- sk->sk_protocol = PX_PROTO_PPTP;
- sk->sk_destruct = pptp_sock_destruct;
-
- po = pppox_sk(sk);
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
- po->sk=sk;
-#endif
- opt=&po->proto.pptp;
-
- opt->seq_sent=0; opt->seq_recv=0;
- opt->ack_recv=0; opt->ack_sent=0;
-
- error = 0;
-out:
- return error;
-}
-#endif
-
-
-static int pptp_ppp_ioctl(struct ppp_channel *chan, unsigned int cmd,
- unsigned long arg)
-{
- struct sock *sk = (struct sock *) chan->private;
- struct pppox_sock *po = pppox_sk(sk);
- struct pptp_opt *opt=&po->proto.pptp;
- void __user *argp = (void __user *)arg;
- int __user *p = argp;
- int err, val;
-
- err = -EFAULT;
- switch (cmd) {
- case PPPIOCGFLAGS:
- val = opt->ppp_flags;
- if (put_user(val, p))
- break;
- err = 0;
- break;
- case PPPIOCSFLAGS:
- if (get_user(val, p))
- break;
- opt->ppp_flags = val & ~SC_RCV_BITS;
- err = 0;
- break;
- default:
- err = -ENOTTY;
- }
-
- return err;
-}
-
-
-static struct pppox_proto pppox_pptp_proto = {
- .create = pptp_create,
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,15)
- .owner = THIS_MODULE,
-#endif
-};
-
-#if defined(CONFIG_GRE) || defined(CONFIG_GRE_MODULE)
-static struct gre_protocol gre_pptp_protocol = {
- .handler = pptp_rcv,
-};
-#elif LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
-static struct inet_protocol net_pptp_protocol = {
- .handler = pptp_rcv,
- .protocol = IPPROTO_GRE,
- .name = "PPTP",
-};
-#else
-static struct net_protocol net_pptp_protocol = {
- .handler = pptp_rcv,
-};
-#endif
-
-static int __init pptp_init_module(void)
-{
- int err=0;
- printk(KERN_INFO "PPTP driver version " PPTP_DRIVER_VERSION "\n");
-
-#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,0)
- callid_sock = __vmalloc((MAX_CALLID + 1) * sizeof(void *),
- GFP_KERNEL | __GFP_ZERO, PAGE_KERNEL);
-#else
- callid_sock = __vmalloc((MAX_CALLID + 1) * sizeof(void *),
- GFP_KERNEL, PAGE_KERNEL);
- memset(callid_sock, 0, (MAX_CALLID + 1) * sizeof(void *));
-#endif
- if (!callid_sock) {
- printk(KERN_ERR "PPTP: cann't allocate memory\n");
- return -ENOMEM;
- }
-
-#if defined(CONFIG_GRE) || defined(CONFIG_GRE_MODULE)
- if (gre_add_protocol(&gre_pptp_protocol, GREPROTO_PPTP) < 0) {
- printk(KERN_INFO "PPTP: can't add protocol\n");
- goto out_free_mem;
- }
-#elif LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
- inet_add_protocol(&net_pptp_protocol);
-#else
- if (inet_add_protocol(&net_pptp_protocol, IPPROTO_GRE) < 0) {
- printk(KERN_INFO "PPTP: can't add protocol\n");
- goto out_free_mem;
- }
-#endif
-
-#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,0)
- err = proto_register(&pptp_sk_proto, 0);
- if (err){
- printk(KERN_INFO "PPTP: can't register sk_proto\n");
- goto out_inet_del_protocol;
- }
-#endif
-
- err = register_pppox_proto(PX_PROTO_PPTP, &pppox_pptp_proto);
- if (err){
- printk(KERN_INFO "PPTP: can't register pppox_proto\n");
- goto out_unregister_sk_proto;
- }
-
- return 0;
-out_unregister_sk_proto:
-#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,0)
- proto_unregister(&pptp_sk_proto);
-#endif
-
-#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,0)
-out_inet_del_protocol:
-#endif
-
-#if defined(CONFIG_GRE) || defined(CONFIG_GRE_MODULE)
- gre_del_protocol(&gre_pptp_protocol, GREPROTO_PPTP);
-#elif LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
- inet_del_protocol(&net_pptp_protocol);
-#else
- inet_del_protocol(&net_pptp_protocol, IPPROTO_GRE);
-#endif
-out_free_mem:
- vfree(callid_sock);
-
- return err;
-}
-
-static void __exit pptp_exit_module(void)
-{
- unregister_pppox_proto(PX_PROTO_PPTP);
-#if defined(CONFIG_GRE) || defined(CONFIG_GRE_MODULE)
-#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,0)
- proto_unregister(&pptp_sk_proto);
-#endif
- gre_del_protocol(&gre_pptp_protocol, GREPROTO_PPTP);
-#elif LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
- inet_del_protocol(&net_pptp_protocol);
-#else
- proto_unregister(&pptp_sk_proto);
- inet_del_protocol(&net_pptp_protocol, IPPROTO_GRE);
-#endif
- vfree(callid_sock);
-}
-
-module_init(pptp_init_module);
-module_exit(pptp_exit_module);
-
-MODULE_DESCRIPTION("Point-to-Point Tunneling Protocol for Linux");
-MODULE_AUTHOR("Kozlov D. (xeb@mail.ru)");
-MODULE_LICENSE("GPL");
-
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
-MODULE_PARM(log_level,"i");
-MODULE_PARM(log_packets,"i");
-#else
-module_param(log_level,int,0);
-module_param(log_packets,int,0);
-#endif
-MODULE_PARM_DESC(log_level,"Logging level (default=0)");
-
diff --git a/drivers/vlan_mon/vlan_mon.c b/drivers/vlan_mon/vlan_mon.c
index d5f42c91..8b699230 100644
--- a/drivers/vlan_mon/vlan_mon.c
+++ b/drivers/vlan_mon/vlan_mon.c
@@ -753,6 +753,9 @@ static int __init vlan_mon_init(void)
}
#endif
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(6,6,0)
+ vlan_pt.af_packet_net = &init_net;
+#endif
dev_add_pack(&vlan_pt);
return 0;
generated by cgit v1.2.3 (git 2.39.1) at 2026-09-20 17:07:40 +0000