bridge.c 18.9 KB
Newer Older
1
/*
2
 * Copyright (C) 2007, 2009, 2011 Red Hat, Inc.
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
 *
 * Authors:
 *     Mark McLoughlin <markmc@redhat.com>
 */

#include <config.h>

24
#if defined(WITH_BRIDGE)
25

26
# include "bridge.h"
27
# include "files.h"
28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48

# include <stdlib.h>
# include <stdio.h>
# include <string.h>
# include <unistd.h>
# include <fcntl.h>
# include <errno.h>
# include <arpa/inet.h>
# include <sys/types.h>
# include <sys/socket.h>
# include <sys/ioctl.h>
# include <paths.h>
# include <sys/wait.h>

# include <linux/param.h>     /* HZ                 */
# include <linux/sockios.h>   /* SIOCBRADDBR etc.   */
# include <linux/if_bridge.h> /* SYSFS_BRIDGE_ATTR  */
# include <linux/if_tun.h>    /* IFF_TUN, IFF_NO_PI */
# include <net/if_arp.h>    /* ARPHRD_ETHER */

# include "internal.h"
49
# include "command.h"
50 51 52
# include "memory.h"
# include "util.h"
# include "logging.h"
53
# include "network.h"
54 55 56

# define JIFFIES_TO_MS(j) (((j)*1000)/HZ)
# define MS_TO_JIFFIES(ms) (((ms)*HZ)/1000)
57 58 59 60 61

struct _brControl {
    int fd;
};

62 63 64 65 66 67 68 69 70
/**
 * brInit:
 * @ctlp: pointer to bridge control return value
 *
 * Initialize a new bridge layer. In case of success
 * @ctlp will contain a pointer to the new bridge structure.
 *
 * Returns 0 in case of success, an error code otherwise.
 */
71 72 73 74 75 76 77 78 79
int
brInit(brControl **ctlp)
{
    int fd;

    if (!ctlp || *ctlp)
        return EINVAL;

    fd = socket(AF_INET, SOCK_STREAM, 0);
E
Eric Blake 已提交
80 81 82
    if (fd < 0 ||
        virSetCloseExec(fd) < 0 ||
        VIR_ALLOC(*ctlp) < 0) {
83
        VIR_FORCE_CLOSE(fd);
E
Eric Blake 已提交
84
        return errno;
85
    }
86 87 88 89 90 91

    (*ctlp)->fd = fd;

    return 0;
}

92 93 94 95 96 97
/**
 * brShutdown:
 * @ctl: pointer to a bridge control
 *
 * Shutdown the bridge layer and deallocate the associated structures
 */
98 99 100 101 102 103
void
brShutdown(brControl *ctl)
{
    if (!ctl)
        return;

104
    VIR_FORCE_CLOSE(ctl->fd);
105

106
    VIR_FREE(ctl);
107 108
}

109 110 111
/**
 * brAddBridge:
 * @ctl: bridge control pointer
112
 * @name: the bridge name
113
 *
114
 * This function register a new bridge
115 116 117
 *
 * Returns 0 in case of success or an errno code in case of failure.
 */
118
# ifdef SIOCBRADDBR
119 120
int
brAddBridge(brControl *ctl,
121
            const char *name)
122
{
123
    if (!ctl || !ctl->fd || !name)
124 125
        return EINVAL;

126 127
    if (ioctl(ctl->fd, SIOCBRADDBR, name) == 0)
        return 0;
128 129 130

    return errno;
}
131
# else
132
int brAddBridge (brControl *ctl ATTRIBUTE_UNUSED,
133
                 const char *name ATTRIBUTE_UNUSED)
134 135 136
{
    return EINVAL;
}
137
# endif
138

139
# ifdef SIOCBRDELBR
140 141 142 143 144 145 146 147 148 149 150
int
brHasBridge(brControl *ctl,
            const char *name)
{
    struct ifreq ifr;

    if (!ctl || !name) {
        errno = EINVAL;
        return -1;
    }

C
Chris Lalancette 已提交
151 152 153
    memset(&ifr, 0, sizeof(struct ifreq));

    if (virStrcpyStatic(ifr.ifr_name, name) == NULL) {
154 155 156 157 158 159 160 161 162
        errno = EINVAL;
        return -1;
    }

    if (ioctl(ctl->fd, SIOCGIFFLAGS, &ifr))
        return -1;

    return 0;
}
163
# else
164
int
165 166
brHasBridge(brControl *ctl ATTRIBUTE_UNUSED,
            const char *name ATTRIBUTE_UNUSED)
