Work on collection of protocols and requirements

cop/collection.go

@@ -0,0 +1,164 @@
+package cop
+
+import (
+	"errors"
+	"fmt"
+	"io/fs"
+	"log"
+	"os"
+	"os/user"
+	"path"
+	"path/filepath"
+	"strings"
+
+	"github.com/go-git/go-git/v5"
+
+	"gitea.mmo.to/ppForge/ppforge/protocol"
+)
+
+// ProtocolCollectionList is a list of all databases, with the most simple interface
+type ProtocolCollectionList struct {
+	PCs []COP
+}
+
+// ProtocolCollectionEntry is a single entry in the file database, additionally to the meta data the path is required
+type ProtocolCollectionEntry struct {
+	Path     string
+	Protocol protocol.ProtocolMeta
+}
+
+// Init initializes the databases, opens the default one and checks for others if available
+func Init() *ProtocolCollectionList {
+	// initialize main list
+	databases := ProtocolCollectionList{[]COP{}}
+	// initialize default db
+	user, err := user.Current()
+	if err != nil {
+		log.Printf("Current user not obtainable: %s", err)
+		log.Fatal("Impossible to open default database")
+	}
+	pathlist := []string{user.HomeDir, ".config", "ppforge"}
+	fdb := FileCOP{COP{map[string]ProtocolCollectionEntry{}, false}, path.Join(pathlist...)}
+	fdb.Open(path.Join(pathlist...))
+	fdb.UpdateCollection()
+	databases.PCs = append(databases.PCs, fdb.COP)
+	log.Printf("Amount of databases available %d", len(databases.PCs))
+	return &databases
+}
+
+// Get a full protocol from a database entry
+func (de *ProtocolCollectionEntry) Get() (*protocol.Protocol, error) {
+	return protocol.LoadNew(de.Path)
+}
+
+// COP represents a Collection of Protocols
+type COP struct {
+	protocols map[string]ProtocolCollectionEntry
+	closed    bool
+}
+
+// FileCOP implements
+type FileCOP struct {
+	COP
+	Path string
+}
+
+// FileCOPFromGitRemote implements retrieving the latest stuff from an external git remote additionally to the FileDatabase functionality
+type FileCOPFromGitRemote struct {
+	FileCOP
+	RemoteGitRepository string
+	gitRepo             git.Repository
+}
+
+// Open the database
+func (fd *FileCOP) Open(path string) error {
+	fileinfo, err := os.Stat(path)
+	if err == os.ErrNotExist {
+		return err
+	}
+	if !fileinfo.IsDir() {
+		return fmt.Errorf("Path %s is not a directory", path)
+	}
+	fd.Path = path
+	fd.closed = false
+	return nil
+}
+
+// Close the database and free the data
+func (fd *FileCOP) Close() error {
+	fd.closed = true
+	return nil
+}
+
+// Protocols returns the map of protocols or an error if the first read failed
+func (fd *FileCOP) Protocols() ([]ProtocolCollectionEntry, error) {
+	if fd.closed {
+		return nil, errors.New("COP closed, no protocols to deliver")
+	}
+	entries := []ProtocolCollectionEntry{}
+	if !fd.closed && len(fd.protocols) == 0 {
+		fd.protocols = map[string]ProtocolCollectionEntry{}
+		err := fd.UpdateCollection()
+		if err != nil {
+			return nil, err
+		}
+	}
+	if entries == nil || len(entries) == 0 {
+		entries = make([]ProtocolCollectionEntry, 0)
+		for _, v := range fd.protocols {
+			entries = append(entries, v)
+		}
+	}
+	return entries, nil
+}
+
+// Add puts a new protocol into the path of the file database
+func (fd *FileCOP) Add(prot *protocol.Protocol) error {
+	if fd.closed {
+		return errors.New("Cannot add, FileCOP is closed")
+	}
+	p := path.Join(fd.Path, prot.Metadata.Name, ".protocoljson")
+	err := prot.Save(p)
+	if err == nil {
+		fd.protocols[prot.Metadata.Name] = ProtocolCollectionEntry{p, prot.Metadata}
+	}
+	return err
+}
+
+// Update updates an existing entry through saving the contents of the protocol to the file, or just adding it anew
+func (fd *FileCOP) Update(prot *protocol.Protocol) error {
+	if fd.closed {
+		return errors.New("Cannot update, FileCOP is closed")
+	}
+	if v, ok := fd.protocols[prot.Metadata.Name]; ok {
+		v.Protocol = prot.Metadata
+		return prot.Save(v.Path)
+	}
+	return fd.Add(prot)
+}
+
+// UpdateCollection just rereads all files
+func (fd *FileCOP) UpdateCollection() error {
+	if fd.closed {
+		return errors.New("Cannot update, FileCOP is closed")
+	}
+	// recurse recursively through the path
+	if fd.protocols == nil {
+		fd.protocols = make(map[string]ProtocolCollectionEntry)
+	}
+	err := filepath.Walk(fd.Path, func(path string, info fs.FileInfo, err error) error {
+		if !info.IsDir() && strings.HasSuffix(info.Name(), ".protocoljson") {
+			prot, err := protocol.LoadNew(path)
+			if err == nil {
+				// add to map
+				// add to map
+				entry := ProtocolCollectionEntry{path, prot.Metadata}
+
+				fd.protocols[prot.Metadata.Name] = entry
+			}
+			return err
+		}
+		return nil
+	})
+	return err
+}

cop/collection_test.go

