/*      $OpenBSD: hostapd.h,v 1.21 2015/01/16 06:40:17 deraadt Exp $    */

/*
 * Copyright (c) 2004, 2005 Reyk Floeter <reyk@openbsd.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#ifndef _HOSTAPD_H
#define _HOSTAPD_H

#include <sys/types.h>
#include <sys/socket.h>
#include <sys/tree.h>

#include <net/if.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#include <errno.h>
#include <event.h>
#include <syslog.h>

#include <net80211/ieee80211.h>
#include <net80211/ieee80211_ioctl.h>

/*
 * hostapd (IAPP) <-> Host AP (APME)
 */

struct hostapd_node {
        u_int8_t        ni_macaddr[IEEE80211_ADDR_LEN];
        u_int8_t        ni_bssid[IEEE80211_ADDR_LEN];
        u_int32_t       ni_associd;
        u_int16_t       ni_capinfo;
        u_int16_t       ni_flags;
        u_int16_t       ni_rxseq;
        u_int16_t       ni_rssi;
};

/*
 * IAPP -> switches (LLC)
 */

struct hostapd_llc {
        struct ether_header x_hdr;
        struct llc x_llc;
} __packed;

#define IAPP_LLC        LLC_XID
#define IAPP_LLC_XID    0x81
#define IAPP_LLC_CLASS  1
#define IAPP_LLC_WINDOW 1 << 1

/*
 * hostapd configuration
 */

struct hostapd_counter {
        u_int64_t       cn_tx_llc;      /* sent LLC messages */
        u_int64_t       cn_rx_iapp;     /* received IAPP messages */
        u_int64_t       cn_tx_iapp;     /* sent IAPP messages */
        u_int64_t       cn_rx_apme;     /* received Host AP messages */
        u_int64_t       cn_tx_apme;     /* sent Host AP messages */
        u_int64_t       cn_rtap_miss;   /* missing radiotap field */
};

#define HOSTAPD_ENTRY_MASK_ADD(_a, _m)  do {                                    \
        (_a)[0] &= (_m)[0];                                                     \
        (_a)[1] &= (_m)[1];                                                     \
        (_a)[2] &= (_m)[2];                                                     \
        (_a)[3] &= (_m)[3];                                                     \
        (_a)[4] &= (_m)[4];                                                     \
        (_a)[5] &= (_m)[5];                                                     \
} while (0);
#define HOSTAPD_ENTRY_MASK_MATCH(_e, _b)        (                               \
        ((_e)->e_lladdr[0] == ((_b)[0] & (_e)->e_addr.a_mask[0])) &&            \
        ((_e)->e_lladdr[1] == ((_b)[1] & (_e)->e_addr.a_mask[1])) &&            \
        ((_e)->e_lladdr[2] == ((_b)[2] & (_e)->e_addr.a_mask[2])) &&            \
        ((_e)->e_lladdr[3] == ((_b)[3] & (_e)->e_addr.a_mask[3])) &&            \
        ((_e)->e_lladdr[4] == ((_b)[4] & (_e)->e_addr.a_mask[4])) &&            \
        ((_e)->e_lladdr[5] == ((_b)[5] & (_e)->e_addr.a_mask[5]))               \
)

struct hostapd_inaddr {
        sa_family_t             in_af;
        union {
                struct in_addr  v4;
                struct in6_addr v6;
        } in_v;
        int                     in_netmask;
};

#define in_v4                   in_v.v4
#define in_v6                   in_v.v6

struct hostapd_entry {
        u_int8_t                        e_lladdr[IEEE80211_ADDR_LEN];
        u_int8_t                        e_flags;

#define HOSTAPD_ENTRY_F_LLADDR          0x00
#define HOSTAPD_ENTRY_F_MASK            0x01
#define HOSTAPD_ENTRY_F_INADDR          0x02

        union {
                u_int8_t                a_mask[IEEE80211_ADDR_LEN];
                struct hostapd_inaddr   a_inaddr;
        }                               e_addr;