167 168 169
{
    return EINVAL;
}
170
# endif
171

172 173 174 175 176 177 178 179 180
/**
 * brDeleteBridge:
 * @ctl: bridge control pointer
 * @name: the bridge name
 *
 * Remove a bridge from the layer.
 *
 * Returns 0 in case of success or an errno code in case of failure.
 */
181
# ifdef SIOCBRDELBR
182 183 184 185 186 187 188 189 190
int
brDeleteBridge(brControl *ctl,
               const char *name)
{
    if (!ctl || !ctl->fd || !name)
        return EINVAL;

    return ioctl(ctl->fd, SIOCBRDELBR, name) == 0 ? 0 : errno;
}
191
# else
192 193 194 195 196 197
int
brDeleteBridge(brControl *ctl ATTRIBUTE_UNUSED,
               const char *name ATTRIBUTE_UNUSED)
{
    return EINVAL;
}
198
# endif
199

200
# if defined(SIOCBRADDIF) && defined(SIOCBRDELIF)
201 202 203 204 205 206 207 208 209 210 211 212 213
static int
brAddDelInterface(brControl *ctl,
                  int cmd,
                  const char *bridge,
                  const char *iface)
{
    struct ifreq ifr;

    if (!ctl || !ctl->fd || !bridge || !iface)
        return EINVAL;

    memset(&ifr, 0, sizeof(struct ifreq));

C
Chris Lalancette 已提交
214 215
    if (virStrcpyStatic(ifr.ifr_name, bridge) == NULL)
        return EINVAL;
216 217 218 219 220 221

    if (!(ifr.ifr_ifindex = if_nametoindex(iface)))
        return ENODEV;

    return ioctl(ctl->fd, cmd, &ifr) == 0 ? 0 : errno;
}
222
# endif
223

224 225 226 227 228
/**
 * brAddInterface:
 * @ctl: bridge control pointer
 * @bridge: the bridge name
 * @iface: the network interface name
229
 *
230 231 232 233
 * Adds an interface to a bridge
 *
 * Returns 0 in case of success or an errno code in case of failure.
 */
234
# ifdef SIOCBRADDIF
235 236 237 238 239 240 241
int
brAddInterface(brControl *ctl,
               const char *bridge,
               const char *iface)
{
    return brAddDelInterface(ctl, SIOCBRADDIF, bridge, iface);
}
242
# else
243 244 245 246 247 248 249
int
brAddInterface(brControl *ctl ATTRIBUTE_UNUSED,
               const char *bridge ATTRIBUTE_UNUSED,
               const char *iface ATTRIBUTE_UNUSED)
{
    return EINVAL;
}
250
# endif
251

252 253 254 255 256
/**
 * brDeleteInterface:
 * @ctl: bridge control pointer
 * @bridge: the bridge name
 * @iface: the network interface name
257
 *
258 259 260 261
 * Removes an interface from a bridge
 *
 * Returns 0 in case of success or an errno code in case of failure.
 */
262
# ifdef SIOCBRDELIF
263 264 265 266 267 268 269
int
brDeleteInterface(brControl *ctl,
                  const char *bridge,
                  const char *iface)
{
    return brAddDelInterface(ctl, SIOCBRDELIF, bridge, iface);
}
270
# else
271 272 273 274 275 276 277
int
brDeleteInterface(brControl *ctl ATTRIBUTE_UNUSED,
                  const char *bridge ATTRIBUTE_UNUSED,
                  const char *iface ATTRIBUTE_UNUSED)
{
    return EINVAL;
}
278
# endif
279

280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311
/**
 * ifSetInterfaceMac:
 * @ctl: bridge control pointer
 * @ifname: interface name to set MTU for
 * @macaddr: MAC address (VIR_MAC_BUFLEN in size)
 *
 * This function sets the @macaddr for a given interface @ifname. This
 * gets rid of the kernel's automatically assigned random MAC.
 *
 * Returns 0 in case of success or an errno code in case of failure.
 */
static int ifSetInterfaceMac(brControl *ctl, const char *ifname,
                             const unsigned char *macaddr)
{
    struct ifreq ifr;

    if (!ctl || !ifname)
        return EINVAL;

    memset(&ifr, 0, sizeof(struct ifreq));
    if (virStrcpyStatic(ifr.ifr_name, ifname) == NULL)
        return EINVAL;

    /* To fill ifr.ifr_hdaddr.sa_family field */
    if (ioctl(ctl->fd, SIOCGIFHWADDR, &ifr) != 0)
        return errno;

    memcpy(ifr.ifr_hwaddr.sa_data, macaddr, VIR_MAC_BUFLEN);

    return ioctl(ctl->fd, SIOCSIFHWADDR, &ifr) == 0 ? 0 : errno;
}

