Convert to use rta_getattr_ functions

User new functions (inspired by libmnl) to do type safe access
of routeing attributes

diff --git a/genl/ctrl.c b/genl/ctrl.c
index 58d13bedc4373d627e0b004376bdb8b2371e4d84..6d97c2690f4966ac9bc9a981d80438189b737772 100644 (file)
--- a/genl/ctrl.c
+++ b/genl/ctrl.c
@@ -104,7 +104,7 @@ int genl_ctrl_resolve_family(const char *family)
                        goto errout;
                }
 
-               ret = *(__u16 *) RTA_DATA(tb[CTRL_ATTR_FAMILY_ID]);
+               ret = rta_getattr_u16(tb[CTRL_ATTR_FAMILY_ID]);
        }
 
 errout:

diff --git a/ip/ip_common.h b/ip/ip_common.h
index 62884375aa75243a3916c87794b357b903511f97..5fa2cc0d1441de3a4b05c9666c0170b47f1e4464 100644 (file)
--- a/ip/ip_common.h
+++ b/ip/ip_common.h
@@ -47,7 +47,7 @@ static inline int rtm_get_table(struct rtmsg *r, struct rtattr **tb)
 {
        __u32 table = r->rtm_table;
        if (tb[RTA_TABLE])
-               table = *(__u32*) RTA_DATA(tb[RTA_TABLE]);
+               table = rta_getattr_u32(tb[RTA_TABLE]);
        return table;
 }
 

diff --git a/ip/ipaddress.c b/ip/ipaddress.c
index 9306a372827d192ceb9f72fe05bfc7e8593ed6c5..9ab65ec78e2224290024ec1ef2a6c4cd67890d20 100644 (file)
--- a/ip/ipaddress.c
+++ b/ip/ipaddress.c
@@ -155,7 +155,7 @@ static void print_queuelen(FILE *f, struct rtattr *tb[IFLA_MAX + 1])
                        return;
 
                memset(&ifr, 0, sizeof(ifr));
