[libvirt] [libvirt-sandbox PATCH v3] Add filter support.

Wednesday, 8 January 2014

This patch adds two new classes, filterref and filterref-parameter.
Network interfaces can now have an associated filter reference with any
number of filterref parameters.  Also added filter= option to
virt-sandbox tool.

---
V2:

- Changed set_filter to set_name and get_filter to get_name.

V3:

- Added type checks on all public methods.
- Call setters on property set.
- Fix install_property flags.
- Remove unneeded HANDLE defines.
- Add missing g_list_free().
- Add missing unref().
- Fixed names in copyright notices.
- Change order of files in Makefile.am

 libvirt-sandbox/Makefile.am                        |   4 +
 .../libvirt-sandbox-builder-container.c            |  36 ++++
 libvirt-sandbox/libvirt-sandbox-builder-machine.c  |  36 ++++
 ...rt-sandbox-config-network-filterref-parameter.c | 208 ++++++++++++++++++++
 ...rt-sandbox-config-network-filterref-parameter.h |  73 +++++++
 .../libvirt-sandbox-config-network-filterref.c     | 218 +++++++++++++++++++++
 .../libvirt-sandbox-config-network-filterref.h     |  74 +++++++
 libvirt-sandbox/libvirt-sandbox-config-network.c   |  42 ++++
 libvirt-sandbox/libvirt-sandbox-config-network.h   |   4 +
 libvirt-sandbox/libvirt-sandbox-config.c           |  39 ++++
 libvirt-sandbox/libvirt-sandbox.h                  |   3 +
 libvirt-sandbox/libvirt-sandbox.sym                |  16 ++
 12 files changed, 753 insertions(+)
 create mode 100644 libvirt-sandbox/libvirt-sandbox-config-network-filterref-parameter.c
 create mode 100644 libvirt-sandbox/libvirt-sandbox-config-network-filterref-parameter.h
 create mode 100644 libvirt-sandbox/libvirt-sandbox-config-network-filterref.c
 create mode 100644 libvirt-sandbox/libvirt-sandbox-config-network-filterref.h

diff --git a/libvirt-sandbox/Makefile.am b/libvirt-sandbox/Makefile.am
index 0882490..720bb06 100644
--- a/libvirt-sandbox/Makefile.am
+++ b/libvirt-sandbox/Makefile.am
@@ -57,6 +57,8 @@ SANDBOX_HEADER_FILES = \
 			libvirt-sandbox-config.h \
 			libvirt-sandbox-config-network.h \
 			libvirt-sandbox-config-network-address.h \
+			libvirt-sandbox-config-network-filterref-parameter.h \
+			libvirt-sandbox-config-network-filterref.h \
 			libvirt-sandbox-config-network-route.h \
 			libvirt-sandbox-config-mount.h \
 			libvirt-sandbox-config-mount-file.h \
@@ -85,6 +87,8 @@ SANDBOX_SOURCE_FILES = \
 			libvirt-sandbox-config.c \
 			libvirt-sandbox-config-network.c \
 			libvirt-sandbox-config-network-address.c \
+			libvirt-sandbox-config-network-filterref.c \
+			libvirt-sandbox-config-network-filterref-parameter.c \
 			libvirt-sandbox-config-network-route.c \
 			libvirt-sandbox-config-mount.c \
 			libvirt-sandbox-config-mount-file.c \
