| 1 | /* SPDX-License-Identifier: GPL-2.0-only */ |
| 2 | /* L2TP internal definitions. |
| 3 | * |
| 4 | * Copyright (c) 2008,2009 Katalix Systems Ltd |
| 5 | */ |
| 6 | #include <linux/refcount.h> |
| 7 | |
| 8 | #ifndef _L2TP_CORE_H_ |
| 9 | #define _L2TP_CORE_H_ |
| 10 | |
| 11 | #include <net/dst.h> |
| 12 | #include <net/sock.h> |
| 13 | |
| 14 | #ifdef CONFIG_XFRM |
| 15 | #include <net/xfrm.h> |
| 16 | #endif |
| 17 | |
| 18 | /* Random numbers used for internal consistency checks of tunnel and session structures */ |
| 19 | #define L2TP_TUNNEL_MAGIC 0x42114DDA |
| 20 | #define L2TP_SESSION_MAGIC 0x0C04EB7D |
| 21 | |
| 22 | /* Per tunnel session hash table size */ |
| 23 | #define L2TP_HASH_BITS 4 |
| 24 | #define L2TP_HASH_SIZE BIT(L2TP_HASH_BITS) |
| 25 | |
| 26 | /* System-wide session hash table size */ |
| 27 | #define L2TP_HASH_BITS_2 8 |
| 28 | #define L2TP_HASH_SIZE_2 BIT(L2TP_HASH_BITS_2) |
| 29 | |
| 30 | struct sk_buff; |
| 31 | |
| 32 | struct l2tp_stats { |
| 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; |
| 42 | atomic_long_t rx_invalid; |
| 43 | }; |
| 44 | |
| 45 | struct l2tp_tunnel; |
| 46 | |
| 47 | /* L2TP session configuration */ |
| 48 | struct l2tp_session_cfg { |
| 49 | enum l2tp_pwtype pw_type; |
| 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 | */ |
| 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 */ |
| 60 | int reorder_timeout; /* configured reorder timeout (in jiffies) */ |
| 61 | char *ifname; |
| 62 | }; |
| 63 | |
| 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 | */ |
| 69 | #define L2TP_SESSION_NAME_MAX 32 |
| 70 | struct l2tp_session { |
| 71 | int magic; /* should be L2TP_SESSION_MAGIC */ |
| 72 | long dead; |
| 73 | |
| 74 | struct l2tp_tunnel *tunnel; /* back pointer to tunnel context */ |
| 75 | u32 session_id; |
| 76 | u32 peer_session_id; |
| 77 | u8 cookie[8]; |
| 78 | int cookie_len; |
| 79 | u8 peer_cookie[8]; |
| 80 | int peer_cookie_len; |
| 81 | u16 l2specific_type; |
| 82 | u16 hdr_len; |
| 83 | u32 nr; /* session NR state (receive) */ |
| 84 | u32 ns; /* session NR state (send) */ |
| 85 | struct sk_buff_head reorder_q; /* receive reorder queue */ |
| 86 | u32 nr_max; /* max NR. Depends on tunnel */ |
| 87 | u32 nr_window_size; /* NR window size */ |
| 88 | u32 nr_oos; /* NR of last OOS packet */ |
| 89 | int nr_oos_count; /* for OOS recovery */ |
| 90 | int nr_oos_count_max; |
| 91 | struct hlist_node hlist; /* hash list node */ |
| 92 | refcount_t ref_count; |
| 93 | |
| 94 | char name[L2TP_SESSION_NAME_MAX]; /* for logging */ |
| 95 | char ifname[IFNAMSIZ]; |
| 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 | */ |
| 101 | int reorder_timeout; /* configured reorder timeout (in jiffies) */ |
| 102 | int reorder_skip; /* set if skip to next nr */ |
| 103 | enum l2tp_pwtype pwtype; |
| 104 | struct l2tp_stats stats; |
| 105 | struct hlist_node global_hlist; /* global hash list node */ |
| 106 | |
| 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 | */ |
| 112 | void (*recv_skb)(struct l2tp_session *session, struct sk_buff *skb, int data_len); |
| 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 | */ |
| 120 | void (*session_close)(struct l2tp_session *session); |
| 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 | */ |
| 127 | void (*show)(struct seq_file *m, void *priv); |
| 128 | |
| 129 | u8 priv[]; /* private data */ |
| 130 | }; |
| 131 | |
| 132 | /* L2TP tunnel configuration */ |
| 133 | struct l2tp_tunnel_cfg { |
| 134 | enum l2tp_encap_type encap; |
| 135 | |
| 136 | /* Used only for kernel-created sockets */ |
| 137 | struct in_addr local_ip; |
| 138 | struct in_addr peer_ip; |
| 139 | #if IS_ENABLED(CONFIG_IPV6) |
| 140 | struct in6_addr *local_ip6; |
| 141 | struct in6_addr *peer_ip6; |
| 142 | #endif |
| 143 | u16 local_udp_port; |
| 144 | u16 peer_udp_port; |
| 145 | unsigned int use_udp_checksums:1, |
| 146 | udp6_zero_tx_checksums:1, |
| 147 | udp6_zero_rx_checksums:1; |
| 148 | }; |
| 149 | |
| 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 | */ |
| 156 | #define L2TP_TUNNEL_NAME_MAX 20 |
| 157 | struct l2tp_tunnel { |
| 158 | int magic; /* Should be L2TP_TUNNEL_MAGIC */ |
| 159 | |
| 160 | unsigned long dead; |
| 161 | |
| 162 | struct rcu_head rcu; |
| 163 | spinlock_t hlist_lock; /* write-protection for session_hlist */ |
| 164 | bool acpt_newsess; /* indicates whether this tunnel accepts |
| 165 | * new sessions. Protected by hlist_lock. |
| 166 | */ |
| 167 | struct hlist_head session_hlist[L2TP_HASH_SIZE]; |
| 168 | /* hashed list of sessions, hashed by id */ |
| 169 | u32 tunnel_id; |
| 170 | u32 peer_tunnel_id; |
| 171 | int version; /* 2=>L2TPv2, 3=>L2TPv3 */ |
| 172 | |
| 173 | char name[L2TP_TUNNEL_NAME_MAX]; /* for logging */ |
| 174 | enum l2tp_encap_type encap; |
| 175 | struct l2tp_stats stats; |
| 176 | |
| 177 | struct list_head list; /* list node on per-namespace list of tunnels */ |
| 178 | struct net *l2tp_net; /* the net we belong to */ |
| 179 | |
| 180 | refcount_t ref_count; |
| 181 | void (*old_sk_destruct)(struct sock *sk); |
| 182 | struct sock *sock; /* parent socket */ |
| 183 | int fd; /* parent fd, if tunnel socket was created |
| 184 | * by userspace |
| 185 | */ |
| 186 | |
| 187 | struct work_struct del_work; |
| 188 | }; |
| 189 | |
| 190 | /* Pseudowire ops callbacks for use with the l2tp genetlink interface */ |
| 191 | struct l2tp_nl_cmd_ops { |
| 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 | */ |
| 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); |
| 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 | */ |
| 207 | void (*session_delete)(struct l2tp_session *session); |
| 208 | }; |
| 209 | |
| 210 | static inline void *l2tp_session_priv(struct l2tp_session *session) |
| 211 | { |
| 212 | return &session->priv[0]; |
| 213 | } |
| 214 | |
| 215 | /* Tunnel and session refcounts */ |
| 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 | |
| 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 | */ |
| 225 | struct l2tp_tunnel *l2tp_tunnel_get(const struct net *net, u32 tunnel_id); |
| 226 | struct l2tp_tunnel *l2tp_tunnel_get_nth(const struct net *net, int nth); |
| 227 | struct l2tp_session *l2tp_tunnel_get_session(struct l2tp_tunnel *tunnel, |
| 228 | u32 session_id); |
| 229 | |
| 230 | struct l2tp_session *l2tp_session_get(const struct net *net, u32 session_id); |
| 231 | struct l2tp_session *l2tp_session_get_nth(struct l2tp_tunnel *tunnel, int nth); |
| 232 | struct l2tp_session *l2tp_session_get_by_ifname(const struct net *net, |
| 233 | const char *ifname); |
| 234 | |
| 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 | */ |
| 239 | int l2tp_tunnel_create(int fd, int version, u32 tunnel_id, |
| 240 | u32 peer_tunnel_id, struct l2tp_tunnel_cfg *cfg, |
| 241 | struct l2tp_tunnel **tunnelp); |
| 242 | int l2tp_tunnel_register(struct l2tp_tunnel *tunnel, struct net *net, |
| 243 | struct l2tp_tunnel_cfg *cfg); |
| 244 | void l2tp_tunnel_delete(struct l2tp_tunnel *tunnel); |
| 245 | |
| 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); |
| 250 | int l2tp_session_register(struct l2tp_session *session, |
| 251 | struct l2tp_tunnel *tunnel); |
| 252 | void l2tp_session_delete(struct l2tp_session *session); |
| 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 | */ |
| 258 | void l2tp_recv_common(struct l2tp_session *session, struct sk_buff *skb, |
| 259 | unsigned char *ptr, unsigned char *optr, u16 hdrflags, |
| 260 | int length); |
| 261 | int l2tp_udp_encap_recv(struct sock *sk, struct sk_buff *skb); |
| 262 | |
| 263 | /* Transmit path helpers for sending packets over the tunnel socket. */ |
| 264 | void l2tp_session_set_header_len(struct l2tp_session *session, int version); |
| 265 | int l2tp_xmit_skb(struct l2tp_session *session, struct sk_buff *skb); |
| 266 | |
| 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); |
| 272 | void l2tp_nl_unregister_ops(enum l2tp_pwtype pw_type); |
| 273 | |
| 274 | /* IOCTL helper for IP encap modules. */ |
| 275 | int l2tp_ioctl(struct sock *sk, int cmd, unsigned long arg); |
| 276 | |
| 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 | |
| 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 | |
| 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 | |
| 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 | |
| 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 | |
| 343 | #define MODULE_ALIAS_L2TP_PWTYPE(type) \ |
| 344 | MODULE_ALIAS("net-l2tp-type-" __stringify(type)) |
| 345 | |
| 346 | #endif /* _L2TP_CORE_H_ */ |