-               strcpy(ifr.ifr_name, (char *)RTA_DATA(tb[IFLA_IFNAME]));
+               strcpy(ifr.ifr_name, rta_getattr_str(tb[IFLA_IFNAME]));
                if (ioctl(s, SIOCGIFTXQLEN, &ifr) < 0) {
                        fprintf(f, "ioctl(SIOCGIFXQLEN) failed: %s\n", strerror(errno));
                        close(s);
@@ -397,7 +397,7 @@ int print_linkinfo(const struct sockaddr_nl *who,
                fprintf(fp, "Deleted ");
 
        fprintf(fp, "%d: %s", ifi->ifi_index,
-               tb[IFLA_IFNAME] ? (char*)RTA_DATA(tb[IFLA_IFNAME]) : "<nil>");
+               tb[IFLA_IFNAME] ? rta_getattr_str(tb[IFLA_IFNAME]) : "<nil>");
 
        if (tb[IFLA_LINK]) {
                SPRINT_BUF(b1);
@@ -417,14 +417,14 @@ int print_linkinfo(const struct sockaddr_nl *who,
        if (tb[IFLA_MTU])
                fprintf(fp, "mtu %u ", *(int*)RTA_DATA(tb[IFLA_MTU]));
        if (tb[IFLA_QDISC])
-               fprintf(fp, "qdisc %s ", (char*)RTA_DATA(tb[IFLA_QDISC]));
+               fprintf(fp, "qdisc %s ", rta_getattr_str(tb[IFLA_QDISC]));
        if (tb[IFLA_MASTER]) {
                SPRINT_BUF(b1);
                fprintf(fp, "master %s ", ll_idx_n2a(*(int*)RTA_DATA(tb[IFLA_MASTER]), b1));
        }
 
        if (tb[IFLA_OPERSTATE])
-               print_operstate(fp, *(__u8 *)RTA_DATA(tb[IFLA_OPERSTATE]));
+               print_operstate(fp, rta_getattr_u8(tb[IFLA_OPERSTATE]));
 
        if (do_link && tb[IFLA_LINKMODE])
                print_linkmode(fp, tb[IFLA_LINKMODE]);
@@ -460,7 +460,7 @@ int print_linkinfo(const struct sockaddr_nl *who,
 
        if (do_link && tb[IFLA_IFALIAS])
                fprintf(fp,"\n    alias %s", 
-                       (const char *) RTA_DATA(tb[IFLA_IFALIAS]));
+                       rta_getattr_str(tb[IFLA_IFALIAS]));
 
        if (do_link && show_stats) {
                if (tb[IFLA_STATS64])
@@ -665,7 +665,7 @@ int print_addrinfo(const struct sockaddr_nl *who, struct nlmsghdr *n,
        if (ifa_flags)
                fprintf(fp, "flags %02x ", ifa_flags);
        if (rta_tb[IFA_LABEL])
-               fprintf(fp, "%s", (char*)RTA_DATA(rta_tb[IFA_LABEL]));
+               fprintf(fp, "%s", rta_getattr_str(rta_tb[IFA_LABEL]));
        if (rta_tb[IFA_CACHEINFO]) {
                struct ifa_cacheinfo *ci = RTA_DATA(rta_tb[IFA_CACHEINFO]);
                fprintf(fp, "%s", _SL_);

diff --git a/ip/iplink_macvlan.c b/ip/iplink_macvlan.c
index 15022aa9cced2cf0bd0cdf972b00c82a7752ad25..ed0e34b727dc3ea77b597c0f16e88507ffdbac0a 100644 (file)
--- a/ip/iplink_macvlan.c
+++ b/ip/iplink_macvlan.c
@@ -79,7 +79,7 @@ static void macvlan_print_opt(struct link_util *lu, FILE *f, struct rtattr *tb[]
            RTA_PAYLOAD(tb[IFLA_MACVLAN_MODE]) < sizeof(__u32))
                return;
 
-       mode = *(__u32 *)RTA_DATA(tb[IFLA_VLAN_ID]);
+       mode = rta_getattr_u32(tb[IFLA_VLAN_ID]);
        fprintf(f, " mode %s ",
                  mode == MACVLAN_MODE_PRIVATE ? "private"
                : mode == MACVLAN_MODE_VEPA    ? "vepa"

diff --git a/ip/iplink_macvtap.c b/ip/iplink_macvtap.c
index 07aed4e609aa70349969d7d544b9188aedd27586..6c7fe1f1f94704acc1a737f556e4938da24ba8a0 100644 (file)
--- a/ip/iplink_macvtap.c
+++ b/ip/iplink_macvtap.c
@@ -76,7 +76,7 @@ static void macvtap_print_opt(struct link_util *lu, FILE *f, struct rtattr *tb[]
            RTA_PAYLOAD(tb[IFLA_MACVLAN_MODE]) < sizeof(__u32))
                return;
 
-       mode = *(__u32 *)RTA_DATA(tb[IFLA_VLAN_ID]);
+       mode = rta_getattr_u32(tb[IFLA_VLAN_ID]);
        fprintf(f, " mode %s ",
                  mode == MACVLAN_MODE_PRIVATE ? "private"
                : mode == MACVLAN_MODE_VEPA    ? "vepa"

diff --git a/ip/iplink_vlan.c b/ip/iplink_vlan.c
index 223feb31635d9b995cbf61c68f1a1dad659b157f..97af8d6c43b6597494617c9c74f4a9b8e31ff909 100644 (file)
--- a/ip/iplink_vlan.c
+++ b/ip/iplink_vlan.c
@@ -183,7 +183,7 @@ static void vlan_print_opt(struct link_util *lu, FILE *f, struct rtattr *tb[])
            RTA_PAYLOAD(tb[IFLA_VLAN_ID]) < sizeof(__u16))
                return;
 
-       fprintf(f, "id %u ", *(__u16 *)RTA_DATA(tb[IFLA_VLAN_ID]));
+       fprintf(f, "id %u ", rta_getattr_u16(tb[IFLA_VLAN_ID]));
 
        if (tb[IFLA_VLAN_FLAGS]) {
                if (RTA_PAYLOAD(tb[IFLA_VLAN_FLAGS]) < sizeof(*flags))

diff --git a/ip/ipneigh.c b/ip/ipneigh.c
index 313cc63ce5e6312c064efb9831f3807dd60af5d1..93cfba257211e0b497fadc8dfc6cbe30e09cbf67 100644 (file)
--- a/ip/ipneigh.c
+++ b/ip/ipneigh.c
@@ -282,7 +282,7 @@ int print_neigh(const struct sockaddr_nl *who, struct nlmsghdr *n, void *arg)
        }
 
        if (tb[NDA_PROBES] && show_stats) {
-               __u32 p = *(__u32 *) RTA_DATA(tb[NDA_PROBES]);
+               __u32 p = rta_getattr_u32(tb[NDA_PROBES]);
                fprintf(fp, " probes %u", p);
        }
 

diff --git a/ip/ipntable.c b/ip/ipntable.c
index b00d3dca106ff1360ebdf2adf193b6bcdbb63f30..639f512cb352898c1af461413682760921bee69d 100644 (file)
--- a/ip/ipntable.c
+++ b/ip/ipntable.c
@@ -376,7 +376,7 @@ int print_ntable(const struct sockaddr_nl *who, struct nlmsghdr *n, void *arg)
                     n->nlmsg_len - NLMSG_LENGTH(sizeof(*ndtm)));
 
        if (tb[NDTA_NAME]) {
-               char *name = RTA_DATA(tb[NDTA_NAME]);
+               const char *name = rta_getattr_str(tb[NDTA_NAME]);
 
                if (strlen(filter.name) > 0 && strcmp(filter.name, name))
                        return 0;
@@ -386,7 +386,7 @@ int print_ntable(const struct sockaddr_nl *who, struct nlmsghdr *n, void *arg)
                             RTA_PAYLOAD(tb[NDTA_PARMS]));
 
                if (tpb[NDTPA_IFINDEX]) {
-                       __u32 ifindex = *(__u32 *)RTA_DATA(tpb[NDTPA_IFINDEX]);
+                       __u32 ifindex = rta_getattr_u32(tpb[NDTPA_IFINDEX]);
 
                        if (filter.index && filter.index != ifindex)
                                return 0;
@@ -406,7 +406,7 @@ int print_ntable(const struct sockaddr_nl *who, struct nlmsghdr *n, void *arg)
                fprintf(fp, "(%d) ", ndtm->ndtm_family);
 
        if (tb[NDTA_NAME]) {
-               char *name = RTA_DATA(tb[NDTA_NAME]);
+               const char *name = rta_getattr_str(tb[NDTA_NAME]);
                fprintf(fp, "%s ", name);
        }
 
@@ -418,19 +418,19 @@ int print_ntable(const struct sockaddr_nl *who, struct nlmsghdr *n, void *arg)
                fprintf(fp, "    ");
 
        if (tb[NDTA_THRESH1]) {
-               __u32 thresh1 = *(__u32 *)RTA_DATA(tb[NDTA_THRESH1]);
+               __u32 thresh1 = rta_getattr_u32(tb[NDTA_THRESH1]);
                fprintf(fp, "thresh1 %u ", thresh1);
        }
        if (tb[NDTA_THRESH2]) {
-               __u32 thresh2 = *(__u32 *)RTA_DATA(tb[NDTA_THRESH2]);
+               __u32 thresh2 = rta_getattr_u32(tb[NDTA_THRESH2]);
                fprintf(fp, "thresh2 %u ", thresh2);
        }
        if (tb[NDTA_THRESH3]) {
-               __u32 thresh3 = *(__u32 *)RTA_DATA(tb[NDTA_THRESH3]);
+               __u32 thresh3 = rta_getattr_u32(tb[NDTA_THRESH3]);
                fprintf(fp, "thresh3 %u ", thresh3);
        }
        if (tb[NDTA_GC_INTERVAL]) {
-               __u64 gc_int = *(__u64 *)RTA_DATA(tb[NDTA_GC_INTERVAL]);
+               __u64 gc_int = rta_getattr_u64(tb[NDTA_GC_INTERVAL]);
                fprintf(fp, "gc_int %llu ", gc_int);
        }
 
@@ -469,7 +469,7 @@ int print_ntable(const struct sockaddr_nl *who, struct nlmsghdr *n, void *arg)
 
        if (tb[NDTA_PARMS]) {
                if (tpb[NDTPA_IFINDEX]) {
-                       __u32 ifindex = *(__u32 *)RTA_DATA(tpb[NDTPA_IFINDEX]);
+                       __u32 ifindex = rta_getattr_u32(tpb[NDTPA_IFINDEX]);
 
                        fprintf(fp, "    ");
                        fprintf(fp, "dev %s ", ll_index_to_name(ifindex));
@@ -479,19 +479,19 @@ int print_ntable(const struct sockaddr_nl *who, struct nlmsghdr *n, void *arg)
                fprintf(fp, "    ");
 
                if (tpb[NDTPA_REFCNT]) {
-                       __u32 refcnt = *(__u32 *)RTA_DATA(tpb[NDTPA_REFCNT]);
+                       __u32 refcnt = rta_getattr_u32(tpb[NDTPA_REFCNT]);
                        fprintf(fp, "refcnt %u ", refcnt);
                }
                if (tpb[NDTPA_REACHABLE_TIME]) {
-                       __u64 reachable = *(__u64 *)RTA_DATA(tpb[NDTPA_REACHABLE_TIME]);
+                       __u64 reachable = rta_getattr_u64(tpb[NDTPA_REACHABLE_TIME]);
                        fprintf(fp, "reachable %llu ", reachable);
                }
                if (tpb[NDTPA_BASE_REACHABLE_TIME]) {
-                       __u64 breachable = *(__u64 *)RTA_DATA(tpb[NDTPA_BASE_REACHABLE_TIME]);
+                       __u64 breachable = rta_getattr_u64(tpb[NDTPA_BASE_REACHABLE_TIME]);
                        fprintf(fp, "base_reachable %llu ", breachable);
                }
                if (tpb[NDTPA_RETRANS_TIME]) {
-                       __u64 retrans = *(__u64 *)RTA_DATA(tpb[NDTPA_RETRANS_TIME]);
+                       __u64 retrans = rta_getattr_u64(tpb[NDTPA_RETRANS_TIME]);
                        fprintf(fp, "retrans %llu ", retrans);
                }
 
@@ -500,15 +500,15 @@ int print_ntable(const struct sockaddr_nl *who, struct nlmsghdr *n, void *arg)
                fprintf(fp, "    ");
 
                if (tpb[NDTPA_GC_STALETIME]) {
-                       __u64 gc_stale = *(__u64 *)RTA_DATA(tpb[NDTPA_GC_STALETIME]);
+                       __u64 gc_stale = rta_getattr_u64(tpb[NDTPA_GC_STALETIME]);
                        fprintf(fp, "gc_stale %llu ", gc_stale);
                }
                if (tpb[NDTPA_DELAY_PROBE_TIME]) {
-                       __u64 delay_probe = *(__u64 *)RTA_DATA(tpb[NDTPA_DELAY_PROBE_TIME]);
+                       __u64 delay_probe = rta_getattr_u64(tpb[NDTPA_DELAY_PROBE_TIME]);
                        fprintf(fp, "delay_probe %llu ", delay_probe);
                }
                if (tpb[NDTPA_QUEUE_LEN]) {
-                       __u32 queue = *(__u32 *)RTA_DATA(tpb[NDTPA_QUEUE_LEN]);
+                       __u32 queue = rta_getattr_u32(tpb[NDTPA_QUEUE_LEN]);
                        fprintf(fp, "queue %u ", queue);
                }
 
@@ -517,15 +517,15 @@ int print_ntable(const struct sockaddr_nl *who, struct nlmsghdr *n, void *arg)
                fprintf(fp, "    ");
 
                if (tpb[NDTPA_APP_PROBES]) {
-                       __u32 aprobe = *(__u32 *)RTA_DATA(tpb[NDTPA_APP_PROBES]);
+                       __u32 aprobe = rta_getattr_u32(tpb[NDTPA_APP_PROBES]);
                        fprintf(fp, "app_probes %u ", aprobe);
                }
                if (tpb[NDTPA_UCAST_PROBES]) {
-                       __u32 uprobe = *(__u32 *)RTA_DATA(tpb[NDTPA_UCAST_PROBES]);
+                       __u32 uprobe = rta_getattr_u32(tpb[NDTPA_UCAST_PROBES]);
                        fprintf(fp, "ucast_probes %u ", uprobe);
                }
                if (tpb[NDTPA_MCAST_PROBES]) {
-                       __u32 mprobe = *(__u32 *)RTA_DATA(tpb[NDTPA_MCAST_PROBES]);
+                       __u32 mprobe = rta_getattr_u32(tpb[NDTPA_MCAST_PROBES]);
                        fprintf(fp, "mcast_probes %u ", mprobe);
                }
 
@@ -534,19 +534,19 @@ int print_ntable(const struct sockaddr_nl *who, struct nlmsghdr *n, void *arg)
                fprintf(fp, "    ");
 
                if (tpb[NDTPA_ANYCAST_DELAY]) {
-                       __u64 anycast_delay = *(__u64 *)RTA_DATA(tpb[NDTPA_ANYCAST_DELAY]);
+                       __u64 anycast_delay = rta_getattr_u64(tpb[NDTPA_ANYCAST_DELAY]);
                        fprintf(fp, "anycast_delay %llu ", anycast_delay);
                }
                if (tpb[NDTPA_PROXY_DELAY]) {
-                       __u64 proxy_delay = *(__u64 *)RTA_DATA(tpb[NDTPA_PROXY_DELAY]);
+                       __u64 proxy_delay = rta_getattr_u64(tpb[NDTPA_PROXY_DELAY]);
                        fprintf(fp, "proxy_delay %llu ", proxy_delay);
                }
                if (tpb[NDTPA_PROXY_QLEN]) {
-                       __u32 pqueue = *(__u32 *)RTA_DATA(tpb[NDTPA_PROXY_QLEN]);
+                       __u32 pqueue = rta_getattr_u32(tpb[NDTPA_PROXY_QLEN]);
                        fprintf(fp, "proxy_queue %u ", pqueue);
                }
                if (tpb[NDTPA_LOCKTIME]) {
-                       __u64 locktime = *(__u64 *)RTA_DATA(tpb[NDTPA_LOCKTIME]);
+                       __u64 locktime = rta_getattr_u64(tpb[NDTPA_LOCKTIME]);
                        fprintf(fp, "locktime %llu ", locktime);
                }
 

diff --git a/ip/iproute.c b/ip/iproute.c
index 2d15c019a8bba160bc60e69c9f70c9918cbe49d3..5cd313edb28e814a92205f033484763b05796909 100644 (file)
--- a/ip/iproute.c
+++ b/ip/iproute.c
@@ -227,7 +227,7 @@ int filter_nlmsg(struct nlmsghdr *n, struct rtattr **tb, int host_len)
        if (filter.realmmask) {
                __u32 realms = 0;
                if (tb[RTA_FLOW])
-                       realms = *(__u32*)RTA_DATA(tb[RTA_FLOW]);
+                       realms = rta_getattr_u32(tb[RTA_FLOW]);
                if ((realms^filter.realm)&filter.realmmask)
                        return 0;
        }
@@ -404,7 +404,7 @@ int print_route(const struct sockaddr_nl *who, struct nlmsghdr *n, void *arg)
                                    abuf, sizeof(abuf)));
        }
        if (tb[RTA_PRIORITY])
-               fprintf(fp, " metric %u ", *(__u32*)RTA_DATA(tb[RTA_PRIORITY]));
+               fprintf(fp, " metric %u ", rta_getattr_u32(tb[RTA_PRIORITY]));
        if (r->rtm_flags & RTNH_F_DEAD)
                fprintf(fp, "dead ");
        if (r->rtm_flags & RTNH_F_ONLINK)
@@ -424,7 +424,7 @@ int print_route(const struct sockaddr_nl *who, struct nlmsghdr *n, void *arg)
        }
 
        if (tb[RTA_FLOW] && filter.realmmask != ~0U) {
-               __u32 to = *(__u32*)RTA_DATA(tb[RTA_FLOW]);
+               __u32 to = rta_getattr_u32(tb[RTA_FLOW]);
                __u32 from = to>>16;
                to &= 0xFFFF;
                fprintf(fp, "realm%s ", from ? "s" : "");
@@ -589,7 +589,7 @@ int print_route(const struct sockaddr_nl *who, struct nlmsghdr *n, void *arg)
                                                            abuf, sizeof(abuf)));
                                }
                                if (tb[RTA_FLOW]) {
-                                       __u32 to = *(__u32*)RTA_DATA(tb[RTA_FLOW]);
+                                       __u32 to = rta_getattr_u32(tb[RTA_FLOW]);
                                        __u32 from = to>>16;
                                        to &= 0xFFFF;
                                        fprintf(fp, " realm%s ", from ? "s" : "");

diff --git a/ip/iprule.c b/ip/iprule.c
index f983731fc12960ca4fad8132f1de4e92eeda1341..a5fcd432a6bd11a4c50f3b678f9c7fa08e783a62 100644 (file)
--- a/ip/iprule.c
+++ b/ip/iprule.c
@@ -131,23 +131,23 @@ int print_rule(const struct sockaddr_nl *who, struct nlmsghdr *n, void *arg)
                __u32 mark = 0, mask = 0;
 
                if (tb[FRA_FWMARK])
-                       mark = *(__u32*)RTA_DATA(tb[FRA_FWMARK]);
+                       mark = rta_getattr_u32(tb[FRA_FWMARK]);
 
                if (tb[FRA_FWMASK] &&
-                   (mask = *(__u32*)RTA_DATA(tb[FRA_FWMASK])) != 0xFFFFFFFF)
+                   (mask = rta_getattr_u32(tb[FRA_FWMASK])) != 0xFFFFFFFF)
                        fprintf(fp, "fwmark 0x%x/0x%x ", mark, mask);
                else
                        fprintf(fp, "fwmark 0x%x ", mark);
        }
 
        if (tb[FRA_IFNAME]) {
-               fprintf(fp, "iif %s ", (char*)RTA_DATA(tb[FRA_IFNAME]));
+               fprintf(fp, "iif %s ", rta_getattr_str(tb[FRA_IFNAME]));
                if (r->rtm_flags & FIB_RULE_IIF_DETACHED)
                        fprintf(fp, "[detached] ");
        }
 
        if (tb[FRA_OIFNAME]) {
-               fprintf(fp, "oif %s ", (char*)RTA_DATA(tb[FRA_OIFNAME]));
+               fprintf(fp, "oif %s ", rta_getattr_str(tb[FRA_OIFNAME]));
                if (r->rtm_flags & FIB_RULE_OIF_DETACHED)
                        fprintf(fp, "[detached] ");
        }
@@ -157,7 +157,7 @@ int print_rule(const struct sockaddr_nl *who, struct nlmsghdr *n, void *arg)
                fprintf(fp, "lookup %s ", rtnl_rttable_n2a(table, b1, sizeof(b1)));
 
        if (tb[FRA_FLOW]) {
-               __u32 to = *(__u32*)RTA_DATA(tb[FRA_FLOW]);
+               __u32 to = rta_getattr_u32(tb[FRA_FLOW]);
                __u32 from = to>>16;
                to &= 0xFFFF;
                if (from) {
@@ -180,7 +180,7 @@ int print_rule(const struct sockaddr_nl *who, struct nlmsghdr *n, void *arg)
        } else if (r->rtm_type == FR_ACT_GOTO) {
                fprintf(fp, "goto ");
                if (tb[FRA_GOTO])
-                       fprintf(fp, "%u", *(__u32 *) RTA_DATA(tb[FRA_GOTO]));
+                       fprintf(fp, "%u", rta_getattr_u32(tb[FRA_GOTO]));
                else
                        fprintf(fp, "none");
                if (r->rtm_flags & FIB_RULE_UNRESOLVED)

diff --git a/ip/ipxfrm.c b/ip/ipxfrm.c
index f55bff9f2f3891781339e44747a46545280c02e5..c7b342060b932a2aa5519a2436ce30490cf806bc 100644 (file)
--- a/ip/ipxfrm.c
+++ b/ip/ipxfrm.c
@@ -806,7 +806,7 @@ void xfrm_xfrma_print(struct rtattr *tb[], __u16 family,
                        return;
                }
 
-               lastused = *(__u64 *)RTA_DATA(tb[XFRMA_LASTUSED]);
+               lastused = rta_getattr_u64(tb[XFRMA_LASTUSED]);
 
                fprintf(fp, "%s", strxf_time(lastused));
                fprintf(fp, "%s", _SL_);

diff --git a/ip/link_gre.c b/ip/link_gre.c
index 5002095bd132c6ad4b9d5cd16dcf15d23a565d6c..839fb29981b679b36141d239f8a2fc9770440d91 100644 (file)
--- a/ip/link_gre.c
+++ b/ip/link_gre.c
@@ -98,35 +98,35 @@ get_failed:
                                    linkinfo[IFLA_INFO_DATA]);
 
                if (greinfo[IFLA_GRE_IKEY])
-                       ikey = *(__u32 *)RTA_DATA(greinfo[IFLA_GRE_IKEY]);
+                       ikey = rta_getattr_u32(greinfo[IFLA_GRE_IKEY]);
 
                if (greinfo[IFLA_GRE_OKEY])
-                       okey = *(__u32 *)RTA_DATA(greinfo[IFLA_GRE_OKEY]);
+                       okey = rta_getattr_u32(greinfo[IFLA_GRE_OKEY]);
 
                if (greinfo[IFLA_GRE_IFLAGS])
-                       iflags = *(__u16 *)RTA_DATA(greinfo[IFLA_GRE_IFLAGS]);
+                       iflags = rta_getattr_u16(greinfo[IFLA_GRE_IFLAGS]);
 
                if (greinfo[IFLA_GRE_OFLAGS])
-                       oflags = *(__u16 *)RTA_DATA(greinfo[IFLA_GRE_OFLAGS]);
+                       oflags = rta_getattr_u16(greinfo[IFLA_GRE_OFLAGS]);
 
                if (greinfo[IFLA_GRE_LOCAL])
-                       saddr = *(__u32 *)RTA_DATA(greinfo[IFLA_GRE_LOCAL]);
+                       saddr = rta_getattr_u32(greinfo[IFLA_GRE_LOCAL]);
 
                if (greinfo[IFLA_GRE_REMOTE])
-                       daddr = *(__u32 *)RTA_DATA(greinfo[IFLA_GRE_REMOTE]);
+                       daddr = rta_getattr_u32(greinfo[IFLA_GRE_REMOTE]);
 
                if (greinfo[IFLA_GRE_PMTUDISC])
-                       pmtudisc = *(__u8 *)RTA_DATA(
+                       pmtudisc = rta_getattr_u8(
                                greinfo[IFLA_GRE_PMTUDISC]);
 
                if (greinfo[IFLA_GRE_TTL])
-                       ttl = *(__u8 *)RTA_DATA(greinfo[IFLA_GRE_TTL]);
+                       ttl = rta_getattr_u8(greinfo[IFLA_GRE_TTL]);
 
                if (greinfo[IFLA_GRE_TOS])
-                       tos = *(__u8 *)RTA_DATA(greinfo[IFLA_GRE_TOS]);
+                       tos = rta_getattr_u8(greinfo[IFLA_GRE_TOS]);
 
                if (greinfo[IFLA_GRE_LINK])
-                       link = *(__u8 *)RTA_DATA(greinfo[IFLA_GRE_LINK]);
+                       link = rta_getattr_u8(greinfo[IFLA_GRE_LINK]);
        }
 
        while (argc > 0) {
@@ -279,7 +279,7 @@ static void gre_print_opt(struct link_util *lu, FILE *f, struct rtattr *tb[])
                return;
 
        if (tb[IFLA_GRE_REMOTE]) {
-               unsigned addr = *(__u32 *)RTA_DATA(tb[IFLA_GRE_REMOTE]);
+               unsigned addr = rta_getattr_u32(tb[IFLA_GRE_REMOTE]);
 
                if (addr)
                        remote = format_host(AF_INET, 4, &addr, s1, sizeof(s1));
@@ -288,7 +288,7 @@ static void gre_print_opt(struct link_util *lu, FILE *f, struct rtattr *tb[])
        fprintf(f, "remote %s ", remote);
 
        if (tb[IFLA_GRE_LOCAL]) {
-               unsigned addr = *(__u32 *)RTA_DATA(tb[IFLA_GRE_LOCAL]);
+               unsigned addr = rta_getattr_u32(tb[IFLA_GRE_LOCAL]);
 
                if (addr)
                        local = format_host(AF_INET, 4, &addr, s1, sizeof(s1));
@@ -296,8 +296,8 @@ static void gre_print_opt(struct link_util *lu, FILE *f, struct rtattr *tb[])
 
        fprintf(f, "local %s ", local);
 
-       if (tb[IFLA_GRE_LINK] && *(__u32 *)RTA_DATA(tb[IFLA_GRE_LINK])) {
-               unsigned link = *(__u32 *)RTA_DATA(tb[IFLA_GRE_LINK]);
+       if (tb[IFLA_GRE_LINK] && rta_getattr_u32(tb[IFLA_GRE_LINK])) {
+               unsigned link = rta_getattr_u32(tb[IFLA_GRE_LINK]);
                const char *n = if_indextoname(link, s2);
 
                if (n)
@@ -306,13 +306,13 @@ static void gre_print_opt(struct link_util *lu, FILE *f, struct rtattr *tb[])
                        fprintf(f, "dev %u ", link);
        }
 
-       if (tb[IFLA_GRE_TTL] && *(__u8 *)RTA_DATA(tb[IFLA_GRE_TTL]))
-               fprintf(f, "ttl %d ", *(__u8 *)RTA_DATA(tb[IFLA_GRE_TTL]));
+       if (tb[IFLA_GRE_TTL] && rta_getattr_u8(tb[IFLA_GRE_TTL]))
+               fprintf(f, "ttl %d ", rta_getattr_u8(tb[IFLA_GRE_TTL]));
        else
                fprintf(f, "ttl inherit ");
 
-       if (tb[IFLA_GRE_TOS] && *(__u8 *)RTA_DATA(tb[IFLA_GRE_TOS])) {
-               int tos = *(__u8 *)RTA_DATA(tb[IFLA_GRE_TOS]);
+       if (tb[IFLA_GRE_TOS] && rta_getattr_u8(tb[IFLA_GRE_TOS])) {
+               int tos = rta_getattr_u8(tb[IFLA_GRE_TOS]);
 
                fputs("tos ", f);
                if (tos == 1)
@@ -322,14 +322,14 @@ static void gre_print_opt(struct link_util *lu, FILE *f, struct rtattr *tb[])
        }
 
        if (tb[IFLA_GRE_PMTUDISC] &&
-           !*(__u8 *)RTA_DATA(tb[IFLA_GRE_PMTUDISC]))
+           !rta_getattr_u8(tb[IFLA_GRE_PMTUDISC]))
                fputs("nopmtudisc ", f);
 
        if (tb[IFLA_GRE_IFLAGS])
-               iflags = *(__u16 *)RTA_DATA(tb[IFLA_GRE_IFLAGS]);
+               iflags = rta_getattr_u16(tb[IFLA_GRE_IFLAGS]);
 
        if (tb[IFLA_GRE_OFLAGS])
-               oflags = *(__u16 *)RTA_DATA(tb[IFLA_GRE_OFLAGS]);
+               oflags = rta_getattr_u16(tb[IFLA_GRE_OFLAGS]);
 
        if ((iflags & GRE_KEY) && tb[IFLA_GRE_IKEY]) {
                inet_ntop(AF_INET, RTA_DATA(tb[IFLA_GRE_IKEY]), s2, sizeof(s2));

diff --git a/misc/ss.c b/misc/ss.c
index 5414f7557ab8c92dd6ba9541021778bd2b766f5f..7beac8ddb24f7d6f4c8f3574ed334ecf539f03c9 100644 (file)
--- a/misc/ss.c
+++ b/misc/ss.c
@@ -1370,7 +1370,7 @@ static void tcp_show_info(const struct nlmsghdr *nlh, struct inet_diag_msg *r)
                }
 
                if (tb[INET_DIAG_CONG])
-                       printf(" %s", (char *) RTA_DATA(tb[INET_DIAG_CONG]));
+                       printf(" %s", rta_getattr_str(tb[INET_DIAG_CONG]));
 
                if (info->tcpi_options & TCPI_OPT_WSCALE)
                        printf(" wscale:%d,%d", info->tcpi_snd_wscale,

diff --git a/tc/em_meta.c b/tc/em_meta.c
index 033e29f2f6c81a1cc1fff7b18f65817a38225ab6..fad6b1222adfb8af98eed135f54c0a3dcd3ab1de 100644 (file)
--- a/tc/em_meta.c
+++ b/tc/em_meta.c
@@ -448,7 +448,7 @@ static inline int print_value(FILE *fd, int type, struct rtattr *rta)
                                    "size mismatch.\n");
                                return -1;
                        }
-                       fprintf(fd, "%d", *(__u32 *) RTA_DATA(rta));
+                       fprintf(fd, "%d", rta_getattr_u32(rta));
                        break;
 
                case TCF_META_TYPE_VAR:
@@ -485,7 +485,7 @@ static int print_object(FILE *fd, struct tcf_meta_val *obj, struct rtattr *rta)
                                        goto size_mismatch;
 
                                fprintf(fd, " mask 0x%08x",
-                                   *(__u32*) RTA_DATA(rta));
+                                   rta_getattr_u32(rta));
                        }
                        break;
        }

diff --git a/tc/f_basic.c b/tc/f_basic.c
index ad41633311813c1c0d56122e66341d03376276a6..67d26ec69e019e5580d7e4b3fc495de61ffe6f7a 100644 (file)
--- a/tc/f_basic.c
+++ b/tc/f_basic.c
@@ -122,7 +122,7 @@ static int basic_print_opt(struct filter_util *qu, FILE *f,
        if (tb[TCA_BASIC_CLASSID]) {
                SPRINT_BUF(b1);
                fprintf(f, "flowid %s ",
-                       sprint_tc_classid(*(__u32*)RTA_DATA(tb[TCA_BASIC_CLASSID]), b1));
+                       sprint_tc_classid(rta_getattr_u32(tb[TCA_BASIC_CLASSID]), b1));
        }
 
        if (tb[TCA_BASIC_EMATCHES])

diff --git a/tc/f_flow.c b/tc/f_flow.c
index 574253d92bf37b1aedc0ccb8e744b119ab8b598b..7d4bb7aff65dee96c008650bb1c353f5257e6dd9 100644 (file)
--- a/tc/f_flow.c
+++ b/tc/f_flow.c
@@ -282,7 +282,7 @@ static int flow_print_opt(struct filter_util *fu, FILE *f, struct rtattr *opt,
        fprintf(f, "handle 0x%x ", handle);
 
        if (tb[TCA_FLOW_MODE]) {
-               __u32 mode = *(__u32 *)RTA_DATA(tb[TCA_FLOW_MODE]);
+               __u32 mode = rta_getattr_u32(tb[TCA_FLOW_MODE]);
 
                switch (mode) {
                case FLOW_MODE_MAP:
@@ -295,7 +295,7 @@ static int flow_print_opt(struct filter_util *fu, FILE *f, struct rtattr *opt,
        }
 
        if (tb[TCA_FLOW_KEYS]) {
-               __u32 keymask = *(__u32 *)RTA_DATA(tb[TCA_FLOW_KEYS]);
+               __u32 keymask = rta_getattr_u32(tb[TCA_FLOW_KEYS]);
                char *sep = "";
 
                fprintf(f, "keys ");
@@ -309,9 +309,9 @@ static int flow_print_opt(struct filter_util *fu, FILE *f, struct rtattr *opt,
        }
 
        if (tb[TCA_FLOW_MASK])
-               mask = *(__u32 *)RTA_DATA(tb[TCA_FLOW_MASK]);
+               mask = rta_getattr_u32(tb[TCA_FLOW_MASK]);
        if (tb[TCA_FLOW_XOR])
-               val = *(__u32 *)RTA_DATA(tb[TCA_FLOW_XOR]);
+               val = rta_getattr_u32(tb[TCA_FLOW_XOR]);
 
        if (mask != ~0 || val != 0) {
                __u32 or = (mask & val) ^ val;
@@ -327,21 +327,21 @@ static int flow_print_opt(struct filter_util *fu, FILE *f, struct rtattr *opt,
 
        if (tb[TCA_FLOW_RSHIFT])
                fprintf(f, "rshift %u ",
-                       *(__u32 *)RTA_DATA(tb[TCA_FLOW_RSHIFT]));
+                       rta_getattr_u32(tb[TCA_FLOW_RSHIFT]));
        if (tb[TCA_FLOW_ADDEND])
                fprintf(f, "addend 0x%x ",
-                       *(__u32 *)RTA_DATA(tb[TCA_FLOW_ADDEND]));
+                       rta_getattr_u32(tb[TCA_FLOW_ADDEND]));
 
        if (tb[TCA_FLOW_DIVISOR])
                fprintf(f, "divisor %u ",
-                       *(__u32 *)RTA_DATA(tb[TCA_FLOW_DIVISOR]));
+                       rta_getattr_u32(tb[TCA_FLOW_DIVISOR]));
        if (tb[TCA_FLOW_BASECLASS])
                fprintf(f, "baseclass %s ",
-                       sprint_tc_classid(*(__u32 *)RTA_DATA(tb[TCA_FLOW_BASECLASS]), b1));
+                       sprint_tc_classid(rta_getattr_u32(tb[TCA_FLOW_BASECLASS]), b1));
 
        if (tb[TCA_FLOW_PERTURB])
                fprintf(f, "perturb %usec ",
-                       *(__u32 *)RTA_DATA(tb[TCA_FLOW_PERTURB]));
+                       rta_getattr_u32(tb[TCA_FLOW_PERTURB]));
 
        if (tb[TCA_FLOW_EMATCHES])
                print_ematch(f, tb[TCA_FLOW_EMATCHES]);

diff --git a/tc/f_fw.c b/tc/f_fw.c
index 219b404f803141a5258ecd27f179e7c8b1926c65..161e2f70df03ac33c0eda9f7722fac03c38433ba 100644 (file)
--- a/tc/f_fw.c
+++ b/tc/f_fw.c
@@ -130,7 +130,7 @@ static int fw_print_opt(struct filter_util *qu, FILE *f, struct rtattr *opt, __u
                if(handle)
                        mark = handle;
                if(tb[TCA_FW_MASK] &&
-                   (mask = *(__u32*)RTA_DATA(tb[TCA_FW_MASK])) != 0xFFFFFFFF)
+                   (mask = rta_getattr_u32(tb[TCA_FW_MASK])) != 0xFFFFFFFF)
                        fprintf(f, "handle 0x%x/0x%x ", mark, mask);
                else
                        fprintf(f, "handle 0x%x ", handle);
@@ -138,14 +138,14 @@ static int fw_print_opt(struct filter_util *qu, FILE *f, struct rtattr *opt, __u
 
        if (tb[TCA_FW_CLASSID]) {
                SPRINT_BUF(b1);
-               fprintf(f, "classid %s ", sprint_tc_classid(*(__u32*)RTA_DATA(tb[TCA_FW_CLASSID]), b1));
+               fprintf(f, "classid %s ", sprint_tc_classid(rta_getattr_u32(tb[TCA_FW_CLASSID]), b1));
        }
 
        if (tb[TCA_FW_POLICE])
                tc_print_police(f, tb[TCA_FW_POLICE]);
        if (tb[TCA_FW_INDEV]) {
                struct rtattr *idev = tb[TCA_FW_INDEV];
-               fprintf(f, "input dev %s ",(char *)RTA_DATA(idev));
+               fprintf(f, "input dev %s ",rta_getattr_str(idev));
        }
 
        if (tb[TCA_FW_ACT]) {

diff --git a/tc/f_route.c b/tc/f_route.c
index eccf924b550122984eacc1db632d1b9d1ab4e713..649e0ec2943575b10f046f1993f0d828c1ed21bf 100644 (file)
--- a/tc/f_route.c
+++ b/tc/f_route.c
@@ -148,12 +148,12 @@ static int route_print_opt(struct filter_util *qu, FILE *f, struct rtattr *opt,
 
        if (tb[TCA_ROUTE4_CLASSID]) {
                SPRINT_BUF(b1);
-               fprintf(f, "flowid %s ", sprint_tc_classid(*(__u32*)RTA_DATA(tb[TCA_ROUTE4_CLASSID]), b1));
+               fprintf(f, "flowid %s ", sprint_tc_classid(rta_getattr_u32(tb[TCA_ROUTE4_CLASSID]), b1));
        }
        if (tb[TCA_ROUTE4_TO])
-               fprintf(f, "to %s ", rtnl_rtrealm_n2a(*(__u32*)RTA_DATA(tb[TCA_ROUTE4_TO]), b1, sizeof(b1)));
+               fprintf(f, "to %s ", rtnl_rtrealm_n2a(rta_getattr_u32(tb[TCA_ROUTE4_TO]), b1, sizeof(b1)));
        if (tb[TCA_ROUTE4_FROM])
-               fprintf(f, "from %s ", rtnl_rtrealm_n2a(*(__u32*)RTA_DATA(tb[TCA_ROUTE4_FROM]), b1, sizeof(b1)));
+               fprintf(f, "from %s ", rtnl_rtrealm_n2a(rta_getattr_u32(tb[TCA_ROUTE4_FROM]), b1, sizeof(b1)));
        if (tb[TCA_ROUTE4_IIF])
                fprintf(f, "fromif %s", ll_index_to_name(*(int*)RTA_DATA(tb[TCA_ROUTE4_IIF])));
        if (tb[TCA_ROUTE4_POLICE])

diff --git a/tc/f_rsvp.c b/tc/f_rsvp.c
index 808310df3159c3a53cee58d0224401faabe8b7b4..8eaf85d815200d88f957dd4b16f69e2124389f1b 100644 (file)
--- a/tc/f_rsvp.c
+++ b/tc/f_rsvp.c
@@ -336,9 +336,9 @@ static int rsvp_print_opt(struct filter_util *qu, FILE *f, struct rtattr *opt, _
        if (tb[TCA_RSVP_CLASSID]) {
                SPRINT_BUF(b1);
                if (!pinfo || pinfo->tunnelhdr == 0)
-                       fprintf(f, "flowid %s ", sprint_tc_classid(*(__u32*)RTA_DATA(tb[TCA_RSVP_CLASSID]), b1));
+                       fprintf(f, "flowid %s ", sprint_tc_classid(rta_getattr_u32(tb[TCA_RSVP_CLASSID]), b1));
                else
-                       fprintf(f, "tunnel %d skip %d ", *(__u32*)RTA_DATA(tb[TCA_RSVP_CLASSID]), pinfo->tunnelhdr);
+                       fprintf(f, "tunnel %d skip %d ", rta_getattr_u32(tb[TCA_RSVP_CLASSID]), pinfo->tunnelhdr);
        } else if (pinfo && pinfo->tunnelhdr)
                fprintf(f, "tunnel [BAD] skip %d ", pinfo->tunnelhdr);
 

diff --git a/tc/f_tcindex.c b/tc/f_tcindex.c
index cb6f854cef180b32677a073471bc8e3d69901886..590c0a6fc14bcc8d18a2ae0acb9728607584c911 100644 (file)
--- a/tc/f_tcindex.c
+++ b/tc/f_tcindex.c
@@ -134,7 +134,7 @@ static int tcindex_print_opt(struct filter_util *qu, FILE *f,
 
                if (RTA_PAYLOAD(tb[TCA_TCINDEX_HASH]) < sizeof(hash))
                        return -1;
-               hash = *(__u16 *) RTA_DATA(tb[TCA_TCINDEX_HASH]);
+               hash = rta_getattr_u16(tb[TCA_TCINDEX_HASH]);
                fprintf(f,"hash %d ",hash);
        }
        if (tb[TCA_TCINDEX_MASK]) {
@@ -142,7 +142,7 @@ static int tcindex_print_opt(struct filter_util *qu, FILE *f,
 
                if (RTA_PAYLOAD(tb[TCA_TCINDEX_MASK]) < sizeof(mask))
                        return -1;
-               mask = *(__u16 *) RTA_DATA(tb[TCA_TCINDEX_MASK]);
+               mask = rta_getattr_u16(tb[TCA_TCINDEX_MASK]);
                fprintf(f,"mask 0x%04x ",mask);
        }
        if (tb[TCA_TCINDEX_SHIFT]) {

diff --git a/tc/f_u32.c b/tc/f_u32.c
index 479b3f1bb8587b256b81816773e7f763e8b9c3a7..975c0b5d035ae67c26fa2f2a6341a0ae733d09f8 100644 (file)
--- a/tc/f_u32.c
+++ b/tc/f_u32.c
@@ -1198,9 +1198,9 @@ static int u32_print_opt(struct filter_util *qu, FILE *f, struct rtattr *opt,
        }
 
        if (tb[TCA_U32_DIVISOR]) {
-               fprintf(f, "ht divisor %d ", *(__u32*)RTA_DATA(tb[TCA_U32_DIVISOR]));
+               fprintf(f, "ht divisor %d ", rta_getattr_u32(tb[TCA_U32_DIVISOR]));
        } else if (tb[TCA_U32_HASH]) {
-               __u32 htid = *(__u32*)RTA_DATA(tb[TCA_U32_HASH]);
+               __u32 htid = rta_getattr_u32(tb[TCA_U32_HASH]);
                fprintf(f, "key ht %x bkt %x ", TC_U32_USERHTID(htid),
                        TC_U32_HASH(htid));
        } else {
@@ -1210,14 +1210,14 @@ static int u32_print_opt(struct filter_util *qu, FILE *f, struct rtattr *opt,
                SPRINT_BUF(b1);
                fprintf(f, "%sflowid %s ",
                        !sel || !(sel->flags&TC_U32_TERMINAL) ? "*" : "",
-                       sprint_tc_classid(*(__u32*)RTA_DATA(tb[TCA_U32_CLASSID]), b1));
+                       sprint_tc_classid(rta_getattr_u32(tb[TCA_U32_CLASSID]), b1));
        } else if (sel && sel->flags&TC_U32_TERMINAL) {
                fprintf(f, "terminal flowid ??? ");
        }
        if (tb[TCA_U32_LINK]) {
                SPRINT_BUF(b1);
                fprintf(f, "link %s ",
-                       sprint_u32_handle(*(__u32*)RTA_DATA(tb[TCA_U32_LINK]), b1));
+                       sprint_u32_handle(rta_getattr_u32(tb[TCA_U32_LINK]), b1));
        }
 
        if (tb[TCA_U32_PCNT]) {
@@ -1278,7 +1278,7 @@ static int u32_print_opt(struct filter_util *qu, FILE *f, struct rtattr *opt,
        }
        if (tb[TCA_U32_INDEV]) {
                struct rtattr *idev = tb[TCA_U32_INDEV];
-               fprintf(f, "\n  input dev %s\n", (char *) RTA_DATA(idev));
+               fprintf(f, "\n  input dev %s\n", rta_getattr_str(idev));
        }
        if (tb[TCA_U32_ACT]) {
                tc_print_action(f, tb[TCA_U32_ACT]);

diff --git a/tc/m_ipt.c b/tc/m_ipt.c
index b8655f85b33d6f07120b19a16d8dd88a7d74aef8..dc2dedc0dd9ce7b481b462b797f29f1edf36798d 100644 (file)
--- a/tc/m_ipt.c
+++ b/tc/m_ipt.c
@@ -552,7 +552,7 @@ print_ipt(struct action_util *au,FILE * f, struct rtattr *arg)
                fprintf(f, "[NULL ipt table name ] assuming mangle ");
        } else {
                fprintf(f, "tablename: %s ",
-                       (char *) RTA_DATA(tb[TCA_IPT_TABLE]));
+                       rta_getattr_str(tb[TCA_IPT_TABLE]));
        }
 
        if (tb[TCA_IPT_HOOK] == NULL) {
@@ -560,7 +560,7 @@ print_ipt(struct action_util *au,FILE * f, struct rtattr *arg)
                return -1;
        } else {
                __u32 hook;
-               hook = *(__u32 *) RTA_DATA(tb[TCA_IPT_HOOK]);
+               hook = rta_getattr_u32(tb[TCA_IPT_HOOK]);
                fprintf(f, " hook: %s \n", ipthooks[hook]);
        }
 
@@ -591,7 +591,7 @@ print_ipt(struct action_util *au,FILE * f, struct rtattr *arg)
                        fprintf(f, " [NULL ipt target index ]\n");
                } else {
                        __u32 index;
-                       index = *(__u32 *) RTA_DATA(tb[TCA_IPT_INDEX]);
+                       index = rta_getattr_u32(tb[TCA_IPT_INDEX]);
                        fprintf(f, " \n\tindex %d", index);
                }
 

diff --git a/tc/m_police.c b/tc/m_police.c
index ace43b52bbf7a7fb4409b8784da5322d8b4307b6..c3869b66541d24369d9929c284ba7dc059471e66 100644 (file)
--- a/tc/m_police.c
+++ b/tc/m_police.c
@@ -353,7 +353,7 @@ print_police(struct action_util *a, FILE *f, struct rtattr *arg)
        if (p->peakrate.rate)
                fprintf(f, "peakrate %s ", sprint_rate(p->peakrate.rate, b1));
        if (tb[TCA_POLICE_AVRATE])
-               fprintf(f, "avrate %s ", sprint_rate(*(__u32*)RTA_DATA(tb[TCA_POLICE_AVRATE]), b1));
+               fprintf(f, "avrate %s ", sprint_rate(rta_getattr_u32(tb[TCA_POLICE_AVRATE]), b1));
        fprintf(f, "action %s", police_action_n2a(p->action, b1, sizeof(b1)));
        if (tb[TCA_POLICE_RESULT]) {
                fprintf(f, "/%s ", police_action_n2a(*(int*)RTA_DATA(tb[TCA_POLICE_RESULT]), b1, sizeof(b1)));

diff --git a/tc/m_xt.c b/tc/m_xt.c
index 8f2a29595ac5655e8db9997b31c0dafa6a340764..bcc4d75146362b04196113da090bd08ee16e4251 100644 (file)
--- a/tc/m_xt.c
+++ b/tc/m_xt.c
@@ -284,7 +284,7 @@ print_ipt(struct action_util *au,FILE * f, struct rtattr *arg)
                fprintf(f, "[NULL ipt table name ] assuming mangle ");
        } else {
                fprintf(f, "tablename: %s ",
-                       (char *) RTA_DATA(tb[TCA_IPT_TABLE]));
+                       rta_getattr_str(tb[TCA_IPT_TABLE]));
        }
 
        if (tb[TCA_IPT_HOOK] == NULL) {
@@ -292,7 +292,7 @@ print_ipt(struct action_util *au,FILE * f, struct rtattr *arg)
                return -1;
        } else {
                __u32 hook;
-               hook = *(__u32 *) RTA_DATA(tb[TCA_IPT_HOOK]);
+               hook = rta_getattr_u32(tb[TCA_IPT_HOOK]);
                fprintf(f, " hook: %s \n", ipthooks[hook]);
        }
 
@@ -328,7 +328,7 @@ print_ipt(struct action_util *au,FILE * f, struct rtattr *arg)
                        fprintf(f, " [NULL ipt target index ]\n");
                } else {
                        __u32 index;
-                       index = *(__u32 *) RTA_DATA(tb[TCA_IPT_INDEX]);
+                       index = rta_getattr_u32(tb[TCA_IPT_INDEX]);
                        fprintf(f, " \n\tindex %d", index);
                }
 

diff --git a/tc/m_xt_old.c b/tc/m_xt_old.c
index 7ed7ecc7a5e68e3e3af4eaec0f3924f57febe79b..554e4ed47af1656ec9cfd68c7e59c5c8fc658786 100644 (file)
--- a/tc/m_xt_old.c
+++ b/tc/m_xt_old.c
@@ -367,7 +367,7 @@ print_ipt(struct action_util *au,FILE * f, struct rtattr *arg)
                fprintf(f, "[NULL ipt table name ] assuming mangle ");
        } else {
                fprintf(f, "tablename: %s ",
-                       (char *) RTA_DATA(tb[TCA_IPT_TABLE]));
+                       rta_getattr_str(tb[TCA_IPT_TABLE]));
        }
 
        if (tb[TCA_IPT_HOOK] == NULL) {
@@ -375,7 +375,7 @@ print_ipt(struct action_util *au,FILE * f, struct rtattr *arg)
                return -1;
        } else {
                __u32 hook;
-               hook = *(__u32 *) RTA_DATA(tb[TCA_IPT_HOOK]);
+               hook = rta_getattr_u32(tb[TCA_IPT_HOOK]);
                fprintf(f, " hook: %s \n", ipthooks[hook]);
        }
 
@@ -406,7 +406,7 @@ print_ipt(struct action_util *au,FILE * f, struct rtattr *arg)
                        fprintf(f, " [NULL ipt target index ]\n");
                } else {
                        __u32 index;
-                       index = *(__u32 *) RTA_DATA(tb[TCA_IPT_INDEX]);
+                       index = rta_getattr_u32(tb[TCA_IPT_INDEX]);
                        fprintf(f, " \n\tindex %d", index);
                }
 

diff --git a/tc/q_atm.c b/tc/q_atm.c
index eec0d77601ef309be8d02e18ed738609a1034ce5..2598e29895a110a3eab6a2418e650c94c8b47049 100644 (file)
--- a/tc/q_atm.c
+++ b/tc/q_atm.c
@@ -210,11 +210,11 @@ static int atm_print_opt(struct qdisc_util *qu, FILE *f, struct rtattr *opt)
        }
        if (tb[TCA_ATM_HDR]) {
                int i;
+               const __u8 *hdr = RTA_DATA(tb[TCA_ATM_HDR]);
 
                fprintf(f,"hdr");
                for (i = 0; i < RTA_PAYLOAD(tb[TCA_ATM_HDR]); i++)
-                       fprintf(f,"%c%02x",i ? '.' : ' ',
-                           ((unsigned char *) RTA_DATA(tb[TCA_ATM_HDR]))[i]);
+                       fprintf(f,"%c%02x", i ? '.' : ' ', hdr[i]);
                if (!i) fprintf(f," .");
                fprintf(f," ");
        }
@@ -224,7 +224,7 @@ static int atm_print_opt(struct qdisc_util *qu, FILE *f, struct rtattr *opt)
                if (RTA_PAYLOAD(tb[TCA_ATM_EXCESS]) < sizeof(excess))
                        fprintf(stderr,"ATM: excess class ID too short\n");
                else {
-                       excess = *(__u32 *) RTA_DATA(tb[TCA_ATM_EXCESS]);
+                       excess = rta_getattr_u32(tb[TCA_ATM_EXCESS]);
                        if (!excess) fprintf(f,"excess clp ");
                        else {
                                char buf[64];

diff --git a/tc/q_choke.c b/tc/q_choke.c
index c616926ffb7ce34a4554569d3c30dd1b982d4423..6fbcadf308b3afe3228c651bf8802fb91163ccea 100644 (file)
--- a/tc/q_choke.c
+++ b/tc/q_choke.c
@@ -182,7 +182,7 @@ static int choke_print_opt(struct qdisc_util *qu, FILE *f, struct rtattr *opt)
                return -1;
        if (tb[TCA_CHOKE_MAX_P] &&
            RTA_PAYLOAD(tb[TCA_CHOKE_MAX_P]) >= sizeof(__u32))
-               max_P = *(__u32 *)RTA_DATA(tb[TCA_CHOKE_MAX_P]);
+               max_P = rta_getattr_u32(tb[TCA_CHOKE_MAX_P]);
 
        fprintf(f, "limit %up min %up max %up ",
                qopt->limit, qopt->qth_min, qopt->qth_max);

diff --git a/tc/q_drr.c b/tc/q_drr.c
index 9d3788f2083c31743c05ebcab91b042cf97937d1..746736ddccb9fe860e0ee715e1a834ccbf74f730 100644 (file)
--- a/tc/q_drr.c
+++ b/tc/q_drr.c
@@ -93,7 +93,7 @@ static int drr_print_opt(struct qdisc_util *qu, FILE *f, struct rtattr *opt)
 
        if (tb[TCA_DRR_QUANTUM])
                fprintf(f, "quantum %s ",
-                       sprint_size(*(__u32 *)RTA_DATA(tb[TCA_DRR_QUANTUM]), b1));
+                       sprint_size(rta_getattr_u32(tb[TCA_DRR_QUANTUM]), b1));
        return 0;
 }
 

diff --git a/tc/q_dsmark.c b/tc/q_dsmark.c
index cfbb33515ed9e0f6e06c5a4d23a1e863c5ad113c..05185c0096c9ac60b80d22891014e79cac4586eb 100644 (file)
--- a/tc/q_dsmark.c
+++ b/tc/q_dsmark.c
@@ -140,25 +140,25 @@ static int dsmark_print_opt(struct qdisc_util *qu, FILE *f, struct rtattr *opt)
                if (!RTA_PAYLOAD(tb[TCA_DSMARK_MASK]))
                        fprintf(stderr,"dsmark: empty mask\n");
                else fprintf(f,"mask 0x%02x ",
-                           *(__u8 *) RTA_DATA(tb[TCA_DSMARK_MASK]));
+                           rta_getattr_u8(tb[TCA_DSMARK_MASK]));
        }
        if (tb[TCA_DSMARK_VALUE]) {
                if (!RTA_PAYLOAD(tb[TCA_DSMARK_VALUE]))
                        fprintf(stderr,"dsmark: empty value\n");
                else fprintf(f,"value 0x%02x ",
-                           *(__u8 *) RTA_DATA(tb[TCA_DSMARK_VALUE]));
+                           rta_getattr_u8(tb[TCA_DSMARK_VALUE]));
        }
        if (tb[TCA_DSMARK_INDICES]) {
                if (RTA_PAYLOAD(tb[TCA_DSMARK_INDICES]) < sizeof(__u16))
                        fprintf(stderr,"dsmark: indices too short\n");
                else fprintf(f,"indices 0x%04x ",
-                           *(__u16 *) RTA_DATA(tb[TCA_DSMARK_INDICES]));
+                           rta_getattr_u16(tb[TCA_DSMARK_INDICES]));
        }
        if (tb[TCA_DSMARK_DEFAULT_INDEX]) {
                if (RTA_PAYLOAD(tb[TCA_DSMARK_DEFAULT_INDEX]) < sizeof(__u16))
                        fprintf(stderr,"dsmark: default_index too short\n");
                else fprintf(f,"default_index 0x%04x ",
-                           *(__u16 *) RTA_DATA(tb[TCA_DSMARK_DEFAULT_INDEX]));
+                           rta_getattr_u16(tb[TCA_DSMARK_DEFAULT_INDEX]));
        }
        if (tb[TCA_DSMARK_SET_TC_INDEX]) fprintf(f,"set_tc_index ");
        return 0;

