Add some configuration options for IPv6CP (the same as for IPCP) as well as an "ipv6cp_enable" flag to enable IPv6 for a session (enabled by default).
Signed-off-by: Benjamin Cama <[email protected]> --- doc/l2tpconfig.1 | 11 +++++++ l2tp_common.c | 7 +++++ l2tp_config.c | 76 +++++++++++++++++++++++++++++++++++++++++++++++++-- l2tp_config_parse.y | 30 ++++++++++++++++++++ l2tp_config_token.l | 5 +++ l2tp_ppp.c | 50 +++++++++++++++++++++++++++++++++ l2tp_rpc.x | 15 ++++++++++ plugins/ppp_unix.c | 10 +++++++ 8 files changed, 201 insertions(+), 3 deletions(-) diff --git a/doc/l2tpconfig.1 b/doc/l2tpconfig.1 index 165fe0e..ae9f177 100644 --- a/doc/l2tpconfig.1 +++ b/doc/l2tpconfig.1 @@ -461,6 +461,17 @@ ipcp_max_cfg_naks - Maximum number of IPCP config-naks to allow ipcp_max_term_reqs - Maximum number of IPCP term-requests to send. Default=3. ipcp_retransmit_interval - IPCP retransmission timeout. Default=3. +ipv6cp_enable - Enable IPv6CP. This will allow for IPv6 + communications. Default: YES +ipv6cp_max_config_requests - Maximum number of IPv6CP config-requests to + transmit without successful acknowledgement + before declaring a failure. Default=10. +ipv6cp_max_config_naks - Maximum number of IPv6CP config-naks to allow + before starting to send config-rejects + instead. Default=10. +ipv6cp_max_terminate_requests - Maximum number of IPv6CP term-requests + to send. Default=3. +ipv6cp_retransmit_interval - IPv6CP retransmission timeout. Default=3. lcp_echo_fail_count - Number of LCP echo failures to accept before assuming peer is down. Default=5. lcp_echo_interval - Send LCP echo-request to peer every N diff --git a/l2tp_common.c b/l2tp_common.c index 9da4e92..944c4a9 100644 --- a/l2tp_common.c +++ b/l2tp_common.c @@ -976,6 +976,13 @@ int l2tp_show_ppp_profile(FILE *file, struct l2tp_api_ppp_profile_msg_data *pp) " max terminate requests: %d, retransmit interval: %d\n", pp->ipcp_max_config_requests, pp->ipcp_max_config_naks, pp->ipcp_max_terminate_requests, pp->ipcp_retransmit_interval); + if (pp->ipv6cp_enable) { + len += fprintf(file, " IPv6CP parameters:-\n"); + len += fprintf(file, " max config requests: %d, max config naks: %d\n" + " max terminate requests: %d, retransmit interval: %d\n", + pp->ipv6cp_max_config_requests, pp->ipv6cp_max_config_naks, + pp->ipv6cp_max_terminate_requests, pp->ipv6cp_retransmit_interval); + } len += fprintf(file, "\n"); return len; diff --git a/l2tp_config.c b/l2tp_config.c index 6c6089c..f711b46 100644 --- a/l2tp_config.c +++ b/l2tp_config.c @@ -3123,6 +3123,11 @@ typedef enum { L2TP_PPP_ARGID_LOCAL_NAME, L2TP_PPP_ARGID_REMOTE_NAME, L2TP_PPP_ARGID_PROXY_ARP, + L2TP_PPP_ARGID_IPV6CP_ENABLE, + L2TP_PPP_ARGID_IPV6CP_MAX_CFG_REQS, + L2TP_PPP_ARGID_IPV6CP_MAX_CFG_NAKS, + L2TP_PPP_ARGID_IPV6CP_MAX_TERM_REQS, + L2TP_PPP_ARGID_IPV6CP_RETX_INTVL, } l2tp_ppp_arg_ids_t; #undef ARG @@ -3187,7 +3192,14 @@ typedef enum { ARG(REMOTE_NAME, "remote_name", 0, string, "Name to assume for the remote peer for authentication purposes"), \ ARG(USE_AS_DEFAULT_ROUTE, "default_route", 0, bool, "Use link as default route"), \ ARG(MULTILINK, "multilink", 0, bool, "Enable PPP multilink connections."), \ - ARG(PROXY_ARP, "proxy_arp", 0, bool, "Use proxy arp.") + ARG(PROXY_ARP, "proxy_arp", 0, bool, "Use proxy arp."), \ + ARG(IPV6CP_ENABLE, "ipv6cp_enable", 0, bool, "Enable IPv6CP"), \ + ARG(IPV6CP_MAX_CFG_REQS,"ipv6cp_max_config_requests", 0, int32, ("Maximum number of IPv6CP config-requests to transmit without successful " \ + "acknowledgement before declaring a failure. Default=10.")), \ + ARG(IPV6CP_MAX_CFG_NAKS,"ipv6cp_max_config_naks", 0, int32, ("Maximum number of IPv6CP config-naks to allow before starting to send " \ + "config-rejects instead. Default=10.")), \ + ARG(IPV6CP_MAX_TERM_REQS,"ipv6cp_max_terminate_requests", 0, int32, "Maximum number of IPv6CP term-requests to send. Default=3."), \ + ARG(IPV6CP_RETX_INTVL, "ipv6cp_retransmit_interval", 0, int32, "IPv6CP retransmission timeout. Default=3.") static struct cli_arg_entry l2tp_args_ppp_profile_create[] = { @@ -3266,7 +3278,14 @@ static struct cli_arg_entry l2tp_args_ppp_profile_unset[] = { FLG(REMOTE_NAME, "remote_name", "Name to assume for the remote peer for authentication purposes"), \ FLG(USE_AS_DEFAULT_ROUTE, "default_route", "Use link as default route"), \ FLG(MULTILINK, "multilink", "Enable PPP multilink connections."), \ - FLG(PROXY_ARP, "proxy_arp", "Use proxy arp."), + FLG(PROXY_ARP, "proxy_arp", "Use proxy arp."), \ + FLG(IPV6CP_ENABLE, "ipv6cp_enable", "Enable IPv6CP"), \ + FLG(IPV6CP_MAX_CFG_REQS,"ipv6cp_max_config_requests", ("Maximum number of IPv6CP config-requests to transmit without successful " \ + "acknowledgement before declaring a failure. Default=10.")), \ + FLG(IPV6CP_MAX_CFG_NAKS,"ipv6cp_max_config_naks", ("Maximum number of IPv6CP config-naks to allow before starting to send " \ + "config-rejects instead. Default=10.")), \ + FLG(IPV6CP_MAX_TERM_REQS,"ipv6cp_max_terminate_requests", "Maximum number of IPv6CP term-requests to send. Default=3."), \ + FLG(IPV6CP_RETX_INTVL, "ipv6cp_retransmit_interval", "IPv6CP retransmission timeout. Default=3."), { NULL, }, }; @@ -3488,6 +3507,22 @@ static int l2tp_parse_ppp_profile_arg(l2tp_ppp_arg_ids_t arg_id, struct cli_node msg->remote_name.valid = 1; msg->flags2 |= L2TP_API_PPP_PROFILE_FLAG_REMOTE_NAME; break; + case L2TP_PPP_ARGID_IPV6CP_ENABLE: + L2TP_ACT_PARSE_ARG(arg, arg_value, ints[0], msg->flags2, L2TP_API_PPP_PROFILE_FLAG_IPV6CP_ENABLE); + msg->ipv6cp_enable = ints[0]; + break; + case L2TP_PPP_ARGID_IPV6CP_MAX_CFG_REQS: + L2TP_ACT_PARSE_ARG(arg, arg_value, msg->ipv6cp_max_config_requests, msg->flags2, L2TP_API_PPP_PROFILE_FLAG_IPV6CP_MAX_CONFIG_REQUESTS); + break; + case L2TP_PPP_ARGID_IPV6CP_MAX_CFG_NAKS: + L2TP_ACT_PARSE_ARG(arg, arg_value, msg->ipv6cp_max_config_naks, msg->flags2, L2TP_API_PPP_PROFILE_FLAG_IPV6CP_MAX_CONFIG_NAKS); + break; + case L2TP_PPP_ARGID_IPV6CP_MAX_TERM_REQS: + L2TP_ACT_PARSE_ARG(arg, arg_value, msg->ipv6cp_max_terminate_requests, msg->flags2, L2TP_API_PPP_PROFILE_FLAG_IPV6CP_MAX_TERMINATE_REQUESTS); + break; + case L2TP_PPP_ARGID_IPV6CP_RETX_INTVL: + L2TP_ACT_PARSE_ARG(arg, arg_value, msg->ipv6cp_retransmit_interval, msg->flags2, L2TP_API_PPP_PROFILE_FLAG_IPV6CP_RETRANSMIT_INTERVAL); + break; } result = 0; @@ -3856,6 +3891,21 @@ static int l2tp_act_ppp_profile_unset(struct cli_node *node, int argc, char *arg case L2TP_PPP_ARGID_REMOTE_NAME: msg.flags2 |= L2TP_API_PPP_PROFILE_FLAG_REMOTE_NAME; break; + case L2TP_PPP_ARGID_IPV6CP_ENABLE: + msg.flags2 |= L2TP_API_PPP_PROFILE_FLAG_IPV6CP_ENABLE; + break; + case L2TP_PPP_ARGID_IPV6CP_MAX_CFG_REQS: + msg.flags2 |= L2TP_API_PPP_PROFILE_FLAG_IPV6CP_MAX_CONFIG_REQUESTS; + break; + case L2TP_PPP_ARGID_IPV6CP_MAX_CFG_NAKS: + msg.flags2 |= L2TP_API_PPP_PROFILE_FLAG_IPV6CP_MAX_CONFIG_NAKS; + break; + case L2TP_PPP_ARGID_IPV6CP_MAX_TERM_REQS: + msg.flags2 |= L2TP_API_PPP_PROFILE_FLAG_IPV6CP_MAX_TERMINATE_REQUESTS; + break; + case L2TP_PPP_ARGID_IPV6CP_RETX_INTVL: + msg.flags2 |= L2TP_API_PPP_PROFILE_FLAG_IPV6CP_RETRANSMIT_INTERVAL; + break; } } L2TP_ACT_END(); @@ -4873,7 +4923,12 @@ static void l2tp_config_dump_ppp_profile(FILE *file, struct l2tp_api_ppp_profile L2TP_API_PPP_PROFILE_FLAG_AUTH_REFUSE_MSCHAP | L2TP_API_PPP_PROFILE_FLAG_AUTH_REFUSE_CHAP | L2TP_API_PPP_PROFILE_FLAG_AUTH_REFUSE_PAP | - L2TP_API_PPP_PROFILE_FLAG_AUTH_PEER))) { + L2TP_API_PPP_PROFILE_FLAG_AUTH_PEER | + L2TP_API_PPP_PROFILE_FLAG_IPV6CP_ENABLE | + L2TP_API_PPP_PROFILE_FLAG_IPV6CP_MAX_CONFIG_REQUESTS | + L2TP_API_PPP_PROFILE_FLAG_IPV6CP_MAX_CONFIG_NAKS | + L2TP_API_PPP_PROFILE_FLAG_IPV6CP_MAX_TERMINATE_REQUESTS | + L2TP_API_PPP_PROFILE_FLAG_IPV6CP_RETRANSMIT_INTERVAL))) { fprintf(file, "ppp profile modify profile_name=%s \\\n", cfg->profile_name); @@ -5028,6 +5083,21 @@ static void l2tp_config_dump_ppp_profile(FILE *file, struct l2tp_api_ppp_profile if (cfg->flags2 & L2TP_API_PPP_PROFILE_FLAG_PROXY_ARP) { fprintf(file, "\tproxy_arp=%s \\\n", Y_OR_N(cfg->proxy_arp)); } + if (cfg->flags2 & L2TP_API_PPP_PROFILE_FLAG_IPV6CP_ENABLE) { + fprintf(file, "\tipv6cp_enable=%s \\\n", Y_OR_N(cfg->ipv6cp_enable)); + } + if (cfg->flags2 & L2TP_API_PPP_PROFILE_FLAG_IPV6CP_MAX_CONFIG_REQUESTS) { + fprintf(file, "\tipv6cp_max_config_requests=%d \\\n", cfg->ipv6cp_max_config_requests); + } + if (cfg->flags2 & L2TP_API_PPP_PROFILE_FLAG_IPV6CP_MAX_CONFIG_NAKS) { + fprintf(file, "\tipv6cp_max_config_naks=%d \\\n", cfg->ipv6cp_max_config_naks); + } + if (cfg->flags2 & L2TP_API_PPP_PROFILE_FLAG_IPV6CP_MAX_TERMINATE_REQUESTS) { + fprintf(file, "\tipv6cp_max_terminate_requests=%d \\\n", cfg->ipv6cp_max_terminate_requests); + } + if (cfg->flags2 & L2TP_API_PPP_PROFILE_FLAG_IPV6CP_RETRANSMIT_INTERVAL) { + fprintf(file, "\tipv6cp_retransmit_interval=%d \\\n", cfg->ipv6cp_retransmit_interval); + } fprintf(file, "\n"); } } diff --git a/l2tp_config_parse.y b/l2tp_config_parse.y index 8c700eb..fdd7015 100644 --- a/l2tp_config_parse.y +++ b/l2tp_config_parse.y @@ -143,6 +143,11 @@ extern void yyfatal(const char *s); %token USE_AS_DEFAULT_ROUTE %token MULTILINK %token PROXY_ARP +%token IPV6CP_ENABLE +%token IPV6CP_MAX_CONFIG_REQUESTS +%token IPV6CP_MAX_CONFIG_NAKS +%token IPV6CP_MAX_TERMINATE_REQUESTS +%token IPV6CP_RETRANSMIT_INTERVAL %token EOT %token SLASH %token BLCL @@ -1167,6 +1172,31 @@ ppp_profile_statement OPTSTRING(ppp_profile.remote_name) = $3.buf; ppp_profile.remote_name.valid = 1; } + | IPV6CP_ENABLE EQUALS BOOL + { + ppp_profile.flags2 |= L2TP_API_PPP_PROFILE_FLAG_IPV6CP_ENABLE; + ppp_profile.ipv6cp_enable = $3; + } + | IPV6CP_MAX_CONFIG_REQUESTS EQUALS DECSTRING + { + ppp_profile.flags2 |= L2TP_API_PPP_PROFILE_FLAG_IPV6CP_MAX_CONFIG_REQUESTS; + ppp_profile.ipv6cp_max_config_requests = $3; + } + | IPV6CP_MAX_CONFIG_NAKS EQUALS DECSTRING + { + ppp_profile.flags2 |= L2TP_API_PPP_PROFILE_FLAG_IPV6CP_MAX_CONFIG_NAKS; + ppp_profile.ipv6cp_max_config_naks = $3; + } + | IPV6CP_MAX_TERMINATE_REQUESTS EQUALS DECSTRING + { + ppp_profile.flags2 |= L2TP_API_PPP_PROFILE_FLAG_IPV6CP_MAX_TERMINATE_REQUESTS; + ppp_profile.ipv6cp_max_terminate_requests = $3; + } + | IPV6CP_RETRANSMIT_INTERVAL EQUALS DECSTRING + { + ppp_profile.flags2 |= L2TP_API_PPP_PROFILE_FLAG_IPV6CP_RETRANSMIT_INTERVAL; + ppp_profile.ipv6cp_retransmit_interval = $3; + } ; tunnel_command diff --git a/l2tp_config_token.l b/l2tp_config_token.l index 9016af6..be522c9 100644 --- a/l2tp_config_token.l +++ b/l2tp_config_token.l @@ -191,6 +191,11 @@ auth_mschapv2 { return(AUTH_MSCHAPV2); } auth_eap { return(AUTH_EAP); } auth_none { return(AUTH_NOAUTH); } auth_peer { return(AUTH_PEER); } +ipv6cp_enable { return(IPV6CP_ENABLE); } +ipv6cp_max_config_requests { return(IPV6CP_MAX_CONFIG_REQUESTS); } +ipv6cp_max_config_naks { return(IPV6CP_MAX_CONFIG_NAKS); } +ipv6cp_max_terminate_requests { return(IPV6CP_MAX_TERMINATE_REQUESTS); } +ipv6cp_retransmit_interval { return(IPV6CP_RETRANSMIT_INTERVAL); } {ws} { } {linecont} { lineno++; } diff --git a/l2tp_ppp.c b/l2tp_ppp.c index 4905973..39f299e 100644 --- a/l2tp_ppp.c +++ b/l2tp_ppp.c @@ -61,6 +61,10 @@ struct l2tp_ppp_profile { char *local_name; char *remote_name; int use_as_default_route; + int ipv6cp_max_config_requests; + int ipv6cp_max_config_naks; + int ipv6cp_max_terminate_requests; + int ipv6cp_retransmit_interval; int multilink:1; int proxy_arp:1; int auth_none:1; @@ -70,6 +74,7 @@ struct l2tp_ppp_profile { int auth_refuse_mschap:1; int auth_refuse_mschapv2:1; int auth_refuse_eap:1; + int ipv6cp_enable:1; }; static struct l2tp_ppp_profile *l2tp_ppp_defaults; @@ -241,6 +246,21 @@ static int l2tp_ppp_profile_modify(l2tp_api_ppp_profile_msg_data *msg, struct l2 if (msg->flags2 & L2TP_API_PPP_PROFILE_FLAG_REMOTE_NAME) { L2TP_SET_OPTSTRING_VAR(profile, remote_name); } + if (msg->flags2 & L2TP_API_PPP_PROFILE_FLAG_IPV6CP_ENABLE) { + profile->ipv6cp_enable = msg->ipv6cp_enable; + } + if (msg->flags2 & L2TP_API_PPP_PROFILE_FLAG_IPV6CP_MAX_CONFIG_REQUESTS) { + profile->ipv6cp_max_config_requests = msg->ipv6cp_max_config_requests; + } + if (msg->flags2 & L2TP_API_PPP_PROFILE_FLAG_IPV6CP_MAX_CONFIG_NAKS) { + profile->ipv6cp_max_config_naks = msg->ipv6cp_max_config_naks; + } + if (msg->flags2 & L2TP_API_PPP_PROFILE_FLAG_IPV6CP_MAX_TERMINATE_REQUESTS) { + profile->ipv6cp_max_terminate_requests = msg->ipv6cp_max_terminate_requests; + } + if (msg->flags2 & L2TP_API_PPP_PROFILE_FLAG_IPV6CP_RETRANSMIT_INTERVAL) { + profile->ipv6cp_retransmit_interval = msg->ipv6cp_retransmit_interval; + } out: return result; @@ -345,6 +365,11 @@ bool_t l2tp_ppp_profile_create_1_svc(l2tp_api_ppp_profile_msg_data msg, int *res goto err; } } + profile->ipv6cp_enable = l2tp_ppp_defaults->ipv6cp_enable; + profile->ipv6cp_max_config_requests = l2tp_ppp_defaults->ipv6cp_max_config_requests; + profile->ipv6cp_max_config_naks = l2tp_ppp_defaults->ipv6cp_max_config_naks; + profile->ipv6cp_max_terminate_requests = l2tp_ppp_defaults->ipv6cp_max_terminate_requests; + profile->ipv6cp_retransmit_interval = l2tp_ppp_defaults->ipv6cp_retransmit_interval; /* Override defaults by user-supplied params */ *result = l2tp_ppp_profile_modify(&msg, profile); @@ -578,6 +603,11 @@ int l2tp_ppp_profile_get(char *name, struct l2tp_api_ppp_profile_msg_data *resul } result->remote_name.valid = 1; } + result->ipv6cp_enable = profile->ipv6cp_enable; + result->ipv6cp_max_config_requests = profile->ipv6cp_max_config_requests; + result->ipv6cp_max_config_naks = profile->ipv6cp_max_config_naks; + result->ipv6cp_max_terminate_requests = profile->ipv6cp_max_terminate_requests; + result->ipv6cp_retransmit_interval = profile->ipv6cp_retransmit_interval; out: L2TP_DEBUG(L2TP_API, "%s: flags=%x/%x result=%d", __func__, result->flags, result->flags2, result->result_code); @@ -843,6 +873,21 @@ bool_t l2tp_ppp_profile_unset_1_svc(l2tp_api_ppp_profile_unset_msg_data msg, int } profile->remote_name = NULL; } + if (msg.flags2 & L2TP_API_PPP_PROFILE_FLAG_IPV6CP_ENABLE) { + profile->ipv6cp_enable = L2TP_API_PPP_PROFILE_DEFAULT_IPV6CP_ENABLE; + } + if (msg.flags2 & L2TP_API_PPP_PROFILE_FLAG_IPV6CP_MAX_CONFIG_REQUESTS) { + profile->ipv6cp_max_config_requests = L2TP_API_PPP_PROFILE_DEFAULT_IPV6CP_MAX_CONFIG_REQUESTS; + } + if (msg.flags2 & L2TP_API_PPP_PROFILE_FLAG_IPV6CP_MAX_CONFIG_NAKS) { + profile->ipv6cp_max_config_naks = L2TP_API_PPP_PROFILE_DEFAULT_IPV6CP_MAX_CONFIG_NAKS; + } + if (msg.flags2 & L2TP_API_PPP_PROFILE_FLAG_IPV6CP_MAX_TERMINATE_REQUESTS) { + profile->ipv6cp_max_terminate_requests = L2TP_API_PPP_PROFILE_DEFAULT_IPV6CP_MAX_TERMINATE_REQUESTS; + } + if (msg.flags2 & L2TP_API_PPP_PROFILE_FLAG_IPV6CP_RETRANSMIT_INTERVAL) { + profile->ipv6cp_retransmit_interval = L2TP_API_PPP_PROFILE_DEFAULT_IPV6CP_RETRANSMIT_INTERVAL; + } /* Clear all requested flags */ profile->flags &= ~(msg.flags); @@ -937,6 +982,11 @@ void l2tp_ppp_init(void) } l2tp_ppp_defaults->local_name = NULL; l2tp_ppp_defaults->remote_name = NULL; + l2tp_ppp_defaults->ipv6cp_enable = L2TP_API_PPP_PROFILE_DEFAULT_IPV6CP_ENABLE; + l2tp_ppp_defaults->ipv6cp_max_config_requests = L2TP_API_PPP_PROFILE_DEFAULT_IPV6CP_MAX_CONFIG_REQUESTS; + l2tp_ppp_defaults->ipv6cp_max_config_naks = L2TP_API_PPP_PROFILE_DEFAULT_IPV6CP_MAX_CONFIG_NAKS; + l2tp_ppp_defaults->ipv6cp_max_terminate_requests = L2TP_API_PPP_PROFILE_DEFAULT_IPV6CP_MAX_TERMINATE_REQUESTS; + l2tp_ppp_defaults->ipv6cp_retransmit_interval = L2TP_API_PPP_PROFILE_DEFAULT_IPV6CP_RETRANSMIT_INTERVAL; USL_LIST_HEAD_INIT(&l2tp_ppp_defaults->list); usl_list_add(&l2tp_ppp_defaults->list, &l2tp_ppp_profile_list); diff --git a/l2tp_rpc.x b/l2tp_rpc.x index 7c48a3f..9692bae 100644 --- a/l2tp_rpc.x +++ b/l2tp_rpc.x @@ -946,6 +946,11 @@ const L2TP_API_PPP_PROFILE_FLAG_AUTH_REFUSE_MSCHAP = 32768; const L2TP_API_PPP_PROFILE_FLAG_AUTH_REFUSE_CHAP = 65536; const L2TP_API_PPP_PROFILE_FLAG_AUTH_REFUSE_PAP = 131072; const L2TP_API_PPP_PROFILE_FLAG_AUTH_PEER = 262144; +const L2TP_API_PPP_PROFILE_FLAG_IPV6CP_ENABLE = 524288; +const L2TP_API_PPP_PROFILE_FLAG_IPV6CP_MAX_CONFIG_REQUESTS = 1048576; +const L2TP_API_PPP_PROFILE_FLAG_IPV6CP_MAX_CONFIG_NAKS = 2097152; +const L2TP_API_PPP_PROFILE_FLAG_IPV6CP_MAX_TERMINATE_REQUESTS = 4194304; +const L2TP_API_PPP_PROFILE_FLAG_IPV6CP_RETRANSMIT_INTERVAL = 8388608; /* Default values for PPP profile attributes. * These are used if an explicit value is not provided by the user. @@ -993,6 +998,11 @@ const L2TP_API_PPP_PROFILE_DEFAULT_RADIUS_HINT = ""; const L2TP_API_PPP_PROFILE_DEFAULT_USE_AS_DEFAULT_ROUTE = 0; const L2TP_API_PPP_PROFILE_DEFAULT_MULTILINK = 0; const L2TP_API_PPP_PROFILE_DEFAULT_PROXY_ARP = 0; +const L2TP_API_PPP_PROFILE_DEFAULT_IPV6CP_ENABLE = 1; +const L2TP_API_PPP_PROFILE_DEFAULT_IPV6CP_MAX_CONFIG_REQUESTS = 10; +const L2TP_API_PPP_PROFILE_DEFAULT_IPV6CP_MAX_CONFIG_NAKS = 10; +const L2TP_API_PPP_PROFILE_DEFAULT_IPV6CP_MAX_TERMINATE_REQUESTS= 3; +const L2TP_API_PPP_PROFILE_DEFAULT_IPV6CP_RETRANSMIT_INTERVAL = 3; enum l2tp_api_ppp_sync_mode { L2TP_API_PPP_SYNCMODE_SYNC_ASYNC, @@ -1051,6 +1061,11 @@ struct l2tp_api_ppp_profile_msg_data { optstring local_name; optstring remote_name; bool proxy_arp; + bool ipv6cp_enable; + int ipv6cp_max_config_requests; + int ipv6cp_max_config_naks; + int ipv6cp_max_terminate_requests; + int ipv6cp_retransmit_interval; }; struct l2tp_api_ppp_profile_list_entry { diff --git a/plugins/ppp_unix.c b/plugins/ppp_unix.c index 869066f..e946368 100644 --- a/plugins/ppp_unix.c +++ b/plugins/ppp_unix.c @@ -164,6 +164,10 @@ static const struct ppp_unix_pppd_arg ppp_unix_pppd_args[] = { PPP_UNIX_PARAM("lcp-restart", lcp_retransmit_interval, LCP_RETRANSMIT_INTERVAL, NONE), PPP_UNIX_PARAM("maxconnect", max_connect_time, MAX_CONNECT_TIME, NONE), PPP_UNIX_PARAM("maxfail", max_failure_count, MAX_FAILURE_COUNT, NONE), + PPP_UNIX_PARAM("ipv6cp-max-configure", ipv6cp_max_config_requests, IPV6CP_MAX_CONFIG_REQUESTS, NONE), + PPP_UNIX_PARAM("ipv6cp-max-failure", ipv6cp_max_config_naks, IPV6CP_MAX_CONFIG_NAKS, NONE), + PPP_UNIX_PARAM("ipv6cp-max-terminate", ipv6cp_max_terminate_requests, IPV6CP_MAX_TERMINATE_REQUESTS, NONE), + PPP_UNIX_PARAM("ipv6cp-restart", ipv6cp_retransmit_interval, IPV6CP_RETRANSMIT_INTERVAL, NONE), { NULL, -1, 0, 0, 0 } }; @@ -372,6 +376,12 @@ static int ppp_unix_params_to_argv(struct ppp_context *ppp, struct l2tp_api_ppp_ argv[arg++] = "require-mschap-v2"; } + /* IPv6CP support; enabled by default */ + if (!((params->flags2 & L2TP_API_PPP_PROFILE_FLAG_IPV6CP_ENABLE) && + !params->ipv6cp_enable)) { + argv[arg++] = "+ipv6"; + } + /* Now handle each parameter from our translation table. Only * add the arg if the ppp profile indicates that it's been * set. -- 1.7.2.5 ------------------------------------------------------------------------------ Try New Relic Now & We'll Send You this Cool Shirt New Relic is the only SaaS-based application performance monitoring service that delivers powerful full stack analytics. Optimize and monitor your browser, app, & servers with just a few lines of code. Try New Relic and get this awesome Nerd Life shirt! http://p.sf.net/sfu/newrelic_d2d_apr _______________________________________________ Openl2tp-users mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/openl2tp-users
