From 5989d4d19cf1ca2d07de5b6571f752f6da01b3fc Mon Sep 17 00:00:00 2001 From: WickedJack99 Date: Sat, 30 Dec 2023 17:34:30 +0100 Subject: [PATCH] Changed processing nftables from three lists to one list of list of list. --- .../DataProcessing/DataProcessorThread.java | 5 +- .../NFTableInformation.java | 50 ++++++++--- .../nftablesProcessing/NFTablesProcessor.java | 84 ++++++++++++++++++- src/main/java/model/src/NFTablesModel.java | 25 ++++-- 4 files changed, 140 insertions(+), 24 deletions(-) diff --git a/src/main/java/controller/src/DataProcessing/DataProcessorThread.java b/src/main/java/controller/src/DataProcessing/DataProcessorThread.java index 0b48ba5..6ff93b0 100644 --- a/src/main/java/controller/src/DataProcessing/DataProcessorThread.java +++ b/src/main/java/controller/src/DataProcessing/DataProcessorThread.java @@ -80,9 +80,8 @@ public final class DataProcessorThread extends Thread { model.getNetworkModel().accessConnections(AccessModifier.WriteEntry, conInf); }break; case NFTablesConfiguration: { - NFTablesProcessor.processDataString(data); - //NFTableInformation nftConfig = - //System.out.println(data); + NFTableInformation nftConf = NFTablesProcessor.processDataString(data); + model.getNFTablesModel().accessNFTConfiguration(AccessModifier.WriteEntry, nftConf); }break; case Undefined: // intended fall through default: { diff --git a/src/main/java/controller/src/DataProcessing/nftablesProcessing/NFTableInformation.java b/src/main/java/controller/src/DataProcessing/nftablesProcessing/NFTableInformation.java index 0554190..95c1f24 100644 --- a/src/main/java/controller/src/DataProcessing/nftablesProcessing/NFTableInformation.java +++ b/src/main/java/controller/src/DataProcessing/nftablesProcessing/NFTableInformation.java @@ -5,22 +5,50 @@ package controller.src.DataProcessing.nftablesProcessing; import java.util.LinkedList; -import java.util.List; public class NFTableInformation { - private List tables = new LinkedList(); - private List chains = new LinkedList(); - private List rules = new LinkedList(); + // Outer list: tables + // Middle lists: chains + // Inner lists: rules + private LinkedList>> tables; - public List getTables() { + public NFTableInformation() {} + + public NFTableInformation(NFTableInformation nftInf) { + this.tables = new LinkedList>>(nftInf.tables); + } + +// list of list of list +// -> table1 +// -> chain1 +// -> tablename +// -> chainname +// -> rule1 +// -> rule2 + +// -> table2 + +/* +for (LinkedList> table : tables) { + for (LinkedList chain : table) { + for (String rule : chain) { + if (rule.startsWith("{\"table")) { + System.out.println(rule); + } else if (rule.startsWith("{\"chain")) { + System.out.println("\t" + rule); + } else { + System.out.println("\t\t" + rule); + } + } + } +} +*/ + + public LinkedList>>getTables() { return tables; } - public List getChains() { - return chains; - } - - public List getRules() { - return rules; + public void setTables(LinkedList>> tables) { + this.tables = tables; } } diff --git a/src/main/java/controller/src/DataProcessing/nftablesProcessing/NFTablesProcessor.java b/src/main/java/controller/src/DataProcessing/nftablesProcessing/NFTablesProcessor.java index 9d64e17..805fc1f 100644 --- a/src/main/java/controller/src/DataProcessing/nftablesProcessing/NFTablesProcessor.java +++ b/src/main/java/controller/src/DataProcessing/nftablesProcessing/NFTablesProcessor.java @@ -1,9 +1,12 @@ /** * @author Aaron Moser * @date 29.12.2023 + * @lastChange 30.12.2023 */ package controller.src.DataProcessing.nftablesProcessing; +import java.util.LinkedList; + import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.databind.JsonMappingException; import com.fasterxml.jackson.databind.JsonNode; @@ -18,38 +21,113 @@ public final class NFTablesProcessor { private static final String RULE_FIELD = "rule"; private static final String NAME_FIELD = "name"; + private enum FieldType { + TABLE, + CHAIN, + RULE, + NONE + } + public static NFTableInformation processDataString(String data) { NFTableInformation nfTableInformation = new NFTableInformation(); ObjectMapper objectMapper = new ObjectMapper(); + + LinkedList>> tables = new LinkedList>>(); + LinkedList> tableChains = null; + LinkedList tableChainRules = null; + try { JsonNode nfttree = objectMapper.readTree(data); JsonNode mainRoot = getField(nfttree, NFT_MAIN_FIELD); + String lastTable = null; + FieldType lastNodeType = FieldType.NONE; for (JsonNode nftObject : mainRoot) { + // If next node is of type table if (isTableEntry(nftObject)) { - nfTableInformation.getTables().add(nftObject.toString()); + switch (lastNodeType) { + // Last node was of type table. Normally chain cares + // about storing the table entry at the beginning of + // the chains rules list but since table is empty, + // the next iteration has to care about storing the + // table at the list. + case FieldType.TABLE: { + tableChainRules = new LinkedList(); + tableChainRules.add(lastTable); + tableChains = new LinkedList>(); + tableChains.add(new LinkedList(tableChainRules)); + tables.add(new LinkedList>(tableChains)); + } // Intended fall through + case FieldType.CHAIN: // Intended fall through + case FieldType.RULE: // Intended fall through + case FieldType.NONE: // Intended fall through + default: { + // Reset all lists except tables list + tableChainRules = new LinkedList(); + tableChains = new LinkedList>(); + } + } + lastNodeType = FieldType.TABLE; + // Store current table description entry + lastTable = nftObject.toString(); + // If next node is chain, the node before must have been of type table, chain or rule } else if (isChainEntry(nftObject)) { - nfTableInformation.getChains().add(nftObject.toString()); + switch (lastNodeType) { + case FieldType.TABLE: { + // Add table and chain to new table chain rules list + tableChainRules.add(lastTable); + tableChainRules.add(nftObject.toString()); + }break; + case FieldType.CHAIN: // Intended fall through + case FieldType.RULE: { + // Add rules of last chain to chain and reset list + tableChains.add(new LinkedList(tableChainRules)); + tableChainRules = new LinkedList(); + // Then add this chains description to list + tableChainRules.add(nftObject.toString()); + }break; + case FieldType.NONE: // Intended fall through + default: { + System.out.println("Error, missing table before chain."); + }break; + } + lastNodeType = FieldType.CHAIN; } else if (isRuleEntry(nftObject)) { - nfTableInformation.getChains().add(nftObject.toString()); + switch (lastNodeType) { + case FieldType.CHAIN: // Intended fall through + case FieldType.RULE: { + tableChainRules.add(nftObject.toString()); + }break; + case FieldType.TABLE:// Intended fall through + case FieldType.NONE: // Intended fall through + default: { + System.out.println("Error, missing chain before rule."); + }break; + } + lastNodeType = FieldType.RULE; } else { // Do nothing } } + if (tableChains != null && !tableChains.isEmpty()) { + tables.add(new LinkedList>(tableChains)); + } } catch (JsonMappingException e) { e.printStackTrace(); } catch (JsonProcessingException e) { e.printStackTrace(); } + nfTableInformation.setTables(tables); return nfTableInformation; } private static boolean isTableEntry(JsonNode node) { return isSpecifiedEntry(node, TABLE_FIELD); + } private static boolean isChainEntry(JsonNode node) { diff --git a/src/main/java/model/src/NFTablesModel.java b/src/main/java/model/src/NFTablesModel.java index f8b946e..e20dfc8 100644 --- a/src/main/java/model/src/NFTablesModel.java +++ b/src/main/java/model/src/NFTablesModel.java @@ -5,17 +5,28 @@ package model.src; import controller.src.DataProcessing.nftablesProcessing.NFTableInformation; +import model.src.ModelConstants.AccessModifier; -public class NFTablesModel { +public final class NFTablesModel { private NFTableInformation nfTableInformation = null; public NFTablesModel() {} - public void setNFTableInformation(NFTableInformation newInformation) { - this.nfTableInformation = newInformation; - } - - public NFTableInformation getNFTableInformation() { - return this.nfTableInformation; + public synchronized NFTableInformation accessNFTConfiguration(AccessModifier accessModifier, NFTableInformation nftInf) { + switch (accessModifier) { + case ReadAllEntries: { + return new NFTableInformation(nfTableInformation); + }//break; + case WriteEntry: { + this.nfTableInformation = new NFTableInformation(nftInf); + }break; + case DeleteAllEntries: { + this.nfTableInformation = new NFTableInformation(); + }break; + case DeleteEntry: // Intended fall through + default: { + }break; + } + return null; } }