static int manager_process_link(Manager *m, struct udev_device *device) {
Link *link;
int r;
if (streq_ptr(udev_device_get_action(device), "remove")) {
uint64_t ifindex;
log_debug("%s: link removed", udev_device_get_sysname(device));
ifindex = udev_device_get_ifindex(device);
link = hashmap_get(m->links, &ifindex);
if (!link)
return 0;
link_free(link);
} else {
r = link_add(m, device, &link);
if (r < 0) {
if (r == -EEXIST)
log_debug("%s: link already exists, ignoring",
link->ifname);
else
log_error("%s: could not handle link: %s",
udev_device_get_sysname(device),
strerror(-r));
} else
log_debug("%s: link (with ifindex %" PRIu64") added",
link->ifname, link->ifindex);
}
return 0;
}
static gboolean
setup (NMPlatform *platform)
{
/* skip zero element */
link_add (platform, NULL, NM_LINK_TYPE_NONE, NULL, 0);
/* add loopback interface */
link_add (platform, "lo", NM_LINK_TYPE_LOOPBACK, NULL, 0);
/* add some ethernets */
link_add (platform, "eth0", NM_LINK_TYPE_ETHERNET, NULL, 0);
link_add (platform, "eth1", NM_LINK_TYPE_ETHERNET, NULL, 0);
link_add (platform, "eth2", NM_LINK_TYPE_ETHERNET, NULL, 0);
return TRUE;
}
static int manager_process_link(Manager *m, struct udev_device *device) {
Link *link;
int r;
if (streq_ptr(udev_device_get_action(device), "remove")) {
uint64_t ifindex;
log_debug("Link removed: %s", udev_device_get_sysname(device));
ifindex = udev_device_get_ifindex(device);
link = hashmap_get(m->links, &ifindex);
if (!link)
return 0;
link_free(link);
} else {
log_debug("New link: %s", udev_device_get_sysname(device));
r = link_add(m, device);
if (r < 0) {
log_error("Could not handle link %s: %s",
udev_device_get_sysname(device),
strerror(-r));
}
}
return 0;
}
/* 这个函数是不会被信号干扰的 */
int at_add_job(const job_des *new_job) {
int ret;
static int isfirst = 1;
struct at_job job;
if (new_job->rep_time == 0 || new_job->rep_time < REP_FOREVER)
return -1;
if (isfirst) {
pthread_mutex_lock(&mut_init);
if (isfirst == 0)
pthread_mutex_unlock(&mut_init);
else {
isfirst = 0;
next_alm = new_job->sec;
if ((ret = init_timer()) != 0)
return ret;
pthread_mutex_unlock(&mut_init);
}
}
if (new_job->sec < next_alm)
sub_each(new_job->sec);
if (tran_job(&job, new_job) == -1)
return -1;
/*link_add返回任务号*/
return link_add(&job, tim_link) == -1 ? -1:job.job_num;
}
static int manager_process_link(Manager *m, struct udev_device *device) {
Link *link = NULL;
int r;
assert(m);
assert(device);
link_get(m, udev_device_get_ifindex(device), &link);
if (streq_ptr(udev_device_get_action(device), "remove")) {
log_debug("%s: link removed", udev_device_get_sysname(device));
if (link)
link_free(link);
} else {
if (link) {
log_debug("%s: link already exists, ignoring",
link->ifname);
return 0;
}
r = link_add(m, device, &link);
if (r < 0) {
log_error("%s: could not handle link: %s",
udev_device_get_sysname(device),
strerror(-r));
} else
log_debug("%s: link (with ifindex %" PRIu64") added",
link->ifname, link->ifindex);
}
return 0;
}
int main(int argc, const char *argv[])
{
V_NODE *head=NULL;
int n=0;
printf("input a number:\n");
scanf("%d",&n);
head = create_link(n);
print_link(head);
link_add(head);
print_link(head);
head = delete_link(head);
print_link(head);
return 0;
}
static gboolean
infiniband_partition_add (NMPlatform *platform, int parent, int p_key)
{
NMFakePlatformLink *parent_device;
char *name;
gboolean success;
parent_device = link_get (platform, parent);
g_return_val_if_fail (parent_device != NULL, FALSE);
name = g_strdup_printf ("%s.%04x", parent_device->link.name, p_key);
success = link_add (platform, name, NM_LINK_TYPE_INFINIBAND, NULL, 0);
g_free (name);
return success;
}
static gboolean
vlan_add (NMPlatform *platform, const char *name, int parent, int vlan_id, guint32 vlan_flags)
{
NMFakePlatformLink *device;
if (!link_add (platform, name, NM_LINK_TYPE_VLAN, NULL, 0))
return FALSE;
device = link_get (platform, link_get_ifindex (platform, name));
g_return_val_if_fail (device, FALSE);
device->vlan_id = vlan_id;
device->link.parent = parent;
return TRUE;
}
static int clean_node(struct at_job *cur) {
struct at_job tmp;
if (cur->job_rep_time == REP_FOREVER || --cur->job_rep_time > 0) {
if (cur->job_org_val < next_alm)
sub_each(cur->job_org_val);
memcpy(&tmp, cur, sizeof(*cur));
tmp.job_val = cur->job_org_val;
if ((tmp.job_arg = malloc(tmp.job_arg_size)) == NULL)
return -1;
memcpy(tmp.job_arg, cur->job_arg, cur->job_arg_size);
link_add(&tmp, tim_link);
link_del(cur, tim_link);
} else
cur->job_sta = AT_INVAL;
return 0;
}
int main(int argc, const char *argv[])
{
V_NODE *head=NULL;
char flag=0;
while(!flag)
{
print_list();
switch(get_choice())
{
case 1 : head= link_add(head);break;
case 2 : head= delete_link(head); break;
case 3 : print_link(head);break;
case 4 : flag=1; break;
default : break;
}
getchar();
getchar();
}
return 0;
}
void
prime()
{
struct ifaddrs *ifap = NULL;
struct ifaddrs *scan;
int sock = -1;
SCLog(_verbose, LOG_DEBUG, CFSTR("prime() called"));
cache_open();
sock = dgram_socket(AF_INET);
if (sock == -1) {
SCLog(TRUE, LOG_ERR, CFSTR("could not get interface list, socket() failed: %s"), strerror(errno));
goto done;
}
if (getifaddrs(&ifap) < 0) {
SCLog(TRUE,
LOG_ERR,
CFSTR("could not get interface info, getifaddrs() failed: %s"),
strerror(errno));
goto done;
}
/* update list of interfaces & link status */
for (scan = ifap; scan != NULL; scan = scan->ifa_next) {
if (scan->ifa_addr == NULL
|| scan->ifa_addr->sa_family != AF_LINK) {
continue;
}
/* get the per-interface link/media information */
link_add(scan->ifa_name);
}
/*
* update IPv4 network addresses already assigned to
* the interfaces.
*/
interface_update_ipv4(ifap, NULL);
/*
* update IPv6 network addresses already assigned to
* the interfaces.
*/
interface_update_ipv6(ifap, NULL);
/*
* update AppleTalk network addresses already assigned
* to the interfaces.
*/
interface_update_appletalk(ifap, NULL);
freeifaddrs(ifap);
done:
if (sock >= 0)
close(sock);
cache_write(store);
cache_close();
return;
}
static void
processEvent_Apple_Network(struct kern_event_msg *ev_msg)
{
const char * eventName = NULL;
int dataLen = (ev_msg->total_size - KEV_MSG_HEADER_SIZE);
void * event_data = &ev_msg->event_data[0];
Boolean handled = TRUE;
char ifr_name[IFNAMSIZ+1];
switch (ev_msg->kev_subclass) {
case KEV_INET_SUBCLASS : {
eventName = inetEventNameString(ev_msg->event_code);
switch (ev_msg->event_code) {
case KEV_INET_NEW_ADDR :
case KEV_INET_CHANGED_ADDR :
case KEV_INET_ADDR_DELETED :
case KEV_INET_SIFDSTADDR :
case KEV_INET_SIFBRDADDR :
case KEV_INET_SIFNETMASK : {
struct kev_in_data * ev;
ev = (struct kev_in_data *)event_data;
if (dataLen < sizeof(*ev)) {
handled = FALSE;
break;
}
copy_if_name(&ev->link_data, ifr_name, sizeof(ifr_name));
interface_update_ipv4(NULL, ifr_name);
break;
}
case KEV_INET_ARPCOLLISION : {
struct kev_in_collision * ev;
ev = (struct kev_in_collision *)event_data;
if ((dataLen < sizeof(*ev))
|| (dataLen < (sizeof(*ev) + ev->hw_len))) {
handled = FALSE;
break;
}
copy_if_name(&ev->link_data, ifr_name, sizeof(ifr_name));
interface_collision_ipv4(ifr_name,
ev->ia_ipaddr,
ev->hw_len,
ev->hw_addr);
break;
}
default :
handled = FALSE;
break;
}
break;
}
case KEV_INET6_SUBCLASS : {
struct kev_in6_data * ev;
eventName = inet6EventNameString(ev_msg->event_code);
ev = (struct kev_in6_data *)event_data;
switch (ev_msg->event_code) {
case KEV_INET6_NEW_USER_ADDR :
case KEV_INET6_CHANGED_ADDR :
case KEV_INET6_ADDR_DELETED :
case KEV_INET6_NEW_LL_ADDR :
case KEV_INET6_NEW_RTADV_ADDR :
case KEV_INET6_DEFROUTER :
if (dataLen < sizeof(*ev)) {
handled = FALSE;
break;
}
copy_if_name(&ev->link_data, ifr_name, sizeof(ifr_name));
interface_update_ipv6(NULL, ifr_name);
break;
default :
handled = FALSE;
break;
}
break;
}
case KEV_DL_SUBCLASS : {
struct net_event_data * ev;
eventName = dlEventNameString(ev_msg->event_code);
ev = (struct net_event_data *)event_data;
switch (ev_msg->event_code) {
case KEV_DL_IF_ATTACHED :
/*
* new interface added
*/
if (dataLen < sizeof(*ev)) {
handled = FALSE;
break;
}
copy_if_name(ev, ifr_name, sizeof(ifr_name));
link_add(ifr_name);
break;
case KEV_DL_IF_DETACHED :
/*
* interface removed
*/
if (dataLen < sizeof(*ev)) {
handled = FALSE;
break;
}
copy_if_name(ev, ifr_name, sizeof(ifr_name));
link_remove(ifr_name);
break;
case KEV_DL_IF_DETACHING :
/*
* interface detaching
*/
if (dataLen < sizeof(*ev)) {
handled = FALSE;
break;
}
copy_if_name(ev, ifr_name, sizeof(ifr_name));
interface_detaching(ifr_name);
break;
case KEV_DL_SIFFLAGS :
case KEV_DL_SIFMETRICS :
case KEV_DL_SIFMTU :
case KEV_DL_SIFPHYS :
case KEV_DL_SIFMEDIA :
case KEV_DL_SIFGENERIC :
case KEV_DL_ADDMULTI :
case KEV_DL_DELMULTI :
handled = FALSE;
break;
case KEV_DL_PROTO_ATTACHED :
case KEV_DL_PROTO_DETACHED : {
struct kev_dl_proto_data * protoEvent;
protoEvent = (struct kev_dl_proto_data *)event_data;
if (dataLen < sizeof(*protoEvent)) {
handled = FALSE;
break;
}
copy_if_name(&protoEvent->link_data,
ifr_name, sizeof(ifr_name));
if (protoEvent->proto_remaining_count == 0) {
mark_if_down(ifr_name);
} else {
mark_if_up(ifr_name);
}
break;
}
case KEV_DL_LINK_OFF :
case KEV_DL_LINK_ON :
/*
* update the link status in the store
*/
if (dataLen < sizeof(*ev)) {
handled = FALSE;
break;
}
copy_if_name(ev, ifr_name, sizeof(ifr_name));
link_update_status(ifr_name, FALSE);
break;
default :
handled = FALSE;
break;
}
break;
}
case KEV_ATALK_SUBCLASS: {
struct kev_atalk_data * ev;
eventName = atalkEventNameString(ev_msg->event_code);
ev = (struct kev_atalk_data *)event_data;
if (dataLen < sizeof(*ev)) {
handled = FALSE;
break;
}
copy_if_name(&ev->link_data, ifr_name, sizeof(ifr_name));
switch (ev_msg->event_code) {
case KEV_ATALK_ENABLED:
interface_update_atalk_address(ev, ifr_name);
break;
case KEV_ATALK_DISABLED:
interface_update_shutdown_atalk();
break;
case KEV_ATALK_ZONEUPDATED:
interface_update_atalk_zone(ev, ifr_name);
break;
case KEV_ATALK_ROUTERUP:
case KEV_ATALK_ROUTERUP_INVALID:
case KEV_ATALK_ROUTERDOWN:
interface_update_appletalk(NULL, ifr_name);
break;
case KEV_ATALK_ZONELISTCHANGED:
break;
default :
handled = FALSE;
break;
}
break;
}
default :
handled = FALSE;
break;
}
if (handled == FALSE) {
CFStringRef evStr;
evStr = CFStringCreateWithCString(NULL,
(eventName != NULL) ? eventName : "New Apple network subclass",
kCFStringEncodingASCII);
logEvent(evStr, ev_msg);
CFRelease(evStr);
}
return;
}
static void
processEvent_Apple_Network(struct kern_event_msg *ev_msg)
{
const char * eventName = NULL;
int dataLen = (ev_msg->total_size - KEV_MSG_HEADER_SIZE);
void * event_data = &ev_msg->event_data[0];
Boolean handled = TRUE;
char ifr_name[IFNAMSIZ];
switch (ev_msg->kev_subclass) {
case KEV_INET_SUBCLASS : {
eventName = inetEventNameString(ev_msg->event_code);
switch (ev_msg->event_code) {
case KEV_INET_NEW_ADDR :
case KEV_INET_CHANGED_ADDR :
case KEV_INET_ADDR_DELETED :
case KEV_INET_SIFDSTADDR :
case KEV_INET_SIFBRDADDR :
case KEV_INET_SIFNETMASK : {
struct kev_in_data * ev;
ev = (struct kev_in_data *)event_data;
if (dataLen < sizeof(*ev)) {
handled = FALSE;
break;
}
copy_if_name(&ev->link_data, ifr_name, sizeof(ifr_name));
interface_update_ipv4(NULL, ifr_name);
break;
}
case KEV_INET_ARPCOLLISION : {
struct kev_in_collision * ev;
ev = (struct kev_in_collision *)event_data;
if ((dataLen < sizeof(*ev))
|| (dataLen < (sizeof(*ev) + ev->hw_len))) {
handled = FALSE;
break;
}
copy_if_name(&ev->link_data, ifr_name, sizeof(ifr_name));
interface_collision_ipv4(ifr_name,
ev->ia_ipaddr,
ev->hw_len,
ev->hw_addr);
break;
}
#if !TARGET_OS_IPHONE
case KEV_INET_PORTINUSE : {
struct kev_in_portinuse * ev;
ev = (struct kev_in_portinuse *)event_data;
if (dataLen < sizeof(*ev)) {
handled = FALSE;
break;
}
port_in_use_ipv4(ev->port, ev->req_pid);
break;
}
#endif /* !TARGET_OS_IPHONE */
default :
handled = FALSE;
break;
}
break;
}
case KEV_INET6_SUBCLASS : {
struct kev_in6_data * ev;
eventName = inet6EventNameString(ev_msg->event_code);
ev = (struct kev_in6_data *)event_data;
switch (ev_msg->event_code) {
case KEV_INET6_NEW_USER_ADDR :
case KEV_INET6_CHANGED_ADDR :
case KEV_INET6_ADDR_DELETED :
case KEV_INET6_NEW_LL_ADDR :
case KEV_INET6_NEW_RTADV_ADDR :
case KEV_INET6_DEFROUTER :
if (dataLen < sizeof(*ev)) {
handled = FALSE;
break;
}
copy_if_name(&ev->link_data, ifr_name, sizeof(ifr_name));
interface_update_ipv6(NULL, ifr_name);
break;
default :
handled = FALSE;
break;
}
break;
}
case KEV_DL_SUBCLASS : {
struct net_event_data * ev;
eventName = dlEventNameString(ev_msg->event_code);
ev = (struct net_event_data *)event_data;
switch (ev_msg->event_code) {
case KEV_DL_IF_ATTACHED :
/*
* new interface added
*/
if (dataLen < sizeof(*ev)) {
handled = FALSE;
break;
}
copy_if_name(ev, ifr_name, sizeof(ifr_name));
link_add(ifr_name);
break;
case KEV_DL_IF_DETACHED :
/*
* interface removed
*/
if (dataLen < sizeof(*ev)) {
handled = FALSE;
break;
}
copy_if_name(ev, ifr_name, sizeof(ifr_name));
link_remove(ifr_name);
break;
case KEV_DL_IF_DETACHING :
/*
* interface detaching
*/
if (dataLen < sizeof(*ev)) {
handled = FALSE;
break;
}
copy_if_name(ev, ifr_name, sizeof(ifr_name));
interface_detaching(ifr_name);
break;
case KEV_DL_PROTO_ATTACHED :
case KEV_DL_PROTO_DETACHED : {
struct kev_dl_proto_data * protoEvent;
protoEvent = (struct kev_dl_proto_data *)event_data;
if (dataLen < sizeof(*protoEvent)) {
handled = FALSE;
break;
}
copy_if_name(&protoEvent->link_data,
ifr_name, sizeof(ifr_name));
if (protoEvent->proto_remaining_count == 0) {
mark_if_down(ifr_name);
} else {
mark_if_up(ifr_name);
}
break;
}
#ifdef KEV_DL_IF_IDLE_ROUTE_REFCNT
case KEV_DL_IF_IDLE_ROUTE_REFCNT: {
/*
* interface route refcnt idle
*/
if (dataLen < sizeof(*ev)) {
handled = FALSE;
break;
}
copy_if_name(ev, ifr_name, sizeof(ifr_name));
interface_update_idle_state(ifr_name);
break;
}
#endif // KEV_DL_IF_IDLE_ROUTE_REFCNT
case KEV_DL_LINK_OFF :
case KEV_DL_LINK_ON :
/*
* update the link status in the store
*/
if (dataLen < sizeof(*ev)) {
handled = FALSE;
break;
}
copy_if_name(ev, ifr_name, sizeof(ifr_name));
link_update_status(ifr_name, FALSE);
break;
#ifdef KEV_DL_LINK_QUALITY_METRIC_CHANGED
case KEV_DL_LINK_QUALITY_METRIC_CHANGED: {
struct kev_dl_link_quality_metric_data * lqm_data;
lqm_data = (struct kev_dl_link_quality_metric_data *) event_data;
if (dataLen < sizeof(*ev)) {
handled = FALSE;
break;
}
copy_if_name(ev, ifr_name, sizeof(ifr_name));
interface_update_quality_metric(ifr_name,
lqm_data->link_quality_metric);
break;
}
#endif // KEV_DL_LINK_QUALITY_METRIC_CHANGED
#ifdef KEV_DL_ISSUES
case KEV_DL_ISSUES: {
struct kev_dl_issues *issues;
issues = (struct kev_dl_issues *)event_data;
if (dataLen < sizeof(*ev)) {
handled = FALSE;
break;
}
copy_if_name(ev, ifr_name, sizeof(ifr_name));
interface_update_link_issues(ifr_name,
issues->timestamp,
issues->modid,
DLIL_MODIDLEN,
issues->info,
(bcmp(issues->info, info_zero, DLIL_MODIDLEN) != 0)
?DLIL_MODARGLEN
:0);
break;
}
#endif // KEV_DL_ISSUES
case KEV_DL_SIFFLAGS :
case KEV_DL_SIFMETRICS :
case KEV_DL_SIFMTU :
case KEV_DL_SIFPHYS :
case KEV_DL_SIFMEDIA :
case KEV_DL_SIFGENERIC :
case KEV_DL_ADDMULTI :
case KEV_DL_DELMULTI :
case KEV_DL_LINK_ADDRESS_CHANGED :
case KEV_DL_WAKEFLAGS_CHANGED :
#ifdef KEV_DL_IFCAP_CHANGED
case KEV_DL_IFCAP_CHANGED :
#endif // KEV_DL_IFCAP_CHANGED
break;
default :
handled = FALSE;
break;
}
break;
}
#ifdef KEV_ND6_SUBCLASS
case KEV_ND6_SUBCLASS : {
eventName = nd6EventNameString(ev_msg->event_code);
switch (ev_msg->event_code) {
case KEV_KEV_ND6_RA :
break;
default :
handled = FALSE;
break;
}
break;
}
#endif // KEV_ND6_SUBCLASS
case KEV_LOG_SUBCLASS : {
break;
}
default :
handled = FALSE;
break;
}
if (handled == FALSE) {
CFStringRef evStr;
evStr = CFStringCreateWithCString(NULL,
(eventName != NULL) ? eventName : "New Apple network subclass",
kCFStringEncodingASCII);
logEvent(evStr, ev_msg);
CFRelease(evStr);
}
return;
}
static void
prime(void)
{
struct ifaddrs *ifap = NULL;
struct ifaddrs *scan;
int sock = -1;
SCLog(_verbose, LOG_DEBUG, CFSTR("prime() called"));
cache_open();
sock = dgram_socket(AF_INET);
if (sock == -1) {
SCLog(TRUE, LOG_ERR, CFSTR("could not get interface list, socket() failed: %s"), strerror(errno));
goto done;
}
if (getifaddrs(&ifap) == -1) {
SCLog(TRUE,
LOG_ERR,
CFSTR("could not get interface info, getifaddrs() failed: %s"),
strerror(errno));
goto done;
}
/* update list of interfaces & link status */
for (scan = ifap; scan != NULL; scan = scan->ifa_next) {
if (scan->ifa_addr == NULL
|| scan->ifa_addr->sa_family != AF_LINK) {
continue;
}
/* get the per-interface link/media information */
link_add(scan->ifa_name);
}
/*
* update IPv4 network addresses already assigned to
* the interfaces.
*/
ipv4_interface_update(ifap, NULL);
/*
* update IPv6 network addresses already assigned to
* the interfaces.
*/
interface_update_ipv6(ifap, NULL);
freeifaddrs(ifap);
done:
if (sock != -1)
close(sock);
cache_write(store);
cache_close();
network_changed = TRUE;
post_network_changed();
/* start handling kernel events */
dispatch_resume(S_kev_source);
return;
}
/**
* openMacvtapTap:
* Create an instance of a macvtap device and open its tap character
* device.
* @tgifname: Interface name that the macvtap is supposed to have. May
* be NULL if this function is supposed to choose a name
* @macaddress: The MAC address for the macvtap device
* @linkdev: The interface name of the NIC to connect to the external bridge
* @mode: int describing the mode for 'bridge', 'vepa' or 'private'.
* @vnet_hdr: 1 to enable IFF_VNET_HDR, 0 to disable it
* @vmuuid: The UUID of the VM the macvtap belongs to
* @virtPortProfile: pointer to object holding the virtual port profile data
* @res_ifname: Pointer to a string pointer where the actual name of the
* interface will be stored into if everything succeeded. It is up
* to the caller to free the string.
*
* Returns file descriptor of the tap device in case of success,
* negative value otherwise with error reported.
*
*/
int
openMacvtapTap(const char *tgifname,
const unsigned char *macaddress,
const char *linkdev,
int mode,
int vnet_hdr,
const unsigned char *vmuuid,
virVirtualPortProfileParamsPtr virtPortProfile,
char **res_ifname)
{
const char *type = "macvtap";
int c, rc;
char ifname[IFNAMSIZ];
int retries, do_retry = 0;
uint32_t macvtapMode = macvtapModeFromInt(mode);
const char *cr_ifname;
int ifindex;
*res_ifname = NULL;
if (tgifname) {
if(ifaceGetIndex(false, tgifname, &ifindex) == 0) {
if (STRPREFIX(tgifname,
MACVTAP_NAME_PREFIX)) {
goto create_name;
}
virReportSystemError(errno,
_("Interface %s already exists"), tgifname);
return -1;
}
cr_ifname = tgifname;
rc = link_add(type, macaddress, 6, tgifname, linkdev,
macvtapMode, &do_retry);
if (rc)
return -1;
} else {
create_name:
retries = 5;
for (c = 0; c < 8192; c++) {
snprintf(ifname, sizeof(ifname), MACVTAP_NAME_PATTERN, c);
if (ifaceGetIndex(false, ifname, &ifindex) == ENODEV) {
rc = link_add(type, macaddress, 6, ifname, linkdev,
macvtapMode, &do_retry);
if (rc == 0)
break;
if (do_retry && --retries)
continue;
return -1;
}
}
cr_ifname = ifname;
}
if (vpAssociatePortProfileId(cr_ifname,
macaddress,
linkdev,
virtPortProfile,
vmuuid) != 0) {
rc = -1;
goto link_del_exit;
}
rc = ifaceUp(cr_ifname);
if (rc != 0) {
virReportSystemError(errno,
_("cannot 'up' interface %s -- another "
"macvtap device may be 'up' and have the same "
"MAC address"),
cr_ifname);
rc = -1;
goto disassociate_exit;
}
rc = openTap(cr_ifname, 10);
if (rc >= 0) {
if (configMacvtapTap(rc, vnet_hdr) < 0) {
close(rc);
rc = -1;
goto disassociate_exit;
}
*res_ifname = strdup(cr_ifname);
} else
goto disassociate_exit;
return rc;
disassociate_exit:
vpDisassociatePortProfileId(cr_ifname,
macaddress,
linkdev,
virtPortProfile);
link_del_exit:
link_del(cr_ifname);
return rc;
}