diff --git a/tc/q_prio.c b/tc/q_prio.c
index 2f54d550b0d8b470cbfac5d2e1bbfb658756ec75..79b4fd0926d2396bc03d1666d207546900eed349 100644 (file)
--- a/tc/q_prio.c
+++ b/tc/q_prio.c
@@ -112,7 +112,7 @@ int prio_print_opt(struct qdisc_util *qu, FILE *f, struct rtattr *opt)
 
        if (tb[TCA_PRIO_MQ])
                fprintf(f, " multiqueue: %s ",
-                   *(unsigned char *)RTA_DATA(tb[TCA_PRIO_MQ]) ? "on" : "off");
+                       rta_getattr_u8(tb[TCA_PRIO_MQ]) ? "on" : "off");
 
        return 0;
 }

diff --git a/tc/q_qfq.c b/tc/q_qfq.c
index 3ade6621892d31f6338f4a06c383e5e2d23f4196..05b4d84e2118450d5d87d1c9fce9dd55fb1140fa 100644 (file)
--- a/tc/q_qfq.c
+++ b/tc/q_qfq.c
@@ -102,12 +102,12 @@ static int qfq_print_opt(struct qdisc_util *qu, FILE *f, struct rtattr *opt)
 
        if (tb[TCA_QFQ_WEIGHT]) {
                fprintf(f, "weight %u ",
-                       *(__u32 *)RTA_DATA(tb[TCA_QFQ_WEIGHT]));
+                       rta_getattr_u32(tb[TCA_QFQ_WEIGHT]));
        }
 
        if (tb[TCA_QFQ_LMAX]) {
                fprintf(f, "maxpkt %u ",
-                       *(__u32 *)RTA_DATA(tb[TCA_QFQ_LMAX]));
+                       rta_getattr_u32(tb[TCA_QFQ_LMAX]));
        }
 
        return 0;

