static virNetworkDriverStatePtr network_driver;
+
static virNetworkDriverStatePtr
networkGetDriver(void)
{
return network_driver;
}
-static void networkDriverLock(virNetworkDriverStatePtr driver)
+
+static void
+networkDriverLock(virNetworkDriverStatePtr driver)
{
virMutexLock(&driver->lock);
}
-static void networkDriverUnlock(virNetworkDriverStatePtr driver)
+
+
+static void
+networkDriverUnlock(virNetworkDriverStatePtr driver)
{
virMutexUnlock(&driver->lock);
}
+
static dnsmasqCapsPtr
networkGetDnsmasqCaps(virNetworkDriverStatePtr driver)
{
return ret;
}
+
static int
networkDnsmasqCapsRefresh(virNetworkDriverStatePtr driver)
{
return 0;
}
-static int networkStateCleanup(void);
-static int networkStartNetwork(virNetworkDriverStatePtr driver,
- virNetworkObjPtr network);
+static int
+networkStateCleanup(void);
+
+static int
+networkStartNetwork(virNetworkDriverStatePtr driver,
+ virNetworkObjPtr network);
+
+static int
+networkShutdownNetwork(virNetworkDriverStatePtr driver,
+ virNetworkObjPtr network);
+
+static int
+networkStartNetworkVirtual(virNetworkDriverStatePtr driver,
+ virNetworkObjPtr network);
+
+static int
+networkShutdownNetworkVirtual(virNetworkDriverStatePtr driver,
+ virNetworkObjPtr network);
-static int networkShutdownNetwork(virNetworkDriverStatePtr driver,
- virNetworkObjPtr network);
+static int
+networkStartNetworkExternal(virNetworkObjPtr network);
-static int networkStartNetworkVirtual(virNetworkDriverStatePtr driver,
- virNetworkObjPtr network);
+static int
+networkShutdownNetworkExternal(virNetworkObjPtr network);
-static int networkShutdownNetworkVirtual(virNetworkDriverStatePtr driver,
- virNetworkObjPtr network);
+static void
+networkReloadFirewallRules(virNetworkDriverStatePtr driver);
-static int networkStartNetworkExternal(virNetworkObjPtr network);
+static void
+networkRefreshDaemons(virNetworkDriverStatePtr driver);
-static int networkShutdownNetworkExternal(virNetworkObjPtr network);
+static int
+networkPlugBandwidth(virNetworkObjPtr net,
+ virDomainNetDefPtr iface);
-static void networkReloadFirewallRules(virNetworkDriverStatePtr driver);
-static void networkRefreshDaemons(virNetworkDriverStatePtr driver);
+static int
+networkUnplugBandwidth(virNetworkObjPtr net,
+ virDomainNetDefPtr iface);
-static int networkPlugBandwidth(virNetworkObjPtr net,
- virDomainNetDefPtr iface);
-static int networkUnplugBandwidth(virNetworkObjPtr net,
- virDomainNetDefPtr iface);
+static void
+networkNetworkObjTaint(virNetworkObjPtr net,
+ virNetworkTaintFlags taint);
-static void networkNetworkObjTaint(virNetworkObjPtr net,
- virNetworkTaintFlags taint);
static virNetworkObjPtr
networkObjFromNetwork(virNetworkPtr net)
return network;
}
+
static int
networkRunHook(virNetworkObjPtr network,
virDomainDefPtr dom,
return ret;
}
+
static char *
networkDnsmasqLeaseFileNameDefault(virNetworkDriverStatePtr driver,
const char *netname)
return leasefile;
}
+
static char *
networkDnsmasqLeaseFileNameCustom(virNetworkDriverStatePtr driver,
const char *bridge)
return leasefile;
}
+
static char *
networkDnsmasqConfigFileName(virNetworkDriverStatePtr driver,
const char *netname)
return conffile;
}
+
static char *
networkRadvdPidfileBasename(const char *netname)
{
return pidfilebase;
}
+
static char *
networkRadvdConfigFileName(virNetworkDriverStatePtr driver,
const char *netname)
return configfile;
}
+
static char *
networkMacMgrFileName(virNetworkDriverStatePtr driver,
const char *bridge)
return filename;
}
+
/* do needed cleanup steps and remove the network from the list */
static int
networkRemoveInactive(virNetworkDriverStatePtr driver,
return ret;
}
+
static int
networkMacMgrAdd(virNetworkDriverStatePtr driver,
virNetworkObjPtr network,
return ret;
}
+
static int
networkMacMgrDel(virNetworkDriverStatePtr driver,
virNetworkObjPtr network,
return ret;
}
+
static char *
networkBridgeDummyNicName(const char *brname)
{
return nicname;
}
+
static int
networkUpdateState(virNetworkObjPtr obj,
void *opaque)
return ret;
}
+
#if HAVE_FIREWALLD
static DBusHandlerResult
firewalld_dbus_filter_bridge(DBusConnection *connection ATTRIBUTE_UNUSED,
- DBusMessage *message, void *user_data)
+ DBusMessage *message,
+ void *user_data)
{
virNetworkDriverStatePtr driver = user_data;
}
#endif
+
static int
networkMigrateStateFiles(virNetworkDriverStatePtr driver)
{
return ret;
}
+
/**
* networkStateInitialize:
*
goto cleanup;
}
+
/**
* networkStateAutoStart:
*
network_driver);
}
+
/**
* networkStateReload:
*
* kill the specified pid/name, and wait a bit to make sure it's dead.
*/
static int
-networkKillDaemon(pid_t pid, const char *daemonName, const char *networkName)
+networkKillDaemon(pid_t pid,
+ const char *daemonName,
+ const char *networkName)
{
size_t i;
int ret = -1;
return ret;
}
+
/* the following does not build a file, it builds a list
* which is later saved into a file
*/
-
static int
networkBuildDnsmasqDhcpHostsList(dnsmasqContext *dctx,
virNetworkIPDefPtr ipdef)
return 0;
}
+
static int
networkBuildDnsmasqHostsList(dnsmasqContext *dctx,
virNetworkDNSDefPtr dnsdef)
return ret;
}
+
/* build the dnsmasq command line */
static int ATTRIBUTE_NONNULL(3)
networkBuildDhcpDaemonCommandLine(virNetworkDriverStatePtr driver,
return ret;
}
+
static int
networkStartDhcpDaemon(virNetworkDriverStatePtr driver,
virNetworkObjPtr network)
return ret;
}
+
/* networkRefreshDhcpDaemon:
* Update dnsmasq config files, then send a SIGHUP so that it rereads
* them. This only works for the dhcp-hostsfile and the
return ret;
}
+
/* networkRestartDhcpDaemon:
*
* kill and restart dnsmasq, in order to update any config that is on
return networkStartDhcpDaemon(driver, network);
}
+
static char radvd1[] = " AdvOtherConfigFlag off;\n\n";
static char radvd2[] = " AdvAutonomous off;\n";
static char radvd3[] = " AdvOnLink on;\n"
" AdvRouterAddr off;\n";
static int
-networkRadvdConfContents(virNetworkObjPtr network, char **configstr)
+networkRadvdConfContents(virNetworkObjPtr network,
+ char **configstr)
{
virBuffer configbuf = VIR_BUFFER_INITIALIZER;
int ret = -1;
return ret;
}
+
/* write file and return its name (which must be freed by caller) */
static int
networkRadvdConfWrite(virNetworkDriverStatePtr driver,
return ret;
}
+
static int
networkStartRadvd(virNetworkDriverStatePtr driver,
virNetworkObjPtr network)
return ret;
}
+
static int
networkRefreshRadvd(virNetworkDriverStatePtr driver,
virNetworkObjPtr network)
return kill(network->radvdPid, SIGHUP);
}
+
#if 0
/* currently unused, so it causes a build error unless we #if it out */
static int
}
#endif /* #if 0 */
+
static int
networkRefreshDaemonsHelper(virNetworkObjPtr net,
void *opaque)
return 0;
}
+
/* SIGHUP/restart any dnsmasq or radvd daemons.
* This should be called when libvirtd is restarted.
*/
driver);
}
+
static int
networkReloadFirewallRulesHelper(virNetworkObjPtr net,
void *opaque ATTRIBUTE_UNUSED)
return 0;
}
+
static void
networkReloadFirewallRules(virNetworkDriverStatePtr driver)
{
NULL);
}
+
/* Enable IP Forwarding. Return 0 for success, -1 for failure. */
static int
-networkEnableIPForwarding(bool enableIPv4, bool enableIPv6)
+networkEnableIPForwarding(bool enableIPv4,
+ bool enableIPv6)
{
int ret = 0;
#ifdef HAVE_SYSCTLBYNAME
return ret;
}
+
static int
networkSetIPv6Sysctls(virNetworkObjPtr network)
{
return ret;
}
+
/* add an IP address to a bridge */
static int
networkAddAddrToBridge(virNetworkObjPtr network,
return ret;
}
+
static int
networkStartNetworkVirtual(virNetworkDriverStatePtr driver,
virNetworkObjPtr network)
return -1;
}
+
static int
networkShutdownNetworkVirtual(virNetworkDriverStatePtr driver,
virNetworkObjPtr network)
return networkStartHandleMACTableManagerMode(network, NULL);
}
+
static int
networkShutdownNetworkBridge(virNetworkObjPtr network ATTRIBUTE_UNUSED)
{
return networkCreateInterfacePool(network->def);
}
-static int networkShutdownNetworkExternal(virNetworkObjPtr network ATTRIBUTE_UNUSED)
+
+static int
+networkShutdownNetworkExternal(virNetworkObjPtr network ATTRIBUTE_UNUSED)
{
/* put anything here that needs to be done each time a network of
* type BRIDGE, PRIVATE, VEPA, HOSTDEV or PASSTHROUGH is shutdown. On
return 0;
}
+
static int
networkStartNetwork(virNetworkDriverStatePtr driver,
virNetworkObjPtr network)
return ret;
}
+
static int
networkShutdownNetwork(virNetworkDriverStatePtr driver,
virNetworkObjPtr network)
}
-static virNetworkPtr networkLookupByUUID(virConnectPtr conn,
- const unsigned char *uuid)
+static virNetworkPtr
+networkLookupByUUID(virConnectPtr conn,
+ const unsigned char *uuid)
{
virNetworkDriverStatePtr driver = networkGetDriver();
virNetworkObjPtr network;
return ret;
}
-static virNetworkPtr networkLookupByName(virConnectPtr conn,
- const char *name)
+
+static virNetworkPtr
+networkLookupByName(virConnectPtr conn,
+ const char *name)
{
virNetworkDriverStatePtr driver = networkGetDriver();
virNetworkObjPtr network;
return ret;
}
-static int networkConnectNumOfNetworks(virConnectPtr conn)
+
+static int
+networkConnectNumOfNetworks(virConnectPtr conn)
{
virNetworkDriverStatePtr driver = networkGetDriver();
int nactive;
return nactive;
}
-static int networkConnectListNetworks(virConnectPtr conn,
- char **const names,
- int nnames)
+
+static int
+networkConnectListNetworks(virConnectPtr conn,
+ char **const names,
+ int nnames)
{
virNetworkDriverStatePtr driver = networkGetDriver();
int got = 0;
return got;
}
-static int networkConnectNumOfDefinedNetworks(virConnectPtr conn)
+
+static int
+networkConnectNumOfDefinedNetworks(virConnectPtr conn)
{
virNetworkDriverStatePtr driver = networkGetDriver();
int ninactive = 0;
return ninactive;
}
-static int networkConnectListDefinedNetworks(virConnectPtr conn, char **const names, int nnames)
+
+static int
+networkConnectListDefinedNetworks(virConnectPtr conn,
+ char **const names,
+ int nnames)
{
virNetworkDriverStatePtr driver = networkGetDriver();
int got = 0;
return got;
}
+
static int
networkConnectListAllNetworks(virConnectPtr conn,
virNetworkPtr **nets,
return ret;
}
+
static int
networkConnectNetworkEventRegisterAny(virConnectPtr conn,
virNetworkPtr net,
return ret;
}
+
static int
networkConnectNetworkEventDeregisterAny(virConnectPtr conn,
int callbackID)
return ret;
}
-static int networkIsActive(virNetworkPtr net)
+
+static int
+networkIsActive(virNetworkPtr net)
{
virNetworkObjPtr obj;
int ret = -1;
return ret;
}
-static int networkIsPersistent(virNetworkPtr net)
+
+static int
+networkIsPersistent(virNetworkPtr net)
{
virNetworkObjPtr obj;
int ret = -1;
}
-
/*
* networkValidateBridgeName() - if no bridge name is set, or if the
* bridge name contains a %d (indicating that this is a template for
return 0;
}
-static virNetworkPtr networkCreateXML(virConnectPtr conn, const char *xml)
+
+static virNetworkPtr
+networkCreateXML(virConnectPtr conn,
+ const char *xml)
{
virNetworkDriverStatePtr driver = networkGetDriver();
virNetworkDefPtr def;
return ret;
}
-static virNetworkPtr networkDefineXML(virConnectPtr conn, const char *xml)
+
+static virNetworkPtr
+networkDefineXML(virConnectPtr conn,
+ const char *xml)
{
virNetworkDriverStatePtr driver = networkGetDriver();
virNetworkDefPtr def = NULL;
return ret;
}
+
static int
networkUndefine(virNetworkPtr net)
{
return ret;
}
+
static int
networkUpdate(virNetworkPtr net,
unsigned int command,
return ret;
}
-static int networkCreate(virNetworkPtr net)
+
+static int
+networkCreate(virNetworkPtr net)
{
virNetworkDriverStatePtr driver = networkGetDriver();
virNetworkObjPtr network;
return ret;
}
-static int networkDestroy(virNetworkPtr net)
+
+static int
+networkDestroy(virNetworkPtr net)
{
virNetworkDriverStatePtr driver = networkGetDriver();
virNetworkObjPtr network;
return ret;
}
-static char *networkGetXMLDesc(virNetworkPtr net,
- unsigned int flags)
+
+static char *
+networkGetXMLDesc(virNetworkPtr net,
+ unsigned int flags)
{
virNetworkObjPtr network;
virNetworkDefPtr def;
return ret;
}
-static char *networkGetBridgeName(virNetworkPtr net) {
+
+static char *
+networkGetBridgeName(virNetworkPtr net)
+{
virNetworkObjPtr network;
char *bridge = NULL;
return bridge;
}
-static int networkGetAutostart(virNetworkPtr net,
- int *autostart)
+
+static int
+networkGetAutostart(virNetworkPtr net,
+ int *autostart)
{
virNetworkObjPtr network;
int ret = -1;
return ret;
}
-static int networkSetAutostart(virNetworkPtr net,
- int autostart)
+
+static int
+networkSetAutostart(virNetworkPtr net,
+ int autostart)
{
virNetworkDriverStatePtr driver = networkGetDriver();
virNetworkObjPtr network;
return ret;
}
+
static int
networkGetDHCPLeases(virNetworkPtr network,
const char *mac,
.stateReload = networkStateReload,
};
-int networkRegister(void)
+int
+networkRegister(void)
{
if (virSetSharedNetworkDriver(&networkDriver) < 0)
return -1;
return 0;
}
+
/********************************************************/
/* A unified function to log network connections and disconnections */
}
}
+
/* Private API to deal with logical switch capabilities.
* These functions are exported so that other parts of libvirt can
* call them, but are not part of the public API and not in the
goto cleanup;
}
+
/* networkNotifyActualDevice:
* @dom: domain definition that @iface belongs to
* @iface: the domain's NetDef with an "actual" device already filled in.
}
-
/* networkReleaseActualDevice:
* @dom: domain definition that @iface belongs to
* @iface: a domain's NetDef (interface definition)
goto cleanup;
}
+
/*
* networkGetNetworkAddress:
* @netname: the name of a network
* completely unsupported.
*/
int
-networkGetNetworkAddress(const char *netname, char **netaddr)
+networkGetNetworkAddress(const char *netname,
+ char **netaddr)
{
virNetworkDriverStatePtr driver = networkGetDriver();
int ret = -1;
return ret;
}
+
/* networkGetActualType:
* @dom: domain definition that @iface belongs to
* @iface: the original NetDef from the domain
return ret;
}
+
/**
* networkNextClassID:
* @net: network object
return ret;
}
+
static int
networkUnplugBandwidth(virNetworkObjPtr net,
virDomainNetDefPtr iface)
return ret;
}
+
static void
networkNetworkObjTaint(virNetworkObjPtr net,
virNetworkTaintFlags taint)
projects / thirdparty / libvirt.git / commitdiff
