rtnetlink.c (4e1a606d552de03aec2b1fd157011bf012fcc870) rtnetlink.c (dac9c9790e542777079999900594fd069ba10489)
1/*
2 * INET An implementation of the TCP/IP protocol suite for the LINUX
3 * operating system. INET is implemented using the BSD Socket
4 * interface as the means of communication with the user level.
5 *
6 * Routing netlink socket interface: protocol independent part.
7 *
8 * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>

--- 116 unchanged lines hidden (view full) ---

125EXPORT_SYMBOL(rtnl_trylock);
126
127int rtnl_is_locked(void)
128{
129 return mutex_is_locked(&rtnl_mutex);
130}
131EXPORT_SYMBOL(rtnl_is_locked);
132
1/*
2 * INET An implementation of the TCP/IP protocol suite for the LINUX
3 * operating system. INET is implemented using the BSD Socket
4 * interface as the means of communication with the user level.
5 *
6 * Routing netlink socket interface: protocol independent part.
7 *
8 * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>

--- 116 unchanged lines hidden (view full) ---

125EXPORT_SYMBOL(rtnl_trylock);
126
127int rtnl_is_locked(void)
128{
129 return mutex_is_locked(&rtnl_mutex);
130}
131EXPORT_SYMBOL(rtnl_is_locked);
132
133bool refcount_dec_and_rtnl_lock(refcount_t *r)
134{
135 return refcount_dec_and_mutex_lock(r, &rtnl_mutex);
136}
137EXPORT_SYMBOL(refcount_dec_and_rtnl_lock);
138
133#ifdef CONFIG_PROVE_LOCKING
134bool lockdep_rtnl_is_held(void)
135{
136 return lockdep_is_held(&rtnl_mutex);
137}
138EXPORT_SYMBOL(lockdep_rtnl_is_held);
139#endif /* #ifdef CONFIG_PROVE_LOCKING */
140

--- 870 unchanged lines hidden (view full) ---

1011 + nla_total_size(MAX_PHYS_ITEM_ID_LEN) /* IFLA_PHYS_PORT_ID */
1012 + nla_total_size(MAX_PHYS_ITEM_ID_LEN) /* IFLA_PHYS_SWITCH_ID */
1013 + nla_total_size(IFNAMSIZ) /* IFLA_PHYS_PORT_NAME */
1014 + rtnl_xdp_size() /* IFLA_XDP */
1015 + nla_total_size(4) /* IFLA_EVENT */
1016 + nla_total_size(4) /* IFLA_NEW_NETNSID */
1017 + nla_total_size(4) /* IFLA_NEW_IFINDEX */
1018 + nla_total_size(1) /* IFLA_PROTO_DOWN */
139#ifdef CONFIG_PROVE_LOCKING
140bool lockdep_rtnl_is_held(void)
141{
142 return lockdep_is_held(&rtnl_mutex);
143}
144EXPORT_SYMBOL(lockdep_rtnl_is_held);
145#endif /* #ifdef CONFIG_PROVE_LOCKING */
146

--- 870 unchanged lines hidden (view full) ---

1017 + nla_total_size(MAX_PHYS_ITEM_ID_LEN) /* IFLA_PHYS_PORT_ID */
1018 + nla_total_size(MAX_PHYS_ITEM_ID_LEN) /* IFLA_PHYS_SWITCH_ID */
1019 + nla_total_size(IFNAMSIZ) /* IFLA_PHYS_PORT_NAME */
1020 + rtnl_xdp_size() /* IFLA_XDP */
1021 + nla_total_size(4) /* IFLA_EVENT */
1022 + nla_total_size(4) /* IFLA_NEW_NETNSID */
1023 + nla_total_size(4) /* IFLA_NEW_IFINDEX */
1024 + nla_total_size(1) /* IFLA_PROTO_DOWN */
1019 + nla_total_size(4) /* IFLA_IF_NETNSID */
1025 + nla_total_size(4) /* IFLA_TARGET_NETNSID */
1020 + nla_total_size(4) /* IFLA_CARRIER_UP_COUNT */
1021 + nla_total_size(4) /* IFLA_CARRIER_DOWN_COUNT */
1022 + nla_total_size(4) /* IFLA_MIN_MTU */
1023 + nla_total_size(4) /* IFLA_MAX_MTU */
1024 + 0;
1025}
1026
1027static int rtnl_vf_ports_fill(struct sk_buff *skb, struct net_device *dev)