diff --git a/tc/q_red.c b/tc/q_red.c
index a07171c4f2f442e3d906219f3c4d3c2a215b9583..89e7320181d52ae0c966580c1192f88046842339 100644 (file)
--- a/tc/q_red.c
+++ b/tc/q_red.c
@@ -176,7 +176,7 @@ static int red_print_opt(struct qdisc_util *qu, FILE *f, struct rtattr *opt)
 
        if (tb[TCA_RED_MAX_P] &&
            RTA_PAYLOAD(tb[TCA_RED_MAX_P]) >= sizeof(__u32))
-               max_P = *(__u32 *)RTA_DATA(tb[TCA_RED_MAX_P]);
+               max_P = rta_getattr_u32(tb[TCA_RED_MAX_P]);
 
        fprintf(f, "limit %s min %s max %s ",
                sprint_size(qopt->limit, b1),

diff --git a/tc/q_rr.c b/tc/q_rr.c
index 1ff3ac96586e942b5fccbe26d8470b4ea9bfbd0e..79072ade6236241132135870655e19f470514ca9 100644 (file)
--- a/tc/q_rr.c
+++ b/tc/q_rr.c
@@ -107,7 +107,7 @@ int rr_print_opt(struct qdisc_util *qu, FILE *f, struct rtattr *opt)
 
        if (tb[TCA_PRIO_MQ])
                fprintf(f, " multiqueue: %s ",
-                   *(unsigned char *)RTA_DATA(tb[TCA_PRIO_MQ]) ? "on" : "off");
+                       rta_getattr_u8(tb[TCA_PRIO_MQ]) ? "on" : "off");
 
        return 0;
 }

