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

diff --git a/pkg/control/e2ap.go b/pkg/control/e2ap.go
index ff9c778..ed2f690 100644
--- a/pkg/control/e2ap.go
+++ b/pkg/control/e2ap.go
@@ -19,66 +19,148 @@
 
 package control
 
+/*
+#include <wrapper.h>
+
+#cgo LDFLAGS: -le2ap_wrapper -le2ap
+*/
+import "C"
+
 import (
-  "encoding/gob"
-  "bytes"
-  "errors"
+	"encoding/hex"
+	"fmt"
+	"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/xapp-frame/pkg/xapp"
 )
 
+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()
+	err, subReq := e2SubReq.UnPack(&e2ap.PackedData{payload})
+	if err != nil {
+		return nil, fmt.Errorf("%s buf[%s]", err.Error(), hex.EncodeToString(payload))
+	}
+	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) (int, *e2ap.PackedData, error) {
+	e2SubReq := packerif.NewPackerSubscriptionRequest()
+	err, packedData := e2SubReq.Pack(req)
+	if err != nil {
+		return 0, nil, err
+	}
+	return xapp.RIC_SUB_REQ, packedData, nil
 }
 
+//-----------------------------------------------------------------------------
+//
+//-----------------------------------------------------------------------------
+func (c *E2ap) UnpackSubscriptionResponse(payload []byte) (*e2ap.E2APSubscriptionResponse, error) {
+	e2SubResp := packerif.NewPackerSubscriptionResponse()
+	err, subResp := e2SubResp.UnPack(&e2ap.PackedData{payload})
+	if err != nil {
+		return nil, fmt.Errorf("%s buf[%s]", err.Error(), hex.EncodeToString(payload))
+	}
+	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) (int, *e2ap.PackedData, error) {
+	e2SubResp := packerif.NewPackerSubscriptionResponse()
+	err, packedData := e2SubResp.Pack(req)
+	if err != nil {
+		return 0, nil, err
+	}
+	return xapp.RIC_SUB_RESP, 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()
+	err, subFail := e2SubFail.UnPack(&e2ap.PackedData{payload})
+	if err != nil {
+		return nil, fmt.Errorf("%s buf[%s]", err.Error(), hex.EncodeToString(payload))
+	}
+	return subFail, nil
+}
+
+func (c *E2ap) PackSubscriptionFailure(req *e2ap.E2APSubscriptionFailure) (int, *e2ap.PackedData, error) {
+	e2SubFail := packerif.NewPackerSubscriptionFailure()
+	err, packedData := e2SubFail.Pack(req)
+	if err != nil {
+		return 0, nil, err
+	}
+	return xapp.RIC_SUB_FAILURE, packedData, nil
+}
+
+//-----------------------------------------------------------------------------
+//
+//-----------------------------------------------------------------------------
+func (c *E2ap) UnpackSubscriptionDeleteRequest(payload []byte) (*e2ap.E2APSubscriptionDeleteRequest, error) {
+	e2SubDelReq := packerif.NewPackerSubscriptionDeleteRequest()
+	err, subDelReq := e2SubDelReq.UnPack(&e2ap.PackedData{payload})
+	if err != nil {
+		return nil, fmt.Errorf("%s buf[%s]", err.Error(), hex.EncodeToString(payload))
+	}
+	return subDelReq, nil
+}
+
+func (c *E2ap) PackSubscriptionDeleteRequest(req *e2ap.E2APSubscriptionDeleteRequest) (int, *e2ap.PackedData, error) {
+	e2SubDelReq := packerif.NewPackerSubscriptionDeleteRequest()
+	err, packedData := e2SubDelReq.Pack(req)
+	if err != nil {
+		return 0, nil, err
+	}
+	return xapp.RIC_SUB_DEL_REQ, packedData, nil
+}
+
+//-----------------------------------------------------------------------------
+//
+//-----------------------------------------------------------------------------
+func (c *E2ap) UnpackSubscriptionDeleteResponse(payload []byte) (*e2ap.E2APSubscriptionDeleteResponse, error) {
+	e2SubDelResp := packerif.NewPackerSubscriptionDeleteResponse()
+	err, subDelResp := e2SubDelResp.UnPack(&e2ap.PackedData{payload})
+	if err != nil {
+		return nil, fmt.Errorf("%s buf[%s]", err.Error(), hex.EncodeToString(payload))
+	}
+	return subDelResp, nil
+}
+
+func (c *E2ap) PackSubscriptionDeleteResponse(req *e2ap.E2APSubscriptionDeleteResponse) (int, *e2ap.PackedData, error) {
+	e2SubDelResp := packerif.NewPackerSubscriptionDeleteResponse()
+	err, packedData := e2SubDelResp.Pack(req)
+	if err != nil {
+		return 0, nil, err
+	}
+	return xapp.RIC_SUB_DEL_RESP, packedData, nil
 }
 
-func (a *Asn1) Encode(message RmrPayload) ([]byte, error) {
-	buffer := new(bytes.Buffer)
-	asn1 := gob.NewEncoder(buffer)
-	if err := asn1.Encode(message); err != nil {
-		return nil, err
-  }
-	return buffer.Bytes(), nil
+//-----------------------------------------------------------------------------
+//
+//-----------------------------------------------------------------------------
+func (c *E2ap) UnpackSubscriptionDeleteFailure(payload []byte) (*e2ap.E2APSubscriptionDeleteFailure, error) {
+	e2SubDelFail := packerif.NewPackerSubscriptionDeleteFailure()
+	err, subDelFail := e2SubDelFail.UnPack(&e2ap.PackedData{payload})
+	if err != nil {
+		return nil, fmt.Errorf("%s buf[%s]", err.Error(), hex.EncodeToString(payload))
+	}
+	return subDelFail, 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) PackSubscriptionDeleteFailure(req *e2ap.E2APSubscriptionDeleteFailure) (int, *e2ap.PackedData, error) {
+	e2SubDelFail := packerif.NewPackerSubscriptionDeleteFailure()
+	err, packedData := e2SubDelFail.Pack(req)
+	if err != nil {
+		return 0, nil, err
+	}
+	return xapp.RIC_SUB_DEL_FAILURE, packedData, nil
 }