Thomas Gleixner | d2912cb | 2019-06-04 10:11:33 +0200 | [diff] [blame] | 1 | /* SPDX-License-Identifier: GPL-2.0-only */ |
Tom Parkin | 20dcb11 | 2020-07-22 17:32:06 +0100 | [diff] [blame] | 2 | /* L2TP internal definitions. |
James Chapman | fd558d1 | 2010-04-02 06:18:33 +0000 | [diff] [blame] | 3 | * |
| 4 | * Copyright (c) 2008,2009 Katalix Systems Ltd |
James Chapman | fd558d1 | 2010-04-02 06:18:33 +0000 | [diff] [blame] | 5 | */ |
Reshetova, Elena | fbea9e0 | 2017-07-04 15:52:57 +0300 | [diff] [blame] | 6 | #include <linux/refcount.h> |
James Chapman | fd558d1 | 2010-04-02 06:18:33 +0000 | [diff] [blame] | 7 | |
| 8 | #ifndef _L2TP_CORE_H_ |
| 9 | #define _L2TP_CORE_H_ |
| 10 | |
Guillaume Nault | 1f5cd2a | 2018-08-03 12:38:34 +0200 | [diff] [blame] | 11 | #include <net/dst.h> |
| 12 | #include <net/sock.h> |
| 13 | |
Guillaume Nault | d6a61ec | 2018-08-10 13:21:55 +0200 | [diff] [blame] | 14 | #ifdef CONFIG_XFRM |
| 15 | #include <net/xfrm.h> |
| 16 | #endif |
| 17 | |
Tom Parkin | 340bb1ac | 2020-07-28 18:20:33 +0100 | [diff] [blame] | 18 | /* Random numbers used for internal consistency checks of tunnel and session structures */ |
James Chapman | fd558d1 | 2010-04-02 06:18:33 +0000 | [diff] [blame] | 19 | #define L2TP_TUNNEL_MAGIC 0x42114DDA |
| 20 | #define L2TP_SESSION_MAGIC 0x0C04EB7D |
| 21 | |
Tom Parkin | 340bb1ac | 2020-07-28 18:20:33 +0100 | [diff] [blame] | 22 | /* Per tunnel session hash table size */ |
James Chapman | fd558d1 | 2010-04-02 06:18:33 +0000 | [diff] [blame] | 23 | #define L2TP_HASH_BITS 4 |
Tom Parkin | dbf82f3f | 2020-07-22 17:32:11 +0100 | [diff] [blame] | 24 | #define L2TP_HASH_SIZE BIT(L2TP_HASH_BITS) |
James Chapman | fd558d1 | 2010-04-02 06:18:33 +0000 | [diff] [blame] | 25 | |
Tom Parkin | 340bb1ac | 2020-07-28 18:20:33 +0100 | [diff] [blame] | 26 | /* System-wide session hash table size */ |
James Chapman | f7faffa | 2010-04-02 06:18:49 +0000 | [diff] [blame] | 27 | #define L2TP_HASH_BITS_2 8 |
Tom Parkin | dbf82f3f | 2020-07-22 17:32:11 +0100 | [diff] [blame] | 28 | #define L2TP_HASH_SIZE_2 BIT(L2TP_HASH_BITS_2) |
James Chapman | f7faffa | 2010-04-02 06:18:49 +0000 | [diff] [blame] | 29 | |
James Chapman | fd558d1 | 2010-04-02 06:18:33 +0000 | [diff] [blame] | 30 | struct sk_buff; |
| 31 | |
| 32 | struct l2tp_stats { |
Tom Parkin | 7b7c071 | 2013-03-19 06:11:22 +0000 | [diff] [blame] | 33 | atomic_long_t tx_packets; |
| 34 | atomic_long_t tx_bytes; |
| 35 | atomic_long_t tx_errors; |
| 36 | atomic_long_t rx_packets; |
| 37 | atomic_long_t rx_bytes; |
| 38 | atomic_long_t rx_seq_discards; |
| 39 | atomic_long_t rx_oos_packets; |
| 40 | atomic_long_t rx_errors; |
| 41 | atomic_long_t rx_cookie_discards; |
Matthias Schiffer | 3e59e88 | 2021-03-03 16:50:49 +0100 | [diff] [blame] | 42 | atomic_long_t rx_invalid; |
James Chapman | fd558d1 | 2010-04-02 06:18:33 +0000 | [diff] [blame] | 43 | }; |
| 44 | |
| 45 | struct l2tp_tunnel; |
| 46 | |
Tom Parkin | 340bb1ac | 2020-07-28 18:20:33 +0100 | [diff] [blame] | 47 | /* L2TP session configuration */ |
James Chapman | fd558d1 | 2010-04-02 06:18:33 +0000 | [diff] [blame] | 48 | struct l2tp_session_cfg { |
James Chapman | f7faffa | 2010-04-02 06:18:49 +0000 | [diff] [blame] | 49 | enum l2tp_pwtype pw_type; |
Tom Parkin | 20dcb11 | 2020-07-22 17:32:06 +0100 | [diff] [blame] | 50 | unsigned int recv_seq:1; /* expect receive packets with sequence numbers? */ |
| 51 | unsigned int send_seq:1; /* send packets with sequence numbers? */ |
| 52 | unsigned int lns_mode:1; /* behave as LNS? |
| 53 | * LAC enables sequence numbers under LNS control. |
| 54 | */ |
James Chapman | f7faffa | 2010-04-02 06:18:49 +0000 | [diff] [blame] | 55 | u16 l2specific_type; /* Layer 2 specific type */ |
| 56 | u8 cookie[8]; /* optional cookie */ |
| 57 | int cookie_len; /* 0, 4 or 8 bytes */ |
| 58 | u8 peer_cookie[8]; /* peer's cookie */ |
| 59 | int peer_cookie_len; /* 0, 4 or 8 bytes */ |
Tom Parkin | 20dcb11 | 2020-07-22 17:32:06 +0100 | [diff] [blame] | 60 | int reorder_timeout; /* configured reorder timeout (in jiffies) */ |
James Chapman | 309795f | 2010-04-02 06:19:10 +0000 | [diff] [blame] | 61 | char *ifname; |
James Chapman | fd558d1 | 2010-04-02 06:18:33 +0000 | [diff] [blame] | 62 | }; |
| 63 | |
Tom Parkin | 340bb1ac | 2020-07-28 18:20:33 +0100 | [diff] [blame] | 64 | /* Represents a session (pseudowire) instance. |
| 65 | * Tracks runtime state including cookies, dataplane packet sequencing, and IO statistics. |
| 66 | * Is linked into a per-tunnel session hashlist; and in the case of an L2TPv3 session into |
| 67 | * an additional per-net ("global") hashlist. |
| 68 | */ |
Tom Parkin | 2a03dd8 | 2020-08-22 15:59:05 +0100 | [diff] [blame] | 69 | #define L2TP_SESSION_NAME_MAX 32 |
James Chapman | fd558d1 | 2010-04-02 06:18:33 +0000 | [diff] [blame] | 70 | struct l2tp_session { |
Tom Parkin | 20dcb11 | 2020-07-22 17:32:06 +0100 | [diff] [blame] | 71 | int magic; /* should be L2TP_SESSION_MAGIC */ |
Guillaume Nault | b228a94 | 2017-09-22 15:39:24 +0200 | [diff] [blame] | 72 | long dead; |
James Chapman | fd558d1 | 2010-04-02 06:18:33 +0000 | [diff] [blame] | 73 | |
Tom Parkin | 20dcb11 | 2020-07-22 17:32:06 +0100 | [diff] [blame] | 74 | struct l2tp_tunnel *tunnel; /* back pointer to tunnel context */ |
James Chapman | fd558d1 | 2010-04-02 06:18:33 +0000 | [diff] [blame] | 75 | u32 session_id; |
| 76 | u32 peer_session_id; |
James Chapman | f7faffa | 2010-04-02 06:18:49 +0000 | [diff] [blame] | 77 | u8 cookie[8]; |
| 78 | int cookie_len; |
| 79 | u8 peer_cookie[8]; |
| 80 | int peer_cookie_len; |
James Chapman | f7faffa | 2010-04-02 06:18:49 +0000 | [diff] [blame] | 81 | u16 l2specific_type; |
| 82 | u16 hdr_len; |
| 83 | u32 nr; /* session NR state (receive) */ |
| 84 | u32 ns; /* session NR state (send) */ |
James Chapman | fd558d1 | 2010-04-02 06:18:33 +0000 | [diff] [blame] | 85 | struct sk_buff_head reorder_q; /* receive reorder queue */ |
James Chapman | 8a1631d | 2013-07-02 20:28:59 +0100 | [diff] [blame] | 86 | u32 nr_max; /* max NR. Depends on tunnel */ |
| 87 | u32 nr_window_size; /* NR window size */ |
James Chapman | a0dbd82 | 2013-07-02 20:29:00 +0100 | [diff] [blame] | 88 | u32 nr_oos; /* NR of last OOS packet */ |
Tom Parkin | 20dcb11 | 2020-07-22 17:32:06 +0100 | [diff] [blame] | 89 | int nr_oos_count; /* for OOS recovery */ |
James Chapman | a0dbd82 | 2013-07-02 20:29:00 +0100 | [diff] [blame] | 90 | int nr_oos_count_max; |
Tom Parkin | 20dcb11 | 2020-07-22 17:32:06 +0100 | [diff] [blame] | 91 | struct hlist_node hlist; /* hash list node */ |
Reshetova, Elena | f00c854 | 2017-07-04 15:52:58 +0300 | [diff] [blame] | 92 | refcount_t ref_count; |
James Chapman | fd558d1 | 2010-04-02 06:18:33 +0000 | [diff] [blame] | 93 | |
Tom Parkin | 2a03dd8 | 2020-08-22 15:59:05 +0100 | [diff] [blame] | 94 | char name[L2TP_SESSION_NAME_MAX]; /* for logging */ |
James Chapman | 309795f | 2010-04-02 06:19:10 +0000 | [diff] [blame] | 95 | char ifname[IFNAMSIZ]; |
Tom Parkin | 20dcb11 | 2020-07-22 17:32:06 +0100 | [diff] [blame] | 96 | unsigned int recv_seq:1; /* expect receive packets with sequence numbers? */ |
| 97 | unsigned int send_seq:1; /* send packets with sequence numbers? */ |
| 98 | unsigned int lns_mode:1; /* behave as LNS? |
| 99 | * LAC enables sequence numbers under LNS control. |
| 100 | */ |
Tom Parkin | 20dcb11 | 2020-07-22 17:32:06 +0100 | [diff] [blame] | 101 | int reorder_timeout; /* configured reorder timeout (in jiffies) */ |
James Chapman | 38d40b3 | 2012-05-09 23:43:08 +0000 | [diff] [blame] | 102 | int reorder_skip; /* set if skip to next nr */ |
James Chapman | f7faffa | 2010-04-02 06:18:49 +0000 | [diff] [blame] | 103 | enum l2tp_pwtype pwtype; |
James Chapman | fd558d1 | 2010-04-02 06:18:33 +0000 | [diff] [blame] | 104 | struct l2tp_stats stats; |
Tom Parkin | 20dcb11 | 2020-07-22 17:32:06 +0100 | [diff] [blame] | 105 | struct hlist_node global_hlist; /* global hash list node */ |
James Chapman | fd558d1 | 2010-04-02 06:18:33 +0000 | [diff] [blame] | 106 | |
Tom Parkin | 340bb1ac | 2020-07-28 18:20:33 +0100 | [diff] [blame] | 107 | /* Session receive handler for data packets. |
| 108 | * Each pseudowire implementation should implement this callback in order to |
| 109 | * handle incoming packets. Packets are passed to the pseudowire handler after |
| 110 | * reordering, if data sequence numbers are enabled for the session. |
| 111 | */ |
James Chapman | fd558d1 | 2010-04-02 06:18:33 +0000 | [diff] [blame] | 112 | void (*recv_skb)(struct l2tp_session *session, struct sk_buff *skb, int data_len); |
Tom Parkin | 340bb1ac | 2020-07-28 18:20:33 +0100 | [diff] [blame] | 113 | |
| 114 | /* Session close handler. |
| 115 | * Each pseudowire implementation may implement this callback in order to carry |
| 116 | * out pseudowire-specific shutdown actions. |
| 117 | * The callback is called by core after unhashing the session and purging its |
| 118 | * reorder queue. |
| 119 | */ |
James Chapman | fd558d1 | 2010-04-02 06:18:33 +0000 | [diff] [blame] | 120 | void (*session_close)(struct l2tp_session *session); |
Tom Parkin | 340bb1ac | 2020-07-28 18:20:33 +0100 | [diff] [blame] | 121 | |
| 122 | /* Session show handler. |
| 123 | * Pseudowire-specific implementation of debugfs session rendering. |
| 124 | * The callback is called by l2tp_debugfs.c after rendering core session |
| 125 | * information. |
| 126 | */ |
James Chapman | 0ad6614 | 2010-04-02 06:19:33 +0000 | [diff] [blame] | 127 | void (*show)(struct seq_file *m, void *priv); |
Tom Parkin | 340bb1ac | 2020-07-28 18:20:33 +0100 | [diff] [blame] | 128 | |
Tom Parkin | 20dcb11 | 2020-07-22 17:32:06 +0100 | [diff] [blame] | 129 | u8 priv[]; /* private data */ |
James Chapman | fd558d1 | 2010-04-02 06:18:33 +0000 | [diff] [blame] | 130 | }; |
| 131 | |
Tom Parkin | 340bb1ac | 2020-07-28 18:20:33 +0100 | [diff] [blame] | 132 | /* L2TP tunnel configuration */ |
James Chapman | fd558d1 | 2010-04-02 06:18:33 +0000 | [diff] [blame] | 133 | struct l2tp_tunnel_cfg { |
James Chapman | 0d76751 | 2010-04-02 06:19:00 +0000 | [diff] [blame] | 134 | enum l2tp_encap_type encap; |
James Chapman | 789a4a2 | 2010-04-02 06:19:40 +0000 | [diff] [blame] | 135 | |
| 136 | /* Used only for kernel-created sockets */ |
| 137 | struct in_addr local_ip; |
| 138 | struct in_addr peer_ip; |
Chris Elston | f9bac8d | 2012-04-29 21:48:52 +0000 | [diff] [blame] | 139 | #if IS_ENABLED(CONFIG_IPV6) |
| 140 | struct in6_addr *local_ip6; |
| 141 | struct in6_addr *peer_ip6; |
| 142 | #endif |
James Chapman | 789a4a2 | 2010-04-02 06:19:40 +0000 | [diff] [blame] | 143 | u16 local_udp_port; |
| 144 | u16 peer_udp_port; |
Tom Herbert | 6b649fea | 2014-05-23 08:47:40 -0700 | [diff] [blame] | 145 | unsigned int use_udp_checksums:1, |
| 146 | udp6_zero_tx_checksums:1, |
| 147 | udp6_zero_rx_checksums:1; |
James Chapman | fd558d1 | 2010-04-02 06:18:33 +0000 | [diff] [blame] | 148 | }; |
| 149 | |
Tom Parkin | 340bb1ac | 2020-07-28 18:20:33 +0100 | [diff] [blame] | 150 | /* Represents a tunnel instance. |
| 151 | * Tracks runtime state including IO statistics. |
| 152 | * Holds the tunnel socket (either passed from userspace or directly created by the kernel). |
| 153 | * Maintains a hashlist of sessions belonging to the tunnel instance. |
| 154 | * Is linked into a per-net list of tunnels. |
| 155 | */ |
Tom Parkin | 2a03dd8 | 2020-08-22 15:59:05 +0100 | [diff] [blame] | 156 | #define L2TP_TUNNEL_NAME_MAX 20 |
James Chapman | fd558d1 | 2010-04-02 06:18:33 +0000 | [diff] [blame] | 157 | struct l2tp_tunnel { |
| 158 | int magic; /* Should be L2TP_TUNNEL_MAGIC */ |
Sabrina Dubroca | 62b982e | 2017-09-26 16:16:43 +0200 | [diff] [blame] | 159 | |
| 160 | unsigned long dead; |
| 161 | |
xeb@mail.ru | 99469c3 | 2012-08-24 01:07:38 +0000 | [diff] [blame] | 162 | struct rcu_head rcu; |
Tom Parkin | 07b8ca3 | 2021-11-26 16:09:03 +0000 | [diff] [blame] | 163 | spinlock_t hlist_lock; /* write-protection for session_hlist */ |
Tom Parkin | 20dcb11 | 2020-07-22 17:32:06 +0100 | [diff] [blame] | 164 | bool acpt_newsess; /* indicates whether this tunnel accepts |
| 165 | * new sessions. Protected by hlist_lock. |
Guillaume Nault | f3c66d4 | 2017-09-01 17:58:48 +0200 | [diff] [blame] | 166 | */ |
James Chapman | fd558d1 | 2010-04-02 06:18:33 +0000 | [diff] [blame] | 167 | struct hlist_head session_hlist[L2TP_HASH_SIZE]; |
Tom Parkin | 20dcb11 | 2020-07-22 17:32:06 +0100 | [diff] [blame] | 168 | /* hashed list of sessions, hashed by id */ |
James Chapman | fd558d1 | 2010-04-02 06:18:33 +0000 | [diff] [blame] | 169 | u32 tunnel_id; |
| 170 | u32 peer_tunnel_id; |
| 171 | int version; /* 2=>L2TPv2, 3=>L2TPv3 */ |
| 172 | |
Tom Parkin | 2a03dd8 | 2020-08-22 15:59:05 +0100 | [diff] [blame] | 173 | char name[L2TP_TUNNEL_NAME_MAX]; /* for logging */ |
James Chapman | 0d76751 | 2010-04-02 06:19:00 +0000 | [diff] [blame] | 174 | enum l2tp_encap_type encap; |
James Chapman | fd558d1 | 2010-04-02 06:18:33 +0000 | [diff] [blame] | 175 | struct l2tp_stats stats; |
| 176 | |
Tom Parkin | 20dcb11 | 2020-07-22 17:32:06 +0100 | [diff] [blame] | 177 | struct list_head list; /* list node on per-namespace list of tunnels */ |
James Chapman | fd558d1 | 2010-04-02 06:18:33 +0000 | [diff] [blame] | 178 | struct net *l2tp_net; /* the net we belong to */ |
| 179 | |
Reshetova, Elena | fbea9e0 | 2017-07-04 15:52:57 +0300 | [diff] [blame] | 180 | refcount_t ref_count; |
Tom Parkin | bef04d1 | 2020-07-22 17:32:10 +0100 | [diff] [blame] | 181 | void (*old_sk_destruct)(struct sock *sk); |
Tom Parkin | 20dcb11 | 2020-07-22 17:32:06 +0100 | [diff] [blame] | 182 | struct sock *sock; /* parent socket */ |
| 183 | int fd; /* parent fd, if tunnel socket was created |
| 184 | * by userspace |
| 185 | */ |
James Chapman | fd558d1 | 2010-04-02 06:18:33 +0000 | [diff] [blame] | 186 | |
Tom Parkin | f8ccac0 | 2013-01-31 23:43:00 +0000 | [diff] [blame] | 187 | struct work_struct del_work; |
James Chapman | fd558d1 | 2010-04-02 06:18:33 +0000 | [diff] [blame] | 188 | }; |
| 189 | |
Tom Parkin | 340bb1ac | 2020-07-28 18:20:33 +0100 | [diff] [blame] | 190 | /* Pseudowire ops callbacks for use with the l2tp genetlink interface */ |
James Chapman | 309795f | 2010-04-02 06:19:10 +0000 | [diff] [blame] | 191 | struct l2tp_nl_cmd_ops { |
Tom Parkin | 340bb1ac | 2020-07-28 18:20:33 +0100 | [diff] [blame] | 192 | /* The pseudowire session create callback is responsible for creating a session |
| 193 | * instance for a specific pseudowire type. |
| 194 | * It must call l2tp_session_create and l2tp_session_register to register the |
| 195 | * session instance, as well as carry out any pseudowire-specific initialisation. |
| 196 | * It must return >= 0 on success, or an appropriate negative errno value on failure. |
| 197 | */ |
Guillaume Nault | f026bc2 | 2017-09-01 17:58:51 +0200 | [diff] [blame] | 198 | int (*session_create)(struct net *net, struct l2tp_tunnel *tunnel, |
| 199 | u32 session_id, u32 peer_session_id, |
| 200 | struct l2tp_session_cfg *cfg); |
Tom Parkin | 340bb1ac | 2020-07-28 18:20:33 +0100 | [diff] [blame] | 201 | |
| 202 | /* The pseudowire session delete callback is responsible for initiating the deletion |
| 203 | * of a session instance. |
| 204 | * It must call l2tp_session_delete, as well as carry out any pseudowire-specific |
| 205 | * teardown actions. |
| 206 | */ |
Tom Parkin | 628703f | 2020-07-28 18:20:30 +0100 | [diff] [blame] | 207 | void (*session_delete)(struct l2tp_session *session); |
James Chapman | 309795f | 2010-04-02 06:19:10 +0000 | [diff] [blame] | 208 | }; |
| 209 | |
James Chapman | fd558d1 | 2010-04-02 06:18:33 +0000 | [diff] [blame] | 210 | static inline void *l2tp_session_priv(struct l2tp_session *session) |
| 211 | { |
| 212 | return &session->priv[0]; |
| 213 | } |
| 214 | |
Tom Parkin | 340bb1ac | 2020-07-28 18:20:33 +0100 | [diff] [blame] | 215 | /* Tunnel and session refcounts */ |
Tom Parkin | 52016e2 | 2020-07-28 18:20:29 +0100 | [diff] [blame] | 216 | void l2tp_tunnel_inc_refcount(struct l2tp_tunnel *tunnel); |
| 217 | void l2tp_tunnel_dec_refcount(struct l2tp_tunnel *tunnel); |
| 218 | void l2tp_session_inc_refcount(struct l2tp_session *session); |
| 219 | void l2tp_session_dec_refcount(struct l2tp_session *session); |
| 220 | |
Tom Parkin | 340bb1ac | 2020-07-28 18:20:33 +0100 | [diff] [blame] | 221 | /* Tunnel and session lookup. |
| 222 | * These functions take a reference on the instances they return, so |
| 223 | * the caller must ensure that the reference is dropped appropriately. |
| 224 | */ |
Guillaume Nault | 54652eb | 2017-08-25 16:51:40 +0200 | [diff] [blame] | 225 | struct l2tp_tunnel *l2tp_tunnel_get(const struct net *net, u32 tunnel_id); |
Guillaume Nault | 5846c13 | 2018-04-12 20:50:33 +0200 | [diff] [blame] | 226 | struct l2tp_tunnel *l2tp_tunnel_get_nth(const struct net *net, int nth); |
Guillaume Nault | 01e28b9 | 2018-08-10 13:21:57 +0200 | [diff] [blame] | 227 | struct l2tp_session *l2tp_tunnel_get_session(struct l2tp_tunnel *tunnel, |
| 228 | u32 session_id); |
Guillaume Nault | 5846c13 | 2018-04-12 20:50:33 +0200 | [diff] [blame] | 229 | |
Guillaume Nault | 01e28b9 | 2018-08-10 13:21:57 +0200 | [diff] [blame] | 230 | struct l2tp_session *l2tp_session_get(const struct net *net, u32 session_id); |
Guillaume Nault | a434621 | 2017-10-31 17:36:42 +0100 | [diff] [blame] | 231 | struct l2tp_session *l2tp_session_get_nth(struct l2tp_tunnel *tunnel, int nth); |
Guillaume Nault | 9aaef50 | 2017-04-12 10:05:29 +0200 | [diff] [blame] | 232 | struct l2tp_session *l2tp_session_get_by_ifname(const struct net *net, |
Guillaume Nault | a434621 | 2017-10-31 17:36:42 +0100 | [diff] [blame] | 233 | const char *ifname); |
James Chapman | fd558d1 | 2010-04-02 06:18:33 +0000 | [diff] [blame] | 234 | |
Tom Parkin | 340bb1ac | 2020-07-28 18:20:33 +0100 | [diff] [blame] | 235 | /* Tunnel and session lifetime management. |
| 236 | * Creation of a new instance is a two-step process: create, then register. |
| 237 | * Destruction is triggered using the *_delete functions, and completes asynchronously. |
| 238 | */ |
Tom Parkin | c9ccd4c | 2020-09-03 09:54:49 +0100 | [diff] [blame] | 239 | int l2tp_tunnel_create(int fd, int version, u32 tunnel_id, |
Joe Perches | c1b1203 | 2013-10-18 13:48:25 -0700 | [diff] [blame] | 240 | u32 peer_tunnel_id, struct l2tp_tunnel_cfg *cfg, |
| 241 | struct l2tp_tunnel **tunnelp); |
Guillaume Nault | 6b9f342 | 2018-04-10 21:01:12 +0200 | [diff] [blame] | 242 | int l2tp_tunnel_register(struct l2tp_tunnel *tunnel, struct net *net, |
| 243 | struct l2tp_tunnel_cfg *cfg); |
Sabrina Dubroca | 62b982e | 2017-09-26 16:16:43 +0200 | [diff] [blame] | 244 | void l2tp_tunnel_delete(struct l2tp_tunnel *tunnel); |
Tom Parkin | 340bb1ac | 2020-07-28 18:20:33 +0100 | [diff] [blame] | 245 | |
Joe Perches | c1b1203 | 2013-10-18 13:48:25 -0700 | [diff] [blame] | 246 | struct l2tp_session *l2tp_session_create(int priv_size, |
| 247 | struct l2tp_tunnel *tunnel, |
| 248 | u32 session_id, u32 peer_session_id, |
| 249 | struct l2tp_session_cfg *cfg); |
Guillaume Nault | 3953ae7 | 2017-10-27 16:51:50 +0200 | [diff] [blame] | 250 | int l2tp_session_register(struct l2tp_session *session, |
| 251 | struct l2tp_tunnel *tunnel); |
Tom Parkin | 628703f | 2020-07-28 18:20:30 +0100 | [diff] [blame] | 252 | void l2tp_session_delete(struct l2tp_session *session); |
Tom Parkin | 340bb1ac | 2020-07-28 18:20:33 +0100 | [diff] [blame] | 253 | |
| 254 | /* Receive path helpers. If data sequencing is enabled for the session these |
| 255 | * functions handle queuing and reordering prior to passing packets to the |
| 256 | * pseudowire code to be passed to userspace. |
| 257 | */ |
Joe Perches | c1b1203 | 2013-10-18 13:48:25 -0700 | [diff] [blame] | 258 | void l2tp_recv_common(struct l2tp_session *session, struct sk_buff *skb, |
| 259 | unsigned char *ptr, unsigned char *optr, u16 hdrflags, |
Guillaume Nault | 2b139e6 | 2018-07-25 14:53:33 +0200 | [diff] [blame] | 260 | int length); |
Joe Perches | c1b1203 | 2013-10-18 13:48:25 -0700 | [diff] [blame] | 261 | int l2tp_udp_encap_recv(struct sock *sk, struct sk_buff *skb); |
James Chapman | fd558d1 | 2010-04-02 06:18:33 +0000 | [diff] [blame] | 262 | |
Tom Parkin | 340bb1ac | 2020-07-28 18:20:33 +0100 | [diff] [blame] | 263 | /* Transmit path helpers for sending packets over the tunnel socket. */ |
| 264 | void l2tp_session_set_header_len(struct l2tp_session *session, int version); |
Tom Parkin | efe0527 | 2020-09-03 09:54:47 +0100 | [diff] [blame] | 265 | int l2tp_xmit_skb(struct l2tp_session *session, struct sk_buff *skb); |
James Chapman | fd558d1 | 2010-04-02 06:18:33 +0000 | [diff] [blame] | 266 | |
Tom Parkin | 340bb1ac | 2020-07-28 18:20:33 +0100 | [diff] [blame] | 267 | /* Pseudowire management. |
| 268 | * Pseudowires should register with l2tp core on module init, and unregister |
| 269 | * on module exit. |
| 270 | */ |
| 271 | int l2tp_nl_register_ops(enum l2tp_pwtype pw_type, const struct l2tp_nl_cmd_ops *ops); |
Joe Perches | c1b1203 | 2013-10-18 13:48:25 -0700 | [diff] [blame] | 272 | void l2tp_nl_unregister_ops(enum l2tp_pwtype pw_type); |
Tom Parkin | 340bb1ac | 2020-07-28 18:20:33 +0100 | [diff] [blame] | 273 | |
| 274 | /* IOCTL helper for IP encap modules. */ |
Breno Leitao | e1d001f | 2023-06-09 08:27:42 -0700 | [diff] [blame] | 275 | int l2tp_ioctl(struct sock *sk, int cmd, int *karg); |
James Chapman | 309795f | 2010-04-02 06:19:10 +0000 | [diff] [blame] | 276 | |
Tom Parkin | 45faeff | 2020-09-03 09:54:51 +0100 | [diff] [blame] | 277 | /* Extract the tunnel structure from a socket's sk_user_data pointer, |
| 278 | * validating the tunnel magic feather. |
| 279 | */ |
| 280 | struct l2tp_tunnel *l2tp_sk_to_tunnel(struct sock *sk); |
| 281 | |
Lorenzo Bianconi | 62e7b6a | 2018-01-16 23:01:55 +0100 | [diff] [blame] | 282 | static inline int l2tp_get_l2specific_len(struct l2tp_session *session) |
| 283 | { |
| 284 | switch (session->l2specific_type) { |
| 285 | case L2TP_L2SPECTYPE_DEFAULT: |
| 286 | return 4; |
| 287 | case L2TP_L2SPECTYPE_NONE: |
| 288 | default: |
| 289 | return 0; |
| 290 | } |
| 291 | } |
| 292 | |
Guillaume Nault | 1f5cd2a | 2018-08-03 12:38:34 +0200 | [diff] [blame] | 293 | static inline u32 l2tp_tunnel_dst_mtu(const struct l2tp_tunnel *tunnel) |
| 294 | { |
| 295 | struct dst_entry *dst; |
| 296 | u32 mtu; |
| 297 | |
| 298 | dst = sk_dst_get(tunnel->sock); |
| 299 | if (!dst) |
| 300 | return 0; |
| 301 | |
| 302 | mtu = dst_mtu(dst); |
| 303 | dst_release(dst); |
| 304 | |
| 305 | return mtu; |
| 306 | } |
| 307 | |
Guillaume Nault | d6a61ec | 2018-08-10 13:21:55 +0200 | [diff] [blame] | 308 | #ifdef CONFIG_XFRM |
| 309 | static inline bool l2tp_tunnel_uses_xfrm(const struct l2tp_tunnel *tunnel) |
| 310 | { |
| 311 | struct sock *sk = tunnel->sock; |
| 312 | |
| 313 | return sk && (rcu_access_pointer(sk->sk_policy[0]) || |
| 314 | rcu_access_pointer(sk->sk_policy[1])); |
| 315 | } |
| 316 | #else |
| 317 | static inline bool l2tp_tunnel_uses_xfrm(const struct l2tp_tunnel *tunnel) |
| 318 | { |
| 319 | return false; |
| 320 | } |
| 321 | #endif |
| 322 | |
Jacob Wen | 4522a70 | 2019-01-30 14:55:14 +0800 | [diff] [blame] | 323 | static inline int l2tp_v3_ensure_opt_in_linear(struct l2tp_session *session, struct sk_buff *skb, |
| 324 | unsigned char **ptr, unsigned char **optr) |
| 325 | { |
| 326 | int opt_len = session->peer_cookie_len + l2tp_get_l2specific_len(session); |
| 327 | |
| 328 | if (opt_len > 0) { |
| 329 | int off = *ptr - *optr; |
| 330 | |
| 331 | if (!pskb_may_pull(skb, off + opt_len)) |
| 332 | return -1; |
| 333 | |
| 334 | if (skb->data != *optr) { |
| 335 | *optr = skb->data; |
| 336 | *ptr = skb->data + off; |
| 337 | } |
| 338 | } |
| 339 | |
| 340 | return 0; |
| 341 | } |
| 342 | |
stephen hemminger | f1f39f9 | 2015-09-23 21:33:34 -0700 | [diff] [blame] | 343 | #define MODULE_ALIAS_L2TP_PWTYPE(type) \ |
| 344 | MODULE_ALIAS("net-l2tp-type-" __stringify(type)) |
| 345 | |
James Chapman | fd558d1 | 2010-04-02 06:18:33 +0000 | [diff] [blame] | 346 | #endif /* _L2TP_CORE_H_ */ |