312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330
/**
 * ifGetMtu
 * @ctl: bridge control pointer
 * @ifname: interface name get MTU for
 *
 * This function gets the @mtu value set for a given interface @ifname.
 *
 * Returns the MTU value in case of success.
 * On error, returns -1 and sets errno accordingly
 */
static int ifGetMtu(brControl *ctl, const char *ifname)
{
    struct ifreq ifr;

    if (!ctl || !ifname) {
        errno = EINVAL;
        return -1;
    }

C
Chris Lalancette 已提交
331 332 333
    memset(&ifr, 0, sizeof(struct ifreq));

    if (virStrcpyStatic(ifr.ifr_name, ifname) == NULL) {
334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364
        errno = EINVAL;
        return -1;
    }

    if (ioctl(ctl->fd, SIOCGIFMTU, &ifr))
        return -1;

    return ifr.ifr_mtu;

}

/**
 * ifSetMtu:
 * @ctl: bridge control pointer
 * @ifname: interface name to set MTU for
 * @mtu: MTU value
 *
 * This function sets the @mtu for a given interface @ifname.  Typically
 * used on a tap device to set up for Jumbo Frames.
 *
 * Returns 0 in case of success or an errno code in case of failure.
 */
static int ifSetMtu(brControl *ctl, const char *ifname, int mtu)
{
    struct ifreq ifr;

    if (!ctl || !ifname)
        return EINVAL;

    memset(&ifr, 0, sizeof(struct ifreq));

C
Chris Lalancette 已提交
365 366
    if (virStrcpyStatic(ifr.ifr_name, ifname) == NULL)
        return EINVAL;
367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393
    ifr.ifr_mtu = mtu;

    return ioctl(ctl->fd, SIOCSIFMTU, &ifr) == 0 ? 0 : errno;
}

/**
 * brSetInterfaceMtu
 * @ctl: bridge control pointer
 * @bridge: name of the bridge interface
 * @ifname: name of the interface whose MTU we want to set
 *
 * Sets the interface mtu to the same MTU of the bridge
 *
 * Returns 0 in case of success or an errno code in case of failure.
 */
static int brSetInterfaceMtu(brControl *ctl,
                             const char *bridge,
                             const char *ifname)
{
    int mtu = ifGetMtu(ctl, bridge);

    if (mtu < 0)
        return errno;

    return ifSetMtu(ctl, ifname, mtu);
}

394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412
/**
 * brProbeVnetHdr:
 * @tapfd: a tun/tap file descriptor
 *
 * Check whether it is safe to enable the IFF_VNET_HDR flag on the
 * tap interface.
 *
 * Setting IFF_VNET_HDR enables QEMU's virtio_net driver to allow
 * guests to pass larger (GSO) packets, with partial checksums, to
 * the host. This greatly increases the achievable throughput.
 *
 * It is only useful to enable this when we're setting up a virtio
 * interface. And it is only *safe* to enable it when we know for
 * sure that a) qemu has support for IFF_VNET_HDR and b) the running
 * kernel implements the TUNGETIFF ioctl(), which qemu needs to query
 * the supplied tapfd.
 *
 * Returns 0 in case of success or an errno code in case of failure.
 */
413
# ifdef IFF_VNET_HDR
414 415 416
static int
brProbeVnetHdr(int tapfd)
{
417
#  if defined(IFF_VNET_HDR) && defined(TUNGETFEATURES) && defined(TUNGETIFF)
418 419 420 421
    unsigned int features;
    struct ifreq dummy;

    if (ioctl(tapfd, TUNGETFEATURES, &features) != 0) {
422 423
        VIR_INFO("Not enabling IFF_VNET_HDR; "
                 "TUNGETFEATURES ioctl() not implemented");
424 425 426 427
        return 0;
    }

    if (!(features & IFF_VNET_HDR)) {
428 429
        VIR_INFO("Not enabling IFF_VNET_HDR; "
                 "TUNGETFEATURES ioctl() reports no IFF_VNET_HDR");
430 431 432 433 434 435 436
        return 0;
    }

    /* The kernel will always return -1 at this point.
     * If TUNGETIFF is not implemented then errno == EBADFD.
     */
    if (ioctl(tapfd, TUNGETIFF, &dummy) != -1 || errno != EBADFD) {
437 438
        VIR_INFO("Not enabling IFF_VNET_HDR; "
                 "TUNGETIFF ioctl() not implemented");
439 440 441
        return 0;
    }

442
    VIR_INFO("Enabling IFF_VNET_HDR");
443 444

    return 1;
445
#  else
446
    (void) tapfd;
447
    VIR_INFO("Not enabling IFF_VNET_HDR; disabled at build time");
448
    return 0;
449
#  endif
450
}
451
# endif
452

