Merge "Move libnl headers to their own project"

        socket.c

LOCAL_C_INCLUDES += \

        $(LOCAL_PATH)/include

        external/libnl-headers

# Static Library

LOCAL_MODULE := libnl_2

/*

 * netlink-generic.h	Local Generic Netlink Interface

 *

 *	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-2006 Thomas Graf <tgraf@suug.ch>

 */

#ifndef NETLINK_GENL_PRIV_H_

#define NETLINK_GENL_PRIV_H_

#include <netlink-local.h>

#include <netlink/netlink.h>

#define GENL_HDRSIZE(hdrlen) (GENL_HDRLEN + (hdrlen))

#endif

/*

 * netlink-local.h		Local Netlink Interface

 *

 *	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_H_

#define NETLINK_LOCAL_H_

#include <stdio.h>

#include <errno.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <fcntl.h>

#include <math.h>

#include <time.h>

#include <stdarg.h>

#include <ctype.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <sys/socket.h>

#include <inttypes.h>

#include <assert.h>

#include <limits.h>

#include <arpa/inet.h>

#include <netdb.h>

#ifndef SOL_NETLINK

#define SOL_NETLINK 270

#endif

#include <linux/types.h>

/* local header copies */

#include <linux/if.h>

#include <linux/if_arp.h>

#include <linux/if_ether.h>

#include <linux/pkt_sched.h>

#include <linux/pkt_cls.h>

#include <linux/gen_stats.h>

#include <linux/ip_mp_alg.h>

#include <netlink/netlink.h>

#include <netlink/handlers.h>

#include <netlink/cache.h>

#include <netlink/route/tc.h>

#include <netlink/object-api.h>

#include <netlink/cache-api.h>

#include <netlink-types.h>

struct trans_tbl {

	int i;

	const char *a;

};

#define __ADD(id, name) { .i = id, .a = #name },

struct trans_list {

	int i;

	char *a;

	struct nl_list_head list;

};

#define NL_DEBUG	1

#define NL_DBG(LVL,FMT,ARG...) \

	do {	\

		if (LVL <= nl_debug) \

			fprintf(stderr, "DBG<" #LVL ">: " FMT, ##ARG); \

	} while (0)

#define BUG()                            \

	do {                                 \

		fprintf(stderr, "BUG: %s:%d\n",  \

			__FILE__, __LINE__);         \

		assert(0);	\

	} while (0)

extern int __nl_read_num_str_file(const char *path,

				  int (*cb)(long, const char *));

extern int __trans_list_add(int, const char *, struct nl_list_head *);

extern void __trans_list_clear(struct nl_list_head *);

extern char *__type2str(int, char *, size_t, struct trans_tbl *, size_t);

extern int __str2type(const char *, struct trans_tbl *, size_t);

extern char *__list_type2str(int, char *, size_t, struct nl_list_head *);

extern int __list_str2type(const char *, struct nl_list_head *);

extern char *__flags2str(int, char *, size_t, struct trans_tbl *, size_t);

extern int __str2flags(const char *, struct trans_tbl *, size_t);

extern void dump_from_ops(struct nl_object *, struct nl_dump_params *);

static inline struct nl_cache *dp_cache(struct nl_object *obj)

{

	if (obj->ce_cache == NULL)

		return nl_cache_mngt_require(obj->ce_ops->oo_name);

	return obj->ce_cache;

}

static inline int nl_cb_call(struct nl_cb *cb, int type, struct nl_msg *msg)

{

	return cb->cb_set[type](msg, cb->cb_args[type]);

}

#define ARRAY_SIZE(X) (sizeof(X) / sizeof((X)[0]))

#ifndef offsetof

#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)

#endif

#define __init __attribute__ ((constructor))

#define __exit __attribute__ ((destructor))

#undef __deprecated

#define __deprecated __attribute__ ((deprecated))

#define min(x,y) ({ \

	typeof(x) _x = (x);	\

	typeof(y) _y = (y);	\

	(void) (&_x == &_y);		\

	_x < _y ? _x : _y; })

#define max(x,y) ({ \

	typeof(x) _x = (x);	\

	typeof(y) _y = (y);	\

	(void) (&_x == &_y);		\

	_x > _y ? _x : _y; })

#define min_t(type,x,y) \

	({ type __x = (x); type __y = (y); __x < __y ? __x: __y; })

#define max_t(type,x,y) \

	({ type __x = (x); type __y = (y); __x > __y ? __x: __y; })

extern int nl_cache_parse(struct nl_cache_ops *, struct sockaddr_nl *,

			  struct nlmsghdr *, struct nl_parser_param *);

static inline void rtnl_copy_ratespec(struct rtnl_ratespec *dst,

				      struct tc_ratespec *src)

{

	dst->rs_cell_log = src->cell_log;

	dst->rs_feature = src->feature;

	dst->rs_addend = src->addend;

	dst->rs_mpu = src->mpu;

	dst->rs_rate = src->rate;

}

static inline void rtnl_rcopy_ratespec(struct tc_ratespec *dst,

				       struct rtnl_ratespec *src)

{

	dst->cell_log = src->rs_cell_log;

	dst->feature = src->rs_feature;

	dst->addend = src->rs_addend;

	dst->mpu = src->rs_mpu;

	dst->rate = src->rs_rate;

}

static inline char *nl_cache_name(struct nl_cache *cache)

{

	return cache->c_ops ? cache->c_ops->co_name : "unknown";

}

#define GENL_FAMILY(id, name) \

	{ \

		{ id, NL_ACT_UNSPEC, name }, \

		END_OF_MSGTYPES_LIST, \

	}

static inline int wait_for_ack(struct nl_sock *sk)

{

	if (sk->s_flags & NL_NO_AUTO_ACK)

		return 0;

	else

		return nl_wait_for_ack(sk);

}

#endif

/*

 * 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>

#include <netlink/object-api.h>

#include <linux/socket.h>

#include <linux/pkt_sched.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_NO_AUTO_ACK		(1<<4)

#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;

	void *			ca_change_data;

};

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;

#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;

	int			nm_refcnt;

};

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;		\

	struct nl_data *	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);

	uint16_t		c_prio;

	uint16_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_cgroup

{

	struct rtnl_ematch_tree *cg_ematch;

	int			cg_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_ematch

{

	uint16_t		e_id;

	uint16_t		e_kind;

	uint16_t		e_flags;

	struct nl_list_head	e_childs;

	struct nl_list_head	e_list;

	struct rtnl_ematch_ops *e_ops;

	char			e_data[0];

};

struct rtnl_ematch_tree

{

	uint16_t		et_progid;

	struct nl_list_head	et_list;

};

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;