@@ -0,0 +1,59 @@
+package cop
+
+import (
+	"fmt"
+	"os"
+	"path"
+	"testing"
+)
+
+func TestOpen(t *testing.T) {
+	fcop := FileCOP{}
+	wd, err := os.Getwd()
+	if err != nil {
+		fmt.Printf("Os error: %s", err)
+		t.Fail()
+	}
+	fcop.Open(path.Join(wd, "..", "test", "cop"))
+	l, err := fcop.Protocols()
+	if err != nil {
+		t.Fail()
+	}
+	for k, v := range fcop.protocols {
+		fmt.Printf("%s->%s\n", k, v.Path)
+	}
+	for _, pce := range l {
+		fmt.Printf("%s//%s\n", pce.Path, pce.Protocol.Name)
+	}
+}
+
+func TestClosed(t *testing.T) {
+	fcop := FileCOP{}
+	wd, err := os.Getwd()
+	if err != nil {
+		fmt.Printf("Os error: %s", err)
+		t.Fail()
+	}
+	fcop.Open(path.Join(wd, "..", "test", "cop"))
+	fcop.Close()
+	l, err := fcop.Protocols()
+	if err == nil || l != nil {
+		fmt.Println("Protocols did not deliver error")
+		t.Fail()
+	}
+	err = fcop.Add(nil)
+	if err == nil {
+		fmt.Println("Add did not deliver error")
+		t.Fail()
+	}
+	err = fcop.Update(nil)
+	if err == nil {
+		fmt.Println("Update did not deliver error")
+		t.Fail()
+	}
+	err = fcop.UpdateCollection()
+	if err == nil {
+		fmt.Println("UpdateCollection did not deliver error")
+		t.Fail()
+	}
+}

dop/protocoldictionary.go

@@ -1,179 +0,0 @@
-package dop
-
-import (
-	"fmt"
-	"io/fs"
-	"log"
-	"os"
-	"os/user"
-	"path"
-	"path/filepath"
-
-	"github.com/go-git/go-git/v5"
-
-	"gitea.mmo.to/ppForge/ppforge/protocol"
-	"gitea.mmo.to/ppForge/ppforge/protocolctl"
-)
-
-// ProtocolDictionaryList is a list of all databases, with the most simple interface
-type ProtocolDictionaryList struct {
-	PDs []ProtocolDictionaryProvider
-}
-
-// ProtocolDictionaryProvider is a simple protocol database interface, which only provides open/close and retrieving the contents
-type ProtocolDictionaryProvider interface {
-	// Open opens a new database
-	Open(path string) error
-	// Close closes a database (only internal flag set)
-	Close() error
-	// Protocols returns the content of the database as map, an error if the first read of the database failed
-	Protocols() ([]ProtocolDictionaryEntry, error)
-}
-
-// ProtocolDatabaseManager is a complex protocol database interface, which allows adding, updating and refreshing of the content
-type ProtocolDatabaseManager interface {
-	Add(prot *protocol.ProtocolStructure) error
-	Update(prot *protocol.ProtocolStructure) error
-	// no remove.
-	UpdateDatabase() error // scans for new protocols
-}
-
-// ProtocolDictionaryEntry is a single entry in the file database, additionally to the meta data the path is required
-type ProtocolDictionaryEntry struct {
-	Path     string
-	Protocol protocol.DOPMeta
-}
-
-// Init initializes the databases, opens the default one and checks for others if available
-func Init() *ProtocolDictionaryList {
-	// initialize main list
-	databases := ProtocolDictionaryList{[]ProtocolDictionaryProvider{}}
-	// initialize default db
-	user, err := user.Current()
-	if err != nil {
-		log.Printf("Current user not obtainable: %s", err)
-		log.Fatal("Impossible to open default database")
-	}
-	pathlist := []string{user.HomeDir, ".config", "ppforge"}
-	fdb := FileDOP{path.Join(pathlist...), map[string]ProtocolDictionaryEntry{}, false}
-	fdb.Open(path.Join(pathlist...))
-	fdb.UpdateDatabase()
-	databases.PDs = append(databases.PDs, fdb)
-	log.Printf("Amount of databases available %d", len(databases.PDs))
-	return &databases
-}
-
-// Get Retrieves the full set of databases
-func (ppfdb *ProtocolDictionaryList) Get() []ProtocolDictionaryProvider {
-	return ppfdb.PDs
-}
-
-// Get a full protocol from a database entry
-func (de *ProtocolDictionaryEntry) Get() (*protocol.ProtocolStructure, error) {
-	return protocolctl.LoadNew(de.Path)
-}
-
-// FileDOP implements ProtocolDatabaseProvider and ProtocolDatabaseManager
-type FileDOP struct {
-	Path      string
-	protocols map[string]ProtocolDictionaryEntry
-	closed    bool
-}
-
-// FileDOPFromGitRemote implements retrieving the latest stuff from an external git remote additionally to the FileDatabase functionality
-// TODO
-type FileDOPFromGitRemote struct {
-	FileDOP
-	RemoteGitRepository string
-	gitRepo             git.Repository
-}
-
-// Open the database
-func (fd FileDOP) Open(path string) error {
-	fileinfo, err := os.Stat(path)
-	if err == os.ErrNotExist {
-		return err
-	}
-	if !fileinfo.IsDir() {
-		return fmt.Errorf("Path %s is not a directory", path)
-	}
-	fd.Path = path
-	fd.closed = false
-	return nil
-}
-
-// Close the database and free the data
-func (fd FileDOP) Close() error {
-	for k := range fd.protocols {
-		delete(fd.protocols, k)
-	}
-	fd.closed = true
-	return nil
-}
-
-// Protocols returns the map of protocols or an error if the first read failed
-func (fd FileDOP) Protocols() ([]ProtocolDictionaryEntry, error) {
-	entries := []ProtocolDictionaryEntry{}
-	if !fd.closed && len(fd.protocols) == 0 {
-		fd.protocols = map[string]ProtocolDictionaryEntry{}
-		// recurse recursively through the path
-		err := filepath.Walk(fd.Path, func(path string, info fs.FileInfo, err error) error {
-			if !info.IsDir() {
-				prot, err := protocolctl.LoadNew(path)
-				if err == nil {
-					// add to map
-					entry := ProtocolDictionaryEntry{path, prot.Metadata}
-
-					fd.protocols[prot.Metadata.Name] = entry
-					entries = append(entries, entry)
-				}
-			}
-			return nil
-		})
-		if err != nil {
-			return nil, err
-		}
-	}
-	if entries == nil || len(entries) == 0 {
-		entries = make([]ProtocolDictionaryEntry, len(fd.protocols))
-		for _, v := range fd.protocols {
-			entries = append(entries, v)
-		}
-	}
-	return entries, nil
-}
-
-// Add puts a new protocol into the path of the file database
-func (fd *FileDOP) Add(prot *protocol.ProtocolStructure) error {
-	p := path.Join(fd.Path, prot.Metadata.Name, ".protocoljson")
-	err := protocolctl.Save(prot, p)
-	if err == nil {
-		fd.protocols[prot.Metadata.Name] = ProtocolDictionaryEntry{p, prot.Metadata}
-	}
-	return err
-}
-
-// Update updates an existing entry through saving the contents of the protocol to the file, or just adding it anew
-func (fd *FileDOP) Update(prot *protocol.ProtocolStructure) error {
-	if v, ok := fd.protocols[prot.Metadata.Name]; ok {
-		v.Protocol = prot.Metadata
-		return protocolctl.Save(prot, v.Path)
-	}
-	return fd.Add(prot)
-}
-
-// UpdateDatabase just rereads all files
-func (fd *FileDOP) UpdateDatabase() error {
-	// recurse recursively through the path
-	err := filepath.Walk(fd.Path, func(path string, info fs.FileInfo, err error) error {
-		if !info.IsDir() {
-			prot, err := protocolctl.LoadNew(path)
-			if err == nil {
-				// add to map
-				fd.protocols[prot.Metadata.Name] = ProtocolDictionaryEntry{path, prot.Metadata}
-			}
-		}
-		return nil
-	})
-	return err
-}

