static bool
cmdNetworkDumpXML(vshControl *ctl, const vshCmd *cmd)
{
virNetworkPtr network;
bool ret = true;
char *dump;
unsigned int flags = 0;
int inactive;
if (!(network = virshCommandOptNetwork(ctl, cmd, NULL)))
return false;
inactive = vshCommandOptBool(cmd, "inactive");
if (inactive)
flags |= VIR_NETWORK_XML_INACTIVE;
dump = virNetworkGetXMLDesc(network, flags);
if (dump != NULL) {
vshPrint(ctl, "%s", dump);
VIR_FREE(dump);
} else {
ret = false;
}
virNetworkFree(network);
return ret;
}
static bool
cmdNetworkDefine(vshControl *ctl, const vshCmd *cmd)
{
virNetworkPtr network;
const char *from = NULL;
bool ret = true;
char *buffer;
virshControlPtr priv = ctl->privData;
if (vshCommandOptStringReq(ctl, cmd, "file", &from) < 0)
return false;
if (virFileReadAll(from, VSH_MAX_XML_FILE, &buffer) < 0)
return false;
network = virNetworkDefineXML(priv->conn, buffer);
VIR_FREE(buffer);
if (network != NULL) {
vshPrintExtra(ctl, _("Network %s defined from %s\n"),
virNetworkGetName(network), from);
virNetworkFree(network);
} else {
vshError(ctl, _("Failed to define network from %s"), from);
ret = false;
}
return ret;
}
static void
virNetworkEventDispatchDefaultFunc(virConnectPtr conn,
virObjectEventPtr event,
virConnectObjectEventGenericCallback cb,
void *cbopaque)
{
virNetworkPtr net = virGetNetwork(conn, event->meta.name, event->meta.uuid);
if (!net)
return;
switch ((virNetworkEventID)event->eventID) {
case VIR_NETWORK_EVENT_ID_LIFECYCLE:
{
virNetworkEventLifecyclePtr networkLifecycleEvent;
networkLifecycleEvent = (virNetworkEventLifecyclePtr)event;
((virConnectNetworkEventLifecycleCallback)cb)(conn, net,
networkLifecycleEvent->type,
networkLifecycleEvent->detail,
cbopaque);
goto cleanup;
}
case VIR_NETWORK_EVENT_ID_LAST:
break;
}
VIR_WARN("Unexpected event ID %d", event->eventID);
cleanup:
virNetworkFree(net);
}
static int DeleteVirtNetwork(EvalContext *ctx, virConnectPtr vc, Attributes a, Promise *pp)
{
virNetworkPtr network;
int ret = true;
if ((network = virNetworkLookupByName(vc, pp->promiser)) == NULL)
{
cfPS(ctx, LOG_LEVEL_VERBOSE, PROMISE_RESULT_NOOP, pp, a, "Couldn't find a network called '%s' - promise assumed kept",
pp->promiser);
return true;
}
if (virNetworkDestroy(network) == 0)
{
cfPS(ctx, LOG_LEVEL_INFO, PROMISE_RESULT_CHANGE, pp, a, "Deleted network '%s' - promise repaired", pp->promiser);
}
else
{
cfPS(ctx, LOG_LEVEL_ERR, PROMISE_RESULT_FAIL, pp, a, "Network deletion of '%s' failed", pp->promiser);
ret = false;
}
virNetworkFree(network);
return ret;
}
void spice_graphHlpThread::run()
{
if ( Q_NULLPTR==ptr_ConnPtr || Q_NULLPTR==*ptr_ConnPtr ) {
emit ptrIsNull();
return;
};
if ( virConnectRef(*ptr_ConnPtr)<0 ) {
sendConnErrors();
return;
};
QStringList nets;
virNetworkPtr *networks = Q_NULLPTR;
unsigned int flags =
VIR_CONNECT_LIST_NETWORKS_ACTIVE |
VIR_CONNECT_LIST_NETWORKS_INACTIVE;
int ret = virConnectListAllNetworks(
*ptr_ConnPtr, &networks, flags);
if ( ret<0 ) {
sendConnErrors();
} else {
// therefore correctly to use for() command,
// because networks[0] can not exist.
for (int i = 0; i < ret; i++) {
nets.append( virNetworkGetName(networks[i]) );
virNetworkFree(networks[i]);
};
if (networks) free(networks);
};
//int devs = virNodeNumOfDevices(ptr_ConnPtr, Q_NULLPTR, 0);
if ( virConnectClose(*ptr_ConnPtr)<0 ) {
sendConnErrors();
};
emit result(nets);
}
static PromiseResult CreateVirtNetwork(EvalContext *ctx, virConnectPtr vc, char **networks, Attributes a, const Promise *pp)
{
virNetworkPtr network;
char *xml_file;
char defaultxml[CF_MAXVARSIZE];
int i, found = false;
snprintf(defaultxml, CF_MAXVARSIZE - 1,
"<network>"
"<name>%s</name>"
"<bridge name=\"virbr0\" />"
"<forward mode=\"nat\"/>"
"<ip address=\"192.168.122.1\" netmask=\"255.255.255.0\">"
"<dhcp>"
"<range start=\"192.168.122.2\" end=\"192.168.122.254\" />" "</dhcp>" "</ip>" "</network>", pp->promiser);
for (i = 0; networks[i] != NULL; i++)
{
Log(LOG_LEVEL_VERBOSE, "Discovered a running network '%s'", networks[i]);
if (strcmp(networks[i], pp->promiser) == 0)
{
found = true;
}
}
if (found)
{
cfPS(ctx, LOG_LEVEL_VERBOSE, PROMISE_RESULT_NOOP, pp, a, "Network '%s' exists - promise kept", pp->promiser);
return PROMISE_RESULT_NOOP;
}
if (a.env.spec)
{
xml_file = xstrdup(a.env.spec);
}
else
{
xml_file = xstrdup(defaultxml);
}
PromiseResult result = PROMISE_RESULT_NOOP;
if ((network = virNetworkCreateXML(vc, xml_file)) == NULL)
{
cfPS(ctx, LOG_LEVEL_ERR, PROMISE_RESULT_FAIL, pp, a, "Unable to create network '%s'", pp->promiser);
free(xml_file);
return PROMISE_RESULT_FAIL;
}
else
{
cfPS(ctx, LOG_LEVEL_INFO, PROMISE_RESULT_CHANGE, pp, a, "Created network '%s' - promise repaired", pp->promiser);
result = PromiseResultUpdate(result, PROMISE_RESULT_CHANGE);
}
free(xml_file);
virNetworkFree(network);
return result;
}
static int CreateVirtNetwork(virConnectPtr vc, char **networks, Attributes a, Promise *pp)
{
virNetworkPtr network;
char *xml_file;
char defaultxml[CF_MAXVARSIZE];
int i, found = false;
snprintf(defaultxml, CF_MAXVARSIZE - 1,
"<network>"
"<name>%s</name>"
"<bridge name=\"virbr0\" />"
"<forward mode=\"nat\"/>"
"<ip address=\"192.168.122.1\" netmask=\"255.255.255.0\">"
"<dhcp>"
"<range start=\"192.168.122.2\" end=\"192.168.122.254\" />" "</dhcp>" "</ip>" "</network>", pp->promiser);
for (i = 0; networks[i] != NULL; i++)
{
CfOut(cf_verbose, "", " -> Discovered a running network \"%s\"", networks[i]);
if (strcmp(networks[i], pp->promiser) == 0)
{
found = true;
}
}
if (found)
{
cfPS(cf_verbose, CF_NOP, "", pp, a, " -> Network \"%s\" exists - promise kept\n", pp->promiser);
return true;
}
if (a.env.spec)
{
xml_file = xstrdup(a.env.spec);
}
else
{
xml_file = xstrdup(defaultxml);
}
if ((network = virNetworkCreateXML(vc, xml_file)) == NULL)
{
cfPS(cf_error, CF_FAIL, "", pp, a, " !! Unable to create network \"%s\"\n", pp->promiser);
free(xml_file);
return false;
}
else
{
cfPS(cf_inform, CF_CHG, "", pp, a, " -> Created network \"%s\" - promise repaired\n", pp->promiser);
}
free(xml_file);
virNetworkFree(network);
return true;
}
static void gvir_network_finalize(GObject *object)
{
GVirNetwork *conn = GVIR_NETWORK(object);
GVirNetworkPrivate *priv = conn->priv;
g_debug("Finalize GVirNetwork=%p", conn);
virNetworkFree(priv->handle);
G_OBJECT_CLASS(gvir_network_parent_class)->finalize(object);
}
int main(int argc, char *argv[])
{
virConnectPtr conn;
virNetworkPtr net;
if(argc != 2)
{
printf("usage: ./start_network domain_network\n");
return -1;
}
conn = virConnectOpen("qemu:///system");
if (conn == NULL)
{
fprintf(stderr, "Failed to open connection to qemu:///system\n");
return -1;
}
net = virNetworkLookupByName(conn, argv[1]);
if (!net)
{
fprintf(stderr, "Network is not found\n");
virConnectClose(conn);
return -1;
}
if (virNetworkCreate(net) < 0)
{
virNetworkFree(net);
virConnectClose(conn);
fprintf(stderr, "Cannot start network\n");
return -1;
}
fprintf(stderr, "Network %s has started\n", argv[1]);
virNetworkFree(net);
virConnectClose(conn);
return 0;
}
int ConnAliveThread::netEventCallback(virConnectPtr _conn, virNetworkPtr net, int event, int detail, void *opaque)
{
//qDebug()<<"netEventCallback"<<_conn;
ConnAliveThread *obj = static_cast<ConnAliveThread*>(opaque);
if ( NULL==obj || *(obj->ptr_ConnPtr)!=_conn ) return 0;
QString msg;
msg = QString("<b>'%1'</b> Network %2 %3\n")
.arg(virNetworkGetName(net))
.arg(obj->netEventToString(event))
.arg(obj->netEventDetailToString(event, detail));
emit obj->connMsg(msg);
if ( obj->onView ) {
Result result;
QStringList virtNetList;
if ( _conn!=NULL && obj->keep_alive ) {
virNetworkPtr *networks = NULL;
unsigned int flags = VIR_CONNECT_LIST_NETWORKS_ACTIVE |
VIR_CONNECT_LIST_NETWORKS_INACTIVE;
// the number of networks found or -1 and sets networks to NULL in case of error.
int ret = virConnectListAllNetworks(_conn, &networks, flags);
if ( ret<0 ) {
obj->sendConnErrors();
return 0;
};
// therefore correctly to use for() command, because networks[0] can not exist.
for (int i = 0; i < ret; i++) {
QStringList currentAttr;
QString autostartStr;
int is_autostart = 0;
if (virNetworkGetAutostart(networks[i], &is_autostart) < 0) {
autostartStr.append("no autostart");
} else autostartStr.append( is_autostart ? "yes" : "no" );
currentAttr<< QString().fromUtf8( virNetworkGetName(networks[i]) )
<< QString( virNetworkIsActive(networks[i]) ? "active" : "inactive" )
<< autostartStr
<< QString( virNetworkIsPersistent(networks[i]) ? "yes" : "no" );
virtNetList.append(currentAttr.join(DFR));
//qDebug()<<currentAttr;
virNetworkFree(networks[i]);
};
free(networks);
};
//result.name = ;
result.type = "network";
//result.number = number;
result.action = GET_ALL_ENTITY_STATE;
result.result = true;
result.msg = virtNetList;
emit obj->netStateChanged(result);
};
return 0;
}
static void
virshNetworkListFree(virshNetworkListPtr list)
{
size_t i;
if (list && list->nets) {
for (i = 0; i < list->nnets; i++) {
if (list->nets[i])
virNetworkFree(list->nets[i]);
}
VIR_FREE(list->nets);
}
VIR_FREE(list);
}
static int
testNetworkDefine(const void *data)
{
const objecteventTest *test = data;
lifecycleEventCounter counter;
virNetworkPtr net;
int id;
int ret = 0;
lifecycleEventCounter_reset(&counter);
id = virConnectNetworkEventRegisterAny(test->conn, NULL,
VIR_NETWORK_EVENT_ID_LIFECYCLE,
VIR_NETWORK_EVENT_CALLBACK(&networkLifecycleCb),
&counter, NULL);
/* Make sure the define event is triggered */
net = virNetworkDefineXML(test->conn, networkDef);
if (virEventRunDefaultImpl() < 0) {
ret = -1;
goto cleanup;
}
if (counter.defineEvents != 1 || counter.unexpectedEvents > 0) {
ret = -1;
goto cleanup;
}
/* Make sure the undefine event is triggered */
virNetworkUndefine(net);
if (virEventRunDefaultImpl() < 0) {
ret = -1;
goto cleanup;
}
if (counter.undefineEvents != 1 || counter.unexpectedEvents > 0) {
ret = -1;
goto cleanup;
}
cleanup:
virConnectNetworkEventDeregisterAny(test->conn, id);
virNetworkFree(net);
return ret;
}
void
vert_cleanup(ErlNifEnv *env, void *obj)
{
VERT_RESOURCE *vp = obj;
if (vp->res == NULL)
return;
switch (vp->type) {
case VERT_RES_CONNECT:
(void)virConnectClose(vp->res);
break;
case VERT_RES_DOMAIN:
(void)virDomainFree(vp->res);
break;
case VERT_RES_INTERFACE:
(void)virInterfaceFree(vp->res);
break;
case VERT_RES_NETWORK:
(void)virNetworkFree(vp->res);
break;
case VERT_RES_NODEDEVICE:
(void)virNodeDeviceFree(vp->res);
break;
#if HAVE_NWFILTER
case VERT_RES_NWFILTER:
(void)virNWFilterFree(vp->res);
break;
#endif
case VERT_RES_SECRET:
(void)virSecretFree(vp->res);
break;
case VERT_RES_STORAGEPOOL:
(void)virStoragePoolFree(vp->res);
break;
case VERT_RES_STORAGEVOL:
(void)virStorageVolFree(vp->res);
break;
case VERT_RES_STREAM:
(void)virStreamFree(vp->res);
break;
default:
break;
}
vp->res = NULL;
}
static void gvir_network_set_property(GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GVirNetwork *conn = GVIR_NETWORK(object);
GVirNetworkPrivate *priv = conn->priv;
switch (prop_id) {
case PROP_HANDLE:
if (priv->handle)
virNetworkFree(priv->handle);
priv->handle = g_value_dup_boxed(value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
}
}
static bool
cmdNetworkDestroy(vshControl *ctl, const vshCmd *cmd)
{
virNetworkPtr network;
bool ret = true;
const char *name;
if (!(network = virshCommandOptNetwork(ctl, cmd, &name)))
return false;
if (virNetworkDestroy(network) == 0) {
vshPrint(ctl, _("Network %s destroyed\n"), name);
} else {
vshError(ctl, _("Failed to destroy network %s"), name);
ret = false;
}
virNetworkFree(network);
return ret;
}
static bool
cmdNetworkInfo(vshControl *ctl, const vshCmd *cmd)
{
virNetworkPtr network;
char uuid[VIR_UUID_STRING_BUFLEN];
int autostart;
int persistent = -1;
int active = -1;
char *bridge = NULL;
if (!(network = virshCommandOptNetwork(ctl, cmd, NULL)))
return false;
vshPrint(ctl, "%-15s %s\n", _("Name:"), virNetworkGetName(network));
if (virNetworkGetUUIDString(network, uuid) == 0)
vshPrint(ctl, "%-15s %s\n", _("UUID:"), uuid);
active = virNetworkIsActive(network);
if (active >= 0)
vshPrint(ctl, "%-15s %s\n", _("Active:"), active? _("yes") : _("no"));
persistent = virNetworkIsPersistent(network);
if (persistent < 0)
vshPrint(ctl, "%-15s %s\n", _("Persistent:"), _("unknown"));
else
vshPrint(ctl, "%-15s %s\n", _("Persistent:"), persistent ? _("yes") : _("no"));
if (virNetworkGetAutostart(network, &autostart) < 0)
vshPrint(ctl, "%-15s %s\n", _("Autostart:"), _("no autostart"));
else
vshPrint(ctl, "%-15s %s\n", _("Autostart:"), autostart ? _("yes") : _("no"));
bridge = virNetworkGetBridgeName(network);
if (bridge)
vshPrint(ctl, "%-15s %s\n", _("Bridge:"), bridge);
VIR_FREE(bridge);
virNetworkFree(network);
return true;
}
Result NetControlThread::getVirtNetXMLDesc()
{
Result result;
QString name = task.object;
result.name = name;
bool read = false;
char *Returns = nullptr;
if ( task.srcConnPtr==nullptr ) {
result.result = false;
result.err = "Connection pointer is NULL.";
return result;
};
virNetworkPtr network = virNetworkLookupByName(
*task.srcConnPtr, name.toUtf8().data());
if ( network!=nullptr ) {
Returns = virNetworkGetXMLDesc(
network, VIR_NETWORK_XML_INACTIVE);
if ( Returns==nullptr )
result.err = sendConnErrors();
else read = true;
virNetworkFree(network);
} else
result.err = sendConnErrors();
QTemporaryFile f;
f.setAutoRemove(false);
f.setFileTemplate(
QString("%1%2XML_Desc-XXXXXX.xml")
.arg(QDir::tempPath()).arg(QDir::separator()));
read = f.open();
if (read) f.write(Returns);
result.fileName.append(f.fileName());
f.close();
if ( Returns!=nullptr ) free(Returns);
result.result = read;
result.msg.append(QString("'<b>%1</b>' Network %2 XML'ed")
.arg(name).arg((read)?"":"don't"));
return result;
}
Result NetControlThread::getAllNetworkList()
{
Result result;
QStringList virtNetList;
if ( task.srcConnPtr!=nullptr && keep_alive ) {
virNetworkPtr *networks = nullptr;
unsigned int flags = VIR_CONNECT_LIST_NETWORKS_ACTIVE |
VIR_CONNECT_LIST_NETWORKS_INACTIVE;
int ret = virConnectListAllNetworks(*task.srcConnPtr, &networks, flags);
if ( ret<0 ) {
result.err = sendConnErrors();
return result;
};
// therefore correctly to use for() command, because networks[0] can not exist.
for (int i = 0; i < ret; i++) {
QStringList currentAttr;
QString autostartStr;
int is_autostart = 0;
if (virNetworkGetAutostart(networks[i], &is_autostart) < 0) {
autostartStr.append("no autostart");
} else autostartStr.append( is_autostart ? "yes" : "no" );
currentAttr<< QString::fromUtf8( virNetworkGetName(networks[i]) )
<< QString( virNetworkIsActive(networks[i]) ? "active" : "inactive" )
<< autostartStr
<< QString( virNetworkIsPersistent(networks[i]) ? "yes" : "no" );
virtNetList.append(currentAttr.join(DFR));
//qDebug()<<currentAttr;
virNetworkFree(networks[i]);
};
if (networks) free(networks);
};
result.result = true;
result.msg = virtNetList;
return result;
}
static virshNetworkListPtr
virshNetworkListCollect(vshControl *ctl,
unsigned int flags)
{
virshNetworkListPtr list = vshMalloc(ctl, sizeof(*list));
size_t i;
int ret;
char **names = NULL;
virNetworkPtr net;
bool success = false;
size_t deleted = 0;
int persistent;
int autostart;
int nActiveNets = 0;
int nInactiveNets = 0;
int nAllNets = 0;
virshControlPtr priv = ctl->privData;
/* try the list with flags support (0.10.2 and later) */
if ((ret = virConnectListAllNetworks(priv->conn,
&list->nets,
flags)) >= 0) {
list->nnets = ret;
goto finished;
}
/* check if the command is actually supported */
if (last_error && last_error->code == VIR_ERR_NO_SUPPORT)
goto fallback;
if (last_error && last_error->code == VIR_ERR_INVALID_ARG) {
/* try the new API again but mask non-guaranteed flags */
unsigned int newflags = flags & (VIR_CONNECT_LIST_NETWORKS_ACTIVE |
VIR_CONNECT_LIST_NETWORKS_INACTIVE);
vshResetLibvirtError();
if ((ret = virConnectListAllNetworks(priv->conn, &list->nets,
newflags)) >= 0) {
list->nnets = ret;
goto filter;
}
}
/* there was an error during the first or second call */
vshError(ctl, "%s", _("Failed to list networks"));
goto cleanup;
fallback:
/* fall back to old method (0.10.1 and older) */
vshResetLibvirtError();
/* Get the number of active networks */
if (!VSH_MATCH(VIR_CONNECT_LIST_NETWORKS_FILTERS_ACTIVE) ||
VSH_MATCH(VIR_CONNECT_LIST_NETWORKS_ACTIVE)) {
if ((nActiveNets = virConnectNumOfNetworks(priv->conn)) < 0) {
vshError(ctl, "%s", _("Failed to get the number of active networks"));
goto cleanup;
}
}
/* Get the number of inactive networks */
if (!VSH_MATCH(VIR_CONNECT_LIST_NETWORKS_FILTERS_ACTIVE) ||
VSH_MATCH(VIR_CONNECT_LIST_NETWORKS_INACTIVE)) {
if ((nInactiveNets = virConnectNumOfDefinedNetworks(priv->conn)) < 0) {
vshError(ctl, "%s", _("Failed to get the number of inactive networks"));
goto cleanup;
}
}
nAllNets = nActiveNets + nInactiveNets;
if (nAllNets == 0)
return list;
names = vshMalloc(ctl, sizeof(char *) * nAllNets);
/* Retrieve a list of active network names */
if (!VSH_MATCH(VIR_CONNECT_LIST_NETWORKS_FILTERS_ACTIVE) ||
VSH_MATCH(VIR_CONNECT_LIST_NETWORKS_ACTIVE)) {
if (virConnectListNetworks(priv->conn,
names, nActiveNets) < 0) {
vshError(ctl, "%s", _("Failed to list active networks"));
goto cleanup;
}
}
/* Add the inactive networks to the end of the name list */
if (!VSH_MATCH(VIR_CONNECT_LIST_NETWORKS_FILTERS_ACTIVE) ||
VSH_MATCH(VIR_CONNECT_LIST_NETWORKS_ACTIVE)) {
if (virConnectListDefinedNetworks(priv->conn,
&names[nActiveNets],
nInactiveNets) < 0) {
vshError(ctl, "%s", _("Failed to list inactive networks"));
goto cleanup;
}
}
list->nets = vshMalloc(ctl, sizeof(virNetworkPtr) * (nAllNets));
list->nnets = 0;
/* get active networks */
for (i = 0; i < nActiveNets; i++) {
if (!(net = virNetworkLookupByName(priv->conn, names[i])))
continue;
list->nets[list->nnets++] = net;
}
/* get inactive networks */
for (i = 0; i < nInactiveNets; i++) {
if (!(net = virNetworkLookupByName(priv->conn, names[i])))
continue;
list->nets[list->nnets++] = net;
}
/* truncate networks that weren't found */
deleted = nAllNets - list->nnets;
filter:
/* filter list the list if the list was acquired by fallback means */
for (i = 0; i < list->nnets; i++) {
net = list->nets[i];
/* persistence filter */
if (VSH_MATCH(VIR_CONNECT_LIST_NETWORKS_FILTERS_PERSISTENT)) {
if ((persistent = virNetworkIsPersistent(net)) < 0) {
vshError(ctl, "%s", _("Failed to get network persistence info"));
goto cleanup;
}
if (!((VSH_MATCH(VIR_CONNECT_LIST_NETWORKS_PERSISTENT) && persistent) ||
(VSH_MATCH(VIR_CONNECT_LIST_NETWORKS_TRANSIENT) && !persistent)))
goto remove_entry;
}
/* autostart filter */
if (VSH_MATCH(VIR_CONNECT_LIST_NETWORKS_FILTERS_AUTOSTART)) {
if (virNetworkGetAutostart(net, &autostart) < 0) {
vshError(ctl, "%s", _("Failed to get network autostart state"));
goto cleanup;
}
if (!((VSH_MATCH(VIR_CONNECT_LIST_NETWORKS_AUTOSTART) && autostart) ||
(VSH_MATCH(VIR_CONNECT_LIST_NETWORKS_NO_AUTOSTART) && !autostart)))
goto remove_entry;
}
/* the pool matched all filters, it may stay */
continue;
remove_entry:
/* the pool has to be removed as it failed one of the filters */
virNetworkFree(list->nets[i]);
list->nets[i] = NULL;
deleted++;
}
finished:
/* sort the list */
if (list->nets && list->nnets)
qsort(list->nets, list->nnets,
sizeof(*list->nets), virshNetworkSorter);
/* truncate the list if filter simulation deleted entries */
if (deleted)
VIR_SHRINK_N(list->nets, list->nnets, deleted);
success = true;
cleanup:
for (i = 0; i < nAllNets; i++)
VIR_FREE(names[i]);
VIR_FREE(names);
if (!success) {
virshNetworkListFree(list);
list = NULL;
}
return list;
}
/**
* virLXCProcessSetupInterfaces:
* @conn: pointer to connection
* @def: pointer to virtual machine structure
* @nveths: number of interfaces
* @veths: interface names
*
* Sets up the container interfaces by creating the veth device pairs and
* attaching the parent end to the appropriate bridge. The container end
* will moved into the container namespace later after clone has been called.
*
* Returns 0 on success or -1 in case of error
*/
static int virLXCProcessSetupInterfaces(virConnectPtr conn,
virDomainDefPtr def,
size_t *nveths,
char ***veths)
{
int ret = -1;
size_t i;
for (i = 0; i < def->nnets; i++) {
char *veth = NULL;
/* If appropriate, grab a physical device from the configured
* network's pool of devices, or resolve bridge device name
* to the one defined in the network definition.
*/
if (networkAllocateActualDevice(def, def->nets[i]) < 0)
goto cleanup;
if (VIR_EXPAND_N(*veths, *nveths, 1) < 0)
goto cleanup;
switch (virDomainNetGetActualType(def->nets[i])) {
case VIR_DOMAIN_NET_TYPE_NETWORK: {
virNetworkPtr network;
char *brname = NULL;
bool fail = false;
int active;
virErrorPtr errobj;
if (!(network = virNetworkLookupByName(conn,
def->nets[i]->data.network.name)))
goto cleanup;
active = virNetworkIsActive(network);
if (active != 1) {
fail = true;
if (active == 0)
virReportError(VIR_ERR_INTERNAL_ERROR,
_("Network '%s' is not active."),
def->nets[i]->data.network.name);
}
if (!fail) {
brname = virNetworkGetBridgeName(network);
if (brname == NULL)
fail = true;
}
/* Make sure any above failure is preserved */
errobj = virSaveLastError();
virNetworkFree(network);
virSetError(errobj);
virFreeError(errobj);
if (fail)
goto cleanup;
if (!(veth = virLXCProcessSetupInterfaceBridged(conn,
def,
def->nets[i],
brname))) {
VIR_FREE(brname);
goto cleanup;
}
VIR_FREE(brname);
break;
}
case VIR_DOMAIN_NET_TYPE_BRIDGE: {
const char *brname = virDomainNetGetActualBridgeName(def->nets[i]);
if (!brname) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("No bridge name specified"));
goto cleanup;
}
if (!(veth = virLXCProcessSetupInterfaceBridged(conn,
def,
def->nets[i],
brname)))
goto cleanup;
} break;
case VIR_DOMAIN_NET_TYPE_DIRECT:
if (!(veth = virLXCProcessSetupInterfaceDirect(conn,
def,
def->nets[i])))
goto cleanup;
break;
case VIR_DOMAIN_NET_TYPE_USER:
case VIR_DOMAIN_NET_TYPE_ETHERNET:
case VIR_DOMAIN_NET_TYPE_SERVER:
case VIR_DOMAIN_NET_TYPE_CLIENT:
case VIR_DOMAIN_NET_TYPE_MCAST:
case VIR_DOMAIN_NET_TYPE_INTERNAL:
case VIR_DOMAIN_NET_TYPE_LAST:
virReportError(VIR_ERR_INTERNAL_ERROR,
_("Unsupported network type %s"),
virDomainNetTypeToString(
virDomainNetGetActualType(def->nets[i])
));
goto cleanup;
}
(*veths)[(*nveths)-1] = veth;
}
ret = 0;
cleanup:
if (ret < 0) {
for (i = 0; i < def->nnets; i++) {
virDomainNetDefPtr iface = def->nets[i];
virNetDevVPortProfilePtr vport = virDomainNetGetActualVirtPortProfile(iface);
if (vport && vport->virtPortType == VIR_NETDEV_VPORT_PROFILE_OPENVSWITCH)
ignore_value(virNetDevOpenvswitchRemovePort(
virDomainNetGetActualBridgeName(iface),
iface->ifname));
networkReleaseActualDevice(def, iface);
}
}
return ret;
}
int
libxlMakeNic(virDomainDefPtr def,
virDomainNetDefPtr l_nic,
libxl_device_nic *x_nic)
{
bool ioemu_nic = STREQ(def->os.type, "hvm");
virDomainNetType actual_type = virDomainNetGetActualType(l_nic);
/* TODO: Where is mtu stored?
*
* x_nics[i].mtu = 1492;
*/
if (l_nic->script && !(actual_type == VIR_DOMAIN_NET_TYPE_BRIDGE ||
actual_type == VIR_DOMAIN_NET_TYPE_ETHERNET)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("specifying a script is only supported with "
"interface types bridge and ethernet"));
return -1;
}
libxl_device_nic_init(x_nic);
virMacAddrGetRaw(&l_nic->mac, x_nic->mac);
if (ioemu_nic)
x_nic->nictype = LIBXL_NIC_TYPE_VIF_IOEMU;
else
x_nic->nictype = LIBXL_NIC_TYPE_VIF;
if (l_nic->model) {
if (VIR_STRDUP(x_nic->model, l_nic->model) < 0)
return -1;
if (STREQ(l_nic->model, "netfront"))
x_nic->nictype = LIBXL_NIC_TYPE_VIF;
}
if (VIR_STRDUP(x_nic->ifname, l_nic->ifname) < 0)
return -1;
switch (actual_type) {
case VIR_DOMAIN_NET_TYPE_BRIDGE:
if (VIR_STRDUP(x_nic->bridge,
virDomainNetGetActualBridgeName(l_nic)) < 0)
return -1;
/* fallthrough */
case VIR_DOMAIN_NET_TYPE_ETHERNET:
if (VIR_STRDUP(x_nic->script, l_nic->script) < 0)
return -1;
break;
case VIR_DOMAIN_NET_TYPE_NETWORK:
{
bool fail = false;
char *brname = NULL;
virNetworkPtr network;
virConnectPtr conn;
virErrorPtr errobj;
if (!(conn = virConnectOpen("xen:///system")))
return -1;
if (!(network =
virNetworkLookupByName(conn, l_nic->data.network.name))) {
virObjectUnref(conn);
return -1;
}
if ((brname = virNetworkGetBridgeName(network))) {
if (VIR_STRDUP(x_nic->bridge, brname) < 0)
fail = true;
} else {
fail = true;
}
VIR_FREE(brname);
/* Preserve any previous failure */
errobj = virSaveLastError();
virNetworkFree(network);
virSetError(errobj);
virFreeError(errobj);
virObjectUnref(conn);
if (fail)
return -1;
break;
}
case VIR_DOMAIN_NET_TYPE_USER:
case VIR_DOMAIN_NET_TYPE_SERVER:
case VIR_DOMAIN_NET_TYPE_CLIENT:
case VIR_DOMAIN_NET_TYPE_MCAST:
case VIR_DOMAIN_NET_TYPE_INTERNAL:
case VIR_DOMAIN_NET_TYPE_DIRECT:
case VIR_DOMAIN_NET_TYPE_HOSTDEV:
case VIR_DOMAIN_NET_TYPE_LAST:
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("unsupported interface type %s"),
virDomainNetTypeToString(l_nic->type));
return -1;
}
return 0;
}
static void
gvir_network_handle_free(GVirNetworkHandle *src)
{
virNetworkFree((virNetworkPtr)src);
}
static char *
umlBuildCommandLineNet(virConnectPtr conn,
virDomainDefPtr vm,
virDomainNetDefPtr def,
int idx)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
char macaddr[VIR_MAC_STRING_BUFLEN];
/* General format: ethNN=type,options */
virBufferAsprintf(&buf, "eth%d=", idx);
switch (def->type) {
case VIR_DOMAIN_NET_TYPE_USER:
/* ethNNN=slirp,macaddr */
virBufferAddLit(&buf, "slirp");
break;
case VIR_DOMAIN_NET_TYPE_ETHERNET:
/* ethNNN=tuntap,tapname,macaddr,gateway */
virBufferAddLit(&buf, "tuntap,");
if (def->ifname) {
virBufferAdd(&buf, def->ifname, -1);
}
if (def->data.ethernet.ipaddr) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("IP address not supported for ethernet interface"));
goto error;
}
break;
case VIR_DOMAIN_NET_TYPE_SERVER:
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("TCP server networking type not supported"));
goto error;
case VIR_DOMAIN_NET_TYPE_CLIENT:
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("TCP client networking type not supported"));
goto error;
case VIR_DOMAIN_NET_TYPE_MCAST:
/* ethNNN=tuntap,macaddr,ipaddr,port */
virBufferAddLit(&buf, "mcast");
break;
case VIR_DOMAIN_NET_TYPE_NETWORK:
{
char *bridge;
virNetworkPtr network = virNetworkLookupByName(conn,
def->data.network.name);
if (!network) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("Network '%s' not found"),
def->data.network.name);
goto error;
}
bridge = virNetworkGetBridgeName(network);
virNetworkFree(network);
if (bridge == NULL) {
goto error;
}
if (umlConnectTapDevice(conn, vm, def, bridge) < 0) {
VIR_FREE(bridge);
goto error;
}
/* ethNNN=tuntap,tapname,macaddr,gateway */
virBufferAsprintf(&buf, "tuntap,%s", def->ifname);
break;
}
case VIR_DOMAIN_NET_TYPE_BRIDGE:
if (umlConnectTapDevice(conn, vm, def,
def->data.bridge.brname) < 0)
goto error;
/* ethNNN=tuntap,tapname,macaddr,gateway */
virBufferAsprintf(&buf, "tuntap,%s", def->ifname);
break;
case VIR_DOMAIN_NET_TYPE_INTERNAL:
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("internal networking type not supported"));
goto error;
case VIR_DOMAIN_NET_TYPE_DIRECT:
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("direct networking type not supported"));
goto error;
case VIR_DOMAIN_NET_TYPE_HOSTDEV:
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("hostdev networking type not supported"));
goto error;
case VIR_DOMAIN_NET_TYPE_LAST:
break;
}
if (def->script) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("interface script execution not supported by this driver"));
goto error;
}
virBufferAsprintf(&buf, ",%s", virMacAddrFormat(&def->mac, macaddr));
if (def->type == VIR_DOMAIN_NET_TYPE_MCAST) {
virBufferAsprintf(&buf, ",%s,%d",
def->data.socket.address,
def->data.socket.port);
}
if (virBufferError(&buf)) {
virReportOOMError();
return NULL;
}
return virBufferContentAndReset(&buf);
error:
virBufferFreeAndReset(&buf);
return NULL;
}