453 454 455 456 457
/**
 * brAddTap:
 * @ctl: bridge control pointer
 * @bridge: the bridge name
 * @ifname: the interface name (or name template)
458
 * @macaddr: desired MAC address (VIR_MAC_BUFLEN long)
459
 * @vnet_hdr: whether to try enabling IFF_VNET_HDR
460 461
 * @tapfd: file descriptor return value for the new tap device
 *
D
typo  
Daniel Veillard 已提交
462
 * This function creates a new tap device on a bridge. @ifname can be either
463
 * a fixed name or a name template with '%d' for dynamic name allocation.
464 465 466 467 468
 * in either case the final name for the bridge will be stored in @ifname.
 * If the @tapfd parameter is supplied, the open tap device file
 * descriptor will be returned, otherwise the TAP device will be made
 * persistent and closed. The caller must use brDeleteTap to remove
 * a persistent TAP devices when it is no longer needed.
469 470 471
 *
 * Returns 0 in case of success or an errno code in case of failure.
 */
472 473 474
int
brAddTap(brControl *ctl,
         const char *bridge,
475
         char **ifname,
476
         const unsigned char *macaddr,
477
         int vnet_hdr,
478
         bool up,
479 480
         int *tapfd)
{
C
Chris Lalancette 已提交
481
    int fd;
482
    struct ifreq ifr;
483

484
    if (!ctl || !ctl->fd || !bridge || !ifname)
485 486 487 488 489
        return EINVAL;

    if ((fd = open("/dev/net/tun", O_RDWR)) < 0)
      return errno;

490 491
    memset(&ifr, 0, sizeof(ifr));

492
    ifr.ifr_flags = IFF_TAP|IFF_NO_PI;
493

494
# ifdef IFF_VNET_HDR
495 496
    if (vnet_hdr && brProbeVnetHdr(fd))
        ifr.ifr_flags |= IFF_VNET_HDR;
497
# else
498
    (void) vnet_hdr;
499
# endif
500

C
Chris Lalancette 已提交
501
    if (virStrcpyStatic(ifr.ifr_name, *ifname) == NULL) {
502 503 504
        errno = EINVAL;
        goto error;
    }
505

C
Chris Lalancette 已提交
506 507 508
    if (ioctl(fd, TUNSETIFF, &ifr) < 0)
        goto error;

509 510 511 512 513 514 515 516
    /* We need to set the interface MAC before adding it
     * to the bridge, because the bridge assumes the lowest
     * MAC of all enslaved interfaces & we don't want it
     * seeing the kernel allocate random MAC for the TAP
     * device before we set our static MAC.
     */
    if ((errno = ifSetInterfaceMac(ctl, ifr.ifr_name, macaddr)))
        goto error;
517 518 519 520 521 522 523 524
    /* We need to set the interface MTU before adding it
     * to the bridge, because the bridge will have its
     * MTU adjusted automatically when we add the new interface.
     */
    if ((errno = brSetInterfaceMtu(ctl, bridge, ifr.ifr_name)))
        goto error;
    if ((errno = brAddInterface(ctl, bridge, ifr.ifr_name)))
        goto error;
525
    if (up && ((errno = brSetInterfaceUp(ctl, ifr.ifr_name, 1))))
526 527 528 529 530 531 532 533 534
        goto error;
    if (!tapfd &&
        (errno = ioctl(fd, TUNSETPERSIST, 1)))
        goto error;
    VIR_FREE(*ifname);
    if (!(*ifname = strdup(ifr.ifr_name)))
        goto error;
    if (tapfd)
        *tapfd = fd;
535
    else
536
        VIR_FORCE_CLOSE(fd);
537
    return 0;
538 539

 error:
540
    VIR_FORCE_CLOSE(fd);
541 542 543 544

    return errno;
}

