rtnetlink.c (63105e83987a08f73accfba78602a073bf219b69) rtnetlink.c (02839cc8d72b49c1440b5019b3f40ca49c4824e5)
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * INET An implementation of the TCP/IP protocol suite for the LINUX
4 * operating system. INET is implemented using the BSD Socket
5 * interface as the means of communication with the user level.
6 *
7 * Routing netlink socket interface: protocol independent part.
8 *

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

3300 }
3301
3302 return 0;
3303}
3304
3305static int rtnl_newlink_create(struct sk_buff *skb, struct ifinfomsg *ifm,
3306 const struct rtnl_link_ops *ops,
3307 struct nlattr **tb, struct nlattr **data,
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * INET An implementation of the TCP/IP protocol suite for the LINUX
4 * operating system. INET is implemented using the BSD Socket
5 * interface as the means of communication with the user level.
6 *
7 * Routing netlink socket interface: protocol independent part.
8 *

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

3300 }
3301
3302 return 0;
3303}
3304
3305static int rtnl_newlink_create(struct sk_buff *skb, struct ifinfomsg *ifm,
3306 const struct rtnl_link_ops *ops,
3307 struct nlattr **tb, struct nlattr **data,
3308 struct netlink_ext_ack *extack);
3308 struct netlink_ext_ack *extack)
3309{
3310 unsigned char name_assign_type = NET_NAME_USER;
3311 struct net *net = sock_net(skb->sk);
3312 struct net *dest_net, *link_net;
3313 struct net_device *dev;
3314 char ifname[IFNAMSIZ];
3315 int err;
3309
3316
3317 if (!ops->alloc && !ops->setup)
3318 return -EOPNOTSUPP;
3319
3320 if (tb[IFLA_IFNAME]) {
3321 nla_strscpy(ifname, tb[IFLA_IFNAME], IFNAMSIZ);
3322 } else {
3323 snprintf(ifname, IFNAMSIZ, "%s%%d", ops->kind);
3324 name_assign_type = NET_NAME_ENUM;
3325 }
3326
3327 dest_net = rtnl_link_get_net_capable(skb, net, tb, CAP_NET_ADMIN);
3328 if (IS_ERR(dest_net))
3329 return PTR_ERR(dest_net);
3330
3331 if (tb[IFLA_LINK_NETNSID]) {
3332 int id = nla_get_s32(tb[IFLA_LINK_NETNSID]);
3333
3334 link_net = get_net_ns_by_id(dest_net, id);
3335 if (!link_net) {
3336 NL_SET_ERR_MSG(extack, "Unknown network namespace id");
3337 err = -EINVAL;
3338 goto out;
3339 }
3340 err = -EPERM;
3341 if (!netlink_ns_capable(skb, link_net->user_ns, CAP_NET_ADMIN))
3342 goto out;
3343 } else {
3344 link_net = NULL;
3345 }
3346
3347 dev = rtnl_create_link(link_net ? : dest_net, ifname,
3348 name_assign_type, ops, tb, extack);
3349 if (IS_ERR(dev)) {
3350 err = PTR_ERR(dev);
3351 goto out;
3352 }
3353
3354 dev->ifindex = ifm->ifi_index;
3355
3356 if (ops->newlink)
3357 err = ops->newlink(link_net ? : net, dev, tb, data, extack);
3358 else
3359 err = register_netdevice(dev);
3360 if (err < 0) {
3361 free_netdev(dev);
3362 goto out;
3363 }
3364
3365 err = rtnl_configure_link(dev, ifm);
3366 if (err < 0)
3367 goto out_unregister;
3368 if (link_net) {
3369 err = dev_change_net_namespace(dev, dest_net, ifname);
3370 if (err < 0)
3371 goto out_unregister;
3372 }
3373 if (tb[IFLA_MASTER]) {
3374 err = do_set_master(dev, nla_get_u32(tb[IFLA_MASTER]), extack);
3375 if (err)
3376 goto out_unregister;
3377 }
3378out:
3379 if (link_net)
3380 put_net(link_net);
3381 put_net(dest_net);
3382 return err;
3383out_unregister:
3384 if (ops->newlink) {
3385 LIST_HEAD(list_kill);
3386
3387 ops->dellink(dev, &list_kill);
3388 unregister_netdevice_many(&list_kill);
3389 } else {
3390 unregister_netdevice(dev);
3391 }
3392 goto out;
3393}
3394
3310struct rtnl_newlink_tbs {
3311 struct nlattr *tb[IFLA_MAX + 1];
3312 struct nlattr *attr[RTNL_MAX_TYPE + 1];
3313 struct nlattr *slave_attr[RTNL_SLAVE_MAX_TYPE + 1];
3314};
3315
3316static int __rtnl_newlink(struct sk_buff *skb, struct nlmsghdr *nlh,
3317 struct rtnl_newlink_tbs *tbs,

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

3484#endif
3485 NL_SET_ERR_MSG(extack, "Unknown device type");
3486 return -EOPNOTSUPP;
3487 }
3488
3489 return rtnl_newlink_create(skb, ifm, ops, tb, data, extack);
3490}
3491
3395struct rtnl_newlink_tbs {
3396 struct nlattr *tb[IFLA_MAX + 1];
3397 struct nlattr *attr[RTNL_MAX_TYPE + 1];
3398 struct nlattr *slave_attr[RTNL_SLAVE_MAX_TYPE + 1];
3399};
3400
3401static int __rtnl_newlink(struct sk_buff *skb, struct nlmsghdr *nlh,
3402 struct rtnl_newlink_tbs *tbs,

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

3569#endif
3570 NL_SET_ERR_MSG(extack, "Unknown device type");
3571 return -EOPNOTSUPP;
3572 }
3573
3574 return rtnl_newlink_create(skb, ifm, ops, tb, data, extack);
3575}
3576
3492static int rtnl_newlink_create(struct sk_buff *skb, struct ifinfomsg *ifm,
3493 const struct rtnl_link_ops *ops,
3494 struct nlattr **tb, struct nlattr **data,
3495 struct netlink_ext_ack *extack)
3496{
3497 unsigned char name_assign_type = NET_NAME_USER;
3498 struct net *net = sock_net(skb->sk);
3499 struct net *dest_net, *link_net;
3500 struct net_device *dev;
3501 char ifname[IFNAMSIZ];
3502 int err;
3503
3504 if (!ops->alloc && !ops->setup)
3505 return -EOPNOTSUPP;
3506
3507 if (tb[IFLA_IFNAME]) {
3508 nla_strscpy(ifname, tb[IFLA_IFNAME], IFNAMSIZ);
3509 } else {
3510 snprintf(ifname, IFNAMSIZ, "%s%%d", ops->kind);
3511 name_assign_type = NET_NAME_ENUM;
3512 }
3513
3514 dest_net = rtnl_link_get_net_capable(skb, net, tb, CAP_NET_ADMIN);
3515 if (IS_ERR(dest_net))
3516 return PTR_ERR(dest_net);
3517
3518 if (tb[IFLA_LINK_NETNSID]) {
3519 int id = nla_get_s32(tb[IFLA_LINK_NETNSID]);
3520
3521 link_net = get_net_ns_by_id(dest_net, id);
3522 if (!link_net) {
3523 NL_SET_ERR_MSG(extack, "Unknown network namespace id");
3524 err = -EINVAL;
3525 goto out;
3526 }
3527 err = -EPERM;
3528 if (!netlink_ns_capable(skb, link_net->user_ns, CAP_NET_ADMIN))
3529 goto out;
3530 } else {
3531 link_net = NULL;
3532 }
3533
3534 dev = rtnl_create_link(link_net ? : dest_net, ifname,
3535 name_assign_type, ops, tb, extack);
3536 if (IS_ERR(dev)) {
3537 err = PTR_ERR(dev);
3538 goto out;
3539 }
3540
3541 dev->ifindex = ifm->ifi_index;
3542
3543 if (ops->newlink)
3544 err = ops->newlink(link_net ? : net, dev, tb, data, extack);
3545 else
3546 err = register_netdevice(dev);
3547 if (err < 0) {
3548 free_netdev(dev);
3549 goto out;
3550 }
3551
3552 err = rtnl_configure_link(dev, ifm);
3553 if (err < 0)
3554 goto out_unregister;
3555 if (link_net) {
3556 err = dev_change_net_namespace(dev, dest_net, ifname);
3557 if (err < 0)
3558 goto out_unregister;
3559 }
3560 if (tb[IFLA_MASTER]) {
3561 err = do_set_master(dev, nla_get_u32(tb[IFLA_MASTER]), extack);
3562 if (err)
3563 goto out_unregister;
3564 }
3565out:
3566 if (link_net)
3567 put_net(link_net);
3568 put_net(dest_net);
3569 return err;
3570out_unregister:
3571 if (ops->newlink) {
3572 LIST_HEAD(list_kill);
3573
3574 ops->dellink(dev, &list_kill);
3575 unregister_netdevice_many(&list_kill);
3576 } else {
3577 unregister_netdevice(dev);
3578 }
3579 goto out;
3580}
3581
3582static int rtnl_newlink(struct sk_buff *skb, struct nlmsghdr *nlh,
3583 struct netlink_ext_ack *extack)
3584{
3585 struct rtnl_newlink_tbs *tbs;
3586 int ret;
3587
3588 tbs = kmalloc(sizeof(*tbs), GFP_KERNEL);
3589 if (!tbs)

--- 2625 unchanged lines hidden --- 		3577static int rtnl_newlink(struct sk_buff *skb, struct nlmsghdr *nlh,
3578 struct netlink_ext_ack *extack)
3579{
3580 struct rtnl_newlink_tbs *tbs;
3581 int ret;
3582
3583 tbs = kmalloc(sizeof(*tbs), GFP_KERNEL);
3584 if (!tbs)

--- 2625 unchanged lines hidden ---