l2tp: add netlink APIs for L2TPv3
Subsystems (3)
James Chapman
maintainerRFC PATCH 7/8 l2tp: add netlink APIs for L2TPv3
Add netlink control API for L2TP.
In L2TPv3, we need to create/delete/modify/query L2TP tunnel and session contexts. The number of parameters is significant. So let's use netlink. Userspace uses this API to control L2TP tunnel/session contexts in the kernel.
net/l2tp/l2tp_netlink.c new file +877 -0
@@ -0,0 +1,877 @@ +/* +* L2TP netlink layer, for management +* +* Copyright (c) 2008,2009 Katalix Systems Ltd +* +* Partly based on the IrDA nelink implementation +* (see net/irda/irnetlink.c) which is: +* Copyright (c) 2007 Samuel Ortiz <[email protected]> +* which is in turn partly based on the wireless netlink code: +* Copyright 2006 Johannes Berg <[email protected]> +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License version 2 as +* published by the Free Software Foundation. +*/ + +#include <net/sock.h> +#include <net/genetlink.h> +#include <net/udp.h> +#include <linux/in.h> +#include <linux/udp.h> +#include <linux/socket.h> +#include <linux/module.h> +#include <linux/list.h> +#include <linux/l2tp.h> + +#include "l2tp_core.h" + + +static struct genl_family l2tp_nl_family = { + .id =GENL_ID_GENERATE , + .name =L2TP_GENL_NAME , + .version =L2TP_GENL_VERSION , + .hdrsize =0 , + .maxattr =L2TP_ATTR_MAX , +}; + +/* Accessed under genl lock */ +static const struct l2tp_nl_cmd_ops *l2tp_nl_cmd_ops[__L2TP_PWTYPE_MAX]; + +static struct l2tp_session *l2tp_nl_session_find (struct genl_info *info) +{ +u32 tunnel_id; +u32 session_id; +char *ifname; +struct l2tp_tunnel *tunnel; +struct l2tp_session *session =NULL ; + +if (info->attrs[L2TP_ATTR_IFNAME ]) { + ifname =nla_data (info->attrs[L2TP_ATTR_IFNAME ]); + session =l2tp_session_find_by_ifname (ifname); + }else if ((info->attrs[L2TP_ATTR_SESSION_ID ]) && + (info->attrs[L2TP_ATTR_CONN_ID ])) { + tunnel_id =nla_get_u32 (info->attrs[L2TP_ATTR_CONN_ID ]); + session_id =nla_get_u32 (info->attrs[L2TP_ATTR_SESSION_ID ]); + tunnel =l2tp_tunnel_find (tunnel_id); +if (tunnel) + session =l2tp_session_find (tunnel, session_id); + } + +return session; +} + +static int l2tp_nl_cmd_noop (struct sk_buff *skb,struct genl_info *info) +{ +struct sk_buff *msg; +void *hdr; +int ret = -ENOBUFS ; + + msg =nlmsg_new (NLMSG_GOODSIZE ,GFP_KERNEL ); +if (!msg) { + ret = -ENOMEM ; + goto out; + } + + hdr =genlmsg_put (msg, info->snd_pid, info->snd_seq, + &l2tp_nl_family,0 ,L2TP_CMD_NOOP ); +if (IS_ERR (hdr)) { + ret =PTR_ERR (hdr); + goto err_out; + } + +genlmsg_end (msg, hdr); + +return genlmsg_unicast (msg, info->snd_pid); + +err_out: +nlmsg_free (msg); + +out: +return ret; +} + +static int l2tp_nl_cmd_tunnel_create (struct sk_buff *skb,struct genl_info *info) +{ +u32 tunnel_id; +u32 peer_tunnel_id; +int proto_version; +int fd; +int ret =0 ; +struct l2tp_tunnel_cfg cfg = {0 , }; +struct l2tp_tunnel *tunnel; + +if (!info->attrs[L2TP_ATTR_CONN_ID ]) { + ret = -EINVAL ; + goto out; + } + tunnel_id =nla_get_u32 (info->attrs[L2TP_ATTR_CONN_ID ]); + +if (!info->attrs[L2TP_ATTR_PEER_CONN_ID ]) { + ret = -EINVAL ; + goto out; + } + peer_tunnel_id =nla_get_u32 (info->attrs[L2TP_ATTR_PEER_CONN_ID ]); + +if (!info->attrs[L2TP_ATTR_PROTO_VERSION ]) { + ret = -EINVAL ; + goto out; + } + proto_version =nla_get_u8 (info->attrs[L2TP_ATTR_PROTO_VERSION ]); + +if (!info->attrs[L2TP_ATTR_ENCAP_TYPE ]) { + ret = -EINVAL ; + goto out; + } + cfg.encap =nla_get_u16 (info->attrs[L2TP_ATTR_ENCAP_TYPE ]); + +if (!info->attrs[L2TP_ATTR_FD ]) { + ret = -EINVAL ; + goto out; + } + fd =nla_get_u32 (info->attrs[L2TP_ATTR_FD ]); + +if (info->attrs[L2TP_ATTR_DEBUG ]) + cfg.debug =nla_get_u32 (info->attrs[L2TP_ATTR_DEBUG ]); + + tunnel =l2tp_tunnel_find (tunnel_id); +if (tunnel !=NULL ) { + ret = -EEXIST ; + goto out; + } + + ret = -EINVAL ; +switch (cfg.encap) { +case L2TP_ENCAPTYPE_UDP : +case L2TP_ENCAPTYPE_IP : + ret =l2tp_tunnel_create (fd, proto_version, tunnel_id, + peer_tunnel_id, &cfg, &tunnel); +break ; + } + +if (ret ==0 ) { + tunnel->nl_pid = info->snd_pid; +l2tp_tunnel_inc_refcount (tunnel); + } + +out: +return ret; +} + +static int l2tp_nl_cmd_tunnel_delete (struct sk_buff *skb,struct genl_info *info) +{ +struct l2tp_tunnel *tunnel; +u32 tunnel_id; +int ret =0 ; + +if (!info->attrs[L2TP_ATTR_CONN_ID ]) { + ret = -EINVAL ; + goto out; + } + tunnel_id =nla_get_u32 (info->attrs[L2TP_ATTR_CONN_ID ]); + + tunnel =l2tp_tunnel_find (tunnel_id); +if (tunnel ==NULL ) { + ret = -ENODEV ; + goto out; + } + +if (tunnel->nl_pid) { + tunnel->nl_pid =0 ; + (void )l2tp_tunnel_delete (tunnel); + } + +out: +return ret; +} + +static int l2tp_nl_cmd_tunnel_modify (struct sk_buff *skb,struct genl_info *info) +{ +struct l2tp_tunnel *tunnel; +u32 tunnel_id; +int ret =0 ; + +if (!info->attrs[L2TP_ATTR_CONN_ID ]) { + ret = -EINVAL ; + goto out; + } + tunnel_id =nla_get_u32 (info->attrs[L2TP_ATTR_CONN_ID ]); + + tunnel =l2tp_tunnel_find (tunnel_id); +if (tunnel ==NULL ) { + ret = -ENODEV ; + goto out; + } + +if (info->attrs[L2TP_ATTR_DEBUG ]) + tunnel->debug =nla_get_u32 (info->attrs[L2TP_ATTR_DEBUG ]); + +out: +return ret; +} + +static int l2tp_nl_tunnel_send (struct sk_buff *skb,u32 pid,u32 seq,int flags, +struct l2tp_tunnel *tunnel) +{ +void *hdr; +struct nlattr *nest; +struct sock *sk =NULL ; +struct inet_sock *inet; + + hdr =genlmsg_put (skb, pid, seq, &l2tp_nl_family, flags, +L2TP_CMD_TUNNEL_GET ); +if (IS_ERR (hdr)) +return PTR_ERR (hdr); + +NLA_PUT_U8 (skb,L2TP_ATTR_PROTO_VERSION , tunnel->version); +NLA_PUT_U32 (skb,L2TP_ATTR_CONN_ID , tunnel->tunnel_id); +NLA_PUT_U32 (skb,L2TP_ATTR_PEER_CONN_ID , tunnel->peer_tunnel_id); +NLA_PUT_U32 (skb,L2TP_ATTR_DEBUG , tunnel->debug); +NLA_PUT_U16 (skb,L2TP_ATTR_ENCAP_TYPE , tunnel->encap); + + nest =nla_nest_start (skb,L2TP_ATTR_STATS ); +if (nest ==NULL ) + goto nla_put_failure; + +NLA_PUT_U64 (skb,L2TP_ATTR_TX_PACKETS , tunnel->stats.tx_packets); +NLA_PUT_U64 (skb,L2TP_ATTR_TX_BYTES , tunnel->stats.tx_bytes); +NLA_PUT_U64 (skb,L2TP_ATTR_TX_ERRORS , tunnel->stats.tx_errors); +NLA_PUT_U64 (skb,L2TP_ATTR_RX_PACKETS , tunnel->stats.rx_packets); +NLA_PUT_U64 (skb,L2TP_ATTR_RX_BYTES , tunnel->stats.rx_bytes); +NLA_PUT_U64 (skb,L2TP_ATTR_RX_SEQ_DISCARDS , tunnel->stats.rx_seq_discards); +NLA_PUT_U64 (skb,L2TP_ATTR_RX_OOS_PACKETS , tunnel->stats.rx_oos_packets); +NLA_PUT_U64 (skb,L2TP_ATTR_RX_ERRORS , tunnel->stats.rx_errors); +nla_nest_end (skb, nest); + + sk = tunnel->sock; +if (!sk) + goto out; + + inet =inet_sk (sk); + +switch (tunnel->encap) { +case L2TP_ENCAPTYPE_UDP : +NLA_PUT_U16 (skb,L2TP_ATTR_UDP_SPORT , inet->sport); +NLA_PUT_U16 (skb,L2TP_ATTR_UDP_DPORT , inet->dport); +if (sk->sk_no_check !=UDP_CSUM_NOXMIT ) +NLA_PUT_FLAG (skb,L2TP_ATTR_UDP_CSUM ); +/* NOBREAK */ +case L2TP_ENCAPTYPE_IP : +NLA_PUT_U32 (skb,L2TP_ATTR_IP_SADDR , inet->saddr); +NLA_PUT_U32 (skb,L2TP_ATTR_IP_DADDR , inet->daddr); +break ; + } + +out: +return genlmsg_end (skb, hdr); + +nla_put_failure: +genlmsg_cancel (skb, hdr); +return -1 ; +} + +static int l2tp_nl_cmd_tunnel_get (struct sk_buff *skb,struct genl_info *info) +{ +struct l2tp_tunnel *tunnel; +struct sk_buff *msg; +u32 tunnel_id; +int ret = -ENOBUFS ; + +if (!info->attrs[L2TP_ATTR_CONN_ID ]) { + ret = -EINVAL ; + goto out; + } + + tunnel_id =nla_get_u32 (info->attrs[L2TP_ATTR_CONN_ID ]); + + tunnel =l2tp_tunnel_find (tunnel_id); +if (tunnel ==NULL ) { + ret = -ENODEV ; + goto out; + } + + msg =nlmsg_new (NLMSG_GOODSIZE ,GFP_KERNEL ); +if (!msg) { + ret = -ENOMEM ; + goto out; + } + + ret =l2tp_nl_tunnel_send (msg, info->snd_pid, info->snd_seq, +NLM_F_ACK , tunnel); +if (ret <0 ) + goto err_out; + +return genlmsg_unicast (msg, info->snd_pid); + +err_out: +nlmsg_free (msg); + +out: +return ret; +} + +static int l2tp_nl_cmd_tunnel_dump (struct sk_buff *skb,struct netlink_callback *cb) +{ +int tunnels_to_skip = cb->args[0 ]; +struct l2tp_tunnel *tunnel; + + tunnel =l2tp_tunnel_find_nth (tunnels_to_skip); +if (tunnel ==NULL ) + goto out; + +l2tp_nl_tunnel_send (skb,NETLINK_CB (cb->skb).pid, + cb->nlh->nlmsg_seq,NLM_F_MULTI , + tunnel); + +out: + cb->args[0 ]++; + +return skb->len; +} + +static int l2tp_nl_cmd_session_create (struct sk_buff *skb,struct genl_info *info) +{ +u32 tunnel_id =0 ; +u32 session_id; +u32 peer_session_id; +int ret =0 ; +struct l2tp_tunnel *tunnel; +struct l2tp_session *session; +struct l2tp_session_cfg cfg = {0 , }; + +if (!info->attrs[L2TP_ATTR_CONN_ID ]) { + ret = -EINVAL ; + goto out; + } + tunnel_id =nla_get_u32 (info->attrs[L2TP_ATTR_CONN_ID ]); + tunnel =l2tp_tunnel_find (tunnel_id); +if (!tunnel) { + ret = -ENODEV ; + goto out; + } + +if (!info->attrs[L2TP_ATTR_SESSION_ID ]) { + ret = -EINVAL ; + goto out; + } + session_id =nla_get_u32 (info->attrs[L2TP_ATTR_SESSION_ID ]); + session =l2tp_session_find (tunnel, session_id); +if (session) { + ret = -EEXIST ; + goto out; + } + +if (!info->attrs[L2TP_ATTR_PEER_SESSION_ID ]) { + ret = -EINVAL ; + goto out; + } + peer_session_id =nla_get_u32 (info->attrs[L2TP_ATTR_PEER_SESSION_ID ]); + +if (!info->attrs[L2TP_ATTR_PW_TYPE ]) { + ret = -EINVAL ; + goto out; + } + cfg.pw_type =nla_get_u16 (info->attrs[L2TP_ATTR_PW_TYPE ]); +if (cfg.pw_type >= __L2TP_PWTYPE_MAX) { + ret = -EINVAL ; + goto out; + } + +if (tunnel->version >2 ) { +if (info->attrs[L2TP_ATTR_OFFSET ]) + cfg.offset =nla_get_u16 (info->attrs[L2TP_ATTR_OFFSET ]); + +if (info->attrs[L2TP_ATTR_DATA_SEQ ]) + cfg.data_seq =nla_get_u8 (info->attrs[L2TP_ATTR_DATA_SEQ ]); + + cfg.l2specific_type =L2TP_L2SPECTYPE_DEFAULT ; +if (info->attrs[L2TP_ATTR_L2SPEC_TYPE ]) + cfg.l2specific_type =nla_get_u8 (info->attrs[L2TP_ATTR_L2SPEC_TYPE ]); + + cfg.l2specific_len =4 ; +if (info->attrs[L2TP_ATTR_L2SPEC_LEN ]) + cfg.l2specific_len =nla_get_u8 (info->attrs[L2TP_ATTR_L2SPEC_LEN ]); + +if (info->attrs[L2TP_ATTR_COOKIE ]) { +u16 len =nla_len (info->attrs[L2TP_ATTR_COOKIE ]); +if (len >8 ) { + ret = -EINVAL ; + goto out; + } + cfg.cookie_len = len; +memcpy (&cfg.cookie[0 ],nla_data (info->attrs[L2TP_ATTR_COOKIE ]), len); + } +if (info->attrs[L2TP_ATTR_PEER_COOKIE ]) { +u16 len =nla_len (info->attrs[L2TP_ATTR_PEER_COOKIE ]); +if (len >8 ) { + ret = -EINVAL ; + goto out; + } + cfg.peer_cookie_len = len; +memcpy (&cfg.peer_cookie[0 ],nla_data (info->attrs[L2TP_ATTR_PEER_COOKIE ]), len); + } +if (info->attrs[L2TP_ATTR_IFNAME ]) + cfg.ifname =nla_data (info->attrs[L2TP_ATTR_IFNAME ]); + +if (info->attrs[L2TP_ATTR_VLAN_ID ]) + cfg.vlan_id =nla_get_u16 (info->attrs[L2TP_ATTR_VLAN_ID ]); + } + +if (info->attrs[L2TP_ATTR_DEBUG ]) + cfg.debug =nla_get_u32 (info->attrs[L2TP_ATTR_DEBUG ]); + +if (info->attrs[L2TP_ATTR_RECV_SEQ ]) + cfg.recv_seq =nla_get_flag (info->attrs[L2TP_ATTR_RECV_SEQ ]); + +if (info->attrs[L2TP_ATTR_SEND_SEQ ]) + cfg.send_seq =nla_get_flag (info->attrs[L2TP_ATTR_SEND_SEQ ]); + +if (info->attrs[L2TP_ATTR_LNS_MODE ]) + cfg.lns_mode =nla_get_flag (info->attrs[L2TP_ATTR_LNS_MODE ]); + +if (info->attrs[L2TP_ATTR_RECV_TIMEOUT ]) + cfg.reorder_timeout =nla_get_msecs (info->attrs[L2TP_ATTR_RECV_TIMEOUT ]); + +if (info->attrs[L2TP_ATTR_MTU ]) + cfg.mtu =nla_get_u16 (info->attrs[L2TP_ATTR_MTU ]); + +if (info->attrs[L2TP_ATTR_MRU ]) + cfg.mru =nla_get_u16 (info->attrs[L2TP_ATTR_MRU ]); + +if ((l2tp_nl_cmd_ops[cfg.pw_type] ==NULL ) || + (l2tp_nl_cmd_ops[cfg.pw_type]->session_create ==NULL )) { + ret = -EPROTONOSUPPORT ; + goto out; + } + +/* Check that pseudowire-specific params are present */ +switch (cfg.pw_type) { +case L2TP_PWTYPE_NONE : +break ; +case L2TP_PWTYPE_ETH_VLAN : +if (!info->attrs[L2TP_ATTR_VLAN_ID ]) { + ret = -EINVAL ; + goto out; + } +break ; +case L2TP_PWTYPE_ETH : +break ; +case L2TP_PWTYPE_PPP : +case L2TP_PWTYPE_PPP_AC : +break ; +case L2TP_PWTYPE_IP : +default : + ret = -EPROTONOSUPPORT ; +break ; + } + + ret = -EPROTONOSUPPORT ; +if (l2tp_nl_cmd_ops[cfg.pw_type]->session_create) + ret = (*l2tp_nl_cmd_ops[cfg.pw_type]->session_create)(tunnel_id, session_id, peer_session_id, &cfg); + + session =l2tp_session_find (tunnel, session_id); +if ((ret ==0 ) && (session)) { + session->nl_pid = info->snd_pid; +l2tp_session_inc_refcount (session); + } + +out: +return ret; +} + +static int l2tp_nl_cmd_session_delete (struct sk_buff *skb,struct genl_info *info) +{ +int ret =0 ; +struct l2tp_session *session; +u16 pw_type; + + session =l2tp_nl_session_find (info); +if (session ==NULL ) { + ret = -ENODEV ; + goto out; + } + +if (session->nl_pid) { + session->nl_pid =0 ; + pw_type = session->pwtype; +if (pw_type < __L2TP_PWTYPE_MAX) +if (l2tp_nl_cmd_ops[pw_type] && l2tp_nl_cmd_ops[pw_type]->session_delete) + ret = (*l2tp_nl_cmd_ops[pw_type]->session_delete)(session); + +l2tp_session_dec_refcount (session); + } + +out: +return ret; +} + +static int l2tp_nl_cmd_session_modify (struct sk_buff *skb,struct genl_info *info) +{ +int ret =0 ; +struct l2tp_session *session; + + session =l2tp_nl_session_find (info); +if (session ==NULL ) { + ret = -ENODEV ; + goto out; + } + +if (info->attrs[L2TP_ATTR_DEBUG ]) + session->debug =nla_get_u32 (info->attrs[L2TP_ATTR_DEBUG ]); + +if (info->attrs[L2TP_ATTR_DATA_SEQ ]) + session->data_seq =nla_get_flag (info->attrs[L2TP_ATTR_DATA_SEQ ]); + +if (info->attrs[L2TP_ATTR_RECV_SEQ ]) + session->recv_seq =nla_get_flag (info->attrs[L2TP_ATTR_RECV_SEQ ]); + +if (info->attrs[L2TP_ATTR_SEND_SEQ ]) + session->send_seq =nla_get_flag (info->attrs[L2TP_ATTR_SEND_SEQ ]); + +if (info->attrs[L2TP_ATTR_LNS_MODE ]) + session->lns_mode =nla_get_flag (info->attrs[L2TP_ATTR_LNS_MODE ]); + +if (info->attrs[L2TP_ATTR_RECV_TIMEOUT ]) + session->reorder_timeout =nla_get_msecs (info->attrs[L2TP_ATTR_RECV_TIMEOUT ]); + +if (info->attrs[L2TP_ATTR_MTU ]) + session->mtu =nla_get_u16 (info->attrs[L2TP_ATTR_MTU ]); + +if (info->attrs[L2TP_ATTR_MRU ]) + session->mru =nla_get_u16 (info->attrs[L2TP_ATTR_MRU ]); + +out: +return ret; +} + +static int l2tp_nl_session_send (struct sk_buff *skb,u32 pid,u32 seq,int flags, +struct l2tp_session *session) +{ +void *hdr; +struct nlattr *nest; +struct l2tp_tunnel *tunnel = session->tunnel; +char *ifname =NULL ; +struct sock *sk =NULL ; + +if (session->get_info) + session->get_info (&ifname); + + sk = tunnel->sock; + + hdr =genlmsg_put (skb, pid, seq, &l2tp_nl_family, flags,L2TP_CMD_SESSION_GET ); +if (IS_ERR (hdr)) +return PTR_ERR (hdr); + +NLA_PUT_U32 (skb,L2TP_ATTR_CONN_ID , tunnel->tunnel_id); +NLA_PUT_U32 (skb,L2TP_ATTR_SESSION_ID , session->session_id); +NLA_PUT_U32 (skb,L2TP_ATTR_PEER_CONN_ID , tunnel->peer_tunnel_id); +NLA_PUT_U32 (skb,L2TP_ATTR_PEER_SESSION_ID , session->peer_session_id); +NLA_PUT_U32 (skb,L2TP_ATTR_DEBUG , session->debug); +NLA_PUT_U16 (skb,L2TP_ATTR_PW_TYPE , session->pwtype); +NLA_PUT_U16 (skb,L2TP_ATTR_MTU , session->mtu); +if (session->mru) +NLA_PUT_U16 (skb,L2TP_ATTR_MRU , session->mru); + +if (ifname && ifname[0 ]) +NLA_PUT_STRING (skb,L2TP_ATTR_IFNAME , ifname); +if (session->cookie_len) +NLA_PUT (skb,L2TP_ATTR_COOKIE , session->cookie_len, &session->cookie[0 ]); +if (session->peer_cookie_len) +NLA_PUT (skb,L2TP_ATTR_PEER_COOKIE , session->peer_cookie_len, &session->peer_cookie[0 ]); +if (session->recv_seq) +NLA_PUT_FLAG (skb,L2TP_ATTR_RECV_SEQ ); +if (session->send_seq) +NLA_PUT_FLAG (skb,L2TP_ATTR_SEND_SEQ ); +if (session->lns_mode) +NLA_PUT_FLAG (skb,L2TP_ATTR_LNS_MODE ); +#ifdef CONFIG_XFRM +if ((sk) && (sk->sk_policy[0 ] || sk->sk_policy[1 ])) +NLA_PUT_FLAG (skb,L2TP_ATTR_USING_IPSEC ); +#endif +if (session->reorder_timeout) +NLA_PUT_MSECS (skb,L2TP_ATTR_RECV_TIMEOUT , session->reorder_timeout); + + nest =nla_nest_start (skb,L2TP_ATTR_STATS ); +if (nest ==NULL ) + goto nla_put_failure; +NLA_PUT_U64 (skb,L2TP_ATTR_TX_PACKETS , session->stats.tx_packets); +NLA_PUT_U64 (skb,L2TP_ATTR_TX_BYTES , session->stats.tx_bytes); +NLA_PUT_U64 (skb,L2TP_ATTR_TX_ERRORS , session->stats.tx_errors); +NLA_PUT_U64 (skb,L2TP_ATTR_RX_PACKETS , session->stats.rx_packets); +NLA_PUT_U64 (skb,L2TP_ATTR_RX_BYTES , session->stats.rx_bytes); +NLA_PUT_U64 (skb,L2TP_ATTR_RX_SEQ_DISCARDS , session->stats.rx_seq_discards); +NLA_PUT_U64 (skb,L2TP_ATTR_RX_OOS_PACKETS , session->stats.rx_oos_packets); +NLA_PUT_U64 (skb,L2TP_ATTR_RX_ERRORS , session->stats.rx_errors); +nla_nest_end (skb, nest); + +return genlmsg_end (skb, hdr); + + nla_put_failure: +genlmsg_cancel (skb, hdr); +return -1 ; +} + +static int l2tp_nl_cmd_session_get (struct sk_buff *skb,struct genl_info *info) +{ +struct l2tp_session *session; +struct sk_buff *msg; +int ret; + + session =l2tp_nl_session_find (info); +if (session ==NULL ) { + ret = -ENODEV ; + goto out; + } + + msg =nlmsg_new (NLMSG_GOODSIZE ,GFP_KERNEL ); +if (!msg) { + ret = -ENOMEM ; + goto out; + } + + ret =l2tp_nl_session_send (msg, info->snd_pid, info->snd_seq, +0 , session); +if (ret <0 ) + goto err_out; + +return genlmsg_unicast (msg, info->snd_pid); + +err_out: +nlmsg_free (msg); + +out: +return ret; +} + +static int l2tp_nl_cmd_session_dump (struct sk_buff *skb,struct netlink_callback *cb) +{ +int sessions_to_skip = cb->args[0 ]; +struct l2tp_session *session; +struct l2tp_tunnel *tunnel; +int tun; +int skipped; + +for (tun =0 ;/* nothing */ ; tun++) { + tunnel =l2tp_tunnel_find_nth (tun); +if (tunnel ==NULL ) +break ; + + session =l2tp_session_find_nth (tunnel, sessions_to_skip, &skipped); +if (session ==NULL ) { + sessions_to_skip -= skipped; +continue ; + } + +if (l2tp_nl_session_send (skb,NETLINK_CB (cb->skb).pid, + cb->nlh->nlmsg_seq,NLM_F_MULTI , + session) <0 ) +break ; + } + + cb->args[0 ]++; + +return skb->len; +} + +static struct nla_policy l2tp_nl_policy[L2TP_ATTR_MAX +1 ] = { + [L2TP_ATTR_NONE ] = { .type =NLA_UNSPEC , }, + [L2TP_ATTR_PW_TYPE ] = { .type =NLA_U16 , }, + [L2TP_ATTR_ENCAP_TYPE ] = { .type =NLA_U16 , }, + [L2TP_ATTR_OFFSET ] = { .type =NLA_U16 , }, + [L2TP_ATTR_DATA_SEQ ] = { .type =NLA_U8 , }, + [L2TP_ATTR_L2SPEC_TYPE ] = { .type =NLA_U8 , }, + [L2TP_ATTR_L2SPEC_LEN ] = { .type =NLA_U8 , }, + [L2TP_ATTR_PROTO_VERSION ] = { .type =NLA_U8 , }, + [L2TP_ATTR_CONN_ID ] = { .type =NLA_U32 , }, + [L2TP_ATTR_PEER_CONN_ID ] = { .type =NLA_U32 , }, + [L2TP_ATTR_SESSION_ID ] = { .type =NLA_U32 , }, + [L2TP_ATTR_PEER_SESSION_ID ] = { .type =NLA_U32 , }, + [L2TP_ATTR_UDP_CSUM ] = { .type =NLA_FLAG , }, + [L2TP_ATTR_VLAN_ID ] = { .type =NLA_U16 , }, + [L2TP_ATTR_DEBUG ] = { .type =NLA_U32 , }, + [L2TP_ATTR_RECV_SEQ ] = { .type =NLA_FLAG , }, + [L2TP_ATTR_SEND_SEQ ] = { .type =NLA_FLAG , }, + [L2TP_ATTR_LNS_MODE ] = { .type =NLA_FLAG , }, + [L2TP_ATTR_USING_IPSEC ] = { .type =NLA_FLAG , }, + [L2TP_ATTR_RECV_TIMEOUT ] = { .type =NLA_MSECS , }, + [L2TP_ATTR_FD ] = { .type =NLA_U32 , }, + [L2TP_ATTR_IP_SADDR ] = { .type =NLA_U32 , }, + [L2TP_ATTR_IP_DADDR ] = { .type =NLA_U32 , }, + [L2TP_ATTR_UDP_SPORT ] = { .type =NLA_U16 , }, + [L2TP_ATTR_UDP_DPORT ] = { .type =NLA_U16 , }, + [L2TP_ATTR_MTU ] = { .type =NLA_U16 , }, + [L2TP_ATTR_MRU ] = { .type =NLA_U16 , }, + [L2TP_ATTR_STATS ] = { .type =NLA_NESTED , }, + [L2TP_ATTR_IFNAME ] = { + .type =NLA_NUL_STRING , + .len =IFNAMSIZ -1 , + }, + [L2TP_ATTR_COOKIE ] = { + .type =NLA_BINARY , + .len =8 , + }, + [L2TP_ATTR_PEER_COOKIE ] = { + .type =NLA_BINARY , + .len =8 , + }, +}; + +static struct genl_ops l2tp_nl_ops[] = { + { + .cmd =L2TP_CMD_NOOP , + .doit = l2tp_nl_cmd_noop, + .policy = l2tp_nl_policy, +/* can be retrieved by unprivileged users */ + }, + { + .cmd =L2TP_CMD_TUNNEL_CREATE , + .doit = l2tp_nl_cmd_tunnel_create, + .policy = l2tp_nl_policy, + .flags =GENL_ADMIN_PERM , + }, + { + .cmd =L2TP_CMD_TUNNEL_DELETE , + .doit = l2tp_nl_cmd_tunnel_delete, + .policy = l2tp_nl_policy, + .flags =GENL_ADMIN_PERM , + }, + { + .cmd =L2TP_CMD_TUNNEL_MODIFY , + .doit = l2tp_nl_cmd_tunnel_modify, + .policy = l2tp_nl_policy, + .flags =GENL_ADMIN_PERM , + }, + { + .cmd =L2TP_CMD_TUNNEL_GET , + .doit = l2tp_nl_cmd_tunnel_get, + .dumpit = l2tp_nl_cmd_tunnel_dump, + .policy = l2tp_nl_policy, + .flags =GENL_ADMIN_PERM , + }, + { + .cmd =L2TP_CMD_SESSION_CREATE , + .doit = l2tp_nl_cmd_session_create, + .policy = l2tp_nl_policy, + .flags =GENL_ADMIN_PERM , + }, + { + .cmd =L2TP_CMD_SESSION_DELETE , + .doit = l2tp_nl_cmd_session_delete, + .policy = l2tp_nl_policy, + .flags =GENL_ADMIN_PERM , + }, + { + .cmd =L2TP_CMD_SESSION_MODIFY , + .doit = l2tp_nl_cmd_session_modify, + .policy = l2tp_nl_policy, + .flags =GENL_ADMIN_PERM , + }, + { + .cmd =L2TP_CMD_SESSION_GET , + .doit = l2tp_nl_cmd_session_get, + .dumpit = l2tp_nl_cmd_session_dump, + .policy = l2tp_nl_policy, + .flags =GENL_ADMIN_PERM , + }, +}; + +static void l2tp_nl_tunnel_cleanup (struct l2tp_tunnel *tunnel,void *arg) +{ +u32 nl_pid = (u32 ) arg; + +if (tunnel->nl_pid == nl_pid) { + tunnel->nl_pid =0 ; +/* Close all sessions */ +l2tp_tunnel_closeall (tunnel); +l2tp_tunnel_dec_refcount (tunnel); + } +} + +static int l2tp_nl_notify (struct notifier_block *nb,unsigned long event,void *arg) +{ +struct netlink_notify *nn = arg; + +switch (event) { +case NETLINK_URELEASE : +l2tp_tunnel_list_walk (l2tp_nl_tunnel_cleanup, (void *) nn->pid); +break ; + } + +return NOTIFY_DONE ; +} + +static struct notifier_block l2tp_nl_notifier = { + .notifier_call = l2tp_nl_notify, +}; + +int l2tp_nl_register_ops (enum l2tp_pwtype pw_type,const struct l2tp_nl_cmd_ops *ops) +{ +int ret; + + ret = -EINVAL ; +if (pw_type >= __L2TP_PWTYPE_MAX) + goto err; + +genl_lock (); + ret = -EBUSY ; +if (l2tp_nl_cmd_ops[pw_type]) + goto out; + + l2tp_nl_cmd_ops[pw_type] = ops; + +out: +genl_unlock (); +err: +return 0 ; +} +EXPORT_SYMBOL_GPL (l2tp_nl_register_ops); + +void l2tp_nl_unregister_ops (enum l2tp_pwtype pw_type) +{ +if (pw_type < __L2TP_PWTYPE_MAX) { +genl_lock (); + l2tp_nl_cmd_ops[pw_type] =NULL ; +genl_unlock (); + } +} +EXPORT_SYMBOL_GPL (l2tp_nl_unregister_ops); + +static int l2tp_nl_init (void ) +{ +int err, i; + +printk (KERN_INFO "L2TP netlink interface: %s\n" , __DATE__" " __TIME__); + err =genl_register_family (&l2tp_nl_family); +if (err) +return err; + +for (i =0 ; i <ARRAY_SIZE (l2tp_nl_ops); i++) { + err =genl_register_ops (&l2tp_nl_family, &l2tp_nl_ops[i]); +if (err) + goto err_out; + } + + err =netlink_register_notifier (&l2tp_nl_notifier); +if (err) + goto err_out; + +return 0 ; + +err_out: +genl_unregister_family (&l2tp_nl_family); +return err; +} + +void l2tp_nl_cleanup (void ) +{ +genl_unregister_family (&l2tp_nl_family); +netlink_unregister_notifier (&l2tp_nl_notifier); +} + +module_init (l2tp_nl_init); +module_exit (l2tp_nl_cleanup); + +MODULE_AUTHOR ("James Chapman <[email protected]>" ); +MODULE_DESCRIPTION ("L2TP netlink" ); +MODULE_LICENSE ("GPL" ); +MODULE_VERSION ("1.0" );
include/linux/l2tp.h +126 -0
142 lines not on this page · raw message
net/l2tp/Makefile +1 -0
@@ -7,3 +7,4 @@ obj-$(CONFIG_L2TP) += l2tp_core.o # Build l2tp as modules if L2TP is M obj-$(subst y,$(CONFIG_L2TP),$(CONFIG_PPPOL2TP)) += l2tp_ppp.o obj-$(subst y,$(CONFIG_L2TP),$(CONFIG_L2TP_IP)) += l2tp_ip.o +obj-$(subst y,$(CONFIG_L2TP),$(CONFIG_L2TP_V3)) += l2tp_netlink.o
net/l2tp/l2tp_core.h +20 -20
@@ -33,26 +33,6 @@ enum { L2TP_MSG_DATA = (1 << 3), /* data packets */ }; -enum l2tp_pwtype { -L2TP_PWTYPE_NONE =0x0000 , -L2TP_PWTYPE_ETH_VLAN =0x0004 , -L2TP_PWTYPE_ETH =0x0005 , -L2TP_PWTYPE_PPP =0x0007 , -L2TP_PWTYPE_PPP_AC =0x0008 , -L2TP_PWTYPE_IP =0x000b , - __L2TP_PWTYPE_MAX -}; - -enum l2tp_l2spec_type { -L2TP_L2SPECTYPE_NONE , -L2TP_L2SPECTYPE_DEFAULT , -}; - -enum l2tp_encap_type { -L2TP_ENCAPTYPE_UDP , -L2TP_ENCAPTYPE_IP , -}; -struct sk_buff ;struct l2tp_stats {
@@ -126,6 +106,7 @@ struct l2tp_session {atomic_t ref_count;char name[32 ];/* for logging */ +char ifname[IFNAMSIZ ]; unsigned data_seq:2; /* data sequencing level* 0 => none, 1 => IP only, * 2 => all
@@ -146,12 +127,15 @@ struct l2tp_session {enum l2tp_pwtype pwtype;struct l2tp_stats stats;struct hlist_node global_hlist;/* Global hash list node */ +u32 nl_pid;/* Netlink pid of creator */ int (*build_header)(struct l2tp_session *session,void *buf);void (*recv_skb)(struct l2tp_session *session,struct sk_buff *skb,int data_len);void (*session_close)(struct l2tp_session *session);void (*ref)(struct l2tp_session *session);void (*deref)(struct l2tp_session *session); +char *(*get_ifname)(void ); +void (*get_info)(char **ifname);#ifdef CONFIG_PROC_FS void (*show)(struct seq_file *m,void *priv);#endif
@@ -192,10 +176,16 @@ struct l2tp_tunnel {void (*old_sk_destruct)(struct sock *);struct sock *sock;/* Parent socket */ int fd; +u32 nl_pid;/* Netlink pid of creator */ uint8_t priv[0 ];/* private data */ }; +struct l2tp_nl_cmd_ops { +int (*session_create)(u32 tunnel_id,u32 session_id,u32 peer_session_id,struct l2tp_session_cfg *cfg); +int (*session_delete)(struct l2tp_session *session); +}; +static inline void *l2tp_tunnel_priv (struct l2tp_tunnel *tunnel) {return &tunnel->priv[0 ];
@@ -227,10 +217,17 @@ out: }extern struct l2tp_session *l2tp_session_find (struct l2tp_tunnel *tunnel,u32 session_id); +extern struct l2tp_session *l2tp_session_find_nth (struct l2tp_tunnel *tunnel,int nth,int *skipped); +extern struct l2tp_session *l2tp_session_find_by_ifname (char *ifname);extern struct l2tp_tunnel *l2tp_tunnel_find (u32 tunnel_id); +extern struct l2tp_tunnel *l2tp_tunnel_find_nth (int nth); +extern void l2tp_tunnel_list_walk (void (*func)(struct l2tp_tunnel *tunnel,void *arg),void *arg); +extern void l2tp_session_list_walk (void (*func)(struct l2tp_session *session,void *arg),void *arg);extern int l2tp_tunnel_create (int fd,int version,u32 tunnel_id,u32 peer_tunnel_id,struct l2tp_tunnel_cfg *cfg,struct l2tp_tunnel **tunnelp); +extern int l2tp_tunnel_delete (struct l2tp_tunnel *tunnel);extern struct l2tp_session *l2tp_session_create (int priv_size,struct l2tp_tunnel *tunnel,u32 session_id,u32 peer_session_id,struct l2tp_session_cfg *cfg); +extern int l2tp_session_delete (struct l2tp_session *session);extern void l2tp_tunnel_free (struct l2tp_tunnel *tunnel);extern void l2tp_session_free (struct l2tp_session *session);extern void l2tp_recv_common (struct l2tp_session *session,struct sk_buff *skb,unsigned char *ptr,unsigned char *optr,u16 hdrflags,int length,int (*payload_hook)(struct sk_buff *skb));
@@ -243,6 +240,9 @@ extern void l2tp_tunnel_destruct(structextern void l2tp_tunnel_closeall (struct l2tp_tunnel *tunnel);extern void l2tp_session_set_header_len (struct l2tp_session *session,int version); +extern int l2tp_nl_register_ops (enum l2tp_pwtype pw_type,const struct l2tp_nl_cmd_ops *ops); +extern void l2tp_nl_unregister_ops (enum l2tp_pwtype pw_type); +/* Tunnel reference counts. Incremented per session that is added to * the tunnel. */
net/l2tp/l2tp_ppp.c +134 -43
279 lines not on this page · raw message
net/l2tp/l2tp_core.c +150 -7
199 lines not on this page · raw message