projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[9P]: build fix with !CONFIG_SYSCTL
[deliverable/linux.git] / include / linux / rtnetlink.h
CommitLineData
1da177e4
LT		 1#ifndef __LINUX_RTNETLINK_H
2#define __LINUX_RTNETLINK_H
3
4#include <linux/netlink.h>
cbde1668 5#include <linux/if_link.h>
e07bca84
TG		 6#include <linux/if_addr.h>
7#include <linux/neighbour.h>
1da177e4
LT		 8
9/****
10 * Routing/neighbour discovery messages.
11 ****/
12
13/* Types of messages */
14
15enum {
16 RTM_BASE = 16,
17#define RTM_BASE RTM_BASE
18
19 RTM_NEWLINK = 16,
20#define RTM_NEWLINK RTM_NEWLINK
21 RTM_DELLINK,
22#define RTM_DELLINK RTM_DELLINK
23 RTM_GETLINK,
24#define RTM_GETLINK RTM_GETLINK
25 RTM_SETLINK,
26#define RTM_SETLINK RTM_SETLINK
27
28 RTM_NEWADDR = 20,
29#define RTM_NEWADDR RTM_NEWADDR
30 RTM_DELADDR,
31#define RTM_DELADDR RTM_DELADDR
32 RTM_GETADDR,
33#define RTM_GETADDR RTM_GETADDR
34
35 RTM_NEWROUTE = 24,
36#define RTM_NEWROUTE RTM_NEWROUTE
37 RTM_DELROUTE,
38#define RTM_DELROUTE RTM_DELROUTE
39 RTM_GETROUTE,
40#define RTM_GETROUTE RTM_GETROUTE
41
42 RTM_NEWNEIGH = 28,
43#define RTM_NEWNEIGH RTM_NEWNEIGH
44 RTM_DELNEIGH,
45#define RTM_DELNEIGH RTM_DELNEIGH
46 RTM_GETNEIGH,
47#define RTM_GETNEIGH RTM_GETNEIGH
48
49 RTM_NEWRULE = 32,
50#define RTM_NEWRULE RTM_NEWRULE
51 RTM_DELRULE,
52#define RTM_DELRULE RTM_DELRULE
53 RTM_GETRULE,
54#define RTM_GETRULE RTM_GETRULE
55
56 RTM_NEWQDISC = 36,
57#define RTM_NEWQDISC RTM_NEWQDISC
58 RTM_DELQDISC,
59#define RTM_DELQDISC RTM_DELQDISC
60 RTM_GETQDISC,
61#define RTM_GETQDISC RTM_GETQDISC
62
63 RTM_NEWTCLASS = 40,
64#define RTM_NEWTCLASS RTM_NEWTCLASS
65 RTM_DELTCLASS,
66#define RTM_DELTCLASS RTM_DELTCLASS
67 RTM_GETTCLASS,
68#define RTM_GETTCLASS RTM_GETTCLASS
69
70 RTM_NEWTFILTER = 44,
71#define RTM_NEWTFILTER RTM_NEWTFILTER
72 RTM_DELTFILTER,
73#define RTM_DELTFILTER RTM_DELTFILTER
74 RTM_GETTFILTER,
75#define RTM_GETTFILTER RTM_GETTFILTER
76
77 RTM_NEWACTION = 48,
78#define RTM_NEWACTION RTM_NEWACTION
79 RTM_DELACTION,
80#define RTM_DELACTION RTM_DELACTION
81 RTM_GETACTION,
82#define RTM_GETACTION RTM_GETACTION
83
84 RTM_NEWPREFIX = 52,
85#define RTM_NEWPREFIX RTM_NEWPREFIX
1da177e4
LT		 86
87 RTM_GETMULTICAST = 58,
88#define RTM_GETMULTICAST RTM_GETMULTICAST
89
90 RTM_GETANYCAST = 62,
91#define RTM_GETANYCAST RTM_GETANYCAST
92
c7fb64db
TG		 93 RTM_NEWNEIGHTBL = 64,
94#define RTM_NEWNEIGHTBL RTM_NEWNEIGHTBL
95 RTM_GETNEIGHTBL = 66,
96#define RTM_GETNEIGHTBL RTM_GETNEIGHTBL
97 RTM_SETNEIGHTBL,
98#define RTM_SETNEIGHTBL RTM_SETNEIGHTBL
99
d775fc09
TG		 100 __RTM_MAX,
101#define RTM_MAX (((__RTM_MAX + 3) & ~3) - 1)
1da177e4
LT		 102};
103
db46edc6
TG		 104#define RTM_NR_MSGTYPES (RTM_MAX + 1 - RTM_BASE)
105#define RTM_NR_FAMILIES (RTM_NR_MSGTYPES >> 2)
f90a0a74
TG		 106#define RTM_FAM(cmd) (((cmd) - RTM_BASE) >> 2)
107
1da177e4
LT		 108/*
109 Generic structure for encapsulation of optional route information.
110 It is reminiscent of sockaddr, but with sa_family replaced
111 with attribute type.
112 */
113
114struct rtattr
115{
116 unsigned short rta_len;
117 unsigned short rta_type;
118};
119
120/* Macros to handle rtattributes */
121
122#define RTA_ALIGNTO 4
123#define RTA_ALIGN(len) ( ((len)+RTA_ALIGNTO-1) & ~(RTA_ALIGNTO-1) )
124#define RTA_OK(rta,len) ((len) >= (int)sizeof(struct rtattr) && \
125 (rta)->rta_len >= sizeof(struct rtattr) && \
126 (rta)->rta_len <= (len))
127#define RTA_NEXT(rta,attrlen) ((attrlen) -= RTA_ALIGN((rta)->rta_len), \
128 (struct rtattr*)(((char*)(rta)) + RTA_ALIGN((rta)->rta_len)))
129#define RTA_LENGTH(len) (RTA_ALIGN(sizeof(struct rtattr)) + (len))
130#define RTA_SPACE(len) RTA_ALIGN(RTA_LENGTH(len))
131#define RTA_DATA(rta) ((void*)(((char*)(rta)) + RTA_LENGTH(0)))
132#define RTA_PAYLOAD(rta) ((int)((rta)->rta_len) - RTA_LENGTH(0))
133
134
135
136
137/******************************************************************************
138 * Definitions used in routing table administration.
139 ****/
140
141struct rtmsg
142{
143 unsigned char rtm_family;
144 unsigned char rtm_dst_len;
145 unsigned char rtm_src_len;
146 unsigned char rtm_tos;
147
148 unsigned char rtm_table; /* Routing table id */
149 unsigned char rtm_protocol; /* Routing protocol; see below */
150 unsigned char rtm_scope; /* See below */
151 unsigned char rtm_type; /* See below */
152
153 unsigned rtm_flags;
154};
155
156/* rtm_type */
157
158enum
159{
160 RTN_UNSPEC,
161 RTN_UNICAST, /* Gateway or direct route */
162 RTN_LOCAL, /* Accept locally */
163 RTN_BROADCAST, /* Accept locally as broadcast,
164 send as broadcast */
165 RTN_ANYCAST, /* Accept locally as broadcast,
166 but send as unicast */
167 RTN_MULTICAST, /* Multicast route */
168 RTN_BLACKHOLE, /* Drop */
169 RTN_UNREACHABLE, /* Destination is unreachable */
170 RTN_PROHIBIT, /* Administratively prohibited */
171 RTN_THROW, /* Not in this table */
172 RTN_NAT, /* Translate this address */
173 RTN_XRESOLVE, /* Use external resolver */
174 __RTN_MAX
175};
176
177#define RTN_MAX (__RTN_MAX - 1)
178
179
180/* rtm_protocol */
181
182#define RTPROT_UNSPEC 0
183#define RTPROT_REDIRECT 1 /* Route installed by ICMP redirects;
184 not used by current IPv4 */
185#define RTPROT_KERNEL 2 /* Route installed by kernel */
186#define RTPROT_BOOT 3 /* Route installed during boot */
187#define RTPROT_STATIC 4 /* Route installed by administrator */
188
189/* Values of protocol >= RTPROT_STATIC are not interpreted by kernel;
190 they are just passed from user and back as is.
191 It will be used by hypothetical multiple routing daemons.
192 Note that protocol values should be standardized in order to
193 avoid conflicts.
194 */
195
196#define RTPROT_GATED 8 /* Apparently, GateD */
197#define RTPROT_RA 9 /* RDISC/ND router advertisements */
198#define RTPROT_MRT 10 /* Merit MRT */
199#define RTPROT_ZEBRA 11 /* Zebra */
200#define RTPROT_BIRD 12 /* BIRD */
201#define RTPROT_DNROUTED 13 /* DECnet routing daemon */
202#define RTPROT_XORP 14 /* XORP */
99cae7fc 203#define RTPROT_NTK 15 /* Netsukuku */
1da177e4
LT		 204
205/* rtm_scope
206
207 Really it is not scope, but sort of distance to the destination.
208 NOWHERE are reserved for not existing destinations, HOST is our
209 local addresses, LINK are destinations, located on directly attached
210 link and UNIVERSE is everywhere in the Universe.
211
212 Intermediate values are also possible f.e. interior routes
213 could be assigned a value between UNIVERSE and LINK.
214*/
215
216enum rt_scope_t
217{
218 RT_SCOPE_UNIVERSE=0,
219/* User defined values */
220 RT_SCOPE_SITE=200,
221 RT_SCOPE_LINK=253,
222 RT_SCOPE_HOST=254,
223 RT_SCOPE_NOWHERE=255
224};
225
226/* rtm_flags */
227
228#define RTM_F_NOTIFY 0x100 /* Notify user of route change */
229#define RTM_F_CLONED 0x200 /* This route is cloned */
230#define RTM_F_EQUALIZE 0x400 /* Multipath equalizer: NI */
231#define RTM_F_PREFIX 0x800 /* Prefix addresses */
232
233/* Reserved table identifiers */
234
235enum rt_class_t
236{
237 RT_TABLE_UNSPEC=0,
238/* User defined values */
239 RT_TABLE_DEFAULT=253,
240 RT_TABLE_MAIN=254,
241 RT_TABLE_LOCAL=255,
b801f549 242 RT_TABLE_MAX=0xFFFFFFFF
1da177e4 243};
1da177e4
LT		 244
245
246/* Routing message attributes */
247
248enum rtattr_type_t
249{
250 RTA_UNSPEC,
251 RTA_DST,
252 RTA_SRC,
253 RTA_IIF,
254 RTA_OIF,
255 RTA_GATEWAY,
256 RTA_PRIORITY,
257 RTA_PREFSRC,
258 RTA_METRICS,
259 RTA_MULTIPATH,
260 RTA_PROTOINFO,
261 RTA_FLOW,
262 RTA_CACHEINFO,
263 RTA_SESSION,
e06e7c61 264 RTA_MP_ALGO, /* no longer used */
9e762a4a 265 RTA_TABLE,
1da177e4
LT		 266 __RTA_MAX
267};
268
269#define RTA_MAX (__RTA_MAX - 1)
270
271#define RTM_RTA(r) ((struct rtattr*)(((char*)(r)) + NLMSG_ALIGN(sizeof(struct rtmsg))))
272#define RTM_PAYLOAD(n) NLMSG_PAYLOAD(n,sizeof(struct rtmsg))
273
274/* RTM_MULTIPATH --- array of struct rtnexthop.
275 *
276 * "struct rtnexthop" describes all necessary nexthop information,
277 * i.e. parameters of path to a destination via this nexthop.
278 *
279 * At the moment it is impossible to set different prefsrc, mtu, window
280 * and rtt for different paths from multipath.
281 */
282
283struct rtnexthop
284{
285 unsigned short rtnh_len;
286 unsigned char rtnh_flags;
287 unsigned char rtnh_hops;
288 int rtnh_ifindex;
289};
290
291/* rtnh_flags */
292
293#define RTNH_F_DEAD 1 /* Nexthop is dead (used by multipath) */
294#define RTNH_F_PERVASIVE 2 /* Do recursive gateway lookup */
295#define RTNH_F_ONLINK 4 /* Gateway is forced on link */
296
297/* Macros to handle hexthops */
298
299#define RTNH_ALIGNTO 4
300#define RTNH_ALIGN(len) ( ((len)+RTNH_ALIGNTO-1) & ~(RTNH_ALIGNTO-1) )
301#define RTNH_OK(rtnh,len) ((rtnh)->rtnh_len >= sizeof(struct rtnexthop) && \
302 ((int)(rtnh)->rtnh_len) <= (len))
303#define RTNH_NEXT(rtnh) ((struct rtnexthop*)(((char*)(rtnh)) + RTNH_ALIGN((rtnh)->rtnh_len)))
304#define RTNH_LENGTH(len) (RTNH_ALIGN(sizeof(struct rtnexthop)) + (len))
305#define RTNH_SPACE(len) RTNH_ALIGN(RTNH_LENGTH(len))
306#define RTNH_DATA(rtnh) ((struct rtattr*)(((char*)(rtnh)) + RTNH_LENGTH(0)))
307
308/* RTM_CACHEINFO */
309
310struct rta_cacheinfo
311{
312 __u32 rta_clntref;
313 __u32 rta_lastuse;
314 __s32 rta_expires;
315 __u32 rta_error;
316 __u32 rta_used;
317
318#define RTNETLINK_HAVE_PEERINFO 1
319 __u32 rta_id;
320 __u32 rta_ts;
321 __u32 rta_tsage;
322};
323
324/* RTM_METRICS --- array of struct rtattr with types of RTAX_* */
325
326enum
327{
328 RTAX_UNSPEC,
329#define RTAX_UNSPEC RTAX_UNSPEC
330 RTAX_LOCK,
331#define RTAX_LOCK RTAX_LOCK
332 RTAX_MTU,
333#define RTAX_MTU RTAX_MTU
334 RTAX_WINDOW,
335#define RTAX_WINDOW RTAX_WINDOW
336 RTAX_RTT,
337#define RTAX_RTT RTAX_RTT
338 RTAX_RTTVAR,
339#define RTAX_RTTVAR RTAX_RTTVAR
340 RTAX_SSTHRESH,
341#define RTAX_SSTHRESH RTAX_SSTHRESH
342 RTAX_CWND,
343#define RTAX_CWND RTAX_CWND
344 RTAX_ADVMSS,
345#define RTAX_ADVMSS RTAX_ADVMSS
346 RTAX_REORDERING,
347#define RTAX_REORDERING RTAX_REORDERING
348 RTAX_HOPLIMIT,
349#define RTAX_HOPLIMIT RTAX_HOPLIMIT
350 RTAX_INITCWND,
351#define RTAX_INITCWND RTAX_INITCWND
352 RTAX_FEATURES,
353#define RTAX_FEATURES RTAX_FEATURES
05bb1fad
DM		 354 RTAX_RTO_MIN,
355#define RTAX_RTO_MIN RTAX_RTO_MIN
1da177e4
LT		 356 __RTAX_MAX
357};
358
359#define RTAX_MAX (__RTAX_MAX - 1)
360
361#define RTAX_FEATURE_ECN 0x00000001
362#define RTAX_FEATURE_SACK 0x00000002
363#define RTAX_FEATURE_TIMESTAMP 0x00000004
364#define RTAX_FEATURE_ALLFRAG 0x00000008
365
366struct rta_session
367{
368 __u8 proto;
8a47077a
PM		 369 __u8 pad1;
370 __u16 pad2;
1da177e4
LT		 371
372 union {
373 struct {
374 __u16 sport;
375 __u16 dport;
376 } ports;
377
378 struct {
379 __u8 type;
380 __u8 code;
381 __u16 ident;
382 } icmpt;
383
384 __u32 spi;
385 } u;
386};
387
1da177e4
LT		 388/****
389 * General form of address family dependent message.
390 ****/
391
392struct rtgenmsg
393{
394 unsigned char rtgen_family;
395};
396
397/*****************************************************************
398 * Link layer specific messages.
399 ****/
400
401/* struct ifinfomsg
402 * passes link level specific information, not dependent
403 * on network protocol.
404 */
405
406struct ifinfomsg
407{
408 unsigned char ifi_family;
409 unsigned char __ifi_pad;
410 unsigned short ifi_type; /* ARPHRD_* */
411 int ifi_index; /* Link index */
412 unsigned ifi_flags; /* IFF_* flags */
413 unsigned ifi_change; /* IFF_* change mask */
414};
415
416/********************************************************************
417 * prefix information
418 ****/
419
420struct prefixmsg
421{
422 unsigned char prefix_family;
8a47077a
PM		 423 unsigned char prefix_pad1;
424 unsigned short prefix_pad2;
1da177e4
LT		 425 int prefix_ifindex;
426 unsigned char prefix_type;
427 unsigned char prefix_len;
428 unsigned char prefix_flags;
8a47077a 429 unsigned char prefix_pad3;
1da177e4
LT		 430};
431
432enum
433{
434 PREFIX_UNSPEC,
435 PREFIX_ADDRESS,
436 PREFIX_CACHEINFO,
437 __PREFIX_MAX
438};
439
440#define PREFIX_MAX (__PREFIX_MAX - 1)
441
442struct prefix_cacheinfo
443{
444 __u32 preferred_time;
445 __u32 valid_time;
446};
447
1da177e4
LT		 448
449/*****************************************************************
450 * Traffic control messages.
451 ****/
452
453struct tcmsg
454{
455 unsigned char tcm_family;
456 unsigned char tcm__pad1;
457 unsigned short tcm__pad2;
458 int tcm_ifindex;
459 __u32 tcm_handle;
460 __u32 tcm_parent;
461 __u32 tcm_info;
462};
463
464enum
465{
466 TCA_UNSPEC,
467 TCA_KIND,
468 TCA_OPTIONS,
469 TCA_STATS,
470 TCA_XSTATS,
471 TCA_RATE,
472 TCA_FCNT,
473 TCA_STATS2,
474 __TCA_MAX
475};
476
477#define TCA_MAX (__TCA_MAX - 1)
478
479#define TCA_RTA(r) ((struct rtattr*)(((char*)(r)) + NLMSG_ALIGN(sizeof(struct tcmsg))))
480#define TCA_PAYLOAD(n) NLMSG_PAYLOAD(n,sizeof(struct tcmsg))
481
ac6d439d
PM		 482#ifndef __KERNEL__
483/* RTnetlink multicast groups - backwards compatibility for userspace */
1da177e4
LT		 484#define RTMGRP_LINK 1
485#define RTMGRP_NOTIFY 2
486#define RTMGRP_NEIGH 4
487#define RTMGRP_TC 8
488
489#define RTMGRP_IPV4_IFADDR 0x10
490#define RTMGRP_IPV4_MROUTE 0x20
491#define RTMGRP_IPV4_ROUTE 0x40
a5cdc030 492#define RTMGRP_IPV4_RULE 0x80
1da177e4
LT		 493
494#define RTMGRP_IPV6_IFADDR 0x100
495#define RTMGRP_IPV6_MROUTE 0x200
496#define RTMGRP_IPV6_ROUTE 0x400
497#define RTMGRP_IPV6_IFINFO 0x800
498
499#define RTMGRP_DECnet_IFADDR 0x1000
500#define RTMGRP_DECnet_ROUTE 0x4000
501
502#define RTMGRP_IPV6_PREFIX 0x20000
ac6d439d
PM		 503#endif
504
505/* RTnetlink multicast groups */
506enum rtnetlink_groups {
507 RTNLGRP_NONE,
508#define RTNLGRP_NONE RTNLGRP_NONE
509 RTNLGRP_LINK,
510#define RTNLGRP_LINK RTNLGRP_LINK
511 RTNLGRP_NOTIFY,
512#define RTNLGRP_NOTIFY RTNLGRP_NOTIFY
513 RTNLGRP_NEIGH,
514#define RTNLGRP_NEIGH RTNLGRP_NEIGH
515 RTNLGRP_TC,
516#define RTNLGRP_TC RTNLGRP_TC
517 RTNLGRP_IPV4_IFADDR,
518#define RTNLGRP_IPV4_IFADDR RTNLGRP_IPV4_IFADDR
519 RTNLGRP_IPV4_MROUTE,
520#define RTNLGRP_IPV4_MROUTE RTNLGRP_IPV4_MROUTE
521 RTNLGRP_IPV4_ROUTE,
522#define RTNLGRP_IPV4_ROUTE RTNLGRP_IPV4_ROUTE
a5cdc030
PM		 523 RTNLGRP_IPV4_RULE,
524#define RTNLGRP_IPV4_RULE RTNLGRP_IPV4_RULE
ac6d439d
PM		 525 RTNLGRP_IPV6_IFADDR,
526#define RTNLGRP_IPV6_IFADDR RTNLGRP_IPV6_IFADDR
527 RTNLGRP_IPV6_MROUTE,
528#define RTNLGRP_IPV6_MROUTE RTNLGRP_IPV6_MROUTE
529 RTNLGRP_IPV6_ROUTE,
530#define RTNLGRP_IPV6_ROUTE RTNLGRP_IPV6_ROUTE
531 RTNLGRP_IPV6_IFINFO,
532#define RTNLGRP_IPV6_IFINFO RTNLGRP_IPV6_IFINFO
533 RTNLGRP_DECnet_IFADDR,
534#define RTNLGRP_DECnet_IFADDR RTNLGRP_DECnet_IFADDR
6b80ebed 535 RTNLGRP_NOP2,
ac6d439d
PM		 536 RTNLGRP_DECnet_ROUTE,
537#define RTNLGRP_DECnet_ROUTE RTNLGRP_DECnet_ROUTE
a8731cbf
SW		 538 RTNLGRP_DECnet_RULE,
539#define RTNLGRP_DECnet_RULE RTNLGRP_DECnet_RULE
6b80ebed 540 RTNLGRP_NOP4,
ac6d439d
PM		 541 RTNLGRP_IPV6_PREFIX,
542#define RTNLGRP_IPV6_PREFIX RTNLGRP_IPV6_PREFIX
101367c2
TG		 543 RTNLGRP_IPV6_RULE,
544#define RTNLGRP_IPV6_RULE RTNLGRP_IPV6_RULE
ac6d439d
PM		 545 __RTNLGRP_MAX
546};
547#define RTNLGRP_MAX (__RTNLGRP_MAX - 1)
1da177e4
LT		 548
549/* TC action piece */
550struct tcamsg
551{
552 unsigned char tca_family;
553 unsigned char tca__pad1;
554 unsigned short tca__pad2;
555};
556#define TA_RTA(r) ((struct rtattr*)(((char*)(r)) + NLMSG_ALIGN(sizeof(struct tcamsg))))
557#define TA_PAYLOAD(n) NLMSG_PAYLOAD(n,sizeof(struct tcamsg))
558#define TCA_ACT_TAB 1 /* attr type must be >=1 */
559#define TCAA_MAX 1
560
561/* End of information exported to user level */
562
563#ifdef __KERNEL__
564
6756ae4b 565#include <linux/mutex.h>
1da177e4
LT		 566
567extern size_t rtattr_strlcpy(char *dest, const struct rtattr *rta, size_t size);
568static __inline__ int rtattr_strcmp(const struct rtattr *rta, const char *str)
569{
570 int len = strlen(str) + 1;
571 return len > rta->rta_len || memcmp(RTA_DATA(rta), str, len);
572}
573
574extern int rtattr_parse(struct rtattr *tb[], int maxattr, struct rtattr *rta, int len);
2371baa4
PM		 575extern int __rtattr_parse_nested_compat(struct rtattr *tb[], int maxattr,
576 struct rtattr *rta, int len);
1da177e4
LT		 577
578#define rtattr_parse_nested(tb, max, rta) \
579 rtattr_parse((tb), (max), RTA_DATA((rta)), RTA_PAYLOAD((rta)))
580
2371baa4
PM		 581#define rtattr_parse_nested_compat(tb, max, rta, data, len) \
582({ data = RTA_PAYLOAD(rta) >= len ? RTA_DATA(rta) : NULL; \
583 __rtattr_parse_nested_compat(tb, max, rta, len); })
584
1da177e4 585extern int rtnetlink_send(struct sk_buff *skb, u32 pid, u32 group, int echo);
2942e900 586extern int rtnl_unicast(struct sk_buff *skb, u32 pid);
97676b6b
TG		 587extern int rtnl_notify(struct sk_buff *skb, u32 pid, u32 group,
588 struct nlmsghdr *nlh, gfp_t flags);
589extern void rtnl_set_sk_err(u32 group, int error);
1da177e4 590extern int rtnetlink_put_metrics(struct sk_buff *skb, u32 *metrics);
e3703b3d
TG		 591extern int rtnl_put_cacheinfo(struct sk_buff *skb, struct dst_entry *dst,
592 u32 id, u32 ts, u32 tsage, long expires,
593 u32 error);
1da177e4
LT		 594
595extern void __rta_fill(struct sk_buff *skb, int attrtype, int attrlen, const void *data);
596
597#define RTA_PUT(skb, attrtype, attrlen, data) \
598({ if (unlikely(skb_tailroom(skb) < (int)RTA_SPACE(attrlen))) \
599 goto rtattr_failure; \
600 __rta_fill(skb, attrtype, attrlen, data); })
601
d675c989 602#define RTA_APPEND(skb, attrlen, data) \
1da177e4
LT		 603({ if (unlikely(skb_tailroom(skb) < (int)(attrlen))) \
604 goto rtattr_failure; \
d675c989
TG		 605 memcpy(skb_put(skb, attrlen), data, attrlen); })
606
607#define RTA_PUT_NOHDR(skb, attrlen, data) \
b3563c4f 608({ RTA_APPEND(skb, RTA_ALIGN(attrlen), data); \
27a884dc 609 memset(skb_tail_pointer(skb) - (RTA_ALIGN(attrlen) - attrlen), 0, \
b3563c4f 610 RTA_ALIGN(attrlen) - attrlen); })
00768244 611
8f48bcd4
TG		 612#define RTA_PUT_U8(skb, attrtype, value) \
613({ u8 _tmp = (value); \
614 RTA_PUT(skb, attrtype, sizeof(u8), &_tmp); })
615
616#define RTA_PUT_U16(skb, attrtype, value) \
617({ u16 _tmp = (value); \
618 RTA_PUT(skb, attrtype, sizeof(u16), &_tmp); })
619
00768244
TG		 620#define RTA_PUT_U32(skb, attrtype, value) \
621({ u32 _tmp = (value); \
622 RTA_PUT(skb, attrtype, sizeof(u32), &_tmp); })
623
624#define RTA_PUT_U64(skb, attrtype, value) \
625({ u64 _tmp = (value); \
626 RTA_PUT(skb, attrtype, sizeof(u64), &_tmp); })
627
628#define RTA_PUT_SECS(skb, attrtype, value) \
629 RTA_PUT_U64(skb, attrtype, (value) / HZ)
630
631#define RTA_PUT_MSECS(skb, attrtype, value) \
632 RTA_PUT_U64(skb, attrtype, jiffies_to_msecs(value))
633
634#define RTA_PUT_STRING(skb, attrtype, value) \
635 RTA_PUT(skb, attrtype, strlen(value) + 1, value)
636
8f48bcd4
TG		 637#define RTA_PUT_FLAG(skb, attrtype) \
638 RTA_PUT(skb, attrtype, 0, NULL);
639
00768244 640#define RTA_NEST(skb, type) \
27a884dc 641({ struct rtattr *__start = (struct rtattr *)skb_tail_pointer(skb); \
00768244
TG		 642 RTA_PUT(skb, type, 0, NULL); \
643 __start; })
644
645#define RTA_NEST_END(skb, start) \
27a884dc 646({ (start)->rta_len = skb_tail_pointer(skb) - (unsigned char *)(start); \
00768244
TG		 647 (skb)->len; })
648
afdc3238
PM		 649#define RTA_NEST_COMPAT(skb, type, attrlen, data) \
650({ struct rtattr *__start = (struct rtattr *)skb_tail_pointer(skb); \
651 RTA_PUT(skb, type, attrlen, data); \
652 RTA_NEST(skb, type); \
653 __start; })
654
655#define RTA_NEST_COMPAT_END(skb, start) \
656({ struct rtattr *__nest = (void *)(start) + NLMSG_ALIGN((start)->rta_len); \
657 (start)->rta_len = skb_tail_pointer(skb) - (unsigned char *)(start); \
658 RTA_NEST_END(skb, __nest); \
659 (skb)->len; })
660
00768244 661#define RTA_NEST_CANCEL(skb, start) \
c52a3f89
TG		 662({ if (start) \
663 skb_trim(skb, (unsigned char *) (start) - (skb)->data); \
00768244
TG		 664 -1; })
665
8f48bcd4
TG		 666#define RTA_GET_U8(rta) \
667({ if (!rta || RTA_PAYLOAD(rta) < sizeof(u8)) \
668 goto rtattr_failure; \
669 *(u8 *) RTA_DATA(rta); })
670
671#define RTA_GET_U16(rta) \
672({ if (!rta || RTA_PAYLOAD(rta) < sizeof(u16)) \
673 goto rtattr_failure; \
674 *(u16 *) RTA_DATA(rta); })
675
00768244
TG		 676#define RTA_GET_U32(rta) \
677({ if (!rta || RTA_PAYLOAD(rta) < sizeof(u32)) \
678 goto rtattr_failure; \
679 *(u32 *) RTA_DATA(rta); })
680
681#define RTA_GET_U64(rta) \
682({ u64 _tmp; \
683 if (!rta || RTA_PAYLOAD(rta) < sizeof(u64)) \
684 goto rtattr_failure; \
685 memcpy(&_tmp, RTA_DATA(rta), sizeof(_tmp)); \
686 _tmp; })
687
8f48bcd4
TG		 688#define RTA_GET_FLAG(rta) (!!(rta))
689
00768244
TG		 690#define RTA_GET_SECS(rta) ((unsigned long) RTA_GET_U64(rta) * HZ)
691#define RTA_GET_MSECS(rta) (msecs_to_jiffies((unsigned long) RTA_GET_U64(rta)))
1da177e4
LT		 692
693static inline struct rtattr *
694__rta_reserve(struct sk_buff *skb, int attrtype, int attrlen)
695{
696 struct rtattr *rta;
697 int size = RTA_LENGTH(attrlen);
698
699 rta = (struct rtattr*)skb_put(skb, RTA_ALIGN(size));
700 rta->rta_type = attrtype;
701 rta->rta_len = size;
b3563c4f 702 memset(RTA_DATA(rta) + attrlen, 0, RTA_ALIGN(size) - size);
1da177e4
LT		 703 return rta;
704}
705
706#define __RTA_PUT(skb, attrtype, attrlen) \
707({ if (unlikely(skb_tailroom(skb) < (int)RTA_SPACE(attrlen))) \
708 goto rtattr_failure; \
709 __rta_reserve(skb, attrtype, attrlen); })
710
711extern void rtmsg_ifinfo(int type, struct net_device *dev, unsigned change);
712
6756ae4b 713/* RTNL is used as a global lock for all changes to network configuration */
1da177e4 714extern void rtnl_lock(void);
1da177e4 715extern void rtnl_unlock(void);
6756ae4b
SH		 716extern int rtnl_trylock(void);
717
1da177e4 718extern void rtnetlink_init(void);
6756ae4b 719extern void __rtnl_unlock(void);
1da177e4
LT		 720
721#define ASSERT_RTNL() do { \
6756ae4b
SH		 722 if (unlikely(rtnl_trylock())) { \
723 rtnl_unlock(); \
1da177e4
LT		 724 printk(KERN_ERR "RTNL: assertion failed at %s (%d)\n", \
725 __FILE__, __LINE__); \
726 dump_stack(); \
727 } \
728} while(0)
729
730#define BUG_TRAP(x) do { \
731 if (unlikely(!(x))) { \
732 printk(KERN_ERR "KERNEL: assertion (%s) failed at %s (%d)\n", \
733 #x, __FILE__ , __LINE__); \
734 } \
735} while(0)
736
9e762a4a
PM		 737static inline u32 rtm_get_table(struct rtattr **rta, u8 table)
738{
739 return RTA_GET_U32(rta[RTA_TABLE-1]);
740rtattr_failure:
741 return table;
742}
743
1da177e4
LT		 744#endif /* __KERNEL__ */
745
746
747#endif /* __LINUX_RTNETLINK_H */
Linux kernel - Deliverables
This page took 0.456933 seconds and 5 git commands to generate.