diff --git a/libvirt-sandbox/libvirt-sandbox-builder-container.c
b/libvirt-sandbox/libvirt-sandbox-builder-container.c
index 43ee5ef..bac8c70 100644
--- a/libvirt-sandbox/libvirt-sandbox-builder-container.c
+++ b/libvirt-sandbox/libvirt-sandbox-builder-container.c
@@ -324,6 +324,8 @@ static gboolean
gvir_sandbox_builder_container_construct_devices(GVirSandboxBuil
     while (tmp) {
         const gchar *source, *mac;
         GVirSandboxConfigNetwork *network = GVIR_SANDBOX_CONFIG_NETWORK(tmp->data);
+        GVirSandboxConfigNetworkFilterref *filterref;
+        GVirConfigDomainInterfaceFilterref *glib_fref;
 
         iface = gvir_config_domain_interface_network_new();
         source = gvir_sandbox_config_network_get_source(network);
@@ -339,6 +341,40 @@ static gboolean
gvir_sandbox_builder_container_construct_devices(GVirSandboxBuil
 
         gvir_config_domain_add_device(domain,
                                       GVIR_CONFIG_DOMAIN_DEVICE(iface));
+
+        filterref = gvir_sandbox_config_network_get_filterref(network);
+        if (filterref) {
+            GList *param_iter, *parameters;
+            const gchar *fref_name =
gvir_sandbox_config_network_filterref_get_name(filterref);
+            glib_fref = gvir_config_domain_interface_filterref_new();
+            gvir_config_domain_interface_filterref_set_name(glib_fref, fref_name);
+            param_iter = parameters =
gvir_sandbox_config_network_filterref_get_parameters(filterref);
+            while (param_iter) {
+                const gchar *name;
+                const gchar *value;
+                GVirSandboxConfigNetworkFilterrefParameter *param =
GVIR_SANDBOX_CONFIG_NETWORK_FILTERREF_PARAMETER(param_iter->data);
+                GVirConfigDomainInterfaceFilterrefParameter *glib_param;
+
+                name = gvir_sandbox_config_network_filterref_parameter_get_name(param);
+                value =
gvir_sandbox_config_network_filterref_parameter_get_value(param);
+
+                glib_param = gvir_config_domain_interface_filterref_parameter_new();
+                gvir_config_domain_interface_filterref_parameter_set_name(glib_param,
name);
+                gvir_config_domain_interface_filterref_parameter_set_value(glib_param,
value);
+
+                gvir_config_domain_interface_filterref_add_parameter(glib_fref,
glib_param);
+                g_object_unref(glib_param);
+
+                param_iter = param_iter->next;
+            }
+
+            g_list_foreach(parameters, (GFunc)g_object_unref, NULL);
+            g_list_free(parameters);
+
+           
gvir_config_domain_interface_set_filterref(GVIR_CONFIG_DOMAIN_INTERFACE(iface),
glib_fref);
+            g_object_unref(glib_fref);
+        }
+
         g_object_unref(iface);
 
         tmp = tmp->next;
diff --git a/libvirt-sandbox/libvirt-sandbox-builder-machine.c
b/libvirt-sandbox/libvirt-sandbox-builder-machine.c
index 131b376..542663c 100644
--- a/libvirt-sandbox/libvirt-sandbox-builder-machine.c
+++ b/libvirt-sandbox/libvirt-sandbox-builder-machine.c
@@ -581,6 +581,8 @@ static gboolean
gvir_sandbox_builder_machine_construct_devices(GVirSandboxBuilde
     while (tmp) {
         const gchar *source, *mac;
         GVirSandboxConfigNetwork *network = GVIR_SANDBOX_CONFIG_NETWORK(tmp->data);
+        GVirSandboxConfigNetworkFilterref *filterref;
+        GVirConfigDomainInterfaceFilterref *glib_fref;
 
         source = gvir_sandbox_config_network_get_source(network);
         if (source) {
@@ -600,6 +602,40 @@ static gboolean
gvir_sandbox_builder_machine_construct_devices(GVirSandboxBuilde
 
         gvir_config_domain_add_device(domain,
                                       GVIR_CONFIG_DOMAIN_DEVICE(iface));
+
+        filterref = gvir_sandbox_config_network_get_filterref(network);
+        if (filterref) {
+            GList *param_iter, *parameters;
+            const gchar *fref_name =
gvir_sandbox_config_network_filterref_get_name(filterref);
+            glib_fref = gvir_config_domain_interface_filterref_new();
+            gvir_config_domain_interface_filterref_set_name(glib_fref, fref_name);
+            param_iter = parameters =
gvir_sandbox_config_network_filterref_get_parameters(filterref);
+            while (param_iter) {
+                const gchar *name;
+                const gchar *value;
+                GVirSandboxConfigNetworkFilterrefParameter *param =
GVIR_SANDBOX_CONFIG_NETWORK_FILTERREF_PARAMETER(param_iter->data);
+                GVirConfigDomainInterfaceFilterrefParameter *glib_param;
+
+                name = gvir_sandbox_config_network_filterref_parameter_get_name(param);
+                value =
gvir_sandbox_config_network_filterref_parameter_get_value(param);
+
+                glib_param = gvir_config_domain_interface_filterref_parameter_new();
+                gvir_config_domain_interface_filterref_parameter_set_name(glib_param,
name);
+                gvir_config_domain_interface_filterref_parameter_set_value(glib_param,
value);
+
+                gvir_config_domain_interface_filterref_add_parameter(glib_fref,
glib_param);
+                g_object_unref(glib_param);
+
+                param_iter = param_iter->next;
+            }
+
+            g_list_foreach(parameters, (GFunc)g_object_unref, NULL);
+            g_list_free(parameters);
+
+            gvir_config_domain_interface_set_filterref(iface, glib_fref);
+            g_object_unref(glib_fref);
+        }
+
         g_object_unref(iface);
 
         tmp = tmp->next;
diff --git a/libvirt-sandbox/libvirt-sandbox-config-network-filterref-parameter.c
b/libvirt-sandbox/libvirt-sandbox-config-network-filterref-parameter.c
new file mode 100644
index 0000000..fabed90
--- /dev/null
+++ b/libvirt-sandbox/libvirt-sandbox-config-network-filterref-parameter.c
@@ -0,0 +1,208 @@
+/*
+ * libvirt-sandbox-config-network-filterref-parameter.c: libvirt sandbox configuration
+ *
+ * Copyright (C) 2013 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Author: Ian Main <imain(a)redhat.com&gt;
+ */
+
+#include <config.h>
+#include <string.h>
+
+#include "libvirt-sandbox/libvirt-sandbox.h"
+
+/**
+ * SECTION: libvirt-sandbox-config-network-filterref-parameter
+ * @short_description: Set parameters for a filter reference.
+ * @include: libvirt-sandbox/libvirt-sandbox.h
+ *
+ * Provides an object to store filter parameter name and value.
+ *
+ * The GVirSandboxConfigNetworkFilterrefParameter object stores a
+ * name and value required to set a single parameter of a filter reference.
+ */
+
+#define GVIR_SANDBOX_CONFIG_NETWORK_FILTERREF_PARAMETER_GET_PRIVATE(obj)                 
       \
+        (G_TYPE_INSTANCE_GET_PRIVATE((obj),
GVIR_SANDBOX_TYPE_CONFIG_NETWORK_FILTERREF_PARAMETER,
GVirSandboxConfigNetworkFilterrefParameterPrivate))
+
+struct _GVirSandboxConfigNetworkFilterrefParameterPrivate
+{
+    gchar *name;
+    gchar *value;
+};
+
+G_DEFINE_TYPE(GVirSandboxConfigNetworkFilterrefParameter,
gvir_sandbox_config_network_filterref_parameter, G_TYPE_OBJECT);
+
+
+enum {
+    PROP_0,
+    PROP_NAME,
+    PROP_VALUE,
+};
+
+enum {
+    LAST_SIGNAL
+};
+
+//static gint signals[LAST_SIGNAL];
+
+
+static void gvir_sandbox_config_network_filterref_parameter_get_property(GObject
*object,
+                                                                         guint prop_id,
+                                                                         GValue *value,
+                                                                         GParamSpec
*pspec)
+{
+    GVirSandboxConfigNetworkFilterrefParameter *config =
GVIR_SANDBOX_CONFIG_NETWORK_FILTERREF_PARAMETER(object);
+    GVirSandboxConfigNetworkFilterrefParameterPrivate *priv = config->priv;
+
+    switch (prop_id) {
+    case PROP_NAME:
+        g_value_set_string(value, priv->name);
+        break;
+
+    case PROP_VALUE:
+        g_value_set_string(value, priv->value);
+        break;
+
+    default:
+        G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
+    }
+}
+
+
+static void gvir_sandbox_config_network_filterref_parameter_set_property(GObject
*object,
+                                                                         guint prop_id,
+                                                                         const GValue
*value,
+                                                                         GParamSpec
*pspec)
+{
+    GVirSandboxConfigNetworkFilterrefParameter *filter =
GVIR_SANDBOX_CONFIG_NETWORK_FILTERREF_PARAMETER(object);
+
+    switch (prop_id) {
+    case PROP_NAME:
+        gvir_sandbox_config_network_filterref_parameter_set_name(filter,
g_value_get_string(value));
+        break;
+
+    case PROP_VALUE:
+        gvir_sandbox_config_network_filterref_parameter_set_value(filter,
g_value_get_string(value));
+        break;
+
+    default:
+        G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
+    }
+}
+
+
+static void gvir_sandbox_config_network_filterref_parameter_finalize(GObject *object)
+{
+    GVirSandboxConfigNetworkFilterrefParameter *config =
GVIR_SANDBOX_CONFIG_NETWORK_FILTERREF_PARAMETER(object);
+    GVirSandboxConfigNetworkFilterrefParameterPrivate *priv = config->priv;
+
+    g_free(priv->name);
+    g_free(priv->value);
+
+   
G_OBJECT_CLASS(gvir_sandbox_config_network_filterref_parameter_parent_class)->finalize(object);
+}
+
+
+static void
gvir_sandbox_config_network_filterref_parameter_class_init(GVirSandboxConfigNetworkFilterrefParameterClass
*klass)
+{
+    GObjectClass *object_class = G_OBJECT_CLASS(klass);
+
+    object_class->finalize =
gvir_sandbox_config_network_filterref_parameter_finalize;
+    object_class->get_property =
gvir_sandbox_config_network_filterref_parameter_get_property;
+    object_class->set_property =
gvir_sandbox_config_network_filterref_parameter_set_property;
+
+    g_object_class_install_property(object_class,
+                                    PROP_NAME,
+                                    g_param_spec_string("name",
+                                                        "Name",
+                                                        "Name of parameter",
+                                                        NULL,
+                                                        G_PARAM_READWRITE |
+                                                        G_PARAM_STATIC_STRINGS));
+
+    g_object_class_install_property(object_class,
+                                    PROP_VALUE,
+                                    g_param_spec_string("value",
+                                                        "Value",
+                                                        "Value of parameter",
+                                                        NULL,
+                                                        G_PARAM_READWRITE |
+                                                        G_PARAM_STATIC_STRINGS));
+
+    g_type_class_add_private(klass,
sizeof(GVirSandboxConfigNetworkFilterrefParameterPrivate));
+}
+
+
+static void
gvir_sandbox_config_network_filterref_parameter_init(GVirSandboxConfigNetworkFilterrefParameter
*param)
+{
+    param->priv = GVIR_SANDBOX_CONFIG_NETWORK_FILTERREF_PARAMETER_GET_PRIVATE(param);
+}
+
+
+/**
+ * gvir_sandbox_config_network_filterref_parameter_new:
+ *
+ * Create a new network config with DHCP enabled
+ *
+ * Returns: (transfer full): a new sandbox network object
+ */
+GVirSandboxConfigNetworkFilterrefParameter
*gvir_sandbox_config_network_filterref_parameter_new(void)
+{
+    return
GVIR_SANDBOX_CONFIG_NETWORK_FILTERREF_PARAMETER(g_object_new(GVIR_SANDBOX_TYPE_CONFIG_NETWORK_FILTERREF_PARAMETER,
+                                                                        NULL));
+}
+
+void
gvir_sandbox_config_network_filterref_parameter_set_name(GVirSandboxConfigNetworkFilterrefParameter
*param,
+                                                              const gchar *name)
+{
+    GVirSandboxConfigNetworkFilterrefParameterPrivate *priv;
+
+    g_return_if_fail(GVIR_SANDBOX_IS_CONFIG_NETWORK_FILTERREF_PARAMETER(param));
+    priv = param->priv;
+    g_free(priv->name);
+    priv->name = g_strdup(name);
+}
+
+const gchar
*gvir_sandbox_config_network_filterref_parameter_get_name(GVirSandboxConfigNetworkFilterrefParameter
*param)
+{
+    GVirSandboxConfigNetworkFilterrefParameterPrivate *priv;
+
+    g_return_val_if_fail(GVIR_SANDBOX_IS_CONFIG_NETWORK_FILTERREF_PARAMETER(param),
NULL);
+    priv = param->priv;
+    return priv->name;
+}
+
+void
gvir_sandbox_config_network_filterref_parameter_set_value(GVirSandboxConfigNetworkFilterrefParameter
*param,
+                                                               const gchar *value)
+{
+    GVirSandboxConfigNetworkFilterrefParameterPrivate *priv;
+
+    g_return_if_fail(GVIR_SANDBOX_IS_CONFIG_NETWORK_FILTERREF_PARAMETER(param));
+    priv = param->priv;
+    g_free(priv->value);
+    priv->value = g_strdup(value);
+}
+
+const gchar
*gvir_sandbox_config_network_filterref_parameter_get_value(GVirSandboxConfigNetworkFilterrefParameter
*param)
+{
+    GVirSandboxConfigNetworkFilterrefParameterPrivate *priv;
+
+    g_return_val_if_fail(GVIR_SANDBOX_IS_CONFIG_NETWORK_FILTERREF_PARAMETER(param),
NULL);
+    priv = param->priv;
+    return priv->value;
+}
diff --git a/libvirt-sandbox/libvirt-sandbox-config-network-filterref-parameter.h
b/libvirt-sandbox/libvirt-sandbox-config-network-filterref-parameter.h
new file mode 100644
index 0000000..9544539
--- /dev/null
+++ b/libvirt-sandbox/libvirt-sandbox-config-network-filterref-parameter.h
@@ -0,0 +1,73 @@
+/*
+ * libvirt-sandbox-config-network-filterref-parameter.h: libvirt sandbox configuration
+ *
+ * Copyright (C) 2013 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Author: Ian Main <imain(a)redhat.com&gt;
+ */
+
+#if !defined(__LIBVIRT_SANDBOX_H__) && !defined(LIBVIRT_SANDBOX_BUILD)
+#error "Only <libvirt-sandbox/libvirt-sandbox.h> can be included
directly."
+#endif
+
+#ifndef __LIBVIRT_SANDBOX_CONFIG_NETWORK_FILTERREF_PARAMETER_H__
+#define __LIBVIRT_SANDBOX_CONFIG_NETWORK_FILTERREF_PARAMETER_H__
+
+G_BEGIN_DECLS
+
+#define GVIR_SANDBOX_TYPE_CONFIG_NETWORK_FILTERREF_PARAMETER           
(gvir_sandbox_config_network_filterref_parameter_get_type ())
+#define GVIR_SANDBOX_CONFIG_NETWORK_FILTERREF_PARAMETER(obj)           
(G_TYPE_CHECK_INSTANCE_CAST ((obj), GVIR_SANDBOX_TYPE_CONFIG_NETWORK_FILTERREF_PARAMETER,
GVirSandboxConfigNetworkFilterrefParameter))
+#define GVIR_SANDBOX_CONFIG_NETWORK_FILTERREF_PARAMETER_CLASS(klass)   
(G_TYPE_CHECK_CLASS_CAST ((klass), GVIR_SANDBOX_TYPE_CONFIG_NETWORK_FILTERREF_PARAMETER,
GVirSandboxConfigNetworkFilterrefParameterClass))
+#define GVIR_SANDBOX_IS_CONFIG_NETWORK_FILTERREF_PARAMETER(obj)        
(G_TYPE_CHECK_INSTANCE_TYPE ((obj),
GVIR_SANDBOX_TYPE_CONFIG_NETWORK_FILTERREF_PARAMETER))
+#define GVIR_SANDBOX_IS_CONFIG_NETWORK_FILTERREF_PARAMETER_CLASS(klass)
(G_TYPE_CHECK_CLASS_TYPE ((klass), GVIR_SANDBOX_TYPE_CONFIG_NETWORK_FILTERREF_PARAMETER))
+#define GVIR_SANDBOX_CONFIG_NETWORK_FILTERREF_PARAMETER_GET_CLASS(obj) 
(G_TYPE_INSTANCE_GET_CLASS ((obj), GVIR_SANDBOX_TYPE_CONFIG_NETWORK_FILTERREF_PARAMETER,
GVirSandboxConfigNetworkFilterrefParameterClass))
+
+typedef struct _GVirSandboxConfigNetworkFilterrefParameter
GVirSandboxConfigNetworkFilterrefParameter;
+typedef struct _GVirSandboxConfigNetworkFilterrefParameterPrivate
GVirSandboxConfigNetworkFilterrefParameterPrivate;
+typedef struct _GVirSandboxConfigNetworkFilterrefParameterClass
GVirSandboxConfigNetworkFilterrefParameterClass;
+
+struct _GVirSandboxConfigNetworkFilterrefParameter
+{
+    GObject parent;
+
+    GVirSandboxConfigNetworkFilterrefParameterPrivate *priv;
+
+    /* Do not add fields to this struct */
+};
+
+struct _GVirSandboxConfigNetworkFilterrefParameterClass
+{
+    GObjectClass parent_class;
+
+    gpointer padding[LIBVIRT_SANDBOX_CLASS_PADDING];
+};
+
+GType gvir_sandbox_config_network_filterref_parameter_get_type(void);
+
+GVirSandboxConfigNetworkFilterrefParameter
*gvir_sandbox_config_network_filterref_parameter_new(void);
+
+void
gvir_sandbox_config_network_filterref_parameter_set_name(GVirSandboxConfigNetworkFilterrefParameter
*param,
+                                                              const gchar *name);
+const gchar
*gvir_sandbox_config_network_filterref_parameter_get_name(GVirSandboxConfigNetworkFilterrefParameter
*param);
+
+void
gvir_sandbox_config_network_filterref_parameter_set_value(GVirSandboxConfigNetworkFilterrefParameter
*param,
+                                                               const gchar *value);
+const gchar
*gvir_sandbox_config_network_filterref_parameter_get_value(GVirSandboxConfigNetworkFilterrefParameter
*param);
+
+G_END_DECLS
+
+#endif /* __LIBVIRT_SANDBOX_CONFIG_NETWORK_FILTERREF_PARAMETER_H__ */
diff --git a/libvirt-sandbox/libvirt-sandbox-config-network-filterref.c
b/libvirt-sandbox/libvirt-sandbox-config-network-filterref.c
new file mode 100644
index 0000000..85b41ae
--- /dev/null
+++ b/libvirt-sandbox/libvirt-sandbox-config-network-filterref.c
@@ -0,0 +1,218 @@
+/*
+ * libvirt-sandbox-config-network-filterref.c: libvirt sandbox filterr reference
+ * configuration
+ *
+ * Copyright (C) 2013 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Author: Ian Main <imain(a)redhat.com&gt;
+ */
+
+#include <config.h>
+#include <string.h>
+
+#include "libvirt-sandbox/libvirt-sandbox.h"
+
+/**
+ * SECTION: libvirt-sandbox-config-network-filterref
+ * @short_description: Add a network filter to a network interface.
+ * @include: libvirt-sandbox/libvirt-sandbox.h
+ * @see_aloso: #GVirSandboxConfig
+ *
+ * Provides an object to store the name of the filter reference.
+ *
+ * The GVirSandboxConfigNetworkFilterref object stores the name of the filter
+ * references associated with a network interface.
+ */
+
+#define GVIR_SANDBOX_CONFIG_NETWORK_FILTERREF_GET_PRIVATE(obj)                         \
+        (G_TYPE_INSTANCE_GET_PRIVATE((obj), GVIR_SANDBOX_TYPE_CONFIG_NETWORK_FILTERREF,
GVirSandboxConfigNetworkFilterrefPrivate))
+
+struct _GVirSandboxConfigNetworkFilterrefPrivate
+{
+    gchar *filter;
+    GList *parameters;
+};
+
+G_DEFINE_TYPE(GVirSandboxConfigNetworkFilterref, gvir_sandbox_config_network_filterref,
G_TYPE_OBJECT);
+
+
+enum {
+    PROP_0,
+    PROP_FILTER
+};
+
+enum {
+    LAST_SIGNAL
+};
+
+//static gint signals[LAST_SIGNAL];
+
+static void gvir_sandbox_config_network_filterref_get_property(GObject *object,
+                                                               guint prop_id,
+                                                               GValue *value,
+                                                               GParamSpec *pspec)
+{
+    GVirSandboxConfigNetworkFilterref *config =
GVIR_SANDBOX_CONFIG_NETWORK_FILTERREF(object);
+    GVirSandboxConfigNetworkFilterrefPrivate *priv = config->priv;
+
+    switch (prop_id) {
+    case PROP_FILTER:
+        g_value_set_string(value, priv->filter);
+        break;
+
+    default:
+        G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
+    }
+}
+
+
+static void gvir_sandbox_config_network_filterref_set_property(GObject *object,
+                                                               guint prop_id,
+                                                               const GValue *value,
+                                                               GParamSpec *pspec)
+{
+    GVirSandboxConfigNetworkFilterref *filterref =
GVIR_SANDBOX_CONFIG_NETWORK_FILTERREF(object);
+
+    switch (prop_id) {
+    case PROP_FILTER:
+        gvir_sandbox_config_network_filterref_set_name(filterref,
g_value_get_string(value));
+        break;
+
+    default:
+        G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
+    }
+}
+
+
+
+static void gvir_sandbox_config_network_filterref_finalize(GObject *object)
+{
+    GVirSandboxConfigNetworkFilterref *config =
GVIR_SANDBOX_CONFIG_NETWORK_FILTERREF(object);
+    GVirSandboxConfigNetworkFilterrefPrivate *priv = config->priv;
+
+    g_free(priv->filter);
+    g_list_foreach(priv->parameters, (GFunc)g_object_unref, NULL);
+    g_list_free(priv->parameters);
+
+   
G_OBJECT_CLASS(gvir_sandbox_config_network_filterref_parent_class)->finalize(object);
+}
+
+
+static void
gvir_sandbox_config_network_filterref_class_init(GVirSandboxConfigNetworkFilterrefClass
*klass)
+{
+    GObjectClass *object_class = G_OBJECT_CLASS(klass);
+
+    object_class->finalize = gvir_sandbox_config_network_filterref_finalize;
+    object_class->get_property = gvir_sandbox_config_network_filterref_get_property;
+    object_class->set_property = gvir_sandbox_config_network_filterref_set_property;
+
+    g_object_class_install_property(object_class,
+                                    PROP_FILTER,
+                                    g_param_spec_string("filter",
+                                                        "Filter name",
+                                                        "The filter reference
name",
+                                                        NULL,
+                                                        G_PARAM_READWRITE |
+                                                        G_PARAM_STATIC_STRINGS));
+
+    g_type_class_add_private(klass, sizeof(GVirSandboxConfigNetworkFilterrefPrivate));
+}
+
+/**
+ * gvir_sandbox_config_network_filterref_new:
+ *
+ * Create a new network filterref config.
+ *
+ * Returns: (transfer full): a new sandbox network_filterref object
+ */
+GVirSandboxConfigNetworkFilterref *gvir_sandbox_config_network_filterref_new(void)
+{
+    return
GVIR_SANDBOX_CONFIG_NETWORK_FILTERREF(g_object_new(GVIR_SANDBOX_TYPE_CONFIG_NETWORK_FILTERREF,
+                                                              NULL));
+}
+
+
+static void gvir_sandbox_config_network_filterref_init(GVirSandboxConfigNetworkFilterref
*config)
+{
+    config->priv = GVIR_SANDBOX_CONFIG_NETWORK_FILTERREF_GET_PRIVATE(config);
+}
+
+
+/**
+ * gvir_sandbox_config_network_filterref_get_name:
+ * @config: (transfer none): the network filter reference name
+ *
+ * Retrieves the network filter reference name.
+ *
+ * Returns: (transfer none): the network filter reference name.
+ */
+const gchar
*gvir_sandbox_config_network_filterref_get_name(GVirSandboxConfigNetworkFilterref
*filterref)
+{
+    GVirSandboxConfigNetworkFilterrefPrivate *priv;
+
+    g_return_val_if_fail(GVIR_SANDBOX_IS_CONFIG_NETWORK_FILTERREF(filterref), NULL);
+    priv = filterref->priv;
+    return priv->filter;
+}
+
+void gvir_sandbox_config_network_filterref_set_name(GVirSandboxConfigNetworkFilterref
*filterref,
+                                                    const gchar *name)
+{
+    GVirSandboxConfigNetworkFilterrefPrivate *priv;
+
+    g_return_if_fail(GVIR_SANDBOX_IS_CONFIG_NETWORK_FILTERREF(filterref));
+    priv = filterref->priv;
+    g_free(priv->filter);
+    priv->filter = g_strdup(name);
+}
+
+/**
+ * gvir_sandbox_config_network_filterref_add_parameter:
+ * @filter: (transfer none): the network filter reference.
+ * @param: (transfer none): the filter parameter
+ *
+ * Add a parameter to a network filter reference.
+ */
+void
gvir_sandbox_config_network_filterref_add_parameter(GVirSandboxConfigNetworkFilterref
*filter,
+                                                        
GVirSandboxConfigNetworkFilterrefParameter *param)
+{
+    GVirSandboxConfigNetworkFilterrefPrivate *priv;
+
+    g_return_if_fail(GVIR_SANDBOX_IS_CONFIG_NETWORK_FILTERREF(filter));
+    g_return_if_fail(GVIR_SANDBOX_IS_CONFIG_NETWORK_FILTERREF_PARAMETER(param));
+    priv = filter->priv;
+    priv->parameters = g_list_append(priv->parameters, g_object_ref(param));
+}
+
+
+/**
+ * gvir_sandbox_config_network_filterref_get_parameters:
+ * @filter: (transfer none): the filter reference configuration
+ *
+ * Retrieve the list of parameters associated with a network filter reference
+ *
+ * Returns: (transfer full)(element-type GVirSandboxConfigNetworkFilterrefParameter): the
parameter list
+ */
+GList
*gvir_sandbox_config_network_filterref_get_parameters(GVirSandboxConfigNetworkFilterref
*filter)
+{
+    GVirSandboxConfigNetworkFilterrefPrivate *priv;
+
+    g_return_val_if_fail(GVIR_SANDBOX_IS_CONFIG_NETWORK_FILTERREF(filter), NULL);
+    priv = filter->priv;
+    g_list_foreach(priv->parameters, (GFunc)g_object_ref, NULL);
+    return g_list_copy(priv->parameters);
+}
diff --git a/libvirt-sandbox/libvirt-sandbox-config-network-filterref.h
b/libvirt-sandbox/libvirt-sandbox-config-network-filterref.h
new file mode 100644
index 0000000..e036a93
--- /dev/null
+++ b/libvirt-sandbox/libvirt-sandbox-config-network-filterref.h
@@ -0,0 +1,74 @@
+/*
+ * libvirt-sandbox-config-network-filterref.h: libvirt sandbox filter reference
+ * configuration
+ *
+ * Copyright (C) 2013 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Author: Ian Main <imain(a)redhat.com&gt;
+ */
+
+#if !defined(__LIBVIRT_SANDBOX_H__) && !defined(LIBVIRT_SANDBOX_BUILD)
+#error "Only <libvirt-sandbox/libvirt-sandbox.h> can be included
directly."
+#endif
+
+#ifndef __LIBVIRT_SANDBOX_CONFIG_NETWORK_FILTERREF_H__
+#define __LIBVIRT_SANDBOX_CONFIG_NETWORK_FILTERREF_H__
+
+G_BEGIN_DECLS
+
+#define GVIR_SANDBOX_TYPE_CONFIG_NETWORK_FILTERREF           
(gvir_sandbox_config_network_filterref_get_type ())
+#define GVIR_SANDBOX_CONFIG_NETWORK_FILTERREF(obj)            (G_TYPE_CHECK_INSTANCE_CAST
((obj), GVIR_SANDBOX_TYPE_CONFIG_NETWORK_FILTERREF, GVirSandboxConfigNetworkFilterref))
+#define GVIR_SANDBOX_CONFIG_NETWORK_FILTERREF_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST
((klass), GVIR_SANDBOX_TYPE_CONFIG_NETWORK_FILTERREF,
GVirSandboxConfigNetworkFilterrefClass))
+#define GVIR_SANDBOX_IS_CONFIG_NETWORK_FILTERREF(obj)         (G_TYPE_CHECK_INSTANCE_TYPE
((obj), GVIR_SANDBOX_TYPE_CONFIG_NETWORK_FILTERREF))
+#define GVIR_SANDBOX_IS_CONFIG_NETWORK_FILTERREF_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE
((klass), GVIR_SANDBOX_TYPE_CONFIG_NETWORK_FILTERREF))
+#define GVIR_SANDBOX_CONFIG_NETWORK_FILTERREF_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS
((obj), GVIR_SANDBOX_TYPE_CONFIG_NETWORK_FILTERREF,
GVirSandboxConfigNetworkFilterrefClass))
+
+typedef struct _GVirSandboxConfigNetworkFilterref GVirSandboxConfigNetworkFilterref;
+typedef struct _GVirSandboxConfigNetworkFilterrefPrivate
GVirSandboxConfigNetworkFilterrefPrivate;
+typedef struct _GVirSandboxConfigNetworkFilterrefClass
GVirSandboxConfigNetworkFilterrefClass;
+
+struct _GVirSandboxConfigNetworkFilterref
+{
+    GObject parent;
+
+    GVirSandboxConfigNetworkFilterrefPrivate *priv;
+
+    /* Do not add fields to this struct */
+};
+
+struct _GVirSandboxConfigNetworkFilterrefClass
+{
+    GObjectClass parent_class;
+
+    gpointer padding[LIBVIRT_SANDBOX_CLASS_PADDING];
+};
+
+GType gvir_sandbox_config_network_filterref_get_type(void);
+
+GVirSandboxConfigNetworkFilterref *gvir_sandbox_config_network_filterref_new(void);
+
+const gchar
*gvir_sandbox_config_network_filterref_get_name(GVirSandboxConfigNetworkFilterref
*config);
+void gvir_sandbox_config_network_filterref_set_name(GVirSandboxConfigNetworkFilterref
*filter, const gchar *name);
+
+void
gvir_sandbox_config_network_filterref_add_parameter(GVirSandboxConfigNetworkFilterref
*filter,
+                                                        
GVirSandboxConfigNetworkFilterrefParameter *param);
+GList
*gvir_sandbox_config_network_filterref_get_parameters(GVirSandboxConfigNetworkFilterref
*filter);
+
+
+G_END_DECLS
+
+#endif /* __LIBVIRT_SANDBOX_CONFIG_NETWORK_FILTERREF_H__ */
diff --git a/libvirt-sandbox/libvirt-sandbox-config-network.c
b/libvirt-sandbox/libvirt-sandbox-config-network.c
index f04cf4c..2bb55bf 100644
--- a/libvirt-sandbox/libvirt-sandbox-config-network.c
+++ b/libvirt-sandbox/libvirt-sandbox-config-network.c
@@ -47,6 +47,7 @@ struct _GVirSandboxConfigNetworkPrivate
     gchar *mac;
     GList *routes;
     GList *addrs;
+    GVirSandboxConfigNetworkFilterref *filterref;
 };
 
 G_DEFINE_TYPE(GVirSandboxConfigNetwork, gvir_sandbox_config_network, G_TYPE_OBJECT);
@@ -133,6 +134,8 @@ static void gvir_sandbox_config_network_finalize(GObject *object)
     g_list_free(priv->addrs);
     g_list_foreach(priv->routes, (GFunc)g_object_unref, NULL);
     g_list_free(priv->routes);
+    if (priv->filterref)
+        g_object_unref(priv->filterref);
 
     G_OBJECT_CLASS(gvir_sandbox_config_network_parent_class)->finalize(object);
 }