dop/protocoldictionary_test.go

@@ -1,9 +0,0 @@
-package dop
-
-import (
-	"testing"
-)
-
-func Test(t *testing.T) {
-
-}

internal/ui/metadata.go

@@ -88,7 +88,7 @@ func NewMetadataProtocol() *ProtocolMetadata {
 	return &md
 }
 
-func (md *ProtocolMetadata) SetProtocol(prot *protocol.ProtocolStructure) {
+func (md *ProtocolMetadata) SetProtocol(prot *protocol.Protocol) {
 	setfunc := func(s string) {
 		protocolctl.UpdateMetaData(
 			prot,
@@ -105,7 +105,6 @@ func (md *ProtocolMetadata) SetProtocol(prot *protocol.ProtocolStructure) {
 	md.VersionValue.SetText(prot.Metadata.Version)
 	md.DescValue.SetText(prot.Metadata.Description)
 	md.ExtendsValue.SetText(prot.Metadata.ExtensionTo)
-	md.OsiLayer.SetSelectedIndex(int(prot.Metadata.OSILayer))
 	md.TcpIpLayer.SetSelectedIndex(int(prot.Metadata.TCPIPLayer))
 	md.SetChanged(setfunc)
 	md.Representation.Refresh()
@@ -115,7 +114,7 @@ func (md *ProtocolMetadata) Unset() {
 	md.SetChanged(func(s string) {})
 }
 
-func (md *PacketMetadata) SetData(pack *packet.Structure) {
+func (md *PacketMetadata) SetData(pack *packet.Packet) {
 
 }
 

internal/ui/packeteditor.go

@@ -17,10 +17,10 @@ type PacketEditor struct {
 
 	ShowShortHints bool
 
-	Reference *packet.Structure
+	Reference *packet.Packet
 }
 
-func NewPacketEditor(ref *packet.Structure) *PacketEditor {
+func NewPacketEditor(ref *packet.Packet) *PacketEditor {
 	metadata := NewMetadataPacket()
 	fields := container.NewGridWrap(fyne.NewSize(300, 200))
 	container := container.NewBorder(nil, nil, metadata.Representation, nil, container.NewVScroll(fields))

internal/ui/packetfieldeditor.go

@@ -39,9 +39,9 @@ func CreatePacketFieldEditor(
 
 	elements := []fyne.CanvasObject{}
 
-	elements = append(elements, widget.NewLabel(ref.GetProtocolField().Name))
+	elements = append(elements, widget.NewLabel("TODO"))
 	if ed.ShowShortHints {
-		elements = append(elements, widget.NewLabel(ref.GetProtocolField().Regex)) // todo: implement real shorthints if feasible
+		elements = append(elements, widget.NewLabel("TODO")) // todo: implement real shorthints if feasible
 	}
 
 	// depending on the input stuff, entry for now

internal/ui/packetfilehandler.go

@@ -14,7 +14,7 @@ type PacketFileHandler struct {
 	changed      bool
 	tab          *container.TabItem
 
-	Reference *packet.Structure
+	Reference *packet.Packet
 }
 
 func NewPacketFileHandler() *PacketFileHandler {

internal/ui/protocoleditor.go

@@ -15,10 +15,10 @@ type ProtocolEditor struct {
 	Metadata       *ProtocolMetadata
 	Fields         []*FieldEditor
 
-	Reference *protocol.ProtocolStructure
+	Reference *protocol.Protocol
 }
 
-func NewProtocolEditor(ref *protocol.ProtocolStructure) *ProtocolEditor {
+func NewProtocolEditor(ref *protocol.Protocol) *ProtocolEditor {
 	metadata := NewMetadataProtocol()
 	fields := container.NewGridWrap(fyne.NewSize(300, 400))
 	container := container.NewBorder(nil, nil, metadata.Representation, nil, container.NewVScroll(fields))

internal/ui/protocolfilehandler.go

@@ -17,7 +17,7 @@ type ProtocolFileHandler struct {
 	changed        bool
 	tab            *container.TabItem
 
-	Reference *protocol.ProtocolStructure
+	Reference *protocol.Protocol
 }
 
 func NewProtocolFileHandler() *ProtocolFileHandler {

packet/fieldvalue.go

@@ -1,20 +0,0 @@
-package packet
-
-import "gitea.mmo.to/ppForge/ppforge/protocol"
-
-// FieldValue implements protocol.ProtocolFieldReferencer
-type FieldValue struct {
-	fieldReference *protocol.Field
-
-	Value string
-}
-
-// GetProtocolField returns the protocol field
-func (fv *FieldValue) GetProtocolField() *protocol.Field {
-	return fv.fieldReference
-}
-
-// SetProtocolField sets the protocl field
-func (fv *FieldValue) SetProtocolField(pf *protocol.Field) {
-	fv.fieldReference = pf
-}

packet/packet.go

@@ -1,26 +1,181 @@
 package packet
 
-import "gitea.mmo.to/ppForge/ppforge/protocol"
+import (
+	"crypto/sha1"
+	"encoding/base64"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io/fs"
+	"os"
+)
+
+// FieldValue implements protocol.ProtocolFieldReferencer
+type FieldValue struct {
+	Field    string
+	FieldNum int
+
+	Value string
+}
+
+// GetProtocolField returns the protocol field
+func (fv *FieldValue) GetProtocolField() (string, int) {
+	return fv.Field, fv.FieldNum
+}
+
+// SetProtocolField sets the protocl field
+func (fv *FieldValue) SetProtocolField(f string, fn int) {
+	fv.Field = f
+	fv.FieldNum = fn
+}
+
+// SetValue sets the value
+func (fv *FieldValue) SetValue(v string) {
+	fv.Value = v
+}
 
 // Layer implements protocol.ProtocolReferencer
 type Layer struct {
-	// needs a reference to a protocol
-	protocolReference *protocol.ProtocolStructure
-
 	ProtocolName string
 	Values       []FieldValue
 }
 
-// Structure contains all layers of a packet
-type Structure struct {
+// Packet contains all layers of a packet and the data in different formats
+type Packet struct {
 	MetaData Metadata
+	data     []byte
+	Hex      string
+	B64      string
+	Sha1     string
 	Layers   []Layer
 }
 
-func (pl *Layer) GetProtocol() *protocol.ProtocolStructure {
-	return pl.protocolReference
+func NewPacketStructure() *Packet {
+	p := Packet{}
+	return &p
+}
+func UpdateMetaData(
+	pack *Packet,
+) {
+	// still empty
 }
 
-func (pl *Layer) Setprotocol(ps *protocol.ProtocolStructure) {
-	pl.protocolReference = ps
+func NewPacketLayer() *Layer {
+	p := Layer{}
+	return &p
+}
+
+func NewEmptyFieldValue() *FieldValue {
+	f := FieldValue{}
+	return &f
+}
+
+func NewFieldValue(
+	field string,
+	fieldnum int,
+	value string,
+) *FieldValue {
+	f := FieldValue{
+		Value: value,
+	}
+	return &f
+}
+
+func (pack *Layer) AppendField(field *FieldValue) int {
+	i := len(pack.Values)
+	pack.Values = append(pack.Values, *field)
+	return i + 1
+}
+
+func (pack *Layer) AddField(index int, field *FieldValue) {
+	if len(pack.Values) == index {
+		pack.AppendField(field)
+		return
+	}
+	ret := make([]FieldValue, 0)
+	ret = append(ret, pack.Values[:index]...)
+	ret = append(ret, *field)
+	ret = append(ret, pack.Values[index:]...)
+	pack.Values = ret
+}
+
+func (pack *Packet) AppendLayer(layer *Layer) {
+	pack.Layers = append(pack.Layers, *layer)
+}
+
+func (pack *Packet) AddLayer(index int, layer *Layer) {
+	if len(pack.Layers) == index {
+		pack.AppendLayer(layer)
+		return
+	}
+	ret := make([]Layer, 0)
+	ret = append(ret, pack.Layers[:index]...)
+	ret = append(ret, *layer)
+	ret = append(ret, pack.Layers[index:]...)
+	pack.Layers = ret
+}
+
+func (pack *Layer) UpdateField(e int, field *FieldValue) {
+	pack.Values[e] = *field
+}
+
+func (pack *Packet) UpdateLayer(e int, layer *Layer) {
+	pack.Layers[e] = *layer
+}
+
+func (pack *Layer) RemoveField(e int) {
+	l := len(pack.Values) - 1
+	ret := make([]FieldValue, l)
+	ret = append(ret, pack.Values[:e]...)
+	ret = append(ret, pack.Values[e+1:]...)
+	pack.Values = ret
+}
+
+func (pack *Packet) RemoveLayer(e int) {
+	l := len(pack.Layers) - 1
+	ret := make([]Layer, l)
+	ret = append(ret, pack.Layers[:e]...)
+	ret = append(ret, pack.Layers[e+1:]...)
+	pack.Layers = ret
+}
+
+func (pack *Packet) Load(path string) error {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		return err
+	}
+	err = json.Unmarshal(data, pack)
+	pack.data, err = base64.StdEncoding.DecodeString(pack.B64)
+	if err != nil {
+		return err
+	}
+	if pack.Sha1 != fmt.Sprintf("%x", sha1.Sum(pack.data)) {
+		return errors.New("sha1sum does not match")
+	}
+	return err
+}
+
+func (pack *Packet) UpdateData() {
+	pack.Hex = fmt.Sprintf("%x", pack.data)
+	pack.B64 = base64.RawStdEncoding.EncodeToString(pack.data)
+	pack.Sha1 = fmt.Sprintf("%x", sha1.Sum(pack.data))
+}
+
+func (pack *Packet) ToJson() string {
+	pack.UpdateData()
+	data, err := json.MarshalIndent(*pack, "", "  ")
+	if err != nil {
+		return ""
+	}
+	return string(data)
+}
+
+func (pack *Packet) Save(path string) error {
+	pack.UpdateData()
+	data, err := json.MarshalIndent(*pack, "", "  ")
+	if err != nil {
+		return err
+	}
+	err = os.WriteFile(path, data, fs.ModeAppend)
+	return err
 }

packet/packet_test.go

@@ -0,0 +1,28 @@
+package packet
+
+import (
+	"testing"
+
+	"gitea.mmo.to/ppForge/ppforge/protocol"
+)
+
+func GenerateProtocol1() *protocol.Protocol {
+
+	return nil
+}
+func GenerateProtocol2() *protocol.Protocol {
+
+	return nil
+}
+
+func TestBinaryGeneration(t *testing.T) {
+
+}
+
+func TestJsonExport(t *testing.T) {
+
+}
+
+func TestJsonImport(t *testing.T) {
+
+}

packet/packetmetadata.go

@@ -3,4 +3,5 @@ package packet
 // Metadata struct is the absolute minimum of metadata
 type Metadata struct {
 	Name     string
+	Revision int
 }

packetctl/packetctl.go

@@ -1,123 +0,0 @@
-package packetctl
-
-import (
-	"encoding/json"
-	"io/fs"
-	"os"
-
-	"gitea.mmo.to/ppForge/ppforge/packet"
-)
-
-func NewPacketStructure() *packet.Structure {
-	p := packet.Structure{}
-	return &p
-}
-
-func UpdateMetaData(
-	pack *packet.Structure,
-) {
-	// still empty
-}
-
-func NewPacketLayer() *packet.Layer {
-	p := packet.Layer{}
-	return &p
-}
-
-func NewEmptyFieldValue() *packet.FieldValue {
-	f := packet.FieldValue{}
-	return &f
-}
-
-func NewFieldValue(
-	value string,
-) *packet.FieldValue {
-	f := packet.FieldValue{
-		Value: value,
-	}
-	return &f
-}
-
-func AppendField(pack *packet.Layer, field *packet.FieldValue) int {
-	i := len(pack.Values)
-	pack.Values = append(pack.Values, *field)
-	return i + 1
-}
-
-func AddField(pack *packet.Layer, index int, field *packet.FieldValue) {
-	if len(pack.Values) == index {
-		AppendField(pack, field)
-		return
-	}
-	ret := make([]packet.FieldValue, 0)
-	ret = append(ret, pack.Values[:index]...)
-	ret = append(ret, *field)
-	ret = append(ret, pack.Values[index:]...)
-	pack.Values = ret
-}
-
-func AppendLayer(pack *packet.Structure, layer *packet.Layer) {
-	pack.Layers = append(pack.Layers, *layer)
-}
-
-func Addlayer(pack *packet.Structure, index int, layer *packet.Layer) {
-	if len(pack.Layers) == index {
-		AppendLayer(pack, layer)
-		return
-	}
-	ret := make([]packet.Layer, 0)
-	ret = append(ret, pack.Layers[:index]...)
-	ret = append(ret, *layer)
-	ret = append(ret, pack.Layers[index:]...)
-	pack.Layers = ret
-}
-
-func UpdateField(pack *packet.Layer, e int, field *packet.FieldValue) {
-	pack.Values[e] = *field
-}
-
-func UpdateLayer(pack *packet.Structure, e int, layer *packet.Layer) {
-	pack.Layers[e] = *layer
-}
-
-func RemoveField(pack *packet.Layer, e int) {
-	l := len(pack.Values) - 1
-	ret := make([]packet.FieldValue, l)
-	ret = append(ret, pack.Values[:e]...)
-	ret = append(ret, pack.Values[e+1:]...)
-	pack.Values = ret
-}
-
-func RemoveLayer(pack *packet.Structure, e int) {
-	l := len(pack.Layers) - 1
-	ret := make([]packet.Layer, l)
-	ret = append(ret, pack.Layers[:e]...)
-	ret = append(ret, pack.Layers[e+1:]...)
-	pack.Layers = ret
-}
-
-func Load(pack *packet.Structure, path string) error {
-	data, err := os.ReadFile(path)
-	if err != nil {
-		return err
-	}
-	err = json.Unmarshal(data, pack)
-	return err
-}
-
-func ToJson(pack *packet.Structure) string {
-	data, err := json.MarshalIndent(*pack, "", "  ")
-	if err != nil {
-		return ""
-	}
-	return string(data)
-}
-
-func Save(pack *packet.Structure, path string) error {
-	data, err := json.MarshalIndent(*pack, "", "  ")
-	if err != nil {
-		return err
-	}
-	err = os.WriteFile(path, data, fs.ModeAppend)
-	return err
-}

protocol/dopmeta.go

@@ -1,16 +0,0 @@
-package protocol
-
-const DOPVersion string = "1.0"
-
-type DOPMeta struct {
-	// DOP metadata version 1.0
-	DOPVersion               string
-	Name                     string
-	Version                  string
-	TCPIPLayer               uint
-	OSILayer                 uint
-	ExtensionTo              string
-	Description              string
-	RequiredJSFunctions      []string
-	LowerLayerIdentification map[string]string
-}

protocol/field.go

@@ -10,6 +10,7 @@ type Field struct {
 	SubFields  []Field // Possible sub-fields
 	Optional   bool    // Is this field required?
 	Payload    bool    // Is this field the payload or next protocol level?
+	JavaScript string
 }
 
 type ProtocolFieldReferencer interface {
@@ -24,3 +25,29 @@ func (f *Field) ToJson() string {
 	}
 	return string(b)
 }
+
+func NewEmptyField() *Field {
+	f := Field{}
+	return &f
+}
+
+func NewField(
+	name string,
+	desc string,
+	regex string,
+	size int,
+	subfields []Field,
+	optional bool,
+	payload bool,
+) *Field {
+	f := Field{
+		Name:      name,
+		Desc:      desc,
+		Regex:     regex,
+		Size:      size,
+		SubFields: subfields,
+		Optional:  optional,
+		Payload:   payload,
+	}
+	return &f
+}

protocol/protocol.go

@@ -1,13 +1,107 @@
 package protocol
 
-type ProtocolStructure struct {
-	Metadata      DOPMeta
+import (
+	"encoding/json"
+	"fmt"
+	"io/fs"
+	"os"
+)
+
+type Protocol struct {
+	Metadata      ProtocolMeta
 	Structure     []*Field
 	DefaultValues []DefaultValue
 	JavaScript    string
 }
 
-type ProtocolReferencer interface {
-	GetProtocol() *ProtocolStructure
-	SetProtocol(prot *ProtocolStructure)
+func (p Protocol) ToJson() string {
+	data, err := json.MarshalIndent(p, "", "  ")
+	if err != nil {
+		return ""
+	}
+	return string(data)
+}
+
+func NewProtocolStructure() *Protocol {
+	p := Protocol{}
+	return &p
+}
+func (prot *Protocol) AppendField(field Field) int {
+	i := len(prot.Structure)
+	prot.Structure = append(prot.Structure, &field)
+	return i + 1
+}
+func (prot *Protocol) AddField(index int, field *Field) {
+	if len(prot.Structure) == index {
+		prot.AppendField(*field)
+		return
+	}
+	ret := make([]*Field, 0)
+	ret = append(ret, prot.Structure[:index]...)
+	ret = append(ret, field)
+	ret = append(ret, prot.Structure[index:]...)
+	prot.Structure = ret
+}
+
+func (prot *Protocol) UpdateFieldByName(name string, field *Field) {
+	var fnd int = -1
+	for i, f := range prot.Structure {
+		if f.Name == name {
+			fnd = i
+		}
+	}
+	if fnd != -1 {
+		prot.Structure[fnd] = field
+	}
+}
+
+func (prot *Protocol) UpdateFieldByElement(element int, field *Field) {
+	prot.Structure[element] = field
+}
+
+func (prot *Protocol) RemoveFieldByName(name string) {
+	element := -1
+	for i, f := range prot.Structure {
+		if f.Name == name {
+			element = i
+		}
+	}
+	if element == -1 {
+		return
+	}
+	prot.RemoveFieldByElement(element)
+}
+
+func (prot *Protocol) RemoveFieldByElement(field int) {
+	ret := make([]*Field, 0)
+	for i, f := range prot.Structure {
+		if i != field {
+			fmt.Printf("appending %d, %s\n", i, f.ToJson())
+			ret = append(ret, f)
+		}
+	}
+	prot.Structure = ret
+}
+
+func (prot *Protocol) Load(path string) error {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		return err
+	}
+	err = json.Unmarshal(data, prot)
+	return err
+}
+func (prot *Protocol) Save(path string) error {
+	data, err := json.MarshalIndent(*prot, "", "  ")
+	if err != nil {
+		return err
+	}
+	err = os.WriteFile(path, data, fs.ModeAppend)
+	return err
+}
+
+func LoadNew(path string) (*Protocol, error) {
+	prot := NewProtocolStructure()
+	err := prot.Load(path)
+	return prot, err
 }

protocol/protocol_test.go

@@ -1,10 +1,8 @@
-package protocolctl
+package protocol
 
 import (
 	"fmt"
 	"testing"
-
-	"gitea.mmo.to/ppForge/ppforge/protocol"
 )
 
 func TestUpdateMetaData(t *testing.T) {
@@ -30,7 +28,6 @@ func TestUpdateMetaData(t *testing.T) {
 	if prot.Metadata.Name != name ||
 		prot.Metadata.Description != desc ||
 		prot.Metadata.ExtensionTo != extensionTo ||
-		prot.Metadata.OSILayer != osilayer ||
 		prot.Metadata.TCPIPLayer != tcpiplayer ||
 		prot.Metadata.Version != version ||
 		prot.Metadata.LowerLayerIdentification != nil ||
@@ -40,8 +37,8 @@ func TestUpdateMetaData(t *testing.T) {
 	}
 }
 
-func GenerateFields() []protocol.Field {
-	slc := make([]protocol.Field, 0)
+func GenerateFields() []Field {
+	slc := make([]Field, 0)
 	for i := 0; i < 10; i++ {
 		field := NewField(
 			fmt.Sprintf("testfield%d", i),
@@ -57,11 +54,11 @@ func GenerateFields() []protocol.Field {
 	return slc
 }
 
-func GenerateStructure() *protocol.ProtocolStructure {
+func GenerateStructure() *Protocol {
 	p := NewProtocolStructure()
 	slc := GenerateFields()
 	for i, e := range slc {
-		AppendField(p, e)
+		p.AppendField(e)
 		fmt.Printf("%d %s\n", i, e.ToJson())
 	}
 	for i, e := range p.Structure {
@@ -82,7 +79,7 @@ func TestFieldAppend(t *testing.T) {
 		false,
 	)
 	p := NewProtocolStructure()
-	AppendField(p, *f)
+	p.AppendField(*f)
 	if p.Structure[0].Name != "testfield" {
 		t.Log("Append failed.")
 		t.Fail()
@@ -110,7 +107,7 @@ func TestUpdateFieldByElement(t *testing.T) {
 	f := NewField(
 		"UpdatedField", "", "", 42, nil, false, true,
 	)
-	UpdateFieldByElement(p, 5, f)
+	p.UpdateFieldByElement(5, f)
 	for i, e := range p.Structure {
 		fmt.Printf("%d %s\n", i, e.ToJson())
 	}
@@ -135,7 +132,7 @@ func TestUpdateFieldByElement(t *testing.T) {
 */
 func TestRemoveFieldByElement(t *testing.T) {
 	p := GenerateStructure()
-	RemoveFieldByElement(p, 3)
+	p.RemoveFieldByElement(3)
 	for i, e := range p.Structure {
 		fmt.Printf("%d %s\n", i, e.ToJson())
 	}
@@ -147,5 +144,5 @@ func TestRemoveFieldByElement(t *testing.T) {
 
 func TestToJson(t *testing.T) {
 	p := GenerateStructure()
-	fmt.Print(ToJson(p))
+	fmt.Print(p.ToJson())
 }

protocol/protocolmeta.go

@@ -0,0 +1,28 @@
+package protocol
+
+type ProtocolMeta struct {
+	Name                     string
+	Revision                 uint
+	Version                  string
+	TCPIPLayer               uint
+	ExtensionTo              string
+	Description              string
+	RequiredJSFunctions      []string
+	LowerLayerIdentification map[string]string
+}
+
+func UpdateMetaData(
+	prot *Protocol,
+	name string,
+	version string,
+	tcpiplayer uint,
+	osilayer uint,
+	extensionTo string,
+	desc string,
+) {
+	prot.Metadata.Name = name
+	prot.Metadata.Description = desc
+	prot.Metadata.ExtensionTo = extensionTo
+	prot.Metadata.Version = version
+	prot.Metadata.TCPIPLayer = tcpiplayer
+}

protocolctl/protocolctl.go

@@ -1,147 +0,0 @@
-package protocolctl
-
-import (
-	"encoding/json"
-	"fmt"
-	"io/fs"
-	"os"
-
-	"gitea.mmo.to/ppForge/ppforge/protocol"
-)
-
-func NewProtocolStructure() *protocol.ProtocolStructure {
-	p := protocol.ProtocolStructure{}
-	return &p
-}
-
-func UpdateMetaData(
-	prot *protocol.ProtocolStructure,
-	name string,
-	version string,
-	tcpiplayer uint,
-	osilayer uint,
-	extensionTo string,
-	desc string,
-) {
-	prot.Metadata.Name = name
-	prot.Metadata.Description = desc
-	prot.Metadata.ExtensionTo = extensionTo
-	prot.Metadata.Version = version
-	prot.Metadata.OSILayer = osilayer
-	prot.Metadata.TCPIPLayer = tcpiplayer
-}
-
-func NewEmptyField() *protocol.Field {
-	f := protocol.Field{}
-	return &f
-}
-
-func NewField(
-	name string,
-	desc string,
-	regex string,
-	size int,
-	subfields []protocol.Field,
-	optional bool,
-	payload bool,
-) *protocol.Field {
-	f := protocol.Field{
-		Name:      name,
-		Desc:      desc,
-		Regex:     regex,
-		Size:      size,
-		SubFields: subfields,
-		Optional:  optional,
-		Payload:   payload,
-	}
-	return &f
-}
-
-func AppendField(prot *protocol.ProtocolStructure, field protocol.Field) int {
-	i := len(prot.Structure)
-	prot.Structure = append(prot.Structure, &field)
-	return i + 1
-}
-func AddField(prot *protocol.ProtocolStructure, index int, field *protocol.Field) {
-	if len(prot.Structure) == index {
-		AppendField(prot, *field)
-		return
-	}
-	ret := make([]*protocol.Field, 0)
-	ret = append(ret, prot.Structure[:index]...)
-	ret = append(ret, field)
-	ret = append(ret, prot.Structure[index:]...)
-	prot.Structure = ret
-}
-
-func UpdateFieldByName(prot *protocol.ProtocolStructure, name string, field *protocol.Field) {
-	var fnd int = -1
-	for i, f := range prot.Structure {
-		if f.Name == name {
-			fnd = i
-		}
-	}
-	if fnd != -1 {
-		prot.Structure[fnd] = field
-	}
-}
-
-func UpdateFieldByElement(prot *protocol.ProtocolStructure, element int, field *protocol.Field) {
-	prot.Structure[element] = field
-}
-
-func RemoveFieldByName(prot *protocol.ProtocolStructure, name string) {
-	element := -1
-	for i, f := range prot.Structure {
-		if f.Name == name {
-			element = i
-		}
-	}
-	if element == -1 {
-		return
-	}
-	RemoveFieldByElement(prot, element)
-}
-
-func RemoveFieldByElement(prot *protocol.ProtocolStructure, field int) {
-	ret := make([]*protocol.Field, 0)
-	for i, f := range prot.Structure {
-		if i != field {
-			fmt.Printf("appending %d, %s\n", i, f.ToJson())
-			ret = append(ret, f)
-		}
-	}
-	prot.Structure = ret
-}
-
-func Load(prot *protocol.ProtocolStructure, path string) error {
-	data, err := os.ReadFile(path)
-	if err != nil {
-		return err
-	}
-	err = json.Unmarshal(data, prot)
-	return err
-}
-
-func LoadNew(path string) (*protocol.ProtocolStructure, error) {
-	prot := NewProtocolStructure()
-	err := Load(prot, path)
-	return prot, err
-}
-
-func ToJson(prot *protocol.ProtocolStructure) string {
-	data, err := json.MarshalIndent(*prot, "", "  ")
-	if err != nil {
-		return ""
-	}
-	return string(data)
-}
-
-func Save(prot *protocol.ProtocolStructure, path string) error {
-	data, err := json.MarshalIndent(*prot, "", "  ")
-	if err != nil {
-		return err
-	}
-	err = os.WriteFile(path, data, fs.ModeAppend)
-	return err
-}

test/cop/blabla.protocoljson

@@ -0,0 +1,34 @@
+{
+  "Metadata": {
+    "Revision": 2,
+    "Name": "blabla",
+    "Version": "",
+    "TCPIPLayer": 0,
+    "ExtensionTo": "",
+    "Description": "",
+    "RequiredJSFunctions": null,
+    "LowerLayerIdentification": null
+  },
+  "Structure": [
+    {
+      "Name": "asdfasdf",
+      "Desc": "",
+      "Regex": "",
+      "Size": 8,
+      "SubFields": null,
+      "Optional": false,
+      "Payload": false
+    },
+    {
+      "Name": "asdfasdfasdf",
+      "Desc": "test",
+      "Regex": "",
+      "Size": 24,
+      "SubFields": null,
+      "Optional": false,
+      "Payload": false
+    }
+  ],
+  "DefaultValues": null,
+  "JavaScript": ""
+}

test/cop/blah.protocoljson

@@ -0,0 +1,61 @@
+{
+  "Metadata": {
+    "Revision": 1,
+    "Name": "blah",
+    "Version": "",
+    "TCPIPLayer": 0,
+    "ExtensionTo": "",
+    "Description": "",
+    "RequiredJSFunctions": null,
+    "LowerLayerIdentification": null
+  },
+  "Structure": [
+    {
+      "Name": "test",
+      "Desc": "",
+      "Regex": "",
+      "Size": 32,
+      "SubFields": null,
+      "Optional": false,
+      "Payload": false
+    },
+    {
+      "Name": "",
+      "Desc": "",
+      "Regex": "",
+      "Size": 32,
+      "SubFields": null,
+      "Optional": false,
+      "Payload": false
+    },
+    {
+      "Name": "",
+      "Desc": "",
+      "Regex": "",
+      "Size": 8,
+      "SubFields": null,
+      "Optional": false,
+      "Payload": false
+    },
+    {
+      "Name": "",
+      "Desc": "",
+      "Regex": "",
+      "Size": 4,
+      "SubFields": null,
+      "Optional": false,
+      "Payload": false
+    },
+    {
+      "Name": "",
+      "Desc": "",
+      "Regex": "",
+      "Size": 20,
+      "SubFields": null,
+      "Optional": false,
+      "Payload": false
+    }
+  ],
+  "DefaultValues": null,
+  "JavaScript": ""
+}

test/cop/test.protocoljson

@@ -0,0 +1,25 @@
+{
+  "Metadata": {
+    "Revision": 1,
+    "Name": "test",
+    "Version": "",
+    "TCPIPLayer": 0,
+    "ExtensionTo": "",
+    "Description": "test",
+    "RequiredJSFunctions": null,
+    "LowerLayerIdentification": null
+  },
+  "Structure": [
+    {
+      "Name": "test",
+      "Desc": "test",
+      "Regex": "",
+      "Size": 128,
+      "SubFields": null,
+      "Optional": false,
+      "Payload": false
+    }
+  ],
+  "DefaultValues": null,
+  "JavaScript": ""
+}