ppp.h

Go to the documentation of this file.

/*
 * Copyright (c) 2019 Intel Corporation.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_NET_PPP_H_
#define ZEPHYR_INCLUDE_NET_PPP_H_
 
#include <zephyr/net/net_if.h>
#include <zephyr/net/net_pkt.h>
#include <zephyr/net/net_stats.h>
#include <zephyr/net/net_mgmt.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define PPP_MRU CONFIG_NET_PPP_MTU_MRU
 
#define PPP_MTU PPP_MRU
 
#define PPP_MAX_TERMINATE_REASON_LEN 32
 
#define PPP_INTERFACE_IDENTIFIER_LEN 8
 
struct ppp_api {
        struct net_if_api iface_api;
 
        int (*start)(const struct device *dev);
 
        int (*stop)(const struct device *dev);
 
        int (*send)(const struct device *dev, struct net_pkt *pkt);
 
#if defined(CONFIG_NET_STATISTICS_PPP)
        struct net_stats_ppp *(*get_stats)(const struct device *dev);
#endif
};
 
/* Make sure that the network interface API is properly setup inside
 * PPP API struct (it is the first one).
 */
BUILD_ASSERT(offsetof(struct ppp_api, iface_api) == 0);
 
enum ppp_protocol_type {
        PPP_IP     = 0x0021, 
        PPP_IPV6   = 0x0057, 
        PPP_IPCP   = 0x8021, 
        PPP_ECP    = 0x8053, 
        PPP_IPV6CP = 0x8057, 
        PPP_CCP    = 0x80FD, 
        PPP_LCP    = 0xc021, 
        PPP_PAP    = 0xc023, 
        PPP_CHAP   = 0xc223, 
        PPP_EAP    = 0xc227, 
};
 
enum ppp_phase {
        PPP_DEAD,
        PPP_ESTABLISH,
        PPP_AUTH,
        PPP_NETWORK,
        PPP_RUNNING,
        PPP_TERMINATE,
};
 
enum ppp_state {
        PPP_INITIAL,
        PPP_STARTING,
        PPP_CLOSED,
        PPP_STOPPED,
        PPP_CLOSING,
        PPP_STOPPING,
        PPP_REQUEST_SENT,
        PPP_ACK_RECEIVED,
        PPP_ACK_SENT,
        PPP_OPENED
};
 
enum ppp_packet_type {
        PPP_CONFIGURE_REQ  = 1,
        PPP_CONFIGURE_ACK  = 2,
        PPP_CONFIGURE_NACK = 3,
        PPP_CONFIGURE_REJ  = 4,
        PPP_TERMINATE_REQ  = 5,
        PPP_TERMINATE_ACK  = 6,
        PPP_CODE_REJ       = 7,
        PPP_PROTOCOL_REJ   = 8,
        PPP_ECHO_REQ       = 9,
        PPP_ECHO_REPLY     = 10,
        PPP_DISCARD_REQ    = 11
};
 
enum lcp_option_type {
        LCP_OPTION_RESERVED = 0,
 
        LCP_OPTION_MRU = 1,
 
        LCP_OPTION_ASYNC_CTRL_CHAR_MAP = 2,
 
        LCP_OPTION_AUTH_PROTO = 3,
 
        LCP_OPTION_QUALITY_PROTO = 4,
 
        LCP_OPTION_MAGIC_NUMBER = 5,
 
        LCP_OPTION_PROTO_COMPRESS = 7,
 
        LCP_OPTION_ADDR_CTRL_COMPRESS = 8
} __packed;
 
enum ipcp_option_type {
        IPCP_OPTION_RESERVED = 0,
 
        IPCP_OPTION_IP_ADDRESSES = 1,
 
        IPCP_OPTION_IP_COMP_PROTO = 2,
 
        IPCP_OPTION_IP_ADDRESS = 3,
 
        /* RFC 1877 */
 
        IPCP_OPTION_DNS1 = 129,
 
        IPCP_OPTION_NBNS1 = 130,
 
        IPCP_OPTION_DNS2 = 131,
 
        IPCP_OPTION_NBNS2 = 132,
} __packed;
 
enum ipv6cp_option_type {
        IPV6CP_OPTION_RESERVED = 0,
 
        IPV6CP_OPTION_INTERFACE_IDENTIFIER = 1,
} __packed;
 
typedef void (*net_ppp_lcp_echo_reply_cb_t)(void *user_data,
                                            size_t user_data_len);
 
struct ppp_my_option_data;
struct ppp_my_option_info;
 
struct ppp_fsm {
        struct k_work_delayable timer;
 
        struct {
                int (*config_info_ack)(struct ppp_fsm *fsm,
                                       struct net_pkt *pkt,
                                       uint16_t length);
 
                struct net_pkt *(*config_info_add)(struct ppp_fsm *fsm);
 
                int  (*config_info_len)(struct ppp_fsm *fsm);
 