@@ -287,6 +290,45 @@ GList
*gvir_sandbox_config_network_get_addresses(GVirSandboxConfigNetwork *confi
 }
 
 /**
+ * gvir_sandbox_config_network_set_filterref:
+ * @config: (transfer none): the sandbox network configuration
+ * @ref: (transfer none): the network filterref
+ *
+ * Set a network filterref for the given network.
+ */
+void gvir_sandbox_config_network_set_filterref(GVirSandboxConfigNetwork *config,
+                                               GVirSandboxConfigNetworkFilterref
*filterref)
+{
+    GVirSandboxConfigNetworkPrivate *priv;
+
+    g_return_if_fail(GVIR_SANDBOX_IS_CONFIG_NETWORK(config));
+    g_return_if_fail(GVIR_SANDBOX_IS_CONFIG_NETWORK_FILTERREF(filterref));
+    priv = config->priv;
+    if (priv->filterref)
+        g_object_unref(priv->filterref);
+    priv->filterref = g_object_ref(filterref);
+}
+
+
+/**
+ * gvir_sandbox_config_network_get_filterref:
+ * @config: (transfer none): the sandbox network configuration
+ *
+ * Retrieve the associated filter reference.
+ *
+ * Returns: (transfer none): The associated filter reference.
+ */
+GVirSandboxConfigNetworkFilterref
*gvir_sandbox_config_network_get_filterref(GVirSandboxConfigNetwork *config)
+{
+    GVirSandboxConfigNetworkPrivate *priv;
+
+    g_return_val_if_fail(GVIR_SANDBOX_IS_CONFIG_NETWORK(config), NULL);
+    priv = config->priv;
+    return priv->filterref;
+}
+
+
+/**
  * gvir_sandbox_config_network_add_route:
  * @config: (transfer none): the sandbox network configuration
  * @addr: (transfer none): the network route
diff --git a/libvirt-sandbox/libvirt-sandbox-config-network.h
b/libvirt-sandbox/libvirt-sandbox-config-network.h
index d926fd1..4a52221 100644
--- a/libvirt-sandbox/libvirt-sandbox-config-network.h
+++ b/libvirt-sandbox/libvirt-sandbox-config-network.h
@@ -78,6 +78,10 @@ void gvir_sandbox_config_network_add_address(GVirSandboxConfigNetwork
*config,
                                              GVirSandboxConfigNetworkAddress *addr);
 GList *gvir_sandbox_config_network_get_addresses(GVirSandboxConfigNetwork *config);
 
+void gvir_sandbox_config_network_set_filterref(GVirSandboxConfigNetwork *config,
+                                               GVirSandboxConfigNetworkFilterref *ref);
+GVirSandboxConfigNetworkFilterref
*gvir_sandbox_config_network_get_filterref(GVirSandboxConfigNetwork *config);
+
 void gvir_sandbox_config_network_add_route(GVirSandboxConfigNetwork *config,
                                            GVirSandboxConfigNetworkRoute *addr);
 GList *gvir_sandbox_config_network_get_routes(GVirSandboxConfigNetwork *config);
diff --git a/libvirt-sandbox/libvirt-sandbox-config.c
b/libvirt-sandbox/libvirt-sandbox-config.c
index b1525a1..f996ea5 100644
--- a/libvirt-sandbox/libvirt-sandbox-config.c
+++ b/libvirt-sandbox/libvirt-sandbox-config.c
@@ -911,6 +911,8 @@ gboolean gvir_sandbox_config_add_network_strv(GVirSandboxConfig
*config,
  *  source=private,address=192.168.122.1/24%192.168.122.255,
  *  address=192.168.122.1/24%192.168.122.255,address=2001:212::204:2/64
  *  route=192.168.122.255/24%192.168.1.1
+ *  filter=clean-traffic
+ *  filter.ip=192.168.122.1
  */
 gboolean gvir_sandbox_config_add_network_opts(GVirSandboxConfig *config,
                                               const gchar *network,
@@ -924,8 +926,10 @@ gboolean gvir_sandbox_config_add_network_opts(GVirSandboxConfig
*config,
     gchar **params = g_strsplit(network, ",", 50);
     gsize j = 0;
     GVirSandboxConfigNetwork *net;
+    GVirSandboxConfigNetworkFilterref *filter;
 
     net = gvir_sandbox_config_network_new();
+    filter = gvir_sandbox_config_network_filterref_new();
     gvir_sandbox_config_network_set_dhcp(net, FALSE);
 
     while (params && params[j]) {
@@ -947,6 +951,40 @@ gboolean gvir_sandbox_config_add_network_opts(GVirSandboxConfig
*config,
         } else if (g_str_has_prefix(param, "mac=")) {
             gvir_sandbox_config_network_set_mac(net,
                                                 param + strlen("mac="));
+        } else if (g_str_has_prefix(param, "filter.")) {
+            GVirSandboxConfigNetworkFilterrefParameter *filter_param;
+            gchar *tail = g_strdup(param + strlen("filter."));
+            gchar *equ = g_strrstr(tail, "=");
+            gchar *name, *name_up, *value;
+
+            if (equ == NULL) {
+                g_free(tail);
+                g_set_error(error, GVIR_SANDBOX_CONFIG_ERROR, 0,
+                            _("No assignment in filter parameter
configuration"));
+                g_object_unref(net);
+                goto cleanup;
+            }
+
+            name = g_strndup(tail, equ - tail);
+            value = g_strdup(equ + 1);
+            /* Convert to upcase for convenience. */
+            name_up = g_ascii_strup(name, -1);
+            g_free(name);
+
+            filter_param = gvir_sandbox_config_network_filterref_parameter_new();
+            gvir_sandbox_config_network_filterref_parameter_set_name(filter_param,
name_up);
+            gvir_sandbox_config_network_filterref_parameter_set_value(filter_param,
value);
+            gvir_sandbox_config_network_filterref_add_parameter(filter, filter_param);
+
+            g_free(tail);
+            g_free(name_up);
+            g_free(value);
+        } else if (g_str_has_prefix(param, "filter=")) {
+            gchar *name = g_strdup(param + strlen("filter="));
+
+            gvir_sandbox_config_network_filterref_set_name(filter, name);
+            gvir_sandbox_config_network_set_filterref(net, filter);
+            g_free(name);
         } else if (g_str_has_prefix(param, "address=")) {
             GVirSandboxConfigNetworkAddress *addr;
             GInetAddress *primaryaddr;
@@ -1090,6 +1128,7 @@ gboolean gvir_sandbox_config_add_network_opts(GVirSandboxConfig
*config,
 
     ret = TRUE;
  cleanup:
+    g_object_unref(filter);
     return ret;
 }
 
diff --git a/libvirt-sandbox/libvirt-sandbox.h b/libvirt-sandbox/libvirt-sandbox.h
index a3f0b2c..adb21a1 100644
--- a/libvirt-sandbox/libvirt-sandbox.h
+++ b/libvirt-sandbox/libvirt-sandbox.h
@@ -25,6 +25,7 @@
 
 /* External includes */
 #include <libvirt-gobject/libvirt-gobject.h>
+#include <locale.h>
 
 /* Local includes */
 #include <libvirt-sandbox/libvirt-sandbox-main.h>
@@ -37,6 +38,8 @@
 #include <libvirt-sandbox/libvirt-sandbox-config-mount-guest-bind.h>
 #include <libvirt-sandbox/libvirt-sandbox-config-mount-ram.h>
 #include <libvirt-sandbox/libvirt-sandbox-config-network-address.h>
+#include <libvirt-sandbox/libvirt-sandbox-config-network-filterref-parameter.h>
+#include <libvirt-sandbox/libvirt-sandbox-config-network-filterref.h>
 #include <libvirt-sandbox/libvirt-sandbox-config-network-route.h>
 #include <libvirt-sandbox/libvirt-sandbox-config-network.h>
 #include <libvirt-sandbox/libvirt-sandbox-config.h>
diff --git a/libvirt-sandbox/libvirt-sandbox.sym b/libvirt-sandbox/libvirt-sandbox.sym
index 7b7c8be..7afef53 100644
--- a/libvirt-sandbox/libvirt-sandbox.sym
+++ b/libvirt-sandbox/libvirt-sandbox.sym
@@ -44,6 +44,7 @@ LIBVIRT_SANDBOX_0.2.1 {
 	gvir_sandbox_config_mount_ram_set_usage;
 
 	gvir_sandbox_config_network_add_address;
+	gvir_sandbox_config_network_set_filterref;
 	gvir_sandbox_config_network_add_route;
 	gvir_sandbox_config_network_get_type;
 	gvir_sandbox_config_network_get_dhcp;
@@ -51,6 +52,7 @@ LIBVIRT_SANDBOX_0.2.1 {
 	gvir_sandbox_config_network_get_source;
 	gvir_sandbox_config_network_get_routes;
 	gvir_sandbox_config_network_get_addresses;
+	gvir_sandbox_config_network_get_filterref;
 	gvir_sandbox_config_network_new;
 	gvir_sandbox_config_network_set_dhcp;
 	gvir_sandbox_config_network_set_mac;
@@ -65,6 +67,20 @@ LIBVIRT_SANDBOX_0.2.1 {
 	gvir_sandbox_config_network_address_set_primary;
 	gvir_sandbox_config_network_address_set_prefix;
 
+	gvir_sandbox_config_network_filterref_get_type;
+	gvir_sandbox_config_network_filterref_new;
+	gvir_sandbox_config_network_filterref_get_name;
+	gvir_sandbox_config_network_filterref_set_name;
+	gvir_sandbox_config_network_filterref_add_parameter;
+	gvir_sandbox_config_network_filterref_get_parameters;
+
+	gvir_sandbox_config_network_filterref_parameter_get_type;
+	gvir_sandbox_config_network_filterref_parameter_new;
+	gvir_sandbox_config_network_filterref_parameter_get_name;
+	gvir_sandbox_config_network_filterref_parameter_set_name;
+	gvir_sandbox_config_network_filterref_parameter_get_value;
+	gvir_sandbox_config_network_filterref_parameter_set_value;
+
 	gvir_sandbox_config_network_route_get_type;
 	gvir_sandbox_config_network_route_get_prefix;
 	gvir_sandbox_config_network_route_get_gateway;
-- 
1.8.1.4


    

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005