extern void
virCapabilitiesSetMacPrefix(virCapsPtr caps,
- unsigned char *prefix)
+ const unsigned char prefix[VIR_MAC_PREFIX_BUFLEN])
{
memcpy(caps->macPrefix, prefix, sizeof(caps->macPrefix));
}
extern void
virCapabilitiesGenerateMac(virCapsPtr caps,
- unsigned char *mac)
+ virMacAddrPtr mac)
{
virMacAddrGenerate(caps->macPrefix, mac);
}
extern void
virCapabilitiesSetMacPrefix(virCapsPtr caps,
- unsigned char *prefix);
+ const unsigned char prefix[VIR_MAC_PREFIX_BUFLEN]);
extern void
virCapabilitiesGenerateMac(virCapsPtr caps,
- unsigned char *mac);
+ virMacAddrPtr mac);
extern void
virCapabilitiesSetEmulatorRequired(virCapsPtr caps);
virUUIDFormat(vm->def->uuid, uuidstr);
if (oldDef)
- virMacAddrFormat(oldDef->mac, oldMacstr);
+ virMacAddrFormat(&oldDef->mac, oldMacstr);
if (newDef)
- virMacAddrFormat(newDef->mac, newMacstr);
+ virMacAddrFormat(&newDef->mac, newMacstr);
if (!(vmname = virAuditEncode("vm", vm->def->name))) {
VIR_WARN("OOM while encoding audit message");
return;
const char *virt;
virUUIDFormat(vmDef->uuid, uuidstr);
- virMacAddrFormat(netDef->mac, macstr);
+ virMacAddrFormat(&netDef->mac, macstr);
rdev = virDomainAuditGetRdev(device);
if (!(vmname = virAuditEncode("vm", vmDef->name)) ||
}
if (macaddr) {
- if (virMacAddrParse((const char *)macaddr, def->mac) < 0) {
+ if (virMacAddrParse((const char *)macaddr, &def->mac) < 0) {
virDomainReportError(VIR_ERR_XML_ERROR,
_("unable to parse mac address '%s'"),
(const char *)macaddr);
goto error;
}
- if (virMacAddrIsMulticast(def->mac)) {
+ if (virMacAddrIsMulticast(&def->mac)) {
virDomainReportError(VIR_ERR_XML_ERROR,
_("expected unicast mac address, found multicast '%s'"),
(const char *)macaddr);
goto error;
}
} else {
- virCapabilitiesGenerateMac(caps, def->mac);
+ virCapabilitiesGenerateMac(caps, &def->mac);
}
if (devaddr) {
return 0;
}
-int virDomainNetIndexByMac(virDomainDefPtr def, const unsigned char *mac)
+int virDomainNetIndexByMac(virDomainDefPtr def, const virMacAddrPtr mac)
{
int i;
for (i = 0; i < def->nnets; i++)
- if (!memcmp(def->nets[i]->mac, mac, VIR_MAC_BUFLEN))
+ if (!virMacAddrCmp(&def->nets[i]->mac, mac))
return i;
return -1;
}
}
virDomainNetDefPtr
-virDomainNetRemoveByMac(virDomainDefPtr def, const unsigned char *mac)
+virDomainNetRemoveByMac(virDomainDefPtr def, const virMacAddrPtr mac)
{
int i = virDomainNetIndexByMac(def, mac);
{
bool identical = false;
- if (memcmp(src->mac, dst->mac, VIR_MAC_BUFLEN) != 0) {
+ if (virMacAddrCmp(&src->mac, &dst->mac) != 0) {
virDomainReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("Target network card mac %02x:%02x:%02x:%02x:%02x:%02x"
"does not match source %02x:%02x:%02x:%02x:%02x:%02x"),
- dst->mac[0], dst->mac[1], dst->mac[2],
- dst->mac[3], dst->mac[4], dst->mac[5],
- src->mac[0], src->mac[1], src->mac[2],
- src->mac[3], src->mac[4], src->mac[5]);
+ dst->mac.addr[0], dst->mac.addr[1], dst->mac.addr[2],
+ dst->mac.addr[3], dst->mac.addr[4], dst->mac.addr[5],
+ src->mac.addr[0], src->mac.addr[1], src->mac.addr[2],
+ src->mac.addr[3], src->mac.addr[4], src->mac.addr[5]);
goto cleanup;
}
virBufferAsprintf(buf,
" <mac address='%02x:%02x:%02x:%02x:%02x:%02x'/>\n",
- def->mac[0], def->mac[1], def->mac[2],
- def->mac[3], def->mac[4], def->mac[5]);
+ def->mac.addr[0], def->mac.addr[1], def->mac.addr[2],
+ def->mac.addr[3], def->mac.addr[4], def->mac.addr[5]);
switch (def->type) {
case VIR_DOMAIN_NET_TYPE_NETWORK:
{
bool isMac = false;
virDomainNetDefPtr net = NULL;
- unsigned char mac[VIR_MAC_BUFLEN];
+ virMacAddr mac;
int i;
- if (virMacAddrParse(device, mac) == 0)
+ if (virMacAddrParse(device, &mac) == 0)
isMac = true;
if (isMac) {
for (i = 0; i < def->nnets; i++) {
- if (memcmp(mac, def->nets[i]->mac, VIR_MAC_BUFLEN) == 0) {
+ if (virMacAddrCmp(&mac, &def->nets[i]->mac) == 0) {
net = def->nets[i];
break;
}
/* Stores the virtual network interface configuration */
struct _virDomainNetDef {
enum virDomainNetType type;
- unsigned char mac[VIR_MAC_BUFLEN];
+ virMacAddr mac;
char *model;
union {
struct {
virDomainDiskDefPtr
virDomainDiskRemoveByName(virDomainDefPtr def, const char *name);
-int virDomainNetIndexByMac(virDomainDefPtr def, const unsigned char *mac);
+int virDomainNetIndexByMac(virDomainDefPtr def, const virMacAddrPtr mac);
int virDomainNetInsert(virDomainDefPtr def, virDomainNetDefPtr net);
virDomainNetDefPtr
virDomainNetRemove(virDomainDefPtr def, size_t i);
virDomainNetDefPtr
-virDomainNetRemoveByMac(virDomainDefPtr def, const unsigned char *mac);
+virDomainNetRemoveByMac(virDomainDefPtr def, const virMacAddrPtr mac);
int virDomainHostdevInsert(virDomainDefPtr def, virDomainHostdevDefPtr hostdev);
virDomainHostdevDefPtr
} else if (cur->type == XML_ELEMENT_NODE &&
xmlStrEqual(cur->name, BAD_CAST "host")) {
char *mac = NULL, *name = NULL, *ip;
- unsigned char addr[6];
+ virMacAddr addr;
virSocketAddr inaddr;
mac = virXMLPropString(cur, "mac");
if (mac != NULL) {
- if (virMacAddrParse(mac, &addr[0]) < 0) {
+ if (virMacAddrParse(mac, &addr) < 0) {
virNetworkReportError(VIR_ERR_XML_ERROR,
_("Cannot parse MAC address '%s' in network '%s'"),
mac, networkName);
VIR_FREE(mac);
return -1;
}
- if (virMacAddrIsMulticast(addr)) {
+ if (virMacAddrIsMulticast(&addr)) {
virNetworkReportError(VIR_ERR_XML_ERROR,
_("expected unicast mac address, found multicast '%s' in network '%s'"),
(const char *)mac, networkName);
tmp = virXPathString("string(./mac[1]/@address)", ctxt);
if (tmp) {
- if (virMacAddrParse(tmp, def->mac) < 0) {
+ if (virMacAddrParse(tmp, &def->mac) < 0) {
virNetworkReportError(VIR_ERR_XML_ERROR,
_("Invalid bridge mac address '%s' in network '%s'"),
tmp, def->name);
VIR_FREE(tmp);
goto error;
}
- if (virMacAddrIsMulticast(def->mac)) {
+ if (virMacAddrIsMulticast(&def->mac)) {
virNetworkReportError(VIR_ERR_XML_ERROR,
_("Invalid multicast bridge mac address '%s' in network '%s'"),
tmp, def->name);
if (def->mac_specified) {
char macaddr[VIR_MAC_STRING_BUFLEN];
- virMacAddrFormat(def->mac, macaddr);
+ virMacAddrFormat(&def->mac, macaddr);
virBufferAsprintf(&buf, " <mac address='%s'/>\n", macaddr);
}
* autogenerate a random one.
*/
virMacAddrGenerate((unsigned char[]){ 0x52, 0x54, 0 },
- def->mac);
+ &def->mac);
def->mac_specified = true;
}
}
char *domain;
unsigned long delay; /* Bridge forward delay (ms) */
unsigned int stp :1; /* Spanning tree protocol */
- unsigned char mac[VIR_MAC_BUFLEN]; /* mac address of bridge device */
+ virMacAddr mac; /* mac address of bridge device */
bool mac_specified;
int forwardType; /* One of virNetworkForwardType constants */
PROTOCOL_ENTRY_LAST
};
-
-static int
-virNWMACAddressParser(const char *input,
- nwMACAddressPtr output)
-{
- return virMacAddrParse(input, &output->addr[0]);
-}
-
-
static int
virNWFilterRuleDetailsParse(xmlNodePtr node,
virNWFilterRuleDefPtr nwf,
break;
case DATATYPE_MACADDR:
- if (virNWMACAddressParser(prop,
- &item->u.macaddr) < 0) {
+ if (virMacAddrParse(prop,
+ &item->u.macaddr) < 0) {
rc = -1;
}
found = 1;
case DATATYPE_MACMASK:
validator = checkMACMask;
- if (virNWMACAddressParser(prop,
- &item->u.macaddr) < 0) {
+ if (virMacAddrParse(prop,
+ &item->u.macaddr) < 0) {
rc = -1;
}
data.v = &item->u.macaddr;
# include "xml.h"
# include "buf.h"
# include "virsocketaddr.h"
+# include "virmacaddr.h"
/* XXX
* The config parser/structs should not be using platform specific
# define NWFILTER_MAC_BGA "01:80:c2:00:00:00"
-typedef struct _nwMACAddress nwMACAddress;
-typedef nwMACAddress *nwMACAddressPtr;
-struct _nwMACAddress {
- unsigned char addr[6];
-};
-
-
typedef struct _nwItemDesc nwItemDesc;
typedef nwItemDesc *nwItemDescPtr;
struct _nwItemDesc {
virNWFilterVarAccessPtr varAccess;
enum attrDatatype datatype;
union {
- nwMACAddress macaddr;
+ virMacAddr macaddr;
virSocketAddr ipaddr;
bool boolean;
uint8_t u8;
typedef int (*virNWFilterCanApplyBasicRules)(void);
typedef int (*virNWFilterApplyBasicRules)(const char *ifname,
- const unsigned char *macaddr);
+ const virMacAddrPtr macaddr);
typedef int (*virNWFilterApplyDHCPOnlyRules)(const char *ifname,
- const unsigned char *macaddr,
+ const virMacAddrPtr macaddr,
virNWFilterVarValuePtr dhcpsrvs,
bool leaveTemporary);
# include "virhash.h"
# include "buf.h"
+# include "virmacaddr.h"
enum virNWFilterVarValueType {
NWFILTER_VALUE_TYPE_SIMPLE,
# virmacaddr.h
+virMacAddrCmp;
+virMacAddrCmpRaw;
virMacAddrCompare;
virMacAddrFormat;
virMacAddrGenerate;
+virMacAddrGetRaw;
virMacAddrIsMulticast;
virMacAddrIsUnicast;
virMacAddrParse;
+virMacAddrSet;
+virMacAddrSetRaw;
# virnetclient.h
//x_nics[i].mtu = 1492;
x_nic->domid = def->id;
- memcpy(x_nic->mac, l_nic->mac, sizeof(libxl_mac));
+ virMacAddrGetRaw(&l_nic->mac, x_nic->mac);
if (l_nic->model && !STREQ(l_nic->model, "netfront")) {
if ((x_nic->model = strdup(l_nic->model)) == NULL) {
(*veths)[(*nveths)] = containerVeth;
(*nveths)++;
- if (virNetDevSetMAC(containerVeth, net->mac) < 0)
+ if (virNetDevSetMAC(containerVeth, &net->mac) < 0)
goto cleanup;
if (vport && vport->virtPortType == VIR_NETDEV_VPORT_PROFILE_OPENVSWITCH)
- ret = virNetDevOpenvswitchAddPort(brname, parentVeth, net->mac,
+ ret = virNetDevOpenvswitchAddPort(brname, parentVeth, &net->mac,
vm->uuid, vport);
else
ret = virNetDevBridgeAddPort(brname, parentVeth);
(*veths)[(*nveths)] = NULL;
if (virNetDevMacVLanCreateWithVPortProfile(
- net->ifname, net->mac,
+ net->ifname, &net->mac,
virDomainNetGetActualDirectDev(net),
virDomainNetGetActualDirectMode(net),
false, false, def->uuid,
goto err0;
}
if (virNetDevTapCreateInBridgePort(network->def->bridge,
- &macTapIfName, network->def->mac,
+ &macTapIfName, &network->def->mac,
NULL, NULL, NULL,
VIR_NETDEV_TAP_CREATE_USE_MAC_FOR_BRIDGE) < 0) {
VIR_FREE(macTapIfName);
req->ifindex,
req->linkdev,
req->nettype,
- req->macaddr,
+ &req->macaddr,
req->filtername,
req->vars,
req->driver);
req->ifindex,
req->linkdev,
req->nettype,
- req->macaddr,
+ &req->macaddr,
req->filtername,
req->vars,
req->driver);
virHashLookup(req->vars->hashTable, NWFILTER_VARNAME_DHCPSERVER);
if (req->techdriver &&
- req->techdriver->applyDHCPOnlyRules(req->ifname, req->macaddr,
+ req->techdriver->applyDHCPOnlyRules(req->ifname, &req->macaddr,
dhcpsrvrs, false) < 0) {
virNWFilterReportError(VIR_ERR_INTERNAL_ERROR,
_("virNWFilterSnoopListDel failed"));
char macaddr[VIR_MAC_STRING_BUFLEN];
const char *ext;
- virMacAddrFormat((unsigned char *)mac, macaddr);
+ virMacAddrFormat(mac, macaddr);
if (dir == PCAP_D_IN /* from VM */) {
/*
static void
virNWFilterSnoopIFKeyFMT(char *ifkey, const unsigned char *vmuuid,
- unsigned const char *macaddr)
+ const virMacAddrPtr macaddr)
{
virUUIDFormat(vmuuid, ifkey);
ifkey[VIR_UUID_STRING_BUFLEN - 1] = '-';
const char *linkdev,
enum virDomainNetType nettype,
const unsigned char *vmuuid,
- const unsigned char *macaddr,
+ const virMacAddrPtr macaddr,
const char *filtername,
virNWFilterHashTablePtr filterparams,
virNWFilterDriverStatePtr driver)
req->linkdev = linkdev ? strdup(linkdev) : NULL;
req->nettype = nettype;
req->ifname = strdup(ifname);
- memcpy(req->macaddr, macaddr, sizeof(req->macaddr));
+ virMacAddrSet(&req->macaddr, macaddr);
req->filtername = strdup(filtername);
req->vars = virNWFilterHashTableCreate(0);
dhcpsrvrs = virHashLookup(filterparams->hashTable,
NWFILTER_VARNAME_DHCPSERVER);
- if (techdriver->applyDHCPOnlyRules(req->ifname, req->macaddr,
+ if (techdriver->applyDHCPOnlyRules(req->ifname, &req->macaddr,
dhcpsrvrs, false) < 0) {
virNWFilterReportError(VIR_ERR_INTERNAL_ERROR, _("applyDHCPOnlyRules "
"failed - spoofing not protected!"));
const char *linkdev,
enum virDomainNetType nettype,
const unsigned char *vmuuid,
- const unsigned char *macaddr,
+ const virMacAddrPtr macaddr,
const char *filtername,
virNWFilterHashTablePtr filterparams,
virNWFilterDriverStatePtr driver);
return -1;
}
- virMacAddrFormat(item->u.macaddr.addr, buf);
+ virMacAddrFormat(&item->u.macaddr, buf);
break;
case DATATYPE_IPV6MASK:
*/
static int
ebtablesApplyBasicRules(const char *ifname,
- const unsigned char *macaddr)
+ const virMacAddrPtr macaddr)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
char chain[MAX_CHAINNAME_LENGTH];
*/
static int
ebtablesApplyDHCPOnlyRules(const char *ifname,
- const unsigned char *macaddr,
+ const virMacAddrPtr macaddr,
virNWFilterVarValuePtr dhcpsrvrs,
bool leaveTemporary)
{
virNWFilterHashTablePtr vars,
enum instCase useNewFilter, bool *foundNewFilter,
bool teardownOld,
- const unsigned char *macaddr,
+ const virMacAddrPtr macaddr,
virNWFilterDriverStatePtr driver,
bool forceWithPendingReq)
{
int ifindex,
const char *linkdev,
enum virDomainNetType nettype,
- const unsigned char *macaddr,
+ const virMacAddrPtr macaddr,
const char *filtername,
virNWFilterHashTablePtr filterparams,
enum instCase useNewFilter,
ifindex,
linkdev,
net->type,
- net->mac,
+ &net->mac,
net->filter,
net->filterparams,
useNewFilter,
int ifindex,
const char *linkdev,
enum virDomainNetType nettype,
- const unsigned char *macaddr,
+ const virMacAddrPtr macaddr,
const char *filtername,
virNWFilterHashTablePtr filterparams,
virNWFilterDriverStatePtr driver)
int ifindex,
const char *linkdev,
enum virDomainNetType nettype,
- const unsigned char *macaddr,
+ const virMacAddrPtr macaddr,
const char *filtername,
virNWFilterHashTablePtr filterparams,
virNWFilterDriverStatePtr driver);
goto done;
}
- virMacAddrFormat(req->macaddr, macaddr);
+ virMacAddrFormat(&req->macaddr, macaddr);
switch (req->howDetect) {
case DETECT_DHCP:
if (techdriver->applyDHCPOnlyRules(req->ifname,
- req->macaddr,
+ &req->macaddr,
NULL, false) < 0) {
req->status = EINVAL;
goto done;
break;
default:
if (techdriver->applyBasicRules(req->ifname,
- req->macaddr) < 0) {
+ &req->macaddr) < 0) {
req->status = EINVAL;
goto done;
}
continue;
}
- if (memcmp(ether_hdr->ether_shost,
- req->macaddr,
- VIR_MAC_BUFLEN) == 0) {
+ if (virMacAddrCmpRaw(&req->macaddr, ether_hdr->ether_shost) == 0) {
/* packets from the VM */
if (etherType == ETHERTYPE_IP &&
break;
}
}
- } else if (memcmp(ether_hdr->ether_dhost,
- req->macaddr,
- VIR_MAC_BUFLEN) == 0) {
+ } else if (virMacAddrCmpRaw(&req->macaddr,
+ ether_hdr->ether_dhost) == 0) {
/* packets to the VM */
if (etherType == ETHERTYPE_IP &&
(header.len >= ethHdrSize +
struct dhcp *dhcp = (struct dhcp *)
((char *)udphdr + sizeof(udphdr));
if (dhcp->op == 2 /* BOOTREPLY */ &&
- !memcmp(&dhcp->chaddr[0],
- req->macaddr,
- 6)) {
+ virMacAddrCmpRaw(
+ &req->macaddr,
+ &dhcp->chaddr[0]) == 0) {
dhcp_opts_len = header.len -
(ethHdrSize + iphdr->ihl * 4 +
sizeof(struct udphdr) +
req->ifindex,
req->linkdev,
req->nettype,
- req->macaddr,
+ &req->macaddr,
req->filtername,
req->filterparams,
req->driver);
int ifindex,
const char *linkdev,
enum virDomainNetType nettype,
- const unsigned char *macaddr,
+ const virMacAddrPtr macaddr,
const char *filtername,
virNWFilterHashTablePtr filterparams,
virNWFilterDriverStatePtr driver,
req->ifindex = ifindex;
req->nettype = nettype;
- memcpy(req->macaddr, macaddr, sizeof(req->macaddr));
+ virMacAddrSet(&req->macaddr, macaddr);
req->driver = driver;
req->filterparams = ht;
ht = NULL;
int ifindex ATTRIBUTE_UNUSED,
const char *linkdev ATTRIBUTE_UNUSED,
enum virDomainNetType nettype ATTRIBUTE_UNUSED,
- const unsigned char *macaddr ATTRIBUTE_UNUSED,
+ const virMacAddrPtr macaddr ATTRIBUTE_UNUSED,
const char *filtername ATTRIBUTE_UNUSED,
virNWFilterHashTablePtr filterparams ATTRIBUTE_UNUSED,
virNWFilterDriverStatePtr driver ATTRIBUTE_UNUSED,
int ifindex;
char linkdev[IF_NAMESIZE];
enum virDomainNetType nettype;
- unsigned char macaddr[VIR_MAC_BUFLEN];
+ virMacAddr macaddr;
char *filtername;
virNWFilterHashTablePtr filterparams;
virNWFilterDriverStatePtr driver;
int ifindex,
const char *linkdev,
enum virDomainNetType nettype,
- const unsigned char *macaddr,
+ const virMacAddrPtr macaddr,
const char *filtername,
virNWFilterHashTablePtr filterparams,
virNWFilterDriverStatePtr driver,
_("MAC address %s too long for destination"), p);
goto error;
}
- if (virMacAddrParse(cpy_temp, net->mac) < 0) {
+ if (virMacAddrParse(cpy_temp, &net->mac) < 0) {
openvzError(VIR_ERR_INTERNAL_ERROR, "%s",
_("Wrong MAC address"));
goto error;
int rc = 0, narg;
const char *prog[OPENVZ_MAX_ARG];
char macaddr[VIR_MAC_STRING_BUFLEN];
- unsigned char host_mac[VIR_MAC_BUFLEN];
+ virMacAddr host_mac;
char host_macaddr[VIR_MAC_STRING_BUFLEN];
struct openvz_driver *driver = conn->privateData;
char *opt = NULL;
ADD_ARG_LIT(vpsid);
}
- virMacAddrFormat(net->mac, macaddr);
- virCapabilitiesGenerateMac(driver->caps, host_mac);
- virMacAddrFormat(host_mac, host_macaddr);
+ virMacAddrFormat(&net->mac, macaddr);
+ virCapabilitiesGenerateMac(driver->caps, &host_mac);
+ virMacAddrFormat(&host_mac, host_macaddr);
if (net->type == VIR_DOMAIN_NET_TYPE_BRIDGE ||
(net->type == VIR_DOMAIN_NET_TYPE_ETHERNET &&
int
networkAllowMacOnPort(struct qemud_driver *driver,
const char * ifname,
- const unsigned char * mac) {
+ const virMacAddrPtr mac) {
int err;
int
networkDisallowMacOnPort(struct qemud_driver *driver,
const char * ifname,
- const unsigned char * mac) {
+ const virMacAddrPtr mac) {
int err;
int networkAllowMacOnPort(struct qemud_driver *driver,
const char * ifname,
- const unsigned char * mac);
+ const virMacAddrPtr mac);
int networkDisallowMacOnPort(struct qemud_driver *driver,
const char * ifname,
- const unsigned char * mac);
+ const virMacAddrPtr mac);
int networkDisableAllFrames(struct qemud_driver *driver);
int networkAddEbtablesRules(struct qemud_driver *driver);
vnet_hdr = 1;
rc = virNetDevMacVLanCreateWithVPortProfile(
- net->ifname, net->mac,
+ net->ifname, &net->mac,
virDomainNetGetActualDirectDev(net),
virDomainNetGetActualDirectMode(net),
true, vnet_hdr, def->uuid,
tap_create_flags |= VIR_NETDEV_TAP_CREATE_VNET_HDR;
}
- err = virNetDevTapCreateInBridgePort(brname, &net->ifname, net->mac,
+ err = virNetDevTapCreateInBridgePort(brname, &net->ifname, &net->mac,
def->uuid, &tapfd,
virDomainNetGetActualVirtPortProfile(net),
tap_create_flags);
}
if (driver->macFilter) {
- if ((err = networkAllowMacOnPort(driver, net->ifname, net->mac))) {
+ if ((err = networkAllowMacOnPort(driver, net->ifname, &net->mac))) {
virReportSystemError(err,
_("failed to add ebtables rule to allow MAC address on '%s'"),
net->ifname);
if (virAsprintf(&str,
"%smacaddr=%02x:%02x:%02x:%02x:%02x:%02x,vlan=%d%s%s%s%s",
prefix ? prefix : "",
- net->mac[0], net->mac[1],
- net->mac[2], net->mac[3],
- net->mac[4], net->mac[5],
+ net->mac.addr[0], net->mac.addr[1],
+ net->mac.addr[2], net->mac.addr[3],
+ net->mac.addr[4], net->mac.addr[5],
vlan,
(net->model ? ",model=" : ""),
(net->model ? net->model : ""),
virBufferAsprintf(&buf, ",vlan=%d", vlan);
virBufferAsprintf(&buf, ",id=%s", net->info.alias);
virBufferAsprintf(&buf, ",mac=%02x:%02x:%02x:%02x:%02x:%02x",
- net->mac[0], net->mac[1],
- net->mac[2], net->mac[3],
- net->mac[4], net->mac[5]);
+ net->mac.addr[0], net->mac.addr[1],
+ net->mac.addr[2], net->mac.addr[3],
+ net->mac.addr[4], net->mac.addr[5]);
if (qemuBuildDeviceAddressStr(&buf, &net->info, qemuCaps) < 0)
goto error;
if (qemuBuildRomStr(&buf, &net->info, qemuCaps) < 0)
for (i = 0 ; i < nkeywords ; i++) {
if (STREQ(keywords[i], "macaddr")) {
genmac = 0;
- if (virMacAddrParse(values[i], def->mac) < 0) {
+ if (virMacAddrParse(values[i], &def->mac) < 0) {
qemuReportError(VIR_ERR_INTERNAL_ERROR,
_("unable to parse mac address '%s'"),
values[i]);
}
if (genmac)
- virCapabilitiesGenerateMac(caps, def->mac);
+ virCapabilitiesGenerateMac(caps, &def->mac);
cleanup:
for (i = 0 ; i < nkeywords ; i++) {
VIR_DEBUG("VEPA mode device %s active in domain %s. Reassociating.",
net->ifname, def->name);
ignore_value(virNetDevMacVLanRestartWithVPortProfile(net->ifname,
- net->mac,
+ &net->mac,
virDomainNetGetActualDirectDev(net),
def->uuid,
virDomainNetGetActualVirtPortProfile(net),
case VIR_DOMAIN_DEVICE_NET:
net = dev->data.net;
- if (virDomainNetIndexByMac(vmdef, net->mac) >= 0) {
+ if (virDomainNetIndexByMac(vmdef, &net->mac) >= 0) {
char macbuf[VIR_MAC_STRING_BUFLEN];
- virMacAddrFormat(net->mac, macbuf);
+
+ virMacAddrFormat(&net->mac, macbuf);
qemuReportError(VIR_ERR_INVALID_ARG,
_("mac %s already exists"), macbuf);
return -1;
case VIR_DOMAIN_DEVICE_NET:
net = dev->data.net;
- if (!(det_net = virDomainNetRemoveByMac(vmdef, net->mac))) {
+ if (!(det_net = virDomainNetRemoveByMac(vmdef, &net->mac))) {
char macbuf[VIR_MAC_STRING_BUFLEN];
- virMacAddrFormat(net->mac, macbuf);
+ virMacAddrFormat(&net->mac, macbuf);
qemuReportError(VIR_ERR_INVALID_ARG,
_("no nic of mac %s"), macbuf);
return -1;
case VIR_DOMAIN_DEVICE_NET:
net = dev->data.net;
- if ((pos = virDomainNetIndexByMac(vmdef, net->mac)) < 0) {
+ if ((pos = virDomainNetIndexByMac(vmdef, &net->mac)) < 0) {
char macbuf[VIR_MAC_STRING_BUFLEN];
- virMacAddrFormat(net->mac, macbuf);
+
+ virMacAddrFormat(&net->mac, macbuf);
qemuReportError(VIR_ERR_INVALID_ARG,
_("mac %s doesn't exist"), macbuf);
return -1;
static int
qemuDomainHostdevNetConfigVirtPortProfile(const char *linkdev, int vf,
virNetDevVPortProfilePtr virtPort,
- const unsigned char *macaddr,
+ const virMacAddrPtr macaddr,
const unsigned char *uuid,
int associate)
{
hostdev->parent.data.net);
if (virtPort)
ret = qemuDomainHostdevNetConfigVirtPortProfile(linkdev, vf,
- virtPort, hostdev->parent.data.net->mac, uuid,
+ virtPort, &hostdev->parent.data.net->mac, uuid,
port_profile_associate);
else
/* Set only mac */
ret = virNetDevReplaceNetConfig(linkdev, vf,
- hostdev->parent.data.net->mac, vlanid,
+ &hostdev->parent.data.net->mac, vlanid,
stateDir);
VIR_FREE(linkdev);
hostdev->parent.data.net);
if (virtPort)
ret = qemuDomainHostdevNetConfigVirtPortProfile(linkdev, vf, virtPort,
- hostdev->parent.data.net->mac, NULL,
+ &hostdev->parent.data.net->mac, NULL,
port_profile_associate);
else
ret = virNetDevRestoreNetConfig(linkdev, vf, stateDir);
int i;
for (i = 0; i < vm->def->nnets; i++) {
- if (memcmp(vm->def->nets[i]->mac, dev->mac, VIR_MAC_BUFLEN) == 0)
+ if (virMacAddrCmp(&vm->def->nets[i]->mac, &dev->mac) == 0)
return vm->def->nets[i];
}
for (i = 0 ; i < vm->def->nnets ; i++) {
virDomainNetDefPtr net = vm->def->nets[i];
- if (!memcmp(net->mac, dev->data.net->mac, sizeof(net->mac))) {
+ if (!virMacAddrCmp(&net->mac, &dev->data.net->mac)) {
detach = net;
break;
}
if (!detach) {
qemuReportError(VIR_ERR_OPERATION_FAILED,
_("network device %02x:%02x:%02x:%02x:%02x:%02x not found"),
- dev->data.net->mac[0], dev->data.net->mac[1],
- dev->data.net->mac[2], dev->data.net->mac[3],
- dev->data.net->mac[4], dev->data.net->mac[5]);
+ dev->data.net->mac.addr[0], dev->data.net->mac.addr[1],
+ dev->data.net->mac.addr[2], dev->data.net->mac.addr[3],
+ dev->data.net->mac.addr[4], dev->data.net->mac.addr[5]);
goto cleanup;
}
if (virDomainNetGetActualType(detach) == VIR_DOMAIN_NET_TYPE_DIRECT) {
ignore_value(virNetDevMacVLanDeleteWithVPortProfile(
- detach->ifname, detach->mac,
+ detach->ifname, &detach->mac,
virDomainNetGetActualDirectDev(detach),
virDomainNetGetActualDirectMode(detach),
virDomainNetGetActualVirtPortProfile(detach),
if ((driver->macFilter) && (detach->ifname != NULL)) {
if ((errno = networkDisallowMacOnPort(driver,
detach->ifname,
- detach->mac))) {
+ &detach->mac))) {
virReportSystemError(errno,
_("failed to remove ebtables rule on '%s'"),
detach->ifname);
if (virDomainNetGetActualType(net) == VIR_DOMAIN_NET_TYPE_DIRECT) {
if (virNetDevVPortProfileAssociate(net->ifname,
virDomainNetGetActualVirtPortProfile(net),
- net->mac,
+ &net->mac,
virDomainNetGetActualDirectDev(net),
-1,
def->uuid,
}
VIR_DEBUG("Port profile Associate succeeded for %s", net->ifname);
- if (virNetDevMacVLanVPortProfileRegisterCallback(net->ifname, net->mac,
+ if (virNetDevMacVLanVPortProfileRegisterCallback(net->ifname, &net->mac,
virDomainNetGetActualDirectDev(net), def->uuid,
virDomainNetGetActualVirtPortProfile(net),
VIR_NETDEV_VPORT_PROFILE_OP_CREATE))
if (virDomainNetGetActualType(net) == VIR_DOMAIN_NET_TYPE_DIRECT) {
ignore_value(virNetDevVPortProfileDisassociate(net->ifname,
virDomainNetGetActualVirtPortProfile(net),
- net->mac,
+ &net->mac,
virDomainNetGetActualDirectDev(net),
-1,
VIR_NETDEV_VPORT_PROFILE_OP_MIGRATE_IN_FINISH));
if (net->ifname == NULL)
continue;
if ((errno = networkDisallowMacOnPort(driver, net->ifname,
- net->mac))) {
+ &net->mac))) {
virReportSystemError(errno,
_("failed to remove ebtables rule to allow MAC address on '%s'"),
net->ifname);
virDomainNetDefPtr net = def->nets[i];
if (virDomainNetGetActualType(net) == VIR_DOMAIN_NET_TYPE_DIRECT) {
ignore_value(virNetDevMacVLanDeleteWithVPortProfile(
- net->ifname, net->mac,
+ net->ifname, &net->mac,
virDomainNetGetActualDirectDev(net),
virDomainNetGetActualDirectMode(net),
virDomainNetGetActualVirtPortProfile(net),
template_ifname = true;
}
- if (virNetDevTapCreateInBridgePort(bridge, &net->ifname, net->mac,
+ if (virNetDevTapCreateInBridgePort(bridge, &net->ifname, &net->mac,
vm->uuid, NULL,
virDomainNetGetActualVirtPortProfile(net),
VIR_NETDEV_TAP_CREATE_IFUP) < 0) {
}
virBufferAsprintf(&buf, ",%02x:%02x:%02x:%02x:%02x:%02x",
- def->mac[0], def->mac[1], def->mac[2],
- def->mac[3], def->mac[4], def->mac[5]);
+ def->mac.addr[0], def->mac.addr[1], def->mac.addr[2],
+ def->mac.addr[3], def->mac.addr[4], def->mac.addr[5]);
if (def->type == VIR_DOMAIN_NET_TYPE_MCAST) {
virBufferAsprintf(&buf, ",%s,%d",
int
ebtablesAddForwardAllowIn(ebtablesContext *ctx,
const char *iface,
- const unsigned char *mac)
+ const virMacAddrPtr mac)
{
char *macaddr;
if (virAsprintf(&macaddr,
"%02x:%02x:%02x:%02x:%02x:%02x",
- mac[0], mac[1],
- mac[2], mac[3],
- mac[4], mac[5]) < 0) {
+ mac->addr[0], mac->addr[1],
+ mac->addr[2], mac->addr[3],
+ mac->addr[4], mac->addr[5]) < 0) {
return -1;
}
return ebtablesForwardAllowIn(ctx, iface, macaddr, ADD);
int
ebtablesRemoveForwardAllowIn(ebtablesContext *ctx,
const char *iface,
- const unsigned char *mac)
+ const virMacAddrPtr mac)
{
char *macaddr;
if (virAsprintf(&macaddr,
"%02x:%02x:%02x:%02x:%02x:%02x",
- mac[0], mac[1],
- mac[2], mac[3],
- mac[4], mac[5]) < 0) {
+ mac->addr[0], mac->addr[1],
+ mac->addr[2], mac->addr[3],
+ mac->addr[4], mac->addr[5]) < 0) {
return -1;
}
return ebtablesForwardAllowIn(ctx, iface, macaddr, REMOVE);
#ifndef __QEMUD_EBTABLES_H__
# define __QEMUD_EBTABLES_H__
+# include "virmacaddr.h"
+
typedef struct
{
char *rule;
int ebtablesAddForwardAllowIn (ebtablesContext *ctx,
const char *iface,
- const unsigned char *mac);
+ const virMacAddrPtr mac);
int ebtablesRemoveForwardAllowIn (ebtablesContext *ctx,
const char *iface,
- const unsigned char *mac);
+ const virMacAddrPtr mac);
int ebtablesAddForwardPolicyReject(ebtablesContext *ctx);
return c > d ? 1 : c < d ? -1 : 0;
}
+/**
+ * virMacAddrCmp:
+ * @mac1: pointer to 1st MAC address
+ * @mac2: pointer to 2nd MAC address
+ *
+ * Return 0 if MAC addresses are equal,
+ * < 0 if mac1 < mac2,
+ * > 0 if mac1 > mac2
+ */
+int
+virMacAddrCmp(const virMacAddrPtr mac1, const virMacAddrPtr mac2)
+{
+ return memcmp(mac1->addr, mac2->addr, VIR_MAC_BUFLEN);
+}
+
+/**
+ * virMacAddrCmpRaw:
+ * @mac1: pointer to 1st MAC address
+ * @mac2: pointer to 2nd MAC address in plain buffer
+ *
+ * Return 0 if MAC addresses are equal,
+ * < 0 if mac1 < mac2,
+ * > 0 if mac1 > mac2
+ */
+int
+virMacAddrCmpRaw(const virMacAddrPtr mac1,
+ const unsigned char mac2[VIR_MAC_BUFLEN])
+{
+ return memcmp(mac1->addr, mac2, VIR_MAC_BUFLEN);
+}
+
+/**
+ * virMacAddrSet
+ * @dst: pointer to destination
+ * @src: pointer to source
+ *
+ * Copy src to dst
+ */
+void
+virMacAddrSet(virMacAddrPtr dst, const virMacAddrPtr src)
+{
+ memcpy(dst, src, sizeof(*src));
+}
+
+/**
+ * virMacAddrSetRaw
+ * @dst: pointer to destination to hold MAC address
+ * @src: raw MAC address data
+ *
+ * Set the MAC address to the given value
+ */
+void
+virMacAddrSetRaw(virMacAddrPtr dst, const unsigned char src[VIR_MAC_BUFLEN])
+{
+ memcpy(dst->addr, src, VIR_MAC_BUFLEN);
+}
+
+/**
+ * virMacAddrGetRaw
+ * @src: pointer to MAC address
+ * @dst: pointer to raw memory to write MAC address into
+ *
+ * Copies the MAC address into raw memory
+ */
+void
+virMacAddrGetRaw(virMacAddrPtr src, unsigned char dst[VIR_MAC_BUFLEN])
+{
+ memcpy(dst, src->addr, VIR_MAC_BUFLEN);
+}
+
/**
* virMacAddrParse:
* @str: string representation of MAC address, e.g., "0:1E:FC:E:3a:CB"
* Return 0 upon success, or -1 in case of error.
*/
int
-virMacAddrParse(const char* str, unsigned char *addr)
+virMacAddrParse(const char* str, virMacAddrPtr addr)
{
int i;
(0xFF < result))
break;
- addr[i] = (unsigned char) result;
+ addr->addr[i] = (unsigned char) result;
if ((i == 5) && (*end_ptr == '\0'))
return 0;
return -1;
}
-void virMacAddrFormat(const unsigned char *addr,
+void virMacAddrFormat(const virMacAddrPtr addr,
char *str)
{
snprintf(str, VIR_MAC_STRING_BUFLEN,
"%02X:%02X:%02X:%02X:%02X:%02X",
- addr[0], addr[1], addr[2],
- addr[3], addr[4], addr[5]);
+ addr->addr[0], addr->addr[1], addr->addr[2],
+ addr->addr[3], addr->addr[4], addr->addr[5]);
str[VIR_MAC_STRING_BUFLEN-1] = '\0';
}
-void virMacAddrGenerate(const unsigned char *prefix,
- unsigned char *addr)
+void virMacAddrGenerate(const unsigned char prefix[VIR_MAC_PREFIX_BUFLEN],
+ virMacAddrPtr addr)
{
- addr[0] = prefix[0];
- addr[1] = prefix[1];
- addr[2] = prefix[2];
- addr[3] = virRandomBits(8);
- addr[4] = virRandomBits(8);
- addr[5] = virRandomBits(8);
+ addr->addr[0] = prefix[0];
+ addr->addr[1] = prefix[1];
+ addr->addr[2] = prefix[2];
+ addr->addr[3] = virRandomBits(8);
+ addr->addr[4] = virRandomBits(8);
+ addr->addr[5] = virRandomBits(8);
}
/* The low order bit of the first byte is the "multicast" bit. */
bool
-virMacAddrIsMulticast(const unsigned char *addr)
+virMacAddrIsMulticast(const virMacAddrPtr mac)
{
- return !!(addr[0] & 1);
+ return !!(mac->addr[0] & 1);
}
bool
-virMacAddrIsUnicast(const unsigned char *addr)
+virMacAddrIsUnicast(const virMacAddrPtr mac)
{
- return !(addr[0] & 1);
+ return !(mac->addr[0] & 1);
}
# define VIR_MAC_PREFIX_BUFLEN 3
# define VIR_MAC_STRING_BUFLEN (VIR_MAC_BUFLEN * 3)
-typedef unsigned char virMacAddr[VIR_MAC_BUFLEN];
+typedef struct _virMacAddr virMacAddr;
+typedef virMacAddr *virMacAddrPtr;
+
+struct _virMacAddr {
+ unsigned char addr[VIR_MAC_BUFLEN];
+};
int virMacAddrCompare(const char *mac1, const char *mac2);
-void virMacAddrFormat(const unsigned char *addr,
+int virMacAddrCmp(const virMacAddrPtr mac1, const virMacAddrPtr mac2);
+int virMacAddrCmpRaw(const virMacAddrPtr mac1,
+ const unsigned char s[VIR_MAC_BUFLEN]);
+void virMacAddrSet(virMacAddrPtr dst, const virMacAddrPtr src);
+void virMacAddrSetRaw(virMacAddrPtr dst, const unsigned char s[VIR_MAC_BUFLEN]);
+void virMacAddrGetRaw(virMacAddrPtr src, unsigned char dst[VIR_MAC_BUFLEN]);
+void virMacAddrFormat(const virMacAddrPtr addr,
char *str);
-void virMacAddrGenerate(const unsigned char *prefix,
- unsigned char *addr);
+void virMacAddrGenerate(const unsigned char prefix[VIR_MAC_PREFIX_BUFLEN],
+ virMacAddrPtr addr);
int virMacAddrParse(const char* str,
- unsigned char *addr) ATTRIBUTE_RETURN_CHECK;
-bool virMacAddrIsUnicast(const unsigned char *addr);
-bool virMacAddrIsMulticast(const unsigned char *addr);
+ virMacAddrPtr addr) ATTRIBUTE_RETURN_CHECK;
+bool virMacAddrIsUnicast(const virMacAddrPtr addr);
+bool virMacAddrIsMulticast(const virMacAddrPtr addr);
#endif /* __VIR_MACADDR_H__ */
/**
* virNetDevSetMAC:
* @ifname: interface name to set MTU for
- * @macaddr: MAC address (VIR_MAC_BUFLEN in size)
+ * @macaddr: MAC address
*
* 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 -1 on failure
*/
int virNetDevSetMAC(const char *ifname,
- const unsigned char *macaddr)
+ const virMacAddrPtr macaddr)
{
int fd = -1;
int ret = -1;
goto cleanup;
}
- memcpy(ifr.ifr_hwaddr.sa_data, macaddr, VIR_MAC_BUFLEN);
+ virMacAddrGetRaw(macaddr, (unsigned char *)ifr.ifr_hwaddr.sa_data);
if (ioctl(fd, SIOCSIFHWADDR, &ifr) < 0) {
virReportSystemError(errno,
}
#else
int virNetDevSetMAC(const char *ifname,
- const unsigned char *macaddr ATTRIBUTE_UNUSED)
+ const virMacAddrPtr macaddr ATTRIBUTE_UNUSED)
{
virReportSystemError(ENOSYS,
_("Cannot set interface MAC on '%s'"),
/**
* virNetDevGetMAC:
* @ifname: interface name to set MTU for
- * @macaddr: MAC address (VIR_MAC_BUFLEN in size)
+ * @macaddr: MAC address
*
* This function gets the @macaddr for a given interface @ifname.
*
* Returns 0 in case of success or -1 on failure
*/
int virNetDevGetMAC(const char *ifname,
- unsigned char *macaddr)
+ virMacAddrPtr macaddr)
{
int fd = -1;
int ret = -1;
goto cleanup;
}
- memcpy(macaddr, ifr.ifr_hwaddr.sa_data, VIR_MAC_BUFLEN);
+ virMacAddrSetRaw(macaddr, (unsigned char *)ifr.ifr_hwaddr.sa_data);
ret = 0;
}
#else
int virNetDevGetMAC(const char *ifname,
- unsigned char *macaddr ATTRIBUTE_UNUSED)
+ virMacAddrPtr macaddr ATTRIBUTE_UNUSED)
{
virReportSystemError(ENOSYS,
_("Cannot get interface MAC on '%s'"),
*/
int
virNetDevReplaceMacAddress(const char *linkdev,
- const unsigned char *macaddress,
+ const virMacAddrPtr macaddress,
const char *stateDir)
{
- unsigned char oldmac[6];
+ virMacAddr oldmac;
char *path = NULL;
char macstr[VIR_MAC_STRING_BUFLEN];
- if (virNetDevGetMAC(linkdev, oldmac) < 0)
+ if (virNetDevGetMAC(linkdev, &oldmac) < 0)
return -1;
virReportOOMError();
return -1;
}
- virMacAddrFormat(oldmac, macstr);
+ virMacAddrFormat(&oldmac, macstr);
if (virFileWriteStr(path, macstr, O_CREAT|O_TRUNC|O_WRONLY) < 0) {
virReportSystemError(errno, _("Unable to preserve mac for %s"),
linkdev);
char *oldmacname = NULL;
char *macstr = NULL;
char *path = NULL;
- unsigned char oldmac[6];
+ virMacAddr oldmac;
if (virAsprintf(&path, "%s/%s",
stateDir,
if (virFileReadAll(path, VIR_MAC_STRING_BUFLEN, &macstr) < 0)
return -1;
- if (virMacAddrParse(macstr, &oldmac[0]) != 0) {
+ if (virMacAddrParse(macstr, &oldmac) != 0) {
virNetDevError(VIR_ERR_INTERNAL_ERROR,
_("Cannot parse MAC address from '%s'"),
oldmacname);
}
/*reset mac and remove file-ignore results*/
- rc = virNetDevSetMAC(linkdev, oldmac);
+ rc = virNetDevSetMAC(linkdev, &oldmac);
ignore_value(unlink(path));
VIR_FREE(macstr);
*/
#if defined(HAVE_STRUCT_IFREQ)
int virNetDevValidateConfig(const char *ifname,
- const unsigned char *macaddr, int ifindex)
+ const virMacAddrPtr macaddr, int ifindex)
{
int fd = -1;
int ret = -1;
goto cleanup;
}
- if (memcmp(&ifr.ifr_hwaddr.sa_data, macaddr, VIR_MAC_BUFLEN) != 0) {
+ if (virMacAddrCmpRaw(macaddr,
+ (unsigned char *)ifr.ifr_hwaddr.sa_data) != 0) {
ret = 0;
goto cleanup;
}
static int
virNetDevSetVfConfig(const char *ifname, int ifindex, int vf,
- bool nltarget_kernel, const unsigned char *macaddr,
+ bool nltarget_kernel, const virMacAddrPtr macaddr,
int vlanid, uint32_t (*getPidFunc)(void))
{
int rc = -1;
.mac = { 0, },
};
- memcpy(ifla_vf_mac.mac, macaddr, VIR_MAC_BUFLEN);
+ virMacAddrGetRaw(macaddr, ifla_vf_mac.mac);
if (nla_put(nl_msg, IFLA_VF_MAC, sizeof(ifla_vf_mac),
&ifla_vf_mac) < 0)
}
static int
-virNetDevParseVfConfig(struct nlattr **tb, int32_t vf, unsigned char *mac,
+virNetDevParseVfConfig(struct nlattr **tb, int32_t vf, virMacAddrPtr mac,
int *vlanid)
{
const char *msg = NULL;
if (tb[IFLA_VF_MAC]) {
vf_mac = RTA_DATA(tb_vf[IFLA_VF_MAC]);
if (vf_mac && vf_mac->vf == vf) {
- memcpy(mac, vf_mac->mac, VIR_MAC_BUFLEN);
+ virMacAddrSetRaw(mac, vf_mac->mac);
found = 1;
}
}
}
static int
-virNetDevGetVfConfig(const char *ifname, int vf, unsigned char *mac,
+virNetDevGetVfConfig(const char *ifname, int vf, virMacAddrPtr mac,
int *vlanid)
{
int rc = -1;
static int
virNetDevReplaceVfConfig(const char *pflinkdev, int vf,
- const unsigned char *macaddress,
+ const virMacAddrPtr macaddress,
int vlanid,
const char *stateDir)
{
- unsigned char oldmac[6];
+ virMacAddr oldmac;
int oldvlanid = -1;
char *path = NULL;
char macstr[VIR_MAC_STRING_BUFLEN];
int ifindex = -1;
- if (virNetDevGetVfConfig(pflinkdev, vf, oldmac, &oldvlanid) < 0)
+ if (virNetDevGetVfConfig(pflinkdev, vf, &oldmac, &oldvlanid) < 0)
return -1;
if (virAsprintf(&path, "%s/%s_vf%d",
return -1;
}
- virMacAddrFormat(oldmac, macstr);
+ virMacAddrFormat(&oldmac, macstr);
if (virFileWriteStr(path, macstr, O_CREAT|O_TRUNC|O_WRONLY) < 0) {
virReportSystemError(errno, _("Unable to preserve mac for pf = %s,"
" vf = %d"), pflinkdev, vf);
int rc = -1;
char *macstr = NULL;
char *path = NULL;
- unsigned char oldmac[6];
+ virMacAddr oldmac;
int vlanid = -1;
int ifindex = -1;
goto cleanup;
}
- if (virMacAddrParse(macstr, &oldmac[0]) != 0) {
+ if (virMacAddrParse(macstr, &oldmac) != 0) {
virNetDevError(VIR_ERR_INTERNAL_ERROR,
_("Cannot parse MAC address from '%s'"),
macstr);
/*reset mac and remove file-ignore results*/
rc = virNetDevSetVfConfig(pflinkdev, ifindex, vf, true,
- oldmac, vlanid, NULL);
+ &oldmac, vlanid, NULL);
ignore_value(unlink(path));
cleanup:
*/
int
virNetDevReplaceNetConfig(char *linkdev, int vf,
- const unsigned char *macaddress, int vlanid,
+ const virMacAddrPtr macaddress, int vlanid,
char *stateDir)
{
if (vf == -1)
# include "virsocketaddr.h"
# include "virnetlink.h"
+# include "virmacaddr.h"
int virNetDevExists(const char *brname)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_RETURN_CHECK;
int virNetDevSetMAC(const char *ifname,
- const unsigned char *macaddr)
+ const virMacAddrPtr macaddr)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_RETURN_CHECK;
int virNetDevGetMAC(const char *ifname,
- unsigned char *macaddr)
+ virMacAddrPtr macaddr)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_RETURN_CHECK;
int virNetDevReplaceMacAddress(const char *linkdev,
- const unsigned char *macaddress,
+ const virMacAddrPtr macaddress,
const char *stateDir)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3)
ATTRIBUTE_RETURN_CHECK;
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_RETURN_CHECK;
int virNetDevValidateConfig(const char *ifname,
- const unsigned char *macaddr, int ifindex)
+ const virMacAddrPtr macaddr, int ifindex)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_RETURN_CHECK;
int virNetDevIsVirtualFunction(const char *ifname)
ATTRIBUTE_RETURN_CHECK;
int virNetDevReplaceNetConfig(char *linkdev, int vf,
- const unsigned char *macaddress, int vlanid,
+ const virMacAddrPtr macaddress, int vlanid,
char *stateDir)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(3) ATTRIBUTE_NONNULL(5);
int
virNetDevMacVLanCreate(const char *ifname,
const char *type,
- const unsigned char *macaddress,
+ const virMacAddrPtr macaddress,
const char *srcdev,
uint32_t macvlan_mode,
int *retry)
struct virNetlinkCallbackData {
char *cr_ifname;
virNetDevVPortProfilePtr virtPortProfile;
- unsigned char macaddress[VIR_MAC_BUFLEN];
+ virMacAddr macaddress;
char *linkdev;
int vf;
unsigned char vmuuid[VIR_UUID_BUFLEN];
VIR_DEBUG("IFLA_VF_MAC = %2x:%2x:%2x:%2x:%2x:%2x",
m[0], m[1], m[2], m[3], m[4], m[5]);
- if (memcmp(calld->macaddress, m, VIR_MAC_BUFLEN))
+ if (virMacAddrCmpRaw(&calld->macaddress, mac->mac))
{
/* Repeat the same check for a broadcast mac */
int i;
- for (i = 0;i < VIR_MAC_BUFLEN; i++) {
- if (calld->macaddress[i] != 0xff) {
+ for (i = 0; i < VIR_MAC_BUFLEN; i++) {
+ if (calld->macaddress.addr[i] != 0xff) {
VIR_DEBUG("MAC address match failed (wasn't broadcast)");
return;
}
VIR_INFO(" if: %s", calld->cr_ifname);
VIR_INFO(" lf: %s", calld->linkdev);
VIR_INFO(" mac: %02x:%02x:%02x:%02x:%02x:%02x",
- calld->macaddress[0], calld->macaddress[1],
- calld->macaddress[2], calld->macaddress[3],
- calld->macaddress[4], calld->macaddress[5]);
+ calld->macaddress.addr[0], calld->macaddress.addr[1],
+ calld->macaddress.addr[2], calld->macaddress.addr[3],
+ calld->macaddress.addr[4], calld->macaddress.addr[5]);
ignore_value(virNetDevVPortProfileAssociate(calld->cr_ifname,
calld->virtPortProfile,
- calld->macaddress,
+ &calld->macaddress,
calld->linkdev,
calld->vf,
calld->vmuuid,
*/
static void
virNetDevMacVLanVPortProfileDestroyCallback(int watch ATTRIBUTE_UNUSED,
- const unsigned char *macaddr ATTRIBUTE_UNUSED,
+ const virMacAddrPtr macaddr ATTRIBUTE_UNUSED,
void *opaque)
{
virNetlinkCallbackDataFree((virNetlinkCallbackDataPtr)opaque);
int
virNetDevMacVLanVPortProfileRegisterCallback(const char *ifname,
- const unsigned char *macaddress,
+ const virMacAddrPtr macaddress,
const char *linkdev,
const unsigned char *vmuuid,
virNetDevVPortProfilePtr virtPortProfile,
if (VIR_ALLOC(calld->virtPortProfile) < 0)
goto memory_error;
memcpy(calld->virtPortProfile, virtPortProfile, sizeof(*virtPortProfile));
- memcpy(calld->macaddress, macaddress, sizeof(calld->macaddress));
+ virMacAddrSet(&calld->macaddress, macaddress);
if ((calld->linkdev = strdup(linkdev)) == NULL)
goto memory_error;
memcpy(calld->vmuuid, vmuuid, sizeof(calld->vmuuid));
* otherwise returns 0; returns -1 on error.
*/
int virNetDevMacVLanCreateWithVPortProfile(const char *tgifname,
- const unsigned char *macaddress,
+ const virMacAddrPtr macaddress,
const char *linkdev,
enum virNetDevMacVLanMode mode,
bool withTap,
* were provided.
*/
int virNetDevMacVLanDeleteWithVPortProfile(const char *ifname,
- const unsigned char *macaddr,
+ const virMacAddrPtr macaddr,
const char *linkdev,
int mode,
virNetDevVPortProfilePtr virtPortProfile,
* Returns 0; returns -1 on error.
*/
int virNetDevMacVLanRestartWithVPortProfile(const char *cr_ifname,
- const unsigned char *macaddress,
+ const virMacAddrPtr macaddress,
const char *linkdev,
const unsigned char *vmuuid,
virNetDevVPortProfilePtr virtPortProfile,
#else /* ! WITH_MACVTAP */
int virNetDevMacVLanCreate(const char *ifname ATTRIBUTE_UNUSED,
const char *type ATTRIBUTE_UNUSED,
- const unsigned char *macaddress ATTRIBUTE_UNUSED,
+ const virMacAddrPtr macaddress ATTRIBUTE_UNUSED,
const char *srcdev ATTRIBUTE_UNUSED,
uint32_t macvlan_mode ATTRIBUTE_UNUSED,
int *retry ATTRIBUTE_UNUSED)
}
int virNetDevMacVLanCreateWithVPortProfile(const char *ifname ATTRIBUTE_UNUSED,
- const unsigned char *macaddress ATTRIBUTE_UNUSED,
+ const virMacAddrPtr macaddress ATTRIBUTE_UNUSED,
const char *linkdev ATTRIBUTE_UNUSED,
enum virNetDevMacVLanMode mode ATTRIBUTE_UNUSED,
bool withTap ATTRIBUTE_UNUSED,
}
int virNetDevMacVLanDeleteWithVPortProfile(const char *ifname ATTRIBUTE_UNUSED,
- const unsigned char *macaddress ATTRIBUTE_UNUSED,
+ const virMacAddrPtr macaddress ATTRIBUTE_UNUSED,
const char *linkdev ATTRIBUTE_UNUSED,
int mode ATTRIBUTE_UNUSED,
virNetDevVPortProfilePtr virtPortProfile ATTRIBUTE_UNUSED,
}
int virNetDevMacVLanRestartWithVPortProfile(const char *cr_ifname ATTRIBUTE_UNUSED,
- const unsigned char *macaddress ATTRIBUTE_UNUSED,
+ const virMacAddrPtr macaddress ATTRIBUTE_UNUSED,
const char *linkdev ATTRIBUTE_UNUSED,
const unsigned char *vmuuid ATTRIBUTE_UNUSED,
virNetDevVPortProfilePtr virtPortProfile ATTRIBUTE_UNUSED,
}
int virNetDevMacVLanVPortProfileRegisterCallback(const char *ifname ATTRIBUTE_UNUSED,
- const unsigned char *macaddress ATTRIBUTE_UNUSED,
+ const virMacAddrPtr macaddress ATTRIBUTE_UNUSED,
const char *linkdev ATTRIBUTE_UNUSED,
const unsigned char *vmuuid ATTRIBUTE_UNUSED,
virNetDevVPortProfilePtr virtPortProfile ATTRIBUTE_UNUSED,
# define __UTIL_MACVTAP_H__
# include "internal.h"
+# include "virmacaddr.h"
# include "virsocketaddr.h"
# include "virnetdevbandwidth.h"
# include "virnetdevvportprofile.h"
int virNetDevMacVLanCreate(const char *ifname,
const char *type,
- const unsigned char *macaddress,
+ const virMacAddrPtr macaddress,
const char *srcdev,
uint32_t macvlan_mode,
int *retry)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_RETURN_CHECK;
int virNetDevMacVLanCreateWithVPortProfile(const char *ifname,
- const unsigned char *macaddress,
+ const virMacAddrPtr macaddress,
const char *linkdev,
enum virNetDevMacVLanMode mode,
bool withTap,
ATTRIBUTE_NONNULL(9) ATTRIBUTE_NONNULL(11) ATTRIBUTE_RETURN_CHECK;
int virNetDevMacVLanDeleteWithVPortProfile(const char *ifname,
- const unsigned char *macaddress,
+ const virMacAddrPtr macaddress,
const char *linkdev,
int mode,
virNetDevVPortProfilePtr virtPortProfile,
ATTRIBUTE_NONNULL(6) ATTRIBUTE_RETURN_CHECK;
int virNetDevMacVLanRestartWithVPortProfile(const char *cr_ifname,
- const unsigned char *macaddress,
+ const virMacAddrPtr macaddress,
const char *linkdev,
const unsigned char *vmuuid,
virNetDevVPortProfilePtr virtPortProfile,
ATTRIBUTE_NONNULL(4) ATTRIBUTE_RETURN_CHECK;
int virNetDevMacVLanVPortProfileRegisterCallback(const char *ifname,
- const unsigned char *macaddress ,
+ const virMacAddrPtr macaddress,
const char *linkdev,
const unsigned char *vmuuid,
virNetDevVPortProfilePtr virtPortProfile,
* Returns 0 in case of success or -1 in case of failure.
*/
int virNetDevOpenvswitchAddPort(const char *brname, const char *ifname,
- const unsigned char *macaddr,
+ const virMacAddrPtr macaddr,
const unsigned char *vmuuid,
virNetDevVPortProfilePtr ovsport)
{
int virNetDevOpenvswitchAddPort(const char *brname,
const char *ifname,
- const unsigned char *macaddr,
+ const virMacAddrPtr macaddr,
const unsigned char *vmuuid,
virNetDevVPortProfilePtr ovsport)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3)
* virNetDevTapCreateInBridgePort:
* @brname: the bridge name
* @ifname: the interface name (or name template)
- * @macaddr: desired MAC address (VIR_MAC_BUFLEN long)
+ * @macaddr: desired MAC address
* @tapfd: file descriptor return value for the new tap device
* @virtPortProfile: bridge/port specific configuration
* @flags: OR of virNetDevTapCreateFlags:
*/
int virNetDevTapCreateInBridgePort(const char *brname,
char **ifname,
- const unsigned char *macaddr,
+ const virMacAddrPtr macaddr,
const unsigned char *vmuuid,
int *tapfd,
virNetDevVPortProfilePtr virtPortProfile,
unsigned int flags)
{
- unsigned char tapmac[VIR_MAC_BUFLEN];
+ virMacAddr tapmac;
if (virNetDevTapCreate(ifname, tapfd, flags) < 0)
return -1;
* seeing the kernel allocate random MAC for the TAP
* device before we set our static MAC.
*/
- memcpy(tapmac, macaddr, VIR_MAC_BUFLEN);
+ virMacAddrSet(&tapmac, macaddr);
if (!(flags & VIR_NETDEV_TAP_CREATE_USE_MAC_FOR_BRIDGE)) {
- if (macaddr[0] == 0xFE) {
+ if (macaddr->addr[0] == 0xFE) {
/* For normal use, the tap device's MAC address cannot
* match the MAC address used by the guest. This results
* in "received packet on vnetX with own address as source
virNetDevTapError(VIR_ERR_CONFIG_UNSUPPORTED,
"Unable to use MAC address starting with "
"reserved value 0xFE - '%02X:%02X:%02X:%02X:%02X:%02X' - ",
- macaddr[0], macaddr[1], macaddr[2],
- macaddr[3], macaddr[4], macaddr[5]);
+ macaddr->addr[0], macaddr->addr[1],
+ macaddr->addr[2], macaddr->addr[3],
+ macaddr->addr[4], macaddr->addr[5]);
goto error;
}
- tapmac[0] = 0xFE; /* Discourage bridge from using TAP dev MAC */
+ tapmac.addr[0] = 0xFE; /* Discourage bridge from using TAP dev MAC */
}
- if (virNetDevSetMAC(*ifname, tapmac) < 0)
+ if (virNetDevSetMAC(*ifname, &tapmac) < 0)
goto error;
/* We need to set the interface MTU before adding it
int virNetDevTapCreateInBridgePort(const char *brname,
char **ifname,
- const unsigned char *macaddr,
+ const virMacAddrPtr macaddr,
const unsigned char *vmuuid,
int *tapfd,
virNetDevVPortProfilePtr virtPortProfile,
static int
virNetDevVPortProfileOpSetLink(const char *ifname, int ifindex,
bool nltarget_kernel,
- const unsigned char *macaddr,
+ const virMacAddrPtr macaddr,
int vlanid,
const char *profileId,
struct ifla_port_vsi *portVsi,
.mac = { 0, },
};
- memcpy(ifla_vf_mac.mac, macaddr, 6);
+ virMacAddrGetRaw(macaddr, ifla_vf_mac.mac);
if (nla_put(nl_msg, IFLA_VF_MAC, sizeof(ifla_vf_mac),
&ifla_vf_mac) < 0)
static int
virNetDevVPortProfileOpCommon(const char *ifname, int ifindex,
bool nltarget_kernel,
- const unsigned char *macaddr,
+ const virMacAddrPtr macaddr,
int vlanid,
const char *profileId,
struct ifla_port_vsi *portVsi,
/* Returns 0 on success, -1 on general failure, and -2 on timeout */
static int
virNetDevVPortProfileOp8021Qbg(const char *ifname,
- const unsigned char *macaddr,
+ const virMacAddrPtr macaddr,
int vf,
const virNetDevVPortProfilePtr virtPort,
enum virNetDevVPortProfileLinkOp virtPortOp,
/* Returns 0 on success, -1 on general failure, and -2 on timeout */
static int
virNetDevVPortProfileOp8021Qbh(const char *ifname,
- const unsigned char *macaddr,
+ const virMacAddrPtr macaddr,
int32_t vf,
const virNetDevVPortProfilePtr virtPort,
const unsigned char *vm_uuid,
int
virNetDevVPortProfileAssociate(const char *macvtap_ifname,
const virNetDevVPortProfilePtr virtPort,
- const unsigned char *macvtap_macaddr,
+ const virMacAddrPtr macvtap_macaddr,
const char *linkdev,
int vf,
const unsigned char *vmuuid,
int
virNetDevVPortProfileDisassociate(const char *macvtap_ifname,
const virNetDevVPortProfilePtr virtPort,
- const unsigned char *macvtap_macaddr,
+ const virMacAddrPtr macvtap_macaddr,
const char *linkdev,
int vf,
enum virNetDevVPortProfileOp vmOp)
#else /* ! WITH_VIRTUALPORT */
int virNetDevVPortProfileAssociate(const char *macvtap_ifname ATTRIBUTE_UNUSED,
const virNetDevVPortProfilePtr virtPort ATTRIBUTE_UNUSED,
- const unsigned char *macvtap_macaddr ATTRIBUTE_UNUSED,
+ const virMacAddrPtr macvtap_macaddr ATTRIBUTE_UNUSED,
const char *linkdev ATTRIBUTE_UNUSED,
int vf ATTRIBUTE_UNUSED,
const unsigned char *vmuuid ATTRIBUTE_UNUSED,
int virNetDevVPortProfileDisassociate(const char *macvtap_ifname ATTRIBUTE_UNUSED,
const virNetDevVPortProfilePtr virtPort ATTRIBUTE_UNUSED,
- const unsigned char *macvtap_macaddr ATTRIBUTE_UNUSED,
+ const virMacAddrPtr macvtap_macaddr ATTRIBUTE_UNUSED,
const char *linkdev ATTRIBUTE_UNUSED,
int vf ATTRIBUTE_UNUSED,
enum virNetDevVPortProfileOp vmOp ATTRIBUTE_UNUSED)
# include "internal.h"
# include "uuid.h"
# include "util.h"
+# include "virmacaddr.h"
# define LIBVIRT_IFLA_VF_PORT_PROFILE_MAX 40
int virNetDevVPortProfileAssociate(const char *ifname,
const virNetDevVPortProfilePtr virtPort,
- const unsigned char *macaddr,
+ const virMacAddrPtr macaddr,
const char *linkdev,
int vf,
const unsigned char *vmuuid,
int virNetDevVPortProfileDisassociate(const char *ifname,
const virNetDevVPortProfilePtr virtPort,
- const unsigned char *macaddr,
+ const virMacAddrPtr macaddr,
const char *linkdev,
int vf,
enum virNetDevVPortProfileOp vmOp)
virNetlinkEventHandleCallback handleCB;
virNetlinkEventRemoveCallback removeCB;
void *opaque;
- unsigned char macaddr[VIR_MAC_BUFLEN];
+ virMacAddr macaddr;
int deleted;
};
if (removeCB) {
(removeCB)(server->handles[i].watch,
- server->handles[i].macaddr,
+ &server->handles[i].macaddr,
server->handles[i].opaque);
}
server->handles[i].deleted = VIR_NETLINK_HANDLE_DELETED;
int
virNetlinkEventAddClient(virNetlinkEventHandleCallback handleCB,
virNetlinkEventRemoveCallback removeCB,
- void *opaque, const unsigned char *macaddr)
+ void *opaque, const virMacAddrPtr macaddr)
{
int i, r, ret = -1;
virNetlinkEventSrvPrivatePtr srv = server;
srv->handles[r].opaque = opaque;
srv->handles[r].deleted = VIR_NETLINK_HANDLE_VALID;
if (macaddr)
- memcpy(srv->handles[r].macaddr, macaddr, VIR_MAC_BUFLEN);
+ virMacAddrSet(&srv->handles[r].macaddr, macaddr);
else
- memset(srv->handles[r].macaddr, 0, VIR_MAC_BUFLEN);
+ virMacAddrSetRaw(&srv->handles[r].macaddr,
+ (unsigned char[VIR_MAC_BUFLEN]){0,0,0,0,0,0});
VIR_DEBUG("added client to loop slot: %d. with macaddr ptr=%p", r, macaddr);
* Returns -1 if the file handle was not registered, 0 upon success
*/
int
-virNetlinkEventRemoveClient(int watch, const unsigned char *macaddr)
+virNetlinkEventRemoveClient(int watch, const virMacAddrPtr macaddr)
{
int i;
int ret = -1;
if ((watch && srv->handles[i].watch == watch) ||
(!watch &&
- memcmp(macaddr, srv->handles[i].macaddr, VIR_MAC_BUFLEN) == 0)) {
+ virMacAddrCmp(macaddr, &srv->handles[i].macaddr) == 0)) {
VIR_DEBUG("removed client: %d by %s.",
srv->handles[i].watch, watch ? "index" : "mac");
# include "config.h"
# include "internal.h"
+# include "virmacaddr.h"
# include <stdint.h>
typedef void (*virNetlinkEventHandleCallback)(unsigned char *msg, int length, struct sockaddr_nl *peer, bool *handled, void *opaque);
-typedef void (*virNetlinkEventRemoveCallback)(int watch, const unsigned char *macaddr, void *opaque);
+typedef void (*virNetlinkEventRemoveCallback)(int watch, const virMacAddrPtr macaddr, void *opaque);
/**
* stopNetlinkEventServer: stop the monitor to receive netlink messages for libvirtd
*/
int virNetlinkEventAddClient(virNetlinkEventHandleCallback handleCB,
virNetlinkEventRemoveCallback removeCB,
- void *opaque, const unsigned char *macaddr);
+ void *opaque, const virMacAddrPtr macaddr);
/**
* virNetlinkEventRemoveClient: unregister a callback from a netlink monitor
*/
-int virNetlinkEventRemoveClient(int watch, const unsigned char *macaddr);
+int virNetlinkEventRemoveClient(int watch, const virMacAddrPtr macaddr);
#endif /* __VIR_NETLINK_H__ */
MACAddress[8], MACAddress[9], MACAddress[10], MACAddress[11]);
/* XXX some real error handling here some day ... */
- if (virMacAddrParse(macaddr, def->nets[netAdpIncCnt]->mac) < 0)
+ if (virMacAddrParse(macaddr, &def->nets[netAdpIncCnt]->mac) < 0)
{}
netAdpIncCnt++;
char macaddr[VIR_MAC_STRING_BUFLEN] = {0};
char macaddrvbox[VIR_MAC_STRING_BUFLEN - 5] = {0};
- virMacAddrFormat(def->nets[i]->mac, macaddr);
+ virMacAddrFormat(&def->nets[i]->mac, macaddr);
snprintf(macaddrvbox, VIR_MAC_STRING_BUFLEN - 5,
"%02X%02X%02X%02X%02X%02X",
- def->nets[i]->mac[0],
- def->nets[i]->mac[1],
- def->nets[i]->mac[2],
- def->nets[i]->mac[3],
- def->nets[i]->mac[4],
- def->nets[i]->mac[5]);
+ def->nets[i]->mac.addr[0],
+ def->nets[i]->mac.addr[1],
+ def->nets[i]->mac.addr[2],
+ def->nets[i]->mac.addr[3],
+ def->nets[i]->mac.addr[4],
+ def->nets[i]->mac.addr[5]);
macaddrvbox[VIR_MAC_STRING_BUFLEN - 6] = '\0';
VIR_DEBUG("NIC(%d): Type: %d", i, def->nets[i]->type);
if (addressType == NULL || STRCASEEQ(addressType, "generated") ||
STRCASEEQ(addressType, "vpx")) {
if (generatedAddress != NULL) {
- if (virMacAddrParse(generatedAddress, (*def)->mac) < 0) {
+ if (virMacAddrParse(generatedAddress, &(*def)->mac) < 0) {
VMX_ERROR(VIR_ERR_INTERNAL_ERROR,
_("Expecting VMX entry '%s' to be MAC address but "
"found '%s'"), generatedAddress_name,
}
} else if (STRCASEEQ(addressType, "static")) {
if (address != NULL) {
- if (virMacAddrParse(address, (*def)->mac) < 0) {
+ if (virMacAddrParse(address, &(*def)->mac) < 0) {
VMX_ERROR(VIR_ERR_INTERNAL_ERROR,
_("Expecting VMX entry '%s' to be MAC address but "
"found '%s'"), address_name, address);
}
/* def:mac -> vmx:addressType, vmx:(generated)Address, vmx:checkMACAddress */
- virMacAddrFormat(def->mac, mac_string);
+ virMacAddrFormat(&def->mac, mac_string);
- prefix = (def->mac[0] << 16) | (def->mac[1] << 8) | def->mac[2];
- suffix = (def->mac[3] << 16) | (def->mac[4] << 8) | def->mac[5];
+ prefix = (def->mac.addr[0] << 16) | (def->mac.addr[1] << 8) | def->mac.addr[2];
+ suffix = (def->mac.addr[3] << 16) | (def->mac.addr[4] << 8) | def->mac.addr[5];
if (prefix == 0x000c29) {
virBufferAsprintf(buffer, "ethernet%d.addressType = \"generated\"\n",
goto cleanup;
char macStr[VIR_MAC_STRING_BUFLEN];
- virMacAddrFormat(dev->data.net->mac, macStr);
+ virMacAddrFormat(&dev->data.net->mac, macStr);
if (!(target = strdup(macStr))) {
virReportOOMError();
char mac[30];
virDomainNetDefPtr def = dev->data.net;
snprintf(mac, sizeof(mac), "%02x:%02x:%02x:%02x:%02x:%02x",
- def->mac[0], def->mac[1], def->mac[2],
- def->mac[3], def->mac[4], def->mac[5]);
+ def->mac.addr[0], def->mac.addr[1], def->mac.addr[2],
+ def->mac.addr[3], def->mac.addr[4], def->mac.addr[5]);
strcpy(class, "vif");
case VIR_DOMAIN_DEVICE_NET:
{
for (i = 0 ; i < def->nnets ; i++) {
- if (!memcmp(def->nets[i]->mac,
- dev->data.net->mac,
- sizeof(def->nets[i]->mac))) {
+ if (!virMacAddrCmp(&def->nets[i]->mac, &dev->data.net->mac)) {
virDomainNetDefFree(def->nets[i]);
if (i < (def->nnets - 1))
memmove(def->nets + i,
tmp = sexpr_node(node, "device/vif/mac");
if (tmp) {
- if (virMacAddrParse(tmp, net->mac) < 0) {
+ if (virMacAddrParse(tmp, &net->mac) < 0) {
XENXS_ERROR(VIR_ERR_INTERNAL_ERROR,
_("malformed mac address '%s'"), tmp);
goto cleanup;
virBufferAsprintf(buf,
"(mac '%02x:%02x:%02x:%02x:%02x:%02x')",
- def->mac[0], def->mac[1], def->mac[2],
- def->mac[3], def->mac[4], def->mac[5]);
+ def->mac.addr[0], def->mac.addr[1], def->mac.addr[2],
+ def->mac.addr[3], def->mac.addr[4], def->mac.addr[5]);
switch (def->type) {
case VIR_DOMAIN_NET_TYPE_BRIDGE:
goto no_memory;
if (mac[0]) {
- if (virMacAddrParse(mac, net->mac) < 0) {
+ if (virMacAddrParse(mac, &net->mac) < 0) {
XENXS_ERROR(VIR_ERR_INTERNAL_ERROR,
_("malformed mac address '%s'"), mac);
goto cleanup;
virConfValuePtr val, tmp;
virBufferAsprintf(&buf, "mac=%02x:%02x:%02x:%02x:%02x:%02x",
- net->mac[0], net->mac[1],
- net->mac[2], net->mac[3],
- net->mac[4], net->mac[5]);
+ net->mac.addr[0], net->mac.addr[1],
+ net->mac.addr[2], net->mac.addr[3],
+ net->mac.addr[4], net->mac.addr[5]);
switch (net->type) {
case VIR_DOMAIN_NET_TYPE_BRIDGE:
const char *state;
const char *value;
const char *desc;
- unsigned char macaddr[VIR_MAC_BUFLEN];
+ virMacAddr macaddr;
const char *element;
const char *attr;
bool config;
goto cleanup;
}
- if (virMacAddrParse(iface, macaddr) == 0) {
+ if (virMacAddrParse(iface, &macaddr) == 0) {
element = "mac";
attr = "address";
} else {
int flags = 0;
char *state = NULL;
char *value = NULL;
- unsigned char macaddr[VIR_MAC_BUFLEN];
+ virMacAddr macaddr;
const char *element;
const char *attr;
bool ret = false;
goto cleanup;
}
- if (virMacAddrParse(iface, macaddr) == 0) {
+ if (virMacAddrParse(iface, &macaddr) == 0) {
element = "mac";
attr = "address";
} else {
projects / libvirt.git / commitdiff