                int (*config_info_nack)(struct ppp_fsm *fsm,
                                        struct net_pkt *pkt,
                                        uint16_t length,
                                        bool rejected);
 
                int (*config_info_req)(struct ppp_fsm *fsm,
                                       struct net_pkt *pkt,
                                       uint16_t length,
                                       struct net_pkt *ret_pkt);
 
                int (*config_info_rej)(struct ppp_fsm *fsm,
                                       struct net_pkt *pkt,
                                       uint16_t length);
 
                void (*config_info_reset)(struct ppp_fsm *fsm);
 
                void (*up)(struct ppp_fsm *fsm);
 
                void (*down)(struct ppp_fsm *fsm);
 
                void (*starting)(struct ppp_fsm *fsm);
 
                void (*finished)(struct ppp_fsm *fsm);
 
                void (*proto_reject)(struct ppp_fsm *fsm);
 
                void (*retransmit)(struct ppp_fsm *fsm);
 
                enum net_verdict (*proto_extension)(struct ppp_fsm *fsm,
                                                    enum ppp_packet_type code,
                                                    uint8_t id,
                                                    struct net_pkt *pkt);
        } cb;
 
        struct {
                const struct ppp_my_option_info *info;
 
                struct ppp_my_option_data *data;
 
                size_t count;
        } my_options;
 
        uint32_t flags;
 
        uint32_t retransmits;
 
        uint32_t nack_loops;
 
        uint32_t recv_nack_loops;
 
        char terminate_reason[PPP_MAX_TERMINATE_REASON_LEN];
 
        uint16_t protocol;
 
        enum ppp_state state;
 
        const char *name;
 
        uint8_t id;
 
        uint8_t req_id;
 
        uint8_t ack_received : 1;
};
 
#define PPP_MY_OPTION_ACKED     BIT(0)
#define PPP_MY_OPTION_REJECTED  BIT(1)
 
struct ppp_my_option_data {
        uint32_t flags;
};
 
#if defined(CONFIG_NET_L2_PPP_OPTION_DNS_USE)
#define IPCP_NUM_MY_OPTIONS     3
#else
#define IPCP_NUM_MY_OPTIONS     1
#endif
#define IPV6CP_NUM_MY_OPTIONS   1
 
enum ppp_flags {
        PPP_CARRIER_UP,
};
 
struct lcp_options {
        uint32_t magic;
 
        uint32_t async_map;
 
        uint16_t mru;
 
        uint16_t auth_proto;
};
 
#if defined(CONFIG_NET_L2_PPP_OPTION_MRU)
#define LCP_NUM_MY_OPTIONS      2
#else
#define LCP_NUM_MY_OPTIONS      1
#endif
 
struct ipcp_options {
        struct in_addr address;
 
        struct in_addr dns1_address;
 
        struct in_addr dns2_address;
};
 
struct ipv6cp_options {
        uint8_t iid[PPP_INTERFACE_IDENTIFIER_LEN];
};
 
struct ppp_context {
        atomic_t flags;
 
        struct k_work_delayable startup;
 
        struct {
                struct ppp_fsm fsm;
 
                struct lcp_options my_options;
 
                struct lcp_options peer_options;
 
                uint32_t magic;
 
                struct ppp_my_option_data my_options_data[LCP_NUM_MY_OPTIONS];
        } lcp;
 
#if defined(CONFIG_NET_IPV4)
        struct {
                struct ppp_fsm fsm;
 
                struct ipcp_options my_options;
 
                struct ipcp_options peer_options;
 
                struct ppp_my_option_data my_options_data[IPCP_NUM_MY_OPTIONS];
        } ipcp;
#endif
 
#if defined(CONFIG_NET_IPV6)
        struct {
                struct ppp_fsm fsm;
 
                struct ipv6cp_options my_options;
 
                struct ipv6cp_options peer_options;
 
                struct ppp_my_option_data my_options_data[IPV6CP_NUM_MY_OPTIONS];
        } ipv6cp;
#endif
 
#if defined(CONFIG_NET_L2_PPP_PAP)
        struct {
                struct ppp_fsm fsm;
        } pap;
#endif
 
#if defined(CONFIG_NET_SHELL)
        struct {
                struct {
                        net_ppp_lcp_echo_reply_cb_t cb;
 
                        void *user_data;
 
                        size_t user_data_len;
                } echo_reply;
 
                struct k_sem wait_echo_reply;
 
                uint32_t echo_req_data;
 
                uint32_t echo_reply_data;
        } shell;
#endif
 
        struct net_if *iface;
 
        struct net_mgmt_event_callback mgmt_evt_cb;
 
        enum ppp_phase phase;
 
        struct k_sem wait_ppp_link_terminated;
 
        struct k_sem wait_ppp_link_down;
 
        enum net_l2_flags ppp_l2_flags;
 