        RB_ENTRY(hostapd_entry)         e_nodes;
        TAILQ_ENTRY(hostapd_entry)      e_entries;
};

#define e_mask                          e_addr.a_mask
#define e_inaddr                        e_addr.a_inaddr

#define HOSTAPD_TABLE_NAMELEN           32

RB_HEAD(hostapd_tree, hostapd_entry);

struct hostapd_table {
        char                            t_name[HOSTAPD_TABLE_NAMELEN];
        u_int8_t                        t_flags;

#define HOSTAPD_TABLE_F_CONST           0x01

        struct hostapd_tree             t_tree;
        TAILQ_HEAD(, hostapd_entry)     t_mask_head;
        TAILQ_ENTRY(hostapd_table)      t_entries;
};

struct hostapd_radiotap {
        u_int32_t       r_present;
        u_int8_t        r_txrate;
        u_int16_t       r_chan;
        u_int16_t       r_chan_flags;
        u_int8_t        r_rssi;
        u_int8_t        r_max_rssi;
};
#define HOSTAPD_RADIOTAP_F(_x)  (1 << IEEE80211_RADIOTAP_##_x)

struct hostapd_ieee80211_frame {
        u_int8_t        i_fc[2];
        u_int8_t        i_dur[2];
        u_int8_t        i_from[IEEE80211_ADDR_LEN];
        u_int8_t        i_to[IEEE80211_ADDR_LEN];
        u_int8_t        i_bssid[IEEE80211_ADDR_LEN];
        u_int8_t        i_seq[2];
        void            *i_data;
        u_int           i_data_len;
};

enum hostapd_action {
        HOSTAPD_ACTION_NONE     = 0,
        HOSTAPD_ACTION_LOG      = 1,
        HOSTAPD_ACTION_RADIOTAP = 2,
        HOSTAPD_ACTION_FRAME    = 3,
        HOSTAPD_ACTION_ADDNODE  = 4,
        HOSTAPD_ACTION_DELNODE  = 5,
        HOSTAPD_ACTION_RESEND   = 6
};

enum hostapd_op {
        HOSTAPD_OP_EQ           = 0,
        HOSTAPD_OP_NE           = 1,
        HOSTAPD_OP_LE           = 2,
        HOSTAPD_OP_LT           = 3,
        HOSTAPD_OP_GE           = 4,
        HOSTAPD_OP_GT           = 5
};

struct hostapd_action_data {
        union {
                struct hostapd_ieee80211_frame  u_frame;
                u_int8_t                        u_lladdr[IEEE80211_ADDR_LEN];
        } a_data;
        u_int16_t                               a_flags;

#define HOSTAPD_ACTION_F_REF_FROM               0x0001
#define HOSTAPD_ACTION_F_REF_TO                 0x0002
#define HOSTAPD_ACTION_F_REF_BSSID              0x0004
#define HOSTAPD_ACTION_F_REF_RANDOM             0x0008
#define HOSTAPD_ACTION_F_REF_FROM_M             0x000f
#define HOSTAPD_ACTION_F_REF_FROM_S             0
#define HOSTAPD_ACTION_F_REF_TO_M               0x00f0
#define HOSTAPD_ACTION_F_REF_TO_S               4
#define HOSTAPD_ACTION_F_REF_BSSID_M            0x0f00
#define HOSTAPD_ACTION_F_REF_BSSID_S            8
#define HOSTAPD_ACTION_F_REF_M                  0x0fff
#define HOSTAPD_ACTION_F_OPT_DIR_AUTO           0x1000
#define HOSTAPD_ACTION_F_OPT_LLADDR             0x2000
#define HOSTAPD_ACTION_F_OPT_TABLE              0x4000
};

#define a_frame                                 a_data.u_frame
#define a_lladdr                                a_data.u_lladdr