diff --git a/tc/tc_class.c b/tc/tc_class.c
index 3a1a0ac0060beda3a04e0383da59d64b627f3e4a..de18fd11524201daf251ac80b4ff739fa376a3c6 100644 (file)
--- a/tc/tc_class.c
+++ b/tc/tc_class.c
@@ -191,7 +191,7 @@ int print_class(const struct sockaddr_nl *who,
                else
                        print_tc_classid(abuf, sizeof(abuf), t->tcm_handle);
        }
-       fprintf(fp, "class %s %s ", (char*)RTA_DATA(tb[TCA_KIND]), abuf);
+       fprintf(fp, "class %s %s ", rta_getattr_str(tb[TCA_KIND]), abuf);
 
        if (filter_ifindex == 0)
                fprintf(fp, "dev %s ", ll_index_to_name(t->tcm_ifindex));

diff --git a/tc/tc_filter.c b/tc/tc_filter.c
index d4b0b671b2bc288a1307b165e31e29e5dd051941..207302fc25019750efa7538a28cd96b0e3e6fa17 100644 (file)
--- a/tc/tc_filter.c
+++ b/tc/tc_filter.c
@@ -240,7 +240,7 @@ int print_filter(const struct sockaddr_nl *who,
                                fprintf(fp, "pref %u ", prio);
                }
        }
