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