Moved changes to current codebase

Signed-off-by: Patryk Strusiewicz-Surmacki <[email protected]>

Author: p-strusiewiczsurmacki-mobica

doc/.custom_wordlist.txt

@@ -133,6 +133,7 @@ networkd
 nm
 passthrough
 programmatically
+pvid
 renderer
 reselection
 runtime
@@ -145,6 +146,8 @@ udev
 unconfigured
 unencrypted
 untagged
+vid
+vlans
 vSwitch
 wpa
 wpasupplicant

doc/netplan-yaml.md

@@ -1337,6 +1337,13 @@ The specific settings for bridges are defined below.
               eth1: 20
     ```
 
+  - **`port-vlans`** (sequence of scalars)
+
+    > Array of bridge VLAN objects. The VLAN list can be specified with the
+    > following syntax: $vid [pvid] [untagged] [, $vid [pvid] [untagged]]..
+    > where $vid is either a single id between 1 and 4094 or a range,
+    > represented as a couple of ids separated by a dash.
+
   - **`forward-delay`** (scalar)
 
     > Specify the period of time the bridge will remain in Listening and
@@ -1345,6 +1352,16 @@ The specific settings for bridges are defined below.
     > If no time suffix is specified, the value will be interpreted as
     > seconds.
 
+  - **`vlans`** (sequence of scalars)
+    > Array of bridge VLAN objects. The VLAN list can be specified with the
+    > following syntax: $vid [pvid] [untagged] [, $vid [pvid] [untagged]]..
+    > where $vid is either a single id between 1 and 4094 or a range,
+    > represented as a couple of ids separated by a dash.
+
+  - **`vlan-filtering`** (boolean)
+
+    > Enables VLAN filtering. Will be enabled by default if *vlans* are defined.
+
   - **`hello-time`** (scalar)
 
     > Specify the interval between two hello packets being sent out from

src/abi.h

@@ -342,6 +342,9 @@ struct netplan_net_definition {
         char* max_age;
         guint path_cost;
         gboolean stp;
+        GArray* vlans;
+        GArray* port_vlans;
+        gboolean vlan_filtering;
     } bridge_params;
     gboolean custom_bridging;
 
@@ -432,3 +435,10 @@ struct netplan_net_definition {
 
     NetplanRAOverrides ra_overrides;
 };
+
+typedef struct {
+    guint vid; //[1..4094]
+    guint vid_to; //set iff vid range defined
+    gboolean pvid;
+    gboolean untagged;
+} NetplanBridgeVlan;

src/generate.c

@@ -203,6 +203,7 @@ find_interface(gchar* interface, GHashTable* netdefs)
 
 int main(int argc, char** argv)
 {
+    g_log_set_handler(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG,  g_log_default_handler, NULL);
     NetplanError* error = NULL;
     GOptionContext* opt_context;
     /* are we being called as systemd generator? */

src/netplan.c

@@ -28,6 +28,7 @@
 #include "yaml-helpers.h"
 #include "util-internal.h"
 #include "names.h"
+#include "nm.h"
 
 gchar *tmp = NULL;
 
@@ -310,6 +311,53 @@ write_bridge_params(yaml_event_t* event, yaml_emitter_t* emitter, const NetplanN
             YAML_MAPPING_CLOSE(event, emitter);
         }
 
+        gboolean has_port_vlans = FALSE;
+        for (unsigned i = 0; i < interfaces->len; ++i) {
+            NetplanNetDefinition *nd = g_array_index(interfaces, NetplanNetDefinition*, i);
+            if (nd->bridge_params.port_vlans || DIRTY(nd, nd->bridge_params.port_vlans)) {
+                has_port_vlans = TRUE;
+                break;
+            }
+        }
+
+        if (has_port_vlans) {
+            YAML_SCALAR_PLAIN(event, emitter, "port-vlans");
+            YAML_MAPPING_OPEN(event, emitter);
+            for (unsigned i = 0; i < interfaces->len; ++i) {
+                NetplanNetDefinition *nd = g_array_index(interfaces, NetplanNetDefinition*, i);
+                if (nd->bridge_params.port_vlans || DIRTY(nd, nd->bridge_params.port_vlans)) {
+                    YAML_SCALAR_PLAIN(event, emitter, nd->id);
+                    YAML_SEQUENCE_OPEN(event, emitter);
+                    for (unsigned i = 0; i < nd->bridge_params.port_vlans->len; ++i) {
+                        NetplanBridgeVlan* vlan = g_array_index(nd->bridge_params.port_vlans, NetplanBridgeVlan*, i);
+                        GString* v = bridge_vlan_str(vlan);
+                        YAML_SCALAR_PLAIN(event, emitter, v->str);
+                        g_string_free(v, TRUE);
+                    }
+                    YAML_SEQUENCE_CLOSE(event, emitter);
+                }
+                
+            }
+            YAML_MAPPING_CLOSE(event, emitter);
+        }
+
+        if (def->bridge_params.vlan_filtering || def->bridge_params.vlans || DIRTY(def, def->bridge_params.vlans)) {
+            YAML_STRING(def, event, emitter, "vlan-filtering", "true");
+            if (def->bridge_params.vlans || DIRTY(def, def->bridge_params.vlans)) {
+                YAML_SCALAR_PLAIN(event, emitter, "vlans");
+                YAML_SEQUENCE_OPEN(event, emitter);
+                for (unsigned i = 0; i < def->bridge_params.vlans->len; ++i) {
+                    NetplanBridgeVlan* vlan = g_array_index(def->bridge_params.vlans, NetplanBridgeVlan*, i);
+                    GString* v = bridge_vlan_str(vlan);
+                    YAML_SCALAR_PLAIN(event, emitter, v->str);
+                    g_string_free(v, TRUE);
+                }
+                YAML_SEQUENCE_CLOSE(event, emitter);
+            }
+        }
+
+        
+
         YAML_MAPPING_CLOSE(event, emitter);
     }
     return TRUE;

src/networkd.c

@@ -987,12 +987,11 @@ _netplan_netdef_write_network_file(
             g_string_append_printf(network, "Learning=%s\n", def->bridge_learning ? "true" : "false");
         if (def->bridge_neigh_suppress != NETPLAN_TRISTATE_UNSET)
             g_string_append_printf(network, "NeighborSuppression=%s\n", def->bridge_neigh_suppress ? "true" : "false");
-	if (def->bridge_params.port_vlans) {
+        if (def->bridge_params.port_vlans) {
             // TODO: research and implement bridge port-vlans for networkd
             g_fprintf(stderr, "ERROR: %s: networkd does not support bridge port-vlans\n", def->id);
             exit(1);
         }
-
     }
     if (def->bond && def->backend != NETPLAN_BACKEND_OVS) {
         g_string_append_printf(network, "Bond=%s\n", def->bond);

src/nm.c

@@ -148,11 +148,11 @@ wifi_band_str(const NetplanWifiBand band)
 /**
  * Return NM bridge vlan string.
  */
-static const char*
+GString*
 bridge_vlan_str(const NetplanBridgeVlan* vlan)
 {
     GString* s = NULL;
-    s = g_string_sized_new(20);
+    s = g_string_sized_new(24);
 
     g_string_append_printf(s, "%u", vlan->vid);
     if (vlan->vid_to)
@@ -161,7 +161,7 @@ bridge_vlan_str(const NetplanBridgeVlan* vlan)
         g_string_append(s, " pvid");
     if (vlan->untagged)
         g_string_append(s, " untagged");
-    return s->str;
+    return s;
 }
 
 /**
@@ -395,7 +395,10 @@ write_nm_bond_parameters(const NetplanNetDefinition* def, GKeyFile *kf)
 STATIC void
 write_bridge_params_nm(const NetplanNetDefinition* def, GKeyFile *kf)
 {
+    g_autoptr(GString) vlans = NULL;
+
     if (def->custom_bridging) {
+        vlans = g_string_sized_new(200);
         if (def->bridge_params.ageing_time)
             g_key_file_set_string(kf, "bridge", "ageing-time", def->bridge_params.ageing_time);
         if (def->bridge_params.priority)
@@ -407,17 +410,17 @@ write_bridge_params_nm(const NetplanNetDefinition* def, GKeyFile *kf)
         if (def->bridge_params.max_age)
             g_key_file_set_string(kf, "bridge", "max-age", def->bridge_params.max_age);
         g_key_file_set_boolean(kf, "bridge", "stp", def->bridge_params.stp);
+        if(def->bridge_params.vlan_filtering || def->bridge_params.vlans)
+            g_key_file_set_string(kf, "bridge", "vlan-filtering", "true");
         if (def->bridge_params.vlans) {
-            g_string_append(params, "vlan-filtering=true\n");
-            g_string_append(params, "vlans=");
             for (unsigned i = 0; i < def->bridge_params.vlans->len; ++i) {
                 if (i > 0)
-                    g_string_append(params, ", ");
-                g_string_append_printf(params, "%s", bridge_vlan_str(
-                                       g_array_index(def->bridge_params.vlans,
-                                       NetplanBridgeVlan*, i)));
+                    g_string_append(vlans, ", ");
+                GString* v = bridge_vlan_str(g_array_index(def->bridge_params.vlans,NetplanBridgeVlan*, i));
+                g_string_append_printf(vlans, "%s", v->str);
+                g_string_free(v, TRUE);
             }
-            g_string_append(params, "\n");
+            g_key_file_set_string(kf, "bridge", "vlans", vlans->str);
         }
     }
 }
@@ -855,16 +858,16 @@ write_nm_conf_access_point(const NetplanNetDefinition* def, const char* rootdir,
             g_key_file_set_uint64(kf, "bridge-port", "priority", def->bridge_params.port_priority);
         if (def->bridge_hairpin != NETPLAN_TRISTATE_UNSET)
             g_key_file_set_boolean(kf, "bridge-port", "hairpin-mode", def->bridge_hairpin);
-	if (def->bridge_params.port_vlans) {
-            g_string_append(s, "vlans=");
+        if (def->bridge_params.port_vlans) {
+            g_autoptr(GString) vlans = g_string_sized_new(200);
             for (unsigned i = 0; i < def->bridge_params.port_vlans->len; ++i) {
                 if (i > 0)
-                    g_string_append(s, ", ");
-                g_string_append_printf(s, "%s", bridge_vlan_str(
-                                       g_array_index(def->bridge_params.port_vlans,
-                                       NetplanBridgeVlan*, i)));
+                    g_string_append(vlans, ", ");
+                GString* v = bridge_vlan_str(g_array_index(def->bridge_params.port_vlans,NetplanBridgeVlan*, i));
+                g_string_append_printf(vlans, "%s", v->str);
+                g_string_free(v, TRUE);
             }
-            g_string_append(s, "\n");
+            g_key_file_set_string(kf, "bridge-port", "vlans", vlans->str);
         }
     }
     if (def->bond) {

src/nm.h

@@ -29,3 +29,6 @@ _netplan_netdef_write_nm(
 
 NETPLAN_INTERNAL gboolean
 _netplan_nm_cleanup(const char* rootdir);
+
+NETPLAN_INTERNAL GString*
+bridge_vlan_str(const NetplanBridgeVlan* vlan);

src/parse.c

@@ -2168,7 +2168,7 @@ handle_bridge_port_priority(NetplanParser* npp, yaml_node_t* node, const char* k
 }
 
 static gboolean
-handle_generic_vlans(yaml_document_t* doc, yaml_node_t* node, GArray** entryptr, const void* data, GError** error)
+handle_generic_vlans(NetplanParser* npp, yaml_node_t* node, GArray** entryptr, GError** error)
 {
     static regex_t re;
     static gboolean re_inited = FALSE;
@@ -2180,8 +2180,8 @@ handle_generic_vlans(yaml_document_t* doc, yaml_node_t* node, GArray** entryptr,
 
     for (yaml_node_item_t *i = node->data.sequence.items.start; i < node->data.sequence.items.top; i++) {
         g_autofree char* vlan = NULL;
-        yaml_node_t *entry = yaml_document_get_node(doc, *i);
-        assert_type(entry, YAML_SCALAR_NODE);
+        yaml_node_t *entry = yaml_document_get_node(&npp->doc, *i);
+        assert_type(npp, entry, YAML_SCALAR_NODE);
 
         vlan = g_strdup(scalar(entry));
 
@@ -2191,7 +2191,7 @@ handle_generic_vlans(yaml_document_t* doc, yaml_node_t* node, GArray** entryptr,
         if (regexec(&re, vlan, maxGroups, groups, 0) == 0) {
             NetplanBridgeVlan* data = g_new0(NetplanBridgeVlan, 1);
             for (unsigned g = 1; g < maxGroups; g = g+2) {
-                if (groups[g].rm_so == (size_t)-1)
+                if (groups[g].rm_so == (int)(size_t)-1)
                     continue; // Invalid group
 
                 char cursorCopy[strlen(vlan) + 1];
@@ -2200,17 +2200,17 @@ handle_generic_vlans(yaml_document_t* doc, yaml_node_t* node, GArray** entryptr,
                 guint v = 0;
                 switch (g) {
                     case 1:
-                        v = g_ascii_strtoull(cursorCopy + groups[g].rm_so, NULL, 10);
+                        v = (guint) g_ascii_strtoull(cursorCopy + groups[g].rm_so, NULL, 10);
                         if (v < 1 || v > 4094)
-                            return yaml_error(node, error, "malformed vlan vid '%u', must be in range [1..4094]", v);
+                            return yaml_error(npp, node, error, "malformed vlan vid '%u', must be in range [1..4094]", v);
                         data->vid = v;
                         break;
                     case 3:
-                        v = g_ascii_strtoull(cursorCopy + groups[g].rm_so, NULL, 10);
+                        v = (guint) g_ascii_strtoull(cursorCopy + groups[g].rm_so, NULL, 10);
                         if (v < 1 || v > 4094)
-                            return yaml_error(node, error, "malformed vlan vid '%u', must be in range [1..4094]", v);
+                            return yaml_error(npp, node, error, "malformed vlan vid '%u', must be in range [1..4094]", v);
                         else if (v <= data->vid)
-                            return yaml_error(node, error, "malformed vlan vid range '%s': %u > %u!", scalar(entry), data->vid, v);
+                            return yaml_error(npp, node, error, "malformed vlan vid range '%s': %u > %u!", scalar(entry), data->vid, v);
                         data->vid_to = v;
                         break;
                     case 5:
@@ -2228,41 +2228,41 @@ handle_generic_vlans(yaml_document_t* doc, yaml_node_t* node, GArray** entryptr,
             continue;
         }
 
-        return yaml_error(node, error, "malformed vlan '%s', must be: $vid [pvid] [untagged] [, $vid [pvid] [untagged]]", scalar(entry));
+        return yaml_error(npp, node, error, "malformed vlan '%s', must be: $vid [pvid] [untagged] [, $vid [pvid] [untagged]]", scalar(entry));
     }
 
     return TRUE;
 }
 
 static gboolean
-handle_bridge_vlans(yaml_document_t* doc, yaml_node_t* node, const void* data, GError** error)
+handle_bridge_vlans(NetplanParser* npp, yaml_node_t* node, const void *, GError** error)
 {
-    return handle_generic_vlans(doc, node, &(cur_netdef->bridge_params.vlans), data, error);
+    return handle_generic_vlans(npp, node, &(npp->current.netdef->bridge_params.vlans), error);
 }
 
 static gboolean
-handle_bridge_port_vlans(yaml_document_t* doc, yaml_node_t* node, const void* data, GError** error)
+handle_bridge_port_vlans(NetplanParser* npp, yaml_node_t* node, const char*, const void*, GError** error)
 {
     for (yaml_node_pair_t* entry = node->data.mapping.pairs.start; entry < node->data.mapping.pairs.top; entry++) {
         yaml_node_t* key, *value;
         NetplanNetDefinition *component;
         GArray** ref_ptr;
 
-        key = yaml_document_get_node(doc, entry->key);
-        assert_type(key, YAML_SCALAR_NODE);
-        value = yaml_document_get_node(doc, entry->value);
-        assert_type(value, YAML_SEQUENCE_NODE);
+        key = yaml_document_get_node(&npp->doc, entry->key);
+        assert_type(npp, key, YAML_SCALAR_NODE);
+        value = yaml_document_get_node(&npp->doc, entry->value);
+        assert_type(npp, value, YAML_SEQUENCE_NODE);
 
-        component = g_hash_table_lookup(netdefs, scalar(key));
+        component = g_hash_table_lookup(npp->parsed_defs, scalar(key));
         if (!component) {
-            add_missing_node(key);
+            add_missing_node(npp, key);
         } else {
             ref_ptr = &(component->bridge_params.port_vlans);
             if (*ref_ptr)
-                return yaml_error(node, error, "%s: interface '%s' already has port vlans",
-                                  cur_netdef->id, scalar(key));
+                return yaml_error(npp, node, error, "%s: interface '%s' already has port vlans",
+                                  npp->current.netdef->id, scalar(key));
 
-            if (!handle_generic_vlans(doc, value, ref_ptr, data, error))
+            if (!handle_generic_vlans(npp, value, ref_ptr, error))
                 return FALSE;
         }
     }
@@ -2277,10 +2277,11 @@ static const mapping_entry_handler bridge_params_handlers[] = {
     {"max-age", YAML_SCALAR_NODE, {.generic=handle_netdef_str}, netdef_offset(bridge_params.max_age)},
     {"path-cost", YAML_MAPPING_NODE, {.map={.custom=handle_bridge_path_cost}}, netdef_offset(bridge_params.path_cost)},
     {"port-priority", YAML_MAPPING_NODE, {.map={.custom=handle_bridge_port_priority}}, netdef_offset(bridge_params.port_priority)},
-    {"port-vlans", YAML_MAPPING_NODE, handle_bridge_port_vlans},
     {"priority", YAML_SCALAR_NODE, {.generic=handle_netdef_guint}, netdef_offset(bridge_params.priority)},
     {"stp", YAML_SCALAR_NODE, {.generic=handle_netdef_bool}, netdef_offset(bridge_params.stp)},
-    {"vlans", YAML_SEQUENCE_NODE, handle_bridge_vlans},
+    {"port-vlans", YAML_MAPPING_NODE, {.map={.custom=handle_bridge_port_vlans}}, netdef_offset(bridge_params.port_vlans)},
+    {"vlans", YAML_SEQUENCE_NODE, {.generic=handle_bridge_vlans}, netdef_offset(bridge_params.vlans)},
+    {"vlan-filtering", YAML_SCALAR_NODE, {.generic=handle_netdef_bool}, netdef_offset(bridge_params.vlan_filtering)},
     {NULL}
 };
 
@@ -3772,6 +3773,7 @@ netplan_parser_load_yaml(NetplanParser* npp, const char* filename, GError** erro
 
     if (!load_yaml(filename, doc, error))
         return FALSE;
+
     return _netplan_parser_load_single_file(npp, filename, doc, error);
 }
 

src/types.c

@@ -339,6 +339,9 @@ reset_netdef(NetplanNetDefinition* netdef, NetplanDefType new_type, NetplanBacke
     FREE_AND_NULLIFY(netdef->bridge_params.forward_delay);
     FREE_AND_NULLIFY(netdef->bridge_params.hello_time);
     FREE_AND_NULLIFY(netdef->bridge_params.max_age);
+    free_garray_with_destructor(&netdef->bridge_params.vlans, g_free);
+    free_garray_with_destructor(&netdef->bridge_params.port_vlans, g_free);
+    netdef->bridge_params.vlan_filtering = FALSE;
     memset(&netdef->bridge_params, 0, sizeof(netdef->bridge_params));
     netdef->custom_bridging = FALSE;