-       fprintf(fp, "%s ", (char*)RTA_DATA(tb[TCA_KIND]));
+       fprintf(fp, "%s ", rta_getattr_str(tb[TCA_KIND]));
        q = get_filter_kind(RTA_DATA(tb[TCA_KIND]));
        if (tb[TCA_OPTIONS]) {
                if (q)

diff --git a/tc/tc_qdisc.c b/tc/tc_qdisc.c
index 0822e63e22d4eeedda8024342b3d2d724a7f80cb..3f932a7bdcf060ff152eed413c7674122024942a 100644 (file)
--- a/tc/tc_qdisc.c
+++ b/tc/tc_qdisc.c
@@ -229,7 +229,7 @@ int print_qdisc(const struct sockaddr_nl *who,
        if (n->nlmsg_type == RTM_DELQDISC)
                fprintf(fp, "deleted ");
 
-       fprintf(fp, "qdisc %s %x: ", (char*)RTA_DATA(tb[TCA_KIND]), t->tcm_handle>>16);
+       fprintf(fp, "qdisc %s %x: ", rta_getattr_str(tb[TCA_KIND]), t->tcm_handle>>16);
        if (filter_ifindex == 0)
                fprintf(fp, "dev %s ", ll_index_to_name(t->tcm_ifindex));
        if (t->tcm_parent == TC_H_ROOT)