struct hostapd_frame {
        struct hostapd_ieee80211_frame  f_frame;
        u_int32_t                       f_radiotap;

        u_int32_t                       f_flags;

#define HOSTAPD_FRAME_F_TYPE            0x00000001
#define HOSTAPD_FRAME_F_TYPE_N          0x00000002
#define HOSTAPD_FRAME_F_SUBTYPE         0x00000004
#define HOSTAPD_FRAME_F_SUBTYPE_N       0x00000008
#define HOSTAPD_FRAME_F_DIR             0x00000010
#define HOSTAPD_FRAME_F_DIR_N           0x00000020
#define HOSTAPD_FRAME_F_FROM            0x00000040
#define HOSTAPD_FRAME_F_FROM_N          0x00000080
#define HOSTAPD_FRAME_F_FROM_TABLE      0x00000100
#define HOSTAPD_FRAME_F_FROM_M          0x000001c0
#define HOSTAPD_FRAME_F_TO              0x00000200
#define HOSTAPD_FRAME_F_TO_N            0x00000400
#define HOSTAPD_FRAME_F_TO_TABLE        0x00000800
#define HOSTAPD_FRAME_F_TO_M            0x00000e00
#define HOSTAPD_FRAME_F_BSSID           0x00001000
#define HOSTAPD_FRAME_F_BSSID_N         0x00002000
#define HOSTAPD_FRAME_F_BSSID_TABLE     0x00004000
#define HOSTAPD_FRAME_F_BSSID_M         0x00007000
#define HOSTAPD_FRAME_F_APME            0x00008000
#define HOSTAPD_FRAME_F_APME_N          0x00010000
#define HOSTAPD_FRAME_F_APME_M          0x00018000
#define HOSTAPD_FRAME_F_RSSI            0x00020000
#define HOSTAPD_FRAME_F_RATE            0x00040000
#define HOSTAPD_FRAME_F_CHANNEL         0x00080000
#define HOSTAPD_FRAME_F_RADIOTAP_M      0x000e0000
#define HOSTAPD_FRAME_F_M               0x0fffffff
#define HOSTAPD_FRAME_F_RET_OK          0x00000000
#define HOSTAPD_FRAME_F_RET_QUICK       0x10000000
#define HOSTAPD_FRAME_F_RET_SKIP        0x20000000
#define HOSTAPD_FRAME_F_RET_M           0xf0000000
#define HOSTAPD_FRAME_F_RET_S           28

#define HOSTAPD_FRAME_TABLE                                             \
        (HOSTAPD_FRAME_F_FROM_TABLE | HOSTAPD_FRAME_F_TO_TABLE |        \
        HOSTAPD_FRAME_F_BSSID_TABLE)
#define HOSTAPD_FRAME_N                                                 \
        (HOSTAPD_FRAME_F_FROM_N | HOSTAPD_FRAME_F_TO_N |                \
        HOSTAPD_FRAME_F_BSSID_N)

        struct hostapd_apme             *f_apme;
        struct hostapd_table            *f_from, *f_to, *f_bssid;
        struct timeval                  f_limit, f_then, f_last;
        long                            f_rate, f_rate_intval;
        long                            f_rate_cnt, f_rate_delay;

        enum hostapd_op                 f_rssi_op, f_txrate_op, f_chan_op;
        short                           f_rssi, f_txrate, f_chan;

        enum hostapd_action             f_action;
        u_int32_t                       f_action_flags;

#define HOSTAPD_ACTION_VERBOSE          0x00000001

        struct hostapd_action_data      f_action_data;

        TAILQ_ENTRY(hostapd_frame)      f_entries;
};

struct hostapd_apme {
        int                             a_raw;
        u_int                           a_rawlen;
        struct event                    a_ev;
        char                            a_iface[IFNAMSIZ];
        u_int8_t                        a_bssid[IEEE80211_ADDR_LEN];
        void                            *a_cfg;
        struct sockaddr_in              a_addr;