--- 565 unchanged lines hidden (view full) ---

1593 ifm = nlmsg_data(nlh);
1594 ifm->ifi_family = AF_UNSPEC;
1595 ifm->__ifi_pad = 0;
1596 ifm->ifi_type = dev->type;
1597 ifm->ifi_index = dev->ifindex;
1598 ifm->ifi_flags = dev_get_flags(dev);
1599 ifm->ifi_change = change;
1600
1026 + nla_total_size(4) /* IFLA_CARRIER_UP_COUNT */
1027 + nla_total_size(4) /* IFLA_CARRIER_DOWN_COUNT */
1028 + nla_total_size(4) /* IFLA_MIN_MTU */
1029 + nla_total_size(4) /* IFLA_MAX_MTU */
1030 + 0;
1031}
1032
1033static int rtnl_vf_ports_fill(struct sk_buff *skb, struct net_device *dev)

--- 565 unchanged lines hidden (view full) ---

1599 ifm = nlmsg_data(nlh);
1600 ifm->ifi_family = AF_UNSPEC;
1601 ifm->__ifi_pad = 0;
1602 ifm->ifi_type = dev->type;
1603 ifm->ifi_index = dev->ifindex;
1604 ifm->ifi_flags = dev_get_flags(dev);
1605 ifm->ifi_change = change;
1606
1601 if (tgt_netnsid >= 0 && nla_put_s32(skb, IFLA_IF_NETNSID, tgt_netnsid))
1607 if (tgt_netnsid >= 0 && nla_put_s32(skb, IFLA_TARGET_NETNSID, tgt_netnsid))
1602 goto nla_put_failure;
1603
1604 if (nla_put_string(skb, IFLA_IFNAME, dev->name) ||
1605 nla_put_u32(skb, IFLA_TXQLEN, dev->tx_queue_len) ||
1606 nla_put_u8(skb, IFLA_OPERSTATE,
1607 netif_running(dev) ? dev->operstate : IF_OPER_DOWN) ||
1608 nla_put_u8(skb, IFLA_LINKMODE, dev->link_mode) ||
1609 nla_put_u32(skb, IFLA_MTU, dev->mtu) ||

--- 122 unchanged lines hidden (view full) ---

1732 [IFLA_PHYS_PORT_ID] = { .type = NLA_BINARY, .len = MAX_PHYS_ITEM_ID_LEN },
1733 [IFLA_CARRIER_CHANGES] = { .type = NLA_U32 }, /* ignored */
1734 [IFLA_PHYS_SWITCH_ID] = { .type = NLA_BINARY, .len = MAX_PHYS_ITEM_ID_LEN },
1735 [IFLA_LINK_NETNSID] = { .type = NLA_S32 },
1736 [IFLA_PROTO_DOWN] = { .type = NLA_U8 },
1737 [IFLA_XDP] = { .type = NLA_NESTED },
1738 [IFLA_EVENT] = { .type = NLA_U32 },
1739 [IFLA_GROUP] = { .type = NLA_U32 },
1608 goto nla_put_failure;
1609
1610 if (nla_put_string(skb, IFLA_IFNAME, dev->name) ||
1611 nla_put_u32(skb, IFLA_TXQLEN, dev->tx_queue_len) ||
1612 nla_put_u8(skb, IFLA_OPERSTATE,
1613 netif_running(dev) ? dev->operstate : IF_OPER_DOWN) ||
1614 nla_put_u8(skb, IFLA_LINKMODE, dev->link_mode) ||
1615 nla_put_u32(skb, IFLA_MTU, dev->mtu) ||

--- 122 unchanged lines hidden (view full) ---

1738 [IFLA_PHYS_PORT_ID] = { .type = NLA_BINARY, .len = MAX_PHYS_ITEM_ID_LEN },
1739 [IFLA_CARRIER_CHANGES] = { .type = NLA_U32 }, /* ignored */
1740 [IFLA_PHYS_SWITCH_ID] = { .type = NLA_BINARY, .len = MAX_PHYS_ITEM_ID_LEN },
1741 [IFLA_LINK_NETNSID] = { .type = NLA_S32 },
1742 [IFLA_PROTO_DOWN] = { .type = NLA_U8 },
1743 [IFLA_XDP] = { .type = NLA_NESTED },
1744 [IFLA_EVENT] = { .type = NLA_U32 },
1745 [IFLA_GROUP] = { .type = NLA_U32 },
1740 [IFLA_IF_NETNSID] = { .type = NLA_S32 },
1746 [IFLA_TARGET_NETNSID] = { .type = NLA_S32 },
1741 [IFLA_CARRIER_UP_COUNT] = { .type = NLA_U32 },
1742 [IFLA_CARRIER_DOWN_COUNT] = { .type = NLA_U32 },
1743 [IFLA_MIN_MTU] = { .type = NLA_U32 },
1744 [IFLA_MAX_MTU] = { .type = NLA_U32 },
1745};
1746
1747static const struct nla_policy ifla_info_policy[IFLA_INFO_MAX+1] = {
1748 [IFLA_INFO_KIND] = { .type = NLA_STRING },

--- 91 unchanged lines hidden (view full) ---

1840{
1841 if (link_master_filtered(dev, master_idx) ||
1842 link_kind_filtered(dev, kind_ops))
1843 return true;
1844
1845 return false;
1846}
1847
1747 [IFLA_CARRIER_UP_COUNT] = { .type = NLA_U32 },
1748 [IFLA_CARRIER_DOWN_COUNT] = { .type = NLA_U32 },
1749 [IFLA_MIN_MTU] = { .type = NLA_U32 },
1750 [IFLA_MAX_MTU] = { .type = NLA_U32 },
1751};
1752
1753static const struct nla_policy ifla_info_policy[IFLA_INFO_MAX+1] = {
1754 [IFLA_INFO_KIND] = { .type = NLA_STRING },

--- 91 unchanged lines hidden (view full) ---

1846{
1847 if (link_master_filtered(dev, master_idx) ||
1848 link_kind_filtered(dev, kind_ops))
1849 return true;
1850
1851 return false;
1852}
1853
1848static struct net *get_target_net(struct sock *sk, int netnsid)
1854/**
1855 * rtnl_get_net_ns_capable - Get netns if sufficiently privileged.
1856 * @sk: netlink socket
1857 * @netnsid: network namespace identifier
1858 *
1859 * Returns the network namespace identified by netnsid on success or an error
1860 * pointer on failure.
1861 */
1862struct net *rtnl_get_net_ns_capable(struct sock *sk, int netnsid)
1849{
1850 struct net *net;
1851
1852 net = get_net_ns_by_id(sock_net(sk), netnsid);
1853 if (!net)
1854 return ERR_PTR(-EINVAL);
1855
1856 /* For now, the caller is required to have CAP_NET_ADMIN in
1857 * the user namespace owning the target net ns.
1858 */
1859 if (!sk_ns_capable(sk, net->user_ns, CAP_NET_ADMIN)) {
1860 put_net(net);
1861 return ERR_PTR(-EACCES);
1862 }
1863 return net;
1864}
1863{
1864 struct net *net;
1865
1866 net = get_net_ns_by_id(sock_net(sk), netnsid);
1867 if (!net)
1868 return ERR_PTR(-EINVAL);
1869
1870 /* For now, the caller is required to have CAP_NET_ADMIN in
1871 * the user namespace owning the target net ns.
1872 */
1873 if (!sk_ns_capable(sk, net->user_ns, CAP_NET_ADMIN)) {
1874 put_net(net);
1875 return ERR_PTR(-EACCES);
1876 }
1877 return net;
1878}
1879EXPORT_SYMBOL_GPL(rtnl_get_net_ns_capable);
1865
1866static int rtnl_dump_ifinfo(struct sk_buff *skb, struct netlink_callback *cb)
1867{
1868 struct net *net = sock_net(skb->sk);
1869 struct net *tgt_net = net;
1870 int h, s_h;
1871 int idx = 0, s_idx;
1872 struct net_device *dev;

--- 16 unchanged lines hidden (view full) ---

1889 * what iproute2 < v3.9.0 used.
1890 * We can detect the old iproute2. Even including the IFLA_EXT_MASK
1891 * attribute, its netlink message is shorter than struct ifinfomsg.
1892 */
1893 hdrlen = nlmsg_len(cb->nlh) < sizeof(struct ifinfomsg) ?
1894 sizeof(struct rtgenmsg) : sizeof(struct ifinfomsg);
1895
1896 if (nlmsg_parse(cb->nlh, hdrlen, tb, IFLA_MAX,
1880
1881static int rtnl_dump_ifinfo(struct sk_buff *skb, struct netlink_callback *cb)
1882{
1883 struct net *net = sock_net(skb->sk);
1884 struct net *tgt_net = net;
1885 int h, s_h;
1886 int idx = 0, s_idx;
1887 struct net_device *dev;

--- 16 unchanged lines hidden (view full) ---

1904 * what iproute2 < v3.9.0 used.
1905 * We can detect the old iproute2. Even including the IFLA_EXT_MASK
1906 * attribute, its netlink message is shorter than struct ifinfomsg.
1907 */
1908 hdrlen = nlmsg_len(cb->nlh) < sizeof(struct ifinfomsg) ?
1909 sizeof(struct rtgenmsg) : sizeof(struct ifinfomsg);
1910
1911 if (nlmsg_parse(cb->nlh, hdrlen, tb, IFLA_MAX,
1897 ifla_policy, NULL) >= 0) {
1898 if (tb[IFLA_IF_NETNSID]) {
1899 netnsid = nla_get_s32(tb[IFLA_IF_NETNSID]);
1900 tgt_net = get_target_net(skb->sk, netnsid);
1912 ifla_policy, cb->extack) >= 0) {
1913 if (tb[IFLA_TARGET_NETNSID]) {
1914 netnsid = nla_get_s32(tb[IFLA_TARGET_NETNSID]);
1915 tgt_net = rtnl_get_net_ns_capable(skb->sk, netnsid);
1901 if (IS_ERR(tgt_net))
1902 return PTR_ERR(tgt_net);
1903 }
1904
1905 if (tb[IFLA_EXT_MASK])
1906 ext_filter_mask = nla_get_u32(tb[IFLA_EXT_MASK]);
1907
1908 if (tb[IFLA_MASTER])

--- 68 unchanged lines hidden (view full) ---

1977}
1978EXPORT_SYMBOL(rtnl_link_get_net);
1979
1980/* Figure out which network namespace we are talking about by
1981 * examining the link attributes in the following order:
1982 *
1983 * 1. IFLA_NET_NS_PID
1984 * 2. IFLA_NET_NS_FD
1916 if (IS_ERR(tgt_net))
1917 return PTR_ERR(tgt_net);
1918 }
1919
1920 if (tb[IFLA_EXT_MASK])
1921 ext_filter_mask = nla_get_u32(tb[IFLA_EXT_MASK]);
1922
1923 if (tb[IFLA_MASTER])

--- 68 unchanged lines hidden (view full) ---

1992}
1993EXPORT_SYMBOL(rtnl_link_get_net);
1994
1995/* Figure out which network namespace we are talking about by
1996 * examining the link attributes in the following order:
1997 *
1998 * 1. IFLA_NET_NS_PID
1999 * 2. IFLA_NET_NS_FD
1985 * 3. IFLA_IF_NETNSID
2000 * 3. IFLA_TARGET_NETNSID
1986 */
1987static struct net *rtnl_link_get_net_by_nlattr(struct net *src_net,
1988 struct nlattr *tb[])
1989{
1990 struct net *net;
1991
1992 if (tb[IFLA_NET_NS_PID] || tb[IFLA_NET_NS_FD])
1993 return rtnl_link_get_net(src_net, tb);
1994
2001 */
2002static struct net *rtnl_link_get_net_by_nlattr(struct net *src_net,
2003 struct nlattr *tb[])
2004{
2005 struct net *net;
2006
2007 if (tb[IFLA_NET_NS_PID] || tb[IFLA_NET_NS_FD])
2008 return rtnl_link_get_net(src_net, tb);
2009
1995 if (!tb[IFLA_IF_NETNSID])
2010 if (!tb[IFLA_TARGET_NETNSID])
1996 return get_net(src_net);
1997
2011 return get_net(src_net);
2012
1998 net = get_net_ns_by_id(src_net, nla_get_u32(tb[IFLA_IF_NETNSID]));
2013 net = get_net_ns_by_id(src_net, nla_get_u32(tb[IFLA_TARGET_NETNSID]));
1999 if (!net)
2000 return ERR_PTR(-EINVAL);
2001
2002 return net;
2003}
2004
2005static struct net *rtnl_link_get_net_capable(const struct sk_buff *skb,
2006 struct net *src_net,

--- 24 unchanged lines hidden (view full) ---

2031 if (netns_id_only) {
2032 if (!tb[IFLA_NET_NS_PID] && !tb[IFLA_NET_NS_FD])
2033 return 0;
2034
2035 NL_SET_ERR_MSG(extack, "specified netns attribute not supported");
2036 return -EOPNOTSUPP;
2037 }
2038
2014 if (!net)
2015 return ERR_PTR(-EINVAL);
2016
2017 return net;
2018}
2019
2020static struct net *rtnl_link_get_net_capable(const struct sk_buff *skb,
2021 struct net *src_net,

--- 24 unchanged lines hidden (view full) ---

2046 if (netns_id_only) {
2047 if (!tb[IFLA_NET_NS_PID] && !tb[IFLA_NET_NS_FD])
2048 return 0;
2049
2050 NL_SET_ERR_MSG(extack, "specified netns attribute not supported");
2051 return -EOPNOTSUPP;
2052 }
2053
2039 if (tb[IFLA_IF_NETNSID] && (tb[IFLA_NET_NS_PID] || tb[IFLA_NET_NS_FD]))
2054 if (tb[IFLA_TARGET_NETNSID] && (tb[IFLA_NET_NS_PID] || tb[IFLA_NET_NS_FD]))
2040 goto invalid_attr;
2041
2055 goto invalid_attr;
2056
2042 if (tb[IFLA_NET_NS_PID] && (tb[IFLA_IF_NETNSID] || tb[IFLA_NET_NS_FD]))
2057 if (tb[IFLA_NET_NS_PID] && (tb[IFLA_TARGET_NETNSID] || tb[IFLA_NET_NS_FD]))
2043 goto invalid_attr;
2044
2058 goto invalid_attr;
2059
2045 if (tb[IFLA_NET_NS_FD] && (tb[IFLA_IF_NETNSID] || tb[IFLA_NET_NS_PID]))
2060 if (tb[IFLA_NET_NS_FD] && (tb[IFLA_TARGET_NETNSID] || tb[IFLA_NET_NS_PID]))
2046 goto invalid_attr;
2047
2048 return 0;
2049
2050invalid_attr:
2051 NL_SET_ERR_MSG(extack, "multiple netns identifying attributes specified");
2052 return -EINVAL;
2053}

--- 259 unchanged lines hidden (view full) ---

2313{
2314 const struct net_device_ops *ops = dev->netdev_ops;
2315 int err;
2316
2317 err = validate_linkmsg(dev, tb);
2318 if (err < 0)
2319 return err;
2320
2061 goto invalid_attr;
2062
2063 return 0;
2064
2065invalid_attr:
2066 NL_SET_ERR_MSG(extack, "multiple netns identifying attributes specified");
2067 return -EINVAL;
2068}

--- 259 unchanged lines hidden (view full) ---

2328{
2329 const struct net_device_ops *ops = dev->netdev_ops;
2330 int err;
2331
2332 err = validate_linkmsg(dev, tb);
2333 if (err < 0)
2334 return err;
2335
2321 if (tb[IFLA_NET_NS_PID] || tb[IFLA_NET_NS_FD] || tb[IFLA_IF_NETNSID]) {
2336 if (tb[IFLA_NET_NS_PID] || tb[IFLA_NET_NS_FD] || tb[IFLA_TARGET_NETNSID]) {
2322 struct net *net = rtnl_link_get_net_capable(skb, dev_net(dev),
2323 tb, CAP_NET_ADMIN);
2324 if (IS_ERR(net)) {
2325 err = PTR_ERR(net);
2326 goto errout;
2327 }
2328
2329 err = dev_change_net_namespace(dev, net, ifname);

--- 426 unchanged lines hidden (view full) ---

2756
2757 err = rtnl_ensure_unique_netns(tb, extack, true);
2758 if (err < 0)
2759 return err;
2760
2761 if (tb[IFLA_IFNAME])
2762 nla_strlcpy(ifname, tb[IFLA_IFNAME], IFNAMSIZ);
2763
2337 struct net *net = rtnl_link_get_net_capable(skb, dev_net(dev),
2338 tb, CAP_NET_ADMIN);
2339 if (IS_ERR(net)) {
2340 err = PTR_ERR(net);
2341 goto errout;
2342 }
2343
2344 err = dev_change_net_namespace(dev, net, ifname);

--- 426 unchanged lines hidden (view full) ---

2771
2772 err = rtnl_ensure_unique_netns(tb, extack, true);
2773 if (err < 0)
2774 return err;
2775
2776 if (tb[IFLA_IFNAME])
2777 nla_strlcpy(ifname, tb[IFLA_IFNAME], IFNAMSIZ);
2778
2764 if (tb[IFLA_IF_NETNSID]) {
2765 netnsid = nla_get_s32(tb[IFLA_IF_NETNSID]);
2766 tgt_net = get_target_net(NETLINK_CB(skb).sk, netnsid);
2779 if (tb[IFLA_TARGET_NETNSID]) {
2780 netnsid = nla_get_s32(tb[IFLA_TARGET_NETNSID]);
2781 tgt_net = rtnl_get_net_ns_capable(NETLINK_CB(skb).sk, netnsid);
2767 if (IS_ERR(tgt_net))
2768 return PTR_ERR(tgt_net);
2769 }
2770
2771 err = -EINVAL;
2772 ifm = nlmsg_data(nlh);
2773 if (ifm->ifi_index > 0)
2774 dev = __dev_get_by_index(tgt_net, ifm->ifi_index);

--- 397 unchanged lines hidden (view full) ---

3172 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFLA_MAX, ifla_policy, extack);
3173 if (err < 0)
3174 return err;
3175
3176 err = rtnl_ensure_unique_netns(tb, extack, true);
3177 if (err < 0)
3178 return err;
3179
2782 if (IS_ERR(tgt_net))
2783 return PTR_ERR(tgt_net);
2784 }
2785
2786 err = -EINVAL;
2787 ifm = nlmsg_data(nlh);
2788 if (ifm->ifi_index > 0)
2789 dev = __dev_get_by_index(tgt_net, ifm->ifi_index);

--- 397 unchanged lines hidden (view full) ---

3187 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFLA_MAX, ifla_policy, extack);
3188 if (err < 0)
3189 return err;
3190
3191 err = rtnl_ensure_unique_netns(tb, extack, true);
3192 if (err < 0)
3193 return err;
3194
3180 if (tb[IFLA_IF_NETNSID]) {
3181 netnsid = nla_get_s32(tb[IFLA_IF_NETNSID]);
3182 tgt_net = get_target_net(NETLINK_CB(skb).sk, netnsid);
3195 if (tb[IFLA_TARGET_NETNSID]) {
3196 netnsid = nla_get_s32(tb[IFLA_TARGET_NETNSID]);
3197 tgt_net = rtnl_get_net_ns_capable(NETLINK_CB(skb).sk, netnsid);
3183 if (IS_ERR(tgt_net))
3184 return PTR_ERR(tgt_net);
3185 }
3186
3187 if (tb[IFLA_IFNAME])
3188 nla_strlcpy(ifname, tb[IFLA_IFNAME], IFNAMSIZ);
3189
3190 if (tb[IFLA_EXT_MASK])

--- 68 unchanged lines hidden (view full) ---

3259
3260 return nlmsg_total_size(min_ifinfo_dump_size);
3261}
3262
3263static int rtnl_dump_all(struct sk_buff *skb, struct netlink_callback *cb)
3264{
3265 int idx;
3266 int s_idx = cb->family;
3198 if (IS_ERR(tgt_net))
3199 return PTR_ERR(tgt_net);
3200 }
3201
3202 if (tb[IFLA_IFNAME])
3203 nla_strlcpy(ifname, tb[IFLA_IFNAME], IFNAMSIZ);
3204
3205 if (tb[IFLA_EXT_MASK])

--- 68 unchanged lines hidden (view full) ---

3274
3275 return nlmsg_total_size(min_ifinfo_dump_size);
3276}
3277
3278static int rtnl_dump_all(struct sk_buff *skb, struct netlink_callback *cb)
3279{
3280 int idx;
3281 int s_idx = cb->family;
3282 int type = cb->nlh->nlmsg_type - RTM_BASE;
3267
3268 if (s_idx == 0)
3269 s_idx = 1;
3270
3271 for (idx = 1; idx <= RTNL_FAMILY_MAX; idx++) {
3272 struct rtnl_link **tab;
3283
3284 if (s_idx == 0)
3285 s_idx = 1;
3286
3287 for (idx = 1; idx <= RTNL_FAMILY_MAX; idx++) {
3288 struct rtnl_link **tab;
3273 int type = cb->nlh->nlmsg_type-RTM_BASE;
3274 struct rtnl_link *link;
3275 rtnl_dumpit_func dumpit;
3276
3277 if (idx < s_idx || idx == PF_PACKET)
3278 continue;
3279
3280 if (type < 0 || type >= RTM_NR_MSGTYPES)
3281 continue;

--- 472 unchanged lines hidden (view full) ---

3754 * So, check for ndmsg with an optional u32 attribute (not used here).
3755 * Fortunately these sizes don't conflict with the size of ifinfomsg
3756 * with an optional attribute.
3757 */
3758 if (nlmsg_len(cb->nlh) != sizeof(struct ndmsg) &&
3759 (nlmsg_len(cb->nlh) != sizeof(struct ndmsg) +
3760 nla_attr_size(sizeof(u32)))) {
3761 err = nlmsg_parse(cb->nlh, sizeof(struct ifinfomsg), tb,
3289 struct rtnl_link *link;
3290 rtnl_dumpit_func dumpit;
3291
3292 if (idx < s_idx || idx == PF_PACKET)
3293 continue;
3294
3295 if (type < 0 || type >= RTM_NR_MSGTYPES)
3296 continue;

--- 472 unchanged lines hidden (view full) ---

3769 * So, check for ndmsg with an optional u32 attribute (not used here).
3770 * Fortunately these sizes don't conflict with the size of ifinfomsg
3771 * with an optional attribute.
3772 */
3773 if (nlmsg_len(cb->nlh) != sizeof(struct ndmsg) &&
3774 (nlmsg_len(cb->nlh) != sizeof(struct ndmsg) +
3775 nla_attr_size(sizeof(u32)))) {
3776 err = nlmsg_parse(cb->nlh, sizeof(struct ifinfomsg), tb,
3762 IFLA_MAX, ifla_policy, NULL);
3777 IFLA_MAX, ifla_policy, cb->extack);
3763 if (err < 0) {
3764 return -EINVAL;
3765 } else if (err == 0) {
3766 if (tb[IFLA_MASTER])
3767 br_idx = nla_get_u32(tb[IFLA_MASTER]);
3768 }
3769
3770 brport_idx = ifm->ifi_index;

--- 1081 unchanged lines hidden --- 		3778 if (err < 0) {
3779 return -EINVAL;
3780 } else if (err == 0) {
3781 if (tb[IFLA_MASTER])
3782 br_idx = nla_get_u32(tb[IFLA_MASTER]);
3783 }
3784
3785 brport_idx = ifm->ifi_index;

--- 1081 unchanged lines hidden ---