545 546 547 548 549 550 551 552 553 554 555 556 557 558 559
int brDeleteTap(brControl *ctl,
                const char *ifname)
{
    struct ifreq try;
    int fd;

    if (!ctl || !ctl->fd || !ifname)
        return EINVAL;

    if ((fd = open("/dev/net/tun", O_RDWR)) < 0)
        return errno;

    memset(&try, 0, sizeof(struct ifreq));
    try.ifr_flags = IFF_TAP|IFF_NO_PI;

C
Chris Lalancette 已提交
560
    if (virStrcpyStatic(try.ifr_name, ifname) == NULL) {
561 562 563 564 565 566 567 568 569 570
        errno = EINVAL;
        goto error;
    }

    if (ioctl(fd, TUNSETIFF, &try) == 0) {
        if ((errno = ioctl(fd, TUNSETPERSIST, 0)))
            goto error;
    }

 error:
571
    VIR_FORCE_CLOSE(fd);
572 573 574 575 576

    return errno;
}


577 578 579 580 581 582 583 584 585 586
/**
 * brSetInterfaceUp:
 * @ctl: bridge control pointer
 * @ifname: the interface name
 * @up: 1 for up, 0 for down
 *
 * Function to control if an interface is activated (up, 1) or not (down, 0)
 *
 * Returns 0 in case of success or an errno code in case of failure.
 */
587 588 589 590 591 592
int
brSetInterfaceUp(brControl *ctl,
                 const char *ifname,
                 int up)
{
    struct ifreq ifr;
E
Eric Blake 已提交
593
    int ifflags;
594 595 596 597 598 599

    if (!ctl || !ifname)
        return EINVAL;

    memset(&ifr, 0, sizeof(struct ifreq));

C
Chris Lalancette 已提交
600 601
    if (virStrcpyStatic(ifr.ifr_name, ifname) == NULL)
        return EINVAL;
602 603 604 605

    if (ioctl(ctl->fd, SIOCGIFFLAGS, &ifr) < 0)
        return errno;

E
Eric Blake 已提交
606
    ifflags = up ? (ifr.ifr_flags | IFF_UP) : (ifr.ifr_flags & ~IFF_UP);
607

E
Eric Blake 已提交
608 609
    if (ifr.ifr_flags != ifflags) {
        ifr.ifr_flags = ifflags;
610 611 612 613 614 615 616 617

        if (ioctl(ctl->fd, SIOCSIFFLAGS, &ifr) < 0)
            return errno;
    }

    return 0;
}

618 619 620 621 622 623 624 625 626 627
/**
 * brGetInterfaceUp:
 * @ctl: bridge control pointer
 * @ifname: the interface name
 * @up: where to store the status
 *
 * Function to query if an interface is activated (1) or not (0)
 *
 * Returns 0 in case of success or an errno code in case of failure.
 */
628 629 630 631 632 633 634
int
brGetInterfaceUp(brControl *ctl,
                 const char *ifname,
                 int *up)
{
    struct ifreq ifr;

635
    if (!ctl || !ifname || !up)
636 637 638 639
        return EINVAL;

    memset(&ifr, 0, sizeof(struct ifreq));

C
Chris Lalancette 已提交
640 641
    if (virStrcpyStatic(ifr.ifr_name, ifname) == NULL)
        return EINVAL;
642 643 644 645 646 647 648 649 650

    if (ioctl(ctl->fd, SIOCGIFFLAGS, &ifr) < 0)
        return errno;

    *up = (ifr.ifr_flags & IFF_UP) ? 1 : 0;

    return 0;
}

651
/**
652
 * brAddInetAddress:
653 654
 * @ctl: bridge control pointer
 * @ifname: the interface name
655 656
 * @addr: the IP address (IPv4 or IPv6)
 * @prefix: number of 1 bits in the netmask
657
 *
658 659 660
 * Add an IP address to an interface. This function *does not* remove
 * any previously added IP addresses - that must be done separately with
 * brDelInetAddress.
661
 *
662
 * Returns 0 in case of success or -1 in case of error.
663 664
 */

665
int
666
brAddInetAddress(brControl *ctl ATTRIBUTE_UNUSED,
667
                 const char *ifname,
668 669
                 virSocketAddr *addr,
                 unsigned int prefix)