        struct event                    a_chanev;
        u_int8_t                        *a_chanavail;
        u_int8_t                        a_curchan;
        u_int                           a_maxchan;
        struct ieee80211chanreq         a_chanreq;

        TAILQ_ENTRY(hostapd_apme)       a_entries;
};

#ifndef IEEE80211_CHAN_MAX
#define IEEE80211_CHAN_MAX      255
#endif

#define HOSTAPD_HOPPER_MDELAY   800

struct hostapd_iapp {
        u_int16_t                       i_cnt;
        int                             i_raw;
        char                            i_iface[IFNAMSIZ];
        int                             i_udp;
        struct event                    i_udp_ev;
        u_int16_t                       i_udp_port;
        struct sockaddr_in              i_addr;
        struct sockaddr_in              i_broadcast;
        struct sockaddr_in              i_multicast;
        u_int8_t                        i_ttl;
        u_int8_t                        i_flags;

#define HOSTAPD_IAPP_F_ADD_NOTIFY       0x01
#define HOSTAPD_IAPP_F_RADIOTAP         0x02
#define HOSTAPD_IAPP_F_ROAMING_ADDRESS  0x04
#define HOSTAPD_IAPP_F_ROAMING_ROUTE    0x08
#define HOSTAPD_IAPP_F_DEFAULT                                                  \
        (HOSTAPD_IAPP_F_ADD_NOTIFY | HOSTAPD_IAPP_F_RADIOTAP)
#define HOSTAPD_IAPP_F_ROAMING                                                  \
        (HOSTAPD_IAPP_F_ROAMING_ROUTE | HOSTAPD_IAPP_F_ROAMING_ADDRESS)
#define HOSTAPD_IAPP_F_ADD              \
        (HOSTAPD_IAPP_F_ADD_NOTIFY | HOSTAPD_IAPP_F_ROAMING)

        struct hostapd_table            *i_addr_tbl;
        struct hostapd_table            *i_route_tbl;
};

struct hostapd_config {
        int                             c_apme_ctl;
        u_int                           c_apme_dlt;
        struct timeval                  c_apme_hopdelay;

        struct hostapd_iapp             c_iapp;

        int                             c_rtsock;
        int                             c_rtseq;

        u_int8_t                        c_flags;

#define HOSTAPD_CFG_F_APME              0x01
#define HOSTAPD_CFG_F_IAPP              0x02
#define HOSTAPD_CFG_F_IAPP_PASSIVE      0x04
#define HOSTAPD_CFG_F_RAW               0x08
#define HOSTAPD_CFG_F_UDP               0x10
#define HOSTAPD_CFG_F_BRDCAST           0x20
#define HOSTAPD_CFG_F_PRIV              0x40

        struct event                    c_priv_ev;

        char                            c_config[PATH_MAX];

        u_int                           c_verbose;
        u_int                           c_debug;
        u_int                           c_id;

        struct hostapd_counter          c_stats;

        TAILQ_HEAD(, hostapd_apme)      c_apmes;
        TAILQ_HEAD(, hostapd_table)     c_tables;
        TAILQ_HEAD(, hostapd_frame)     c_frames;
};

#define HOSTAPD_USER    "_hostapd"
#define HOSTAPD_CONFIG  "/etc/hostapd.conf"
#define HOSTAPD_DLT     DLT_IEEE802_11

#define HOSTAPD_LOG             0
#define HOSTAPD_LOG_VERBOSE     1
#define HOSTAPD_LOG_DEBUG       2

#define PRINTF                  hostapd_printf
#define etheraddr_string(_s)    ether_ntoa((struct ether_addr*)_s)
#define TTEST2(var, l)          (                                               \
        snapend - (l) <= snapend && (const u_char *)&(var) <= snapend - (l)     \
)
#define TTEST(var)              TTEST2(var, sizeof(var))
#define TCHECK2(var, l)         if (!TTEST2(var, l)) goto trunc
#define TCHECK(var)             TCHECK2(var, sizeof(var))