        int network_protos_open;
 
        int network_protos_up;
 
        uint16_t is_ready_to_serve : 1;
 
        uint16_t is_enabled : 1;
 
        uint16_t is_enable_done : 1;
 
        uint16_t is_ipcp_up : 1;
 
        uint16_t is_ipcp_open : 1;
 
        uint16_t is_ipv6cp_up : 1;
 
        uint16_t is_ipv6cp_open : 1;
 
        uint16_t is_pap_up : 1;
 
        uint16_t is_pap_open : 1;
};
 
void net_ppp_init(struct net_if *iface);
 
/* Management API for PPP */
 
#define PPP_L2_CTX_TYPE struct ppp_context
 
#define NET_PPP_LAYER   NET_MGMT_LAYER_L2
#define NET_PPP_CODE    NET_MGMT_LAYER_CODE_PPP
#define NET_PPP_BASE    (NET_MGMT_IFACE_BIT |                           \
                         NET_MGMT_LAYER(NET_PPP_LAYER) |                \
                         NET_MGMT_LAYER_CODE(NET_PPP_CODE))
#define NET_PPP_EVENT   (NET_PPP_BASE | NET_MGMT_EVENT_BIT)
 
enum {
        NET_EVENT_PPP_CMD_CARRIER_ON_VAL,
        NET_EVENT_PPP_CMD_CARRIER_OFF_VAL,
        NET_EVENT_PPP_CMD_PHASE_RUNNING_VAL,
        NET_EVENT_PPP_CMD_PHASE_DEAD_VAL,
 
        NET_EVENT_PPP_CMD_MAX
};
 
BUILD_ASSERT(NET_EVENT_PPP_CMD_MAX <= NET_MGMT_MAX_COMMANDS,
             "Number of events in net_event_ppp_cmd exceeds the limit");
 
enum net_event_ppp_cmd {
        NET_MGMT_CMD(NET_EVENT_PPP_CMD_CARRIER_ON),
        NET_MGMT_CMD(NET_EVENT_PPP_CMD_CARRIER_OFF),
        NET_MGMT_CMD(NET_EVENT_PPP_CMD_PHASE_RUNNING),
        NET_MGMT_CMD(NET_EVENT_PPP_CMD_PHASE_DEAD),
};
 
struct net_if;
 
#define NET_EVENT_PPP_CARRIER_ON                                        \
        (NET_PPP_EVENT | NET_EVENT_PPP_CMD_CARRIER_ON)
 
#define NET_EVENT_PPP_CARRIER_OFF                                       \
        (NET_PPP_EVENT | NET_EVENT_PPP_CMD_CARRIER_OFF)
 
#define NET_EVENT_PPP_PHASE_RUNNING                                     \
        (NET_PPP_EVENT | NET_EVENT_PPP_CMD_PHASE_RUNNING)
 
#define NET_EVENT_PPP_PHASE_DEAD                                        \
        (NET_PPP_EVENT | NET_EVENT_PPP_CMD_PHASE_DEAD)
 
#if defined(CONFIG_NET_L2_PPP_MGMT)
void ppp_mgmt_raise_carrier_on_event(struct net_if *iface);
#else
static inline void ppp_mgmt_raise_carrier_on_event(struct net_if *iface)
{
        ARG_UNUSED(iface);
}
#endif
 
#if defined(CONFIG_NET_L2_PPP_MGMT)
void ppp_mgmt_raise_carrier_off_event(struct net_if *iface);
#else
static inline void ppp_mgmt_raise_carrier_off_event(struct net_if *iface)
{
        ARG_UNUSED(iface);
}
#endif
 
#if defined(CONFIG_NET_L2_PPP_MGMT)
void ppp_mgmt_raise_phase_running_event(struct net_if *iface);
#else
static inline void ppp_mgmt_raise_phase_running_event(struct net_if *iface)
{
        ARG_UNUSED(iface);
}
#endif
 
#if defined(CONFIG_NET_L2_PPP_MGMT)
void ppp_mgmt_raise_phase_dead_event(struct net_if *iface);
#else
static inline void ppp_mgmt_raise_phase_dead_event(struct net_if *iface)
{
        ARG_UNUSED(iface);
}
#endif
 
#if defined(CONFIG_NET_L2_PPP)
int net_ppp_ping(int idx, int32_t timeout);
#else
static inline int net_ppp_ping(int idx, int32_t timeout)
{
        ARG_UNUSED(idx);
        ARG_UNUSED(timeout);
 
        return -ENOTSUP;
}
#endif
 
#if defined(CONFIG_NET_L2_PPP) && defined(CONFIG_NET_SHELL)
struct ppp_context *net_ppp_context_get(int idx);
#else
static inline struct ppp_context *net_ppp_context_get(int idx)
{
        ARG_UNUSED(idx);
 
        return NULL;
}
#endif
 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_NET_PPP_H_ */