670
{
J
Jiri Denemark 已提交
671
    virCommandPtr cmd = NULL;
672 673
    char *addrstr = NULL, *bcaststr = NULL;
    virSocketAddr broadcast;
674 675 676 677
    int ret = -1;

    if (!(addrstr = virSocketFormatAddr(addr)))
        goto cleanup;
678 679 680 681 682 683
    /* format up a broadcast address if this is IPv4 */
    if ((VIR_SOCKET_IS_FAMILY(addr, AF_INET)) &&
        ((virSocketAddrBroadcastByPrefix(addr, prefix, &broadcast) < 0) ||
         !(bcaststr = virSocketFormatAddr(&broadcast)))) {
        goto cleanup;
    }
684 685 686
    cmd = virCommandNew(IP_PATH);
    virCommandAddArgList(cmd, "addr", "add", NULL);
    virCommandAddArgFormat(cmd, "%s/%u", addrstr, prefix);
687 688
    if (bcaststr)
        virCommandAddArgList(cmd, "broadcast", bcaststr, NULL);
689 690 691 692 693 694 695 696
    virCommandAddArgList(cmd, "dev", ifname, NULL);

    if (virCommandRun(cmd, NULL) < 0)
        goto cleanup;

    ret = 0;
cleanup:
    VIR_FREE(addrstr);
697
    VIR_FREE(bcaststr);
698 699
    virCommandFree(cmd);
    return ret;
700 701
}

702
/**
703
 * brDelInetAddress:
704 705
 * @ctl: bridge control pointer
 * @ifname: the interface name
706 707
 * @addr: the IP address (IPv4 or IPv6)
 * @prefix: number of 1 bits in the netmask
708
 *
709
 * Delete an IP address from an interface.
710
 *
711
 * Returns 0 in case of success or -1 in case of error.
712 713
 */

714
int
715
brDelInetAddress(brControl *ctl ATTRIBUTE_UNUSED,
716
                 const char *ifname,
717 718
                 virSocketAddr *addr,
                 unsigned int prefix)
719
{
J
Jiri Denemark 已提交
720
    virCommandPtr cmd = NULL;
721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738
    char *addrstr;
    int ret = -1;

    if (!(addrstr = virSocketFormatAddr(addr)))
        goto cleanup;
    cmd = virCommandNew(IP_PATH);
    virCommandAddArgList(cmd, "addr", "del", NULL);
    virCommandAddArgFormat(cmd, "%s/%u", addrstr, prefix);
    virCommandAddArgList(cmd, "dev", ifname, NULL);

    if (virCommandRun(cmd, NULL) < 0)
        goto cleanup;

    ret = 0;
cleanup:
    VIR_FREE(addrstr);
    virCommandFree(cmd);
    return ret;
739 740
}

741 742 743 744 745 746 747 748
/**
 * brSetForwardDelay:
 * @ctl: bridge control pointer
 * @bridge: the bridge name
 * @delay: delay in seconds
 *
 * Set the bridge forward delay
 *
749
 * Returns 0 in case of success or -1 on failure
750
 */
751

752
int
753
brSetForwardDelay(brControl *ctl ATTRIBUTE_UNUSED,
754 755 756
                  const char *bridge,
                  int delay)
{
757 758
    virCommandPtr cmd;
    int ret = -1;
759

760 761 762
    cmd = virCommandNew(BRCTL);
    virCommandAddArgList(cmd, "setfd", bridge, NULL);
    virCommandAddArgFormat(cmd, "%d", delay);
763

764 765
    if (virCommandRun(cmd, NULL) < 0)
        goto cleanup;
766

767 768 769 770
    ret = 0;
cleanup:
    virCommandFree(cmd);
    return ret;
771 772
}

773 774 775 776 777 778 779 780 781
/**
 * brSetEnableSTP:
 * @ctl: bridge control pointer
 * @bridge: the bridge name
 * @enable: 1 to enable, 0 to disable
 *
 * Control whether the bridge participates in the spanning tree protocol,
 * in general don't disable it without good reasons.
 *
782
 * Returns 0 in case of success or -1 on failure
783
 */
784
int
785
brSetEnableSTP(brControl *ctl ATTRIBUTE_UNUSED,
786 787 788
               const char *bridge,
               int enable)
{
789 790
    virCommandPtr cmd;
    int ret = -1;
791

792 793 794 795
    cmd = virCommandNew(BRCTL);
    virCommandAddArgList(cmd, "stp", bridge,
                         enable ? "on" : "off",
                         NULL);
796

797 798 799 800 801 802 803
    if (virCommandRun(cmd, NULL) < 0)
        goto cleanup;

    ret = 0;
cleanup:
    virCommandFree(cmd);
    return ret;
804 805
}

806
#endif /* WITH_BRIDGE */