stv0g/libnl
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity
libnl/include/netlink-types.h
Thomas Graf 1155370f52 Rename struct nl_handle to struct nl_sock 
The idea of a common handle is long revised and only misleading,
nl_handle really represents a socket with some additional
action handlers assigned to it.

Alias for nl_handle is kept for backwards compatibility.
2008-05-15 13:26:32 +02:00

809 lines
15 KiB
C
Raw Blame History

/*
* netlink-types.h Netlink Types (Private)
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation version 2.1
* of the License.
*
* Copyright (c) 2003-2008 Thomas Graf <tgraf@suug.ch>
*/
#ifndef NETLINK_LOCAL_TYPES_H_
#define NETLINK_LOCAL_TYPES_H_
#include <netlink/list.h>
#include <netlink/route/link.h>
#include <netlink/route/qdisc.h>
#include <netlink/route/rtnl.h>
#include <netlink/route/route.h>
#define NL_SOCK_BUFSIZE_SET (1<<0)
#define NL_SOCK_PASSCRED (1<<1)
#define NL_OWN_PORT (1<<2)
#define NL_MSG_PEEK (1<<3)
#define NL_MSG_CRED_PRESENT 1
struct nl_cache_ops;
struct nl_sock;
struct nl_object;
struct nl_cb
{
nl_recvmsg_msg_cb_t cb_set[NL_CB_TYPE_MAX+1];
void * cb_args[NL_CB_TYPE_MAX+1];
nl_recvmsg_err_cb_t cb_err;
void * cb_err_arg;
/** May be used to replace nl_recvmsgs with your own implementation
* in all internal calls to nl_recvmsgs. */
int (*cb_recvmsgs_ow)(struct nl_sock *,
struct nl_cb *);
/** Overwrite internal calls to nl_recv, must return the number of
* octets read and allocate a buffer for the received data. */
int (*cb_recv_ow)(struct nl_sock *,
struct sockaddr_nl *,
unsigned char **,
struct ucred **);
/** Overwrites internal calls to nl_send, must send the netlink
* message. */
int (*cb_send_ow)(struct nl_sock *,
struct nl_msg *);
int cb_refcnt;
};
struct nl_sock
{
struct sockaddr_nl s_local;
struct sockaddr_nl s_peer;
int s_fd;
int s_proto;
unsigned int s_seq_next;
unsigned int s_seq_expect;
int s_flags;
struct nl_cb * s_cb;
};
struct nl_cache
{
struct nl_list_head c_items;
int c_nitems;
int c_iarg1;
int c_iarg2;
struct nl_cache_ops * c_ops;
};
struct nl_cache_assoc
{
struct nl_cache * ca_cache;
change_func_t ca_change;
};
struct nl_cache_mngr
{
int cm_protocol;
int cm_flags;
int cm_nassocs;
struct nl_sock * cm_handle;
struct nl_cache_assoc * cm_assocs;
};
struct nl_parser_param;
struct genl_info
{
struct sockaddr_nl * who;
struct nlmsghdr * nlh;
struct genlmsghdr * genlhdr;
void * userhdr;
struct nlattr ** attrs;
};
#define LOOSE_COMPARISON 1
#define NL_OBJ_MARK 1
struct nl_object
{
NLHDR_COMMON
};
struct nl_data
{
size_t d_size;
void * d_data;
};
struct nl_addr
{
int a_family;
unsigned int a_maxsize;
unsigned int a_len;
int a_prefixlen;
int a_refcnt;
char a_addr[0];
};
struct nl_msg
{
int nm_protocol;
int nm_flags;
struct sockaddr_nl nm_src;
struct sockaddr_nl nm_dst;
struct ucred nm_creds;
struct nlmsghdr * nm_nlh;
size_t nm_size;
};
struct rtnl_link_map
{
uint64_t lm_mem_start;
uint64_t lm_mem_end;
uint64_t lm_base_addr;
uint16_t lm_irq;
uint8_t lm_dma;
uint8_t lm_port;
};
#define IFQDISCSIZ 32
struct rtnl_link
{
NLHDR_COMMON
char l_name[IFNAMSIZ];
uint32_t l_family;
uint32_t l_arptype;
uint32_t l_index;
uint32_t l_flags;
uint32_t l_change;
uint32_t l_mtu;
uint32_t l_link;
uint32_t l_txqlen;
uint32_t l_weight;
uint32_t l_master;
struct nl_addr *l_addr;
struct nl_addr *l_bcast;
char l_qdisc[IFQDISCSIZ];
struct rtnl_link_map l_map;
uint64_t l_stats[RTNL_LINK_STATS_MAX+1];
uint32_t l_flag_mask;
uint8_t l_operstate;
uint8_t l_linkmode;
/* 2 byte hole */
struct rtnl_link_info_ops *l_info_ops;
void * l_info;
};
struct rtnl_ncacheinfo
{
uint32_t nci_confirmed; /**< Time since neighbour validty was last confirmed */
uint32_t nci_used; /**< Time since neighbour entry was last ued */
uint32_t nci_updated; /**< Time since last update */
uint32_t nci_refcnt; /**< Reference counter */
};
struct rtnl_neigh
{
NLHDR_COMMON
uint32_t n_family;
uint32_t n_ifindex;
uint16_t n_state;
uint8_t n_flags;
uint8_t n_type;
struct nl_addr *n_lladdr;
struct nl_addr *n_dst;
uint32_t n_probes;
struct rtnl_ncacheinfo n_cacheinfo;
uint32_t n_state_mask;
uint32_t n_flag_mask;
};
struct rtnl_addr_cacheinfo
{
/* Preferred lifetime in seconds */
uint32_t aci_prefered;
/* Valid lifetime in seconds */
uint32_t aci_valid;
/* Timestamp of creation in 1/100s seince boottime */
uint32_t aci_cstamp;
/* Timestamp of last update in 1/100s since boottime */
uint32_t aci_tstamp;
};
struct rtnl_addr
{
NLHDR_COMMON
uint8_t a_family;
uint8_t a_prefixlen;
uint8_t a_flags;
uint8_t a_scope;
uint32_t a_ifindex;
struct nl_addr *a_peer;
struct nl_addr *a_local;
struct nl_addr *a_bcast;
struct nl_addr *a_anycast;
struct nl_addr *a_multicast;
struct rtnl_addr_cacheinfo a_cacheinfo;
char a_label[IFNAMSIZ];
uint32_t a_flag_mask;
};
struct rtnl_nexthop
{
uint8_t rtnh_flags;
uint8_t rtnh_flag_mask;
uint8_t rtnh_weight;
/* 1 byte spare */
uint32_t rtnh_ifindex;
struct nl_addr * rtnh_gateway;
uint32_t ce_mask; /* HACK to support attr macros */
struct nl_list_head rtnh_list;
uint32_t rtnh_realms;
};
struct rtnl_route
{
NLHDR_COMMON
uint8_t rt_family;
uint8_t rt_dst_len;
uint8_t rt_src_len;
uint8_t rt_tos;
uint8_t rt_protocol;
uint8_t rt_scope;
uint8_t rt_type;
uint8_t rt_nmetrics;
uint32_t rt_flags;
struct nl_addr * rt_dst;
struct nl_addr * rt_src;
uint32_t rt_table;
uint32_t rt_iif;
uint32_t rt_prio;
uint32_t rt_metrics[RTAX_MAX];
uint32_t rt_metrics_mask;
uint32_t rt_nr_nh;
struct nl_addr * rt_pref_src;
struct nl_list_head rt_nexthops;
struct rtnl_rtcacheinfo rt_cacheinfo;
uint32_t rt_flag_mask;
};
struct rtnl_rule
{
NLHDR_COMMON
uint64_t r_mark;
uint32_t r_prio;
uint32_t r_realms;
uint32_t r_table;
uint8_t r_dsfield;
uint8_t r_type;
uint8_t r_family;
uint8_t r_src_len;
uint8_t r_dst_len;
char r_iif[IFNAMSIZ];
struct nl_addr *r_src;
struct nl_addr *r_dst;
struct nl_addr *r_srcmap;
};
struct rtnl_neightbl_parms
{
/**
* Interface index of the device this parameter set is assigned
* to or 0 for the default set.
*/
uint32_t ntp_ifindex;
/**
* Number of references to this parameter set.
*/
uint32_t ntp_refcnt;
/**
* Queue length for pending arp requests, i.e. the number of
* packets which are accepted from other layers while the
* neighbour address is still being resolved
*/
uint32_t ntp_queue_len;
/**
* Number of requests to send to the user level ARP daemon.
* Specify 0 to disable.
*/
uint32_t ntp_app_probes;
/**
* Maximum number of retries for unicast solicitation.
*/
uint32_t ntp_ucast_probes;
/**
* Maximum number of retries for multicast solicitation.
*/
uint32_t ntp_mcast_probes;
/**
* Base value in milliseconds to ompute reachable time, see RFC2461.
*/
uint64_t ntp_base_reachable_time;
/**
* Actual reachable time (read-only)
*/
uint64_t ntp_reachable_time; /* secs */
/**
* The time in milliseconds between retransmitted Neighbor
* Solicitation messages.
*/
uint64_t ntp_retrans_time;
/**
* Interval in milliseconds to check for stale neighbour
* entries.
*/
uint64_t ntp_gc_stale_time; /* secs */
/**
* Delay in milliseconds for the first time probe if
* the neighbour is reachable.
*/
uint64_t ntp_probe_delay; /* secs */
/**
* Maximum delay in milliseconds of an answer to a neighbour
* solicitation message.
*/
uint64_t ntp_anycast_delay;
/**
* Minimum age in milliseconds before a neighbour entry
* may be replaced.
*/
uint64_t ntp_locktime;
/**
* Delay in milliseconds before answering to an ARP request
* for which a proxy ARP entry exists.
*/
uint64_t ntp_proxy_delay;
/**
* Queue length for the delayed proxy arp requests.
*/
uint32_t ntp_proxy_qlen;
/**
* Mask of available parameter attributes
*/
uint32_t ntp_mask;
};
#define NTBLNAMSIZ 32
/**
* Neighbour table
* @ingroup neightbl
*/
struct rtnl_neightbl
{
NLHDR_COMMON
char nt_name[NTBLNAMSIZ];
uint32_t nt_family;
uint32_t nt_gc_thresh1;
uint32_t nt_gc_thresh2;
uint32_t nt_gc_thresh3;
uint64_t nt_gc_interval;
struct ndt_config nt_config;
struct rtnl_neightbl_parms nt_parms;
struct ndt_stats nt_stats;
};
struct rtnl_ratespec
{
uint8_t rs_cell_log;
uint16_t rs_feature;
uint16_t rs_addend;
uint16_t rs_mpu;
uint32_t rs_rate;
};
struct rtnl_tstats
{
struct {
uint64_t bytes;
uint64_t packets;
} tcs_basic;
struct {
uint32_t bps;
uint32_t pps;
} tcs_rate_est;
struct {
uint32_t qlen;
uint32_t backlog;
uint32_t drops;
uint32_t requeues;
uint32_t overlimits;
} tcs_queue;
};
#define TCKINDSIZ 32
#define NL_TCA_GENERIC(pre) \
NLHDR_COMMON \
uint32_t pre ##_family; \
uint32_t pre ##_ifindex; \
uint32_t pre ##_handle; \
uint32_t pre ##_parent; \
uint32_t pre ##_info; \
char pre ##_kind[TCKINDSIZ]; \
struct nl_data * pre ##_opts; \
uint64_t pre ##_stats[RTNL_TC_STATS_MAX+1]; \
struct nl_data * pre ##_xstats; \
void * pre ##_subdata; \
struct rtnl_tca
{
NL_TCA_GENERIC(tc);
};
struct rtnl_qdisc
{
NL_TCA_GENERIC(q);
struct rtnl_qdisc_ops *q_ops;
};
struct rtnl_class
{
NL_TCA_GENERIC(c);
struct rtnl_class_ops *c_ops;
};
struct rtnl_cls
{
NL_TCA_GENERIC(c);
uint32_t c_prio;
uint32_t c_protocol;
struct rtnl_cls_ops *c_ops;
};
struct rtnl_u32
{
uint32_t cu_divisor;
uint32_t cu_hash;
uint32_t cu_classid;
uint32_t cu_link;
struct nl_data * cu_pcnt;
struct nl_data * cu_selector;
struct nl_data * cu_act;
struct nl_data * cu_police;
char cu_indev[IFNAMSIZ];
int cu_mask;
};
struct rtnl_fw
{
uint32_t cf_classid;
struct nl_data * cf_act;
struct nl_data * cf_police;
char cf_indev[IFNAMSIZ];
int cf_mask;
};
struct rtnl_dsmark_qdisc
{
uint16_t qdm_indices;
uint16_t qdm_default_index;
uint32_t qdm_set_tc_index;
uint32_t qdm_mask;
};
struct rtnl_dsmark_class
{
uint8_t cdm_bmask;
uint8_t cdm_value;
uint32_t cdm_mask;
};
struct rtnl_fifo
{
uint32_t qf_limit;
uint32_t qf_mask;
};
struct rtnl_prio
{
uint32_t qp_bands;
uint8_t qp_priomap[TC_PRIO_MAX+1];
uint32_t qp_mask;
};
struct rtnl_tbf
{
uint32_t qt_limit;
uint32_t qt_mpu;
struct rtnl_ratespec qt_rate;
uint32_t qt_rate_bucket;
uint32_t qt_rate_txtime;
struct rtnl_ratespec qt_peakrate;
uint32_t qt_peakrate_bucket;
uint32_t qt_peakrate_txtime;
uint32_t qt_mask;
};
struct rtnl_sfq
{
uint32_t qs_quantum;
uint32_t qs_perturb;
uint32_t qs_limit;
uint32_t qs_divisor;
uint32_t qs_flows;
uint32_t qs_mask;
};
struct rtnl_netem_corr
{
uint32_t nmc_delay;
uint32_t nmc_loss;
uint32_t nmc_duplicate;
};
struct rtnl_netem_reo
{
uint32_t nmro_probability;
uint32_t nmro_correlation;
};
struct rtnl_netem_crpt
{
uint32_t nmcr_probability;
uint32_t nmcr_correlation;
};
struct rtnl_netem_dist
{
int16_t * dist_data;
size_t dist_size;
};
struct rtnl_netem
{
uint32_t qnm_latency;
uint32_t qnm_limit;
uint32_t qnm_loss;
uint32_t qnm_gap;
uint32_t qnm_duplicate;
uint32_t qnm_jitter;
uint32_t qnm_mask;
struct rtnl_netem_corr qnm_corr;
struct rtnl_netem_reo qnm_ro;
struct rtnl_netem_crpt qnm_crpt;
struct rtnl_netem_dist qnm_dist;
};
struct rtnl_htb_qdisc
{
uint32_t qh_rate2quantum;
uint32_t qh_defcls;
uint32_t qh_mask;
};
struct rtnl_htb_class
{
uint32_t ch_prio;
uint32_t ch_mtu;
struct rtnl_ratespec ch_rate;
struct rtnl_ratespec ch_ceil;
uint32_t ch_rbuffer;
uint32_t ch_cbuffer;
uint32_t ch_quantum;
uint8_t ch_overhead;
uint8_t ch_mpu;
uint32_t ch_mask;
};
struct rtnl_cbq
{
struct tc_cbq_lssopt cbq_lss;
struct tc_ratespec cbq_rate;
struct tc_cbq_wrropt cbq_wrr;
struct tc_cbq_ovl cbq_ovl;
struct tc_cbq_fopt cbq_fopt;
struct tc_cbq_police cbq_police;
};
struct rtnl_red
{
uint32_t qr_limit;
uint32_t qr_qth_min;
uint32_t qr_qth_max;
uint8_t qr_flags;
uint8_t qr_wlog;
uint8_t qr_plog;
uint8_t qr_scell_log;
uint32_t qr_mask;
};
struct flnl_request
{
NLHDR_COMMON
struct nl_addr * lr_addr;
uint32_t lr_fwmark;
uint8_t lr_tos;
uint8_t lr_scope;
uint8_t lr_table;
};
struct flnl_result
{
NLHDR_COMMON
struct flnl_request * fr_req;
uint8_t fr_table_id;
uint8_t fr_prefixlen;
uint8_t fr_nh_sel;
uint8_t fr_type;
uint8_t fr_scope;
uint32_t fr_error;
};
#define GENL_OP_HAS_POLICY 1
#define GENL_OP_HAS_DOIT 2
#define GENL_OP_HAS_DUMPIT 4
struct genl_family_op
{
uint32_t o_id;
uint32_t o_flags;
struct nl_list_head o_list;
};
struct genl_family
{
NLHDR_COMMON
uint16_t gf_id;
char gf_name[GENL_NAMSIZ];
uint32_t gf_version;
uint32_t gf_hdrsize;
uint32_t gf_maxattr;
struct nl_list_head gf_ops;
};
union nfnl_ct_proto
{
struct {
uint16_t src;
uint16_t dst;
} port;
struct {
uint16_t id;
uint8_t type;
uint8_t code;
} icmp;
};
struct nfnl_ct_dir {
struct nl_addr * src;
struct nl_addr * dst;
union nfnl_ct_proto proto;
uint64_t packets;
uint64_t bytes;
};
union nfnl_ct_protoinfo {
struct {
uint8_t state;
} tcp;
};
struct nfnl_ct {
NLHDR_COMMON
uint8_t ct_family;
uint8_t ct_proto;
union nfnl_ct_protoinfo ct_protoinfo;
uint32_t ct_status;
uint32_t ct_status_mask;
uint32_t ct_timeout;
uint32_t ct_mark;
uint32_t ct_use;
uint32_t ct_id;
struct nfnl_ct_dir ct_orig;
struct nfnl_ct_dir ct_repl;
};
struct nfnl_log {
NLHDR_COMMON
uint16_t log_group;
uint8_t log_copy_mode;
uint32_t log_copy_range;
uint32_t log_flush_timeout;
uint32_t log_alloc_size;
uint32_t log_queue_threshold;
uint32_t log_flags;
uint32_t log_flag_mask;
};
struct nfnl_log_msg {
NLHDR_COMMON
uint8_t log_msg_family;
uint8_t log_msg_hook;
uint16_t log_msg_hwproto;
uint32_t log_msg_mark;
struct timeval log_msg_timestamp;
uint32_t log_msg_indev;
uint32_t log_msg_outdev;
uint32_t log_msg_physindev;
uint32_t log_msg_physoutdev;
uint8_t log_msg_hwaddr[8];
int log_msg_hwaddr_len;
void * log_msg_payload;
int log_msg_payload_len;
char * log_msg_prefix;
uint32_t log_msg_uid;
uint32_t log_msg_gid;
uint32_t log_msg_seq;
uint32_t log_msg_seq_global;
};
struct nfnl_queue {
NLHDR_COMMON
uint16_t queue_group;
uint32_t queue_maxlen;
uint32_t queue_copy_range;
uint8_t queue_copy_mode;
};
struct nfnl_queue_msg {
NLHDR_COMMON
uint16_t queue_msg_group;
uint8_t queue_msg_family;
uint8_t queue_msg_hook;
uint16_t queue_msg_hwproto;
uint32_t queue_msg_packetid;
uint32_t queue_msg_mark;
struct timeval queue_msg_timestamp;
uint32_t queue_msg_indev;
uint32_t queue_msg_outdev;
uint32_t queue_msg_physindev;
uint32_t queue_msg_physoutdev;
uint8_t queue_msg_hwaddr[8];
int queue_msg_hwaddr_len;
void * queue_msg_payload;
int queue_msg_payload_len;
uint32_t queue_msg_verdict;
};
#endif
Reference in a new issue View git blame Copy permalink