X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=pkg%2Fcontrol%2Fe2ap.go;h=8f7fb6387de5ceb92dbb2d18a5c5bcc19a1f47a8;hb=375c141ce21767f7bda94ec435fdf833b41fbbd2;hp=ff9c778ef777f17265304bf4642422276cbf90ff;hpb=4511475f03107eb53c88545649898e3cfbcc2765;p=ric-plt%2Fsubmgr.git

diff --git a/pkg/control/e2ap.go b/pkg/control/e2ap.go
index ff9c778..8f7fb63 100644
--- a/pkg/control/e2ap.go
+++ b/pkg/control/e2ap.go
@@ -19,66 +19,206 @@
 
 package control
 
+/*
+#include <wrapper.h>
+
+#cgo LDFLAGS: -le2ap_wrapper -le2ap
+*/
+import "C"
+
 import (
-  "encoding/gob"
-  "bytes"
-  "errors"
+	"gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap"
+	"gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap_wrapper"
+	"gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/packer"
 )
 
+var packerif e2ap.E2APPackerIf = e2ap_wrapper.NewAsn1E2Packer()
+
 type E2ap struct {
 }
 
-func (c *E2ap) GetSubscriptionSequenceNumber(payload []byte) (int, error) {
-  asn1 := new(Asn1)
-  message, err := asn1.Decode(payload)
-  if err != nil {
-    return 0, errors.New("Unable to decode payload due to "+ err.Error()) 
-  }
-  return message.SubscriptionId, nil
+//-----------------------------------------------------------------------------
+//
+//-----------------------------------------------------------------------------
+func (c *E2ap) UnpackSubscriptionRequest(payload []byte) (*e2ap.E2APSubscriptionRequest, error) {
+	e2SubReq := packerif.NewPackerSubscriptionRequest()
+	packedData := &packer.PackedData{}
+	packedData.Buf = payload
+	err := e2SubReq.UnPack(packedData)
+	if err != nil {
+		return nil, err
+	}
+	err, subReq := e2SubReq.Get()
+	if err != nil {
+		return nil, err
+	}
+	return subReq, nil
 }
 
-func (c *E2ap) SetSubscriptionSequenceNumber(payload []byte, newSubscriptionid int) ([]byte ,error) {
-  asn1 := new(Asn1)
-  message, err := asn1.Decode(payload)
-  if err != nil {
-    return make([]byte,0), errors.New("Unable to decode payload due to "+ err.Error()) 
-  }
-  message.SubscriptionId = newSubscriptionid
-  payload, err = asn1.Encode(message)
-  if err != nil {
-    return make([]byte,0), errors.New("Unable to encode message due to "+ err.Error()) 
-  }
-  return payload, nil
+func (c *E2ap) PackSubscriptionRequest(req *e2ap.E2APSubscriptionRequest) (*packer.PackedData, error) {
+	e2SubReq := packerif.NewPackerSubscriptionRequest()
+	err := e2SubReq.Set(req)
+	if err != nil {
+		return nil, err
+	}
+	err, packedData := e2SubReq.Pack(nil)
+	if err != nil {
+		return nil, err
+	}
+	return packedData, nil
 }
 
+//-----------------------------------------------------------------------------
+//
+//-----------------------------------------------------------------------------
+func (c *E2ap) UnpackSubscriptionResponse(payload []byte) (*e2ap.E2APSubscriptionResponse, error) {
+	e2SubResp := packerif.NewPackerSubscriptionResponse()
+	packedData := &packer.PackedData{}
+	packedData.Buf = payload
+	err := e2SubResp.UnPack(packedData)
+	if err != nil {
+		return nil, err
+	}
+	err, subResp := e2SubResp.Get()
+	if err != nil {
+		return nil, err
+	}
+	return subResp, nil
+}
 
-func (c *E2ap) GetPayloadContent(payload []byte) (content string, err error) {
-  asn1 := new(Asn1)
-  message, err := asn1.Decode(payload)
-  content = message.Content
-  return
+func (c *E2ap) PackSubscriptionResponse(req *e2ap.E2APSubscriptionResponse) (*packer.PackedData, error) {
+	e2SubResp := packerif.NewPackerSubscriptionResponse()
+	err := e2SubResp.Set(req)
+	if err != nil {
+		return nil, err
+	}
+	err, packedData := e2SubResp.Pack(nil)
+	if err != nil {
+		return nil, err
+	}
+	return packedData, nil
 }
-/*
-Serialize and Deserialize message using this until real ASN1 GO wrapper is not in place
-*/
-type Asn1 struct {
+
+//-----------------------------------------------------------------------------
+//
+//-----------------------------------------------------------------------------
+func (c *E2ap) UnpackSubscriptionFailure(payload []byte) (*e2ap.E2APSubscriptionFailure, error) {
+	e2SubFail := packerif.NewPackerSubscriptionFailure()
+	packedData := &packer.PackedData{}
+	packedData.Buf = payload
+	err := e2SubFail.UnPack(packedData)
+	if err != nil {
+		return nil, err
+	}
+	err, subFail := e2SubFail.Get()
+	if err != nil {
+		return nil, err
+	}
+	return subFail, nil
+}
+
+func (c *E2ap) PackSubscriptionFailure(req *e2ap.E2APSubscriptionFailure) (*packer.PackedData, error) {
+	e2SubFail := packerif.NewPackerSubscriptionFailure()
+	err := e2SubFail.Set(req)
+	if err != nil {
+		return nil, err
+	}
+	err, packedData := e2SubFail.Pack(nil)
+	if err != nil {
+		return nil, err
+	}
+	return packedData, nil
+}
+
+//-----------------------------------------------------------------------------
+//
+//-----------------------------------------------------------------------------
+func (c *E2ap) UnpackSubscriptionDeleteRequest(payload []byte) (*e2ap.E2APSubscriptionDeleteRequest, error) {
+	e2SubDelReq := packerif.NewPackerSubscriptionDeleteRequest()
+	packedData := &packer.PackedData{}
+	packedData.Buf = payload
+	err := e2SubDelReq.UnPack(packedData)
+	if err != nil {
+		return nil, err
+	}
+	err, subDelReq := e2SubDelReq.Get()
+	if err != nil {
+		return nil, err
+	}
+	return subDelReq, nil
 }
 
-func (a *Asn1) Encode(message RmrPayload) ([]byte, error) {
-	buffer := new(bytes.Buffer)
-	asn1 := gob.NewEncoder(buffer)
-	if err := asn1.Encode(message); err != nil {
+func (c *E2ap) PackSubscriptionDeleteRequest(req *e2ap.E2APSubscriptionDeleteRequest) (*packer.PackedData, error) {
+	e2SubDelReq := packerif.NewPackerSubscriptionDeleteRequest()
+	err := e2SubDelReq.Set(req)
+	if err != nil {
+		return nil, err
+	}
+	err, packedData := e2SubDelReq.Pack(nil)
+	if err != nil {
+		return nil, err
+	}
+	return packedData, nil
+}
+
+//-----------------------------------------------------------------------------
+//
+//-----------------------------------------------------------------------------
+func (c *E2ap) UnpackSubscriptionDeleteResponse(payload []byte) (*e2ap.E2APSubscriptionDeleteResponse, error) {
+	e2SubDelResp := packerif.NewPackerSubscriptionDeleteResponse()
+	packedData := &packer.PackedData{}
+	packedData.Buf = payload
+	err := e2SubDelResp.UnPack(packedData)
+	if err != nil {
+		return nil, err
+	}
+	err, subDelResp := e2SubDelResp.Get()
+	if err != nil {
 		return nil, err
-  }
-	return buffer.Bytes(), nil
+	}
+	return subDelResp, nil
 }
 
-func (a *Asn1) Decode(data []byte) (RmrPayload, error) {
-  message := new(RmrPayload)
-  buffer := bytes.NewBuffer(data)
-	asn1 := gob.NewDecoder(buffer)
-	if err := asn1.Decode(message); err != nil {
-		return RmrPayload{}, err
-  }
-	return *message, nil
+func (c *E2ap) PackSubscriptionDeleteResponse(req *e2ap.E2APSubscriptionDeleteResponse) (*packer.PackedData, error) {
+	e2SubDelResp := packerif.NewPackerSubscriptionDeleteResponse()
+	err := e2SubDelResp.Set(req)
+	if err != nil {
+		return nil, err
+	}
+	err, packedData := e2SubDelResp.Pack(nil)
+	if err != nil {
+		return nil, err
+	}
+	return packedData, nil
+}
+
+//-----------------------------------------------------------------------------
+//
+//-----------------------------------------------------------------------------
+func (c *E2ap) UnpackSubscriptionDeleteFailure(payload []byte) (*e2ap.E2APSubscriptionDeleteFailure, error) {
+	e2SubDelFail := packerif.NewPackerSubscriptionDeleteFailure()
+	packedData := &packer.PackedData{}
+	packedData.Buf = payload
+	err := e2SubDelFail.UnPack(packedData)
+	if err != nil {
+		return nil, err
+	}
+	err, subDelFail := e2SubDelFail.Get()
+	if err != nil {
+		return nil, err
+	}
+	return subDelFail, nil
+}
+
+func (c *E2ap) PackSubscriptionDeleteFailure(req *e2ap.E2APSubscriptionDeleteFailure) (*packer.PackedData, error) {
+	e2SubDelFail := packerif.NewPackerSubscriptionDeleteFailure()
+	err := e2SubDelFail.Set(req)
+	if err != nil {
+		return nil, err
+	}
+	err, packedData := e2SubDelFail.Pack(nil)
+	if err != nil {
+		return nil, err
+	}
+	return packedData, nil
 }