__BEGIN_DECLS

void     hostapd_log(u_int, const char *, ...);
void     hostapd_printf(const char *, ...);
void     hostapd_fatal(const char *, ...);
int      hostapd_bpf_open(u_int);
void     hostapd_cleanup(struct hostapd_config *);
int      hostapd_check_file_secrecy(int, const char *);
void     hostapd_randval(u_int8_t *, const u_int)
            __attribute__((__bounded__(__buffer__, 1, 2)));

struct hostapd_table *hostapd_table_add(struct hostapd_config *,
            const char *);
struct hostapd_table *hostapd_table_lookup(struct hostapd_config *,
            const char *);
struct hostapd_entry *hostapd_entry_add(struct hostapd_table *,
            u_int8_t *);
struct hostapd_entry *hostapd_entry_lookup(struct hostapd_table *,
            u_int8_t *);
void     hostapd_entry_update(struct hostapd_table *,
            struct hostapd_entry *);

RB_PROTOTYPE(hostapd_tree, hostapd_entry, e_nodes, hostapd_entry_cmp);

int      hostapd_parse_file(struct hostapd_config *);
int      hostapd_parse_symset(char *);

void     hostapd_priv_init(struct hostapd_config *);
int      hostapd_priv_llc_xid(struct hostapd_config *, struct hostapd_node *);
void     hostapd_priv_apme_bssid(struct hostapd_apme *);
int      hostapd_priv_apme_getnode(struct hostapd_apme *,
            struct hostapd_node *);
int      hostapd_priv_apme_setnode(struct hostapd_apme *,
            struct hostapd_node *node, int);
int      hostapd_priv_roaming(struct hostapd_apme *, struct hostapd_node *,
            int);

void     hostapd_apme_init(struct hostapd_apme *);
int      hostapd_apme_deauth(struct hostapd_apme *);
int      hostapd_apme_add(struct hostapd_config *, const char *);
void     hostapd_apme_term(struct hostapd_apme *);
struct hostapd_apme *hostapd_apme_lookup(struct hostapd_config *,
            const char *);
void     hostapd_apme_input(int, short, void *);
int      hostapd_apme_output(struct hostapd_apme *,
            struct hostapd_ieee80211_frame *);
int      hostapd_apme_addnode(struct hostapd_apme *,
            struct hostapd_node *node);
int      hostapd_apme_delnode(struct hostapd_apme *,
            struct hostapd_node *node);
int      hostapd_apme_offset(struct hostapd_apme *, u_int8_t *,
            const u_int);
struct hostapd_apme *hostapd_apme_addhopper(struct hostapd_config *,
            const char *);
void     hostapd_apme_sethopper(struct hostapd_apme *, int);

void     hostapd_iapp_init(struct hostapd_config *);
void     hostapd_iapp_term(struct hostapd_config *);
int      hostapd_iapp_add_notify(struct hostapd_apme *,
            struct hostapd_node *);
int      hostapd_iapp_radiotap(struct hostapd_apme *,
            u_int8_t *, const u_int);
void     hostapd_iapp_input(int, short, void *);

void     hostapd_llc_init(struct hostapd_config *);
int      hostapd_llc_send_xid(struct hostapd_config *, struct hostapd_node *);

int      hostapd_handle_input(struct hostapd_apme *, u_int8_t *, u_int);

void     hostapd_print_ieee80211(u_int, u_int, u_int8_t *, u_int);

void     hostapd_roaming_init(struct hostapd_config *);
void     hostapd_roaming_term(struct hostapd_apme *);
int      hostapd_roaming(struct hostapd_apme *, struct hostapd_node *, int);
int      hostapd_roaming_add(struct hostapd_apme *,
            struct hostapd_node *node);
int      hostapd_roaming_del(struct hostapd_apme *,
            struct hostapd_node *node);

__END_DECLS

#endif /* _